@alivault/pico 0.3.1 → 0.4.0

package/.output/server/_libs/hast-util-to-jsx-runtime+[...].mjs

@@ -1,7 +1,8 @@
 import { i as __toESM, t as __commonJSMin } from "../_runtime.mjs";
-import { a as stringify, c as svg, i as stringify$1, l as find, r as whitespace, s as html, u as hastToReact } from "./@pierre/diffs+[...].mjs";
+import { a as stringify$1, d as svg, f as find, p as hastToReact, r as whitespace, s as stringify, u as html } from "./@pierre/diffs+[...].mjs";
 import "./devlop.mjs";
 import { t as name } from "./estree-util-is-identifier-name.mjs";
+import { o as pointStart } from "./hast-util-raw+[...].mjs";
 //#region node_modules/.pnpm/inline-style-parser@0.2.7/node_modules/inline-style-parser/cjs/index.js
 var require_cjs$2 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	var COMMENT_REGEX = /\/\*[^*]*\*+([^/*][^*]*\*+)*\//g;
@@ -305,86 +306,6 @@ var require_cjs = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	module.exports = StyleToJS;
 }));
 //#endregion
-//#region node_modules/.pnpm/unist-util-position@5.0.0/node_modules/unist-util-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 PositionLike
-* @property {PointLike | null | undefined} [start]
-* @property {PointLike | null | undefined} [end]
-*
-* @typedef PointLike
-* @property {number | null | undefined} [line]
-* @property {number | null | undefined} [column]
-* @property {number | null | undefined} [offset]
-*/
-/**
-* Get the ending point of `node`.
-*
-* @param node
-*   Node.
-* @returns
-*   Point.
-*/
-var pointEnd = point$1("end");
-/**
-* Get the starting point of `node`.
-*
-* @param node
-*   Node.
-* @returns
-*   Point.
-*/
-var pointStart = point$1("start");
-/**
-* Get the positional info of `node`.
-*
-* @param {'end' | 'start'} type
-*   Side.
-* @returns
-*   Getter.
-*/
-function point$1(type) {
-	return point;
-	/**
-	* Get the point info of `node` at a bound side.
-	*
-	* @param {Node | NodeLike | null | undefined} [node]
-	* @returns {Point | undefined}
-	*/
-	function point(node) {
-		const point = node && node.position && node.position[type] || {};
-		if (typeof point.line === "number" && point.line > 0 && typeof point.column === "number" && point.column > 0) return {
-			line: point.line,
-			column: point.column,
-			offset: typeof point.offset === "number" && point.offset > -1 ? point.offset : void 0
-		};
-	}
-}
-/**
-* Get the positional info of `node`.
-*
-* @param {Node | NodeLike | null | undefined} [node]
-*   Node.
-* @returns {Position | undefined}
-*   Position.
-*/
-function position$1(node) {
-	const start = pointStart(node);
-	const end = pointEnd(node);
-	if (start && end) return {
-		start,
-		end
-	};
-}
-//#endregion
 //#region node_modules/.pnpm/unist-util-stringify-position@4.0.0/node_modules/unist-util-stringify-position/lib/index.js
 /**
 * @typedef {import('unist').Node} Node
@@ -1241,4 +1162,4 @@ function toDash($0) {
 	return "-" + $0.toLowerCase();
 }
 //#endregion
-export { pointStart as a, pointEnd as i, VFileMessage as n, position$1 as o, stringifyPosition as r, toJsxRuntime as t };
+export { VFileMessage as n, stringifyPosition as r, toJsxRuntime as t };

package/.output/server/_libs/mdast-util-find-and-replace.mjs

@@ -0,0 +1,198 @@
+import { i as convert, r as visitParents } from "./hast-util-raw+[...].mjs";
+import { t as escapeStringRegexp } from "./escape-string-regexp.mjs";
+//#region node_modules/.pnpm/mdast-util-find-and-replace@3.0.2/node_modules/mdast-util-find-and-replace/lib/index.js
+/**
+* @import {Nodes, Parents, PhrasingContent, Root, Text} from 'mdast'
+* @import {BuildVisitor, Test, VisitorResult} from 'unist-util-visit-parents'
+*/
+/**
+* @typedef RegExpMatchObject
+*   Info on the match.
+* @property {number} index
+*   The index of the search at which the result was found.
+* @property {string} input
+*   A copy of the search string in the text node.
+* @property {[...Array<Parents>, Text]} stack
+*   All ancestors of the text node, where the last node is the text itself.
+*
+* @typedef {RegExp | string} Find
+*   Pattern to find.
+*
+*   Strings are escaped and then turned into global expressions.
+*
+* @typedef {Array<FindAndReplaceTuple>} FindAndReplaceList
+*   Several find and replaces, in array form.
+*
+* @typedef {[Find, Replace?]} FindAndReplaceTuple
+*   Find and replace in tuple form.
+*
+* @typedef {ReplaceFunction | string | null | undefined} Replace
+*   Thing to replace with.
+*
+* @callback ReplaceFunction
+*   Callback called when a search matches.
+* @param {...any} parameters
+*   The parameters are the result of corresponding search expression:
+*
+*   * `value` (`string`) — whole match
+*   * `...capture` (`Array<string>`) — matches from regex capture groups
+*   * `match` (`RegExpMatchObject`) — info on the match
+* @returns {Array<PhrasingContent> | PhrasingContent | string | false | null | undefined}
+*   Thing to replace with.
+*
+*   * when `null`, `undefined`, `''`, remove the match
+*   * …or when `false`, do not replace at all
+*   * …or when `string`, replace with a text node of that value
+*   * …or when `Node` or `Array<Node>`, replace with those nodes
+*
+* @typedef {[RegExp, ReplaceFunction]} Pair
+*   Normalized find and replace.
+*
+* @typedef {Array<Pair>} Pairs
+*   All find and replaced.
+*
+* @typedef Options
+*   Configuration.
+* @property {Test | null | undefined} [ignore]
+*   Test for which nodes to ignore (optional).
+*/
+/**
+* Find patterns in a tree and replace them.
+*
+* The algorithm searches the tree in *preorder* for complete values in `Text`
+* nodes.
+* Partial matches are not supported.
+*
+* @param {Nodes} tree
+*   Tree to change.
+* @param {FindAndReplaceList | FindAndReplaceTuple} list
+*   Patterns to find.
+* @param {Options | null | undefined} [options]
+*   Configuration (when `find` is not `Find`).
+* @returns {undefined}
+*   Nothing.
+*/
+function findAndReplace(tree, list, options) {
+	const ignored = convert((options || {}).ignore || []);
+	const pairs = toPairs(list);
+	let pairIndex = -1;
+	while (++pairIndex < pairs.length) visitParents(tree, "text", visitor);
+	/** @type {BuildVisitor<Root, 'text'>} */
+	function visitor(node, parents) {
+		let index = -1;
+		/** @type {Parents | undefined} */
+		let grandparent;
+		while (++index < parents.length) {
+			const parent = parents[index];
+			/** @type {Array<Nodes> | undefined} */
+			const siblings = grandparent ? grandparent.children : void 0;
+			if (ignored(parent, siblings ? siblings.indexOf(parent) : void 0, grandparent)) return;
+			grandparent = parent;
+		}
+		if (grandparent) return handler(node, parents);
+	}
+	/**
+	* Handle a text node which is not in an ignored parent.
+	*
+	* @param {Text} node
+	*   Text node.
+	* @param {Array<Parents>} parents
+	*   Parents.
+	* @returns {VisitorResult}
+	*   Result.
+	*/
+	function handler(node, parents) {
+		const parent = parents[parents.length - 1];
+		const find = pairs[pairIndex][0];
+		const replace = pairs[pairIndex][1];
+		let start = 0;
+		const index = parent.children.indexOf(node);
+		let change = false;
+		/** @type {Array<PhrasingContent>} */
+		let nodes = [];
+		find.lastIndex = 0;
+		let match = find.exec(node.value);
+		while (match) {
+			const position = match.index;
+			/** @type {RegExpMatchObject} */
+			const matchObject = {
+				index: match.index,
+				input: match.input,
+				stack: [...parents, node]
+			};
+			let value = replace(...match, matchObject);
+			if (typeof value === "string") value = value.length > 0 ? {
+				type: "text",
+				value
+			} : void 0;
+			if (value === false) find.lastIndex = position + 1;
+			else {
+				if (start !== position) nodes.push({
+					type: "text",
+					value: node.value.slice(start, position)
+				});
+				if (Array.isArray(value)) nodes.push(...value);
+				else if (value) nodes.push(value);
+				start = position + match[0].length;
+				change = true;
+			}
+			if (!find.global) break;
+			match = find.exec(node.value);
+		}
+		if (change) {
+			if (start < node.value.length) nodes.push({
+				type: "text",
+				value: node.value.slice(start)
+			});
+			parent.children.splice(index, 1, ...nodes);
+		} else nodes = [node];
+		return index + nodes.length;
+	}
+}
+/**
+* Turn a tuple or a list of tuples into pairs.
+*
+* @param {FindAndReplaceList | FindAndReplaceTuple} tupleOrList
+*   Schema.
+* @returns {Pairs}
+*   Clean pairs.
+*/
+function toPairs(tupleOrList) {
+	/** @type {Pairs} */
+	const result = [];
+	if (!Array.isArray(tupleOrList)) throw new TypeError("Expected find and replace tuple or list of tuples");
+	/** @type {FindAndReplaceList} */
+	const list = !tupleOrList[0] || Array.isArray(tupleOrList[0]) ? tupleOrList : [tupleOrList];
+	let index = -1;
+	while (++index < list.length) {
+		const tuple = list[index];
+		result.push([toExpression(tuple[0]), toFunction(tuple[1])]);
+	}
+	return result;
+}
+/**
+* Turn a find into an expression.
+*
+* @param {Find} find
+*   Find.
+* @returns {RegExp}
+*   Expression.
+*/
+function toExpression(find) {
+	return typeof find === "string" ? new RegExp(escapeStringRegexp(find), "g") : find;
+}
+/**
+* Turn a replace into a function.
+*
+* @param {Replace} replace
+*   Replace.
+* @returns {ReplaceFunction}
+*   Function.
+*/
+function toFunction(replace) {
+	return typeof replace === "function" ? replace : function() {
+		return replace;
+	};
+}
+//#endregion
+export { findAndReplace as t };

package/.output/server/_libs/mdast-util-gfm+[...].mjs

@@ -1,294 +1,10 @@
-import { o as ccount } from "./@pierre/diffs+[...].mjs";
+import { c as ccount } from "./@pierre/diffs+[...].mjs";
 import "./devlop.mjs";
+import { i as convert, n as visit } from "./hast-util-raw+[...].mjs";
 import { _ as toString, f as unicodePunctuation, i as classifyCharacter, m as normalizeIdentifier, p as unicodeWhitespace } from "./mdast-util-from-markdown+[...].mjs";
-import { n as visitParents, r as convert, t as findAndReplace } from "./mdast-util-find-and-replace+[...].mjs";
+import { t as findAndReplace } from "./mdast-util-find-and-replace.mjs";
 import { t as markdownTable } from "./markdown-table.mjs";
 import { t as longestStreak } from "./longest-streak.mjs";
-//#region node_modules/.pnpm/unist-util-visit@5.1.0/node_modules/unist-util-visit/lib/index.js
-/**
-* @import {Node as UnistNode, Parent as UnistParent} from 'unist'
-* @import {VisitorResult} from 'unist-util-visit-parents'
-*/
-/**
-* @typedef {Exclude<import('unist-util-is').Test, undefined> | undefined} Test
-*   Test from `unist-util-is`.
-*
-*   Note: we have remove and add `undefined`, because otherwise when generating
-*   automatic `.d.ts` files, TS tries to flatten paths from a local perspective,
-*   which doesn’t work when publishing on npm.
-*/
-/**
-* @typedef {(
-*   Fn extends (value: any) => value is infer Thing
-*   ? Thing
-*   : Fallback
-* )} Predicate
-*   Get the value of a type guard `Fn`.
-* @template Fn
-*   Value; typically function that is a type guard (such as `(x): x is Y`).
-* @template Fallback
-*   Value to yield if `Fn` is not a type guard.
-*/
-/**
-* @typedef {(
-*   Check extends null | undefined // No test.
-*   ? Value
-*   : Value extends {type: Check} // String (type) test.
-*   ? Value
-*   : Value extends Check // Partial test.
-*   ? Value
-*   : Check extends Function // Function test.
-*   ? Predicate<Check, Value> extends Value
-*     ? Predicate<Check, Value>
-*     : never
-*   : never // Some other test?
-* )} MatchesOne
-*   Check whether a node matches a primitive check in the type system.
-* @template Value
-*   Value; typically unist `Node`.
-* @template Check
-*   Value; typically `unist-util-is`-compatible test, but not arrays.
-*/
-/**
-* @typedef {(
-*   Check extends ReadonlyArray<any>
-*   ? MatchesOne<Value, Check[number]>
-*   : MatchesOne<Value, Check>
-* )} Matches
-*   Check whether a node matches a check in the type system.
-* @template Value
-*   Value; typically unist `Node`.
-* @template Check
-*   Value; typically `unist-util-is`-compatible test.
-*/
-/**
-* @typedef {0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10} Uint
-*   Number; capped reasonably.
-*/
-/**
-* @typedef {I extends 0 ? 1 : I extends 1 ? 2 : I extends 2 ? 3 : I extends 3 ? 4 : I extends 4 ? 5 : I extends 5 ? 6 : I extends 6 ? 7 : I extends 7 ? 8 : I extends 8 ? 9 : 10} Increment
-*   Increment a number in the type system.
-* @template {Uint} [I=0]
-*   Index.
-*/
-/**
-* @typedef {(
-*   Node extends UnistParent
-*   ? Node extends {children: Array<infer Children>}
-*     ? Child extends Children ? Node : never
-*     : never
-*   : never
-* )} InternalParent
-*   Collect nodes that can be parents of `Child`.
-* @template {UnistNode} Node
-*   All node types in a tree.
-* @template {UnistNode} Child
-*   Node to search for.
-*/
-/**
-* @typedef {InternalParent<InclusiveDescendant<Tree>, Child>} Parent
-*   Collect nodes in `Tree` that can be parents of `Child`.
-* @template {UnistNode} Tree
-*   All node types in a tree.
-* @template {UnistNode} Child
-*   Node to search for.
-*/
-/**
-* @typedef {(
-*   Depth extends Max
-*   ? never
-*   :
-*     | InternalParent<Node, Child>
-*     | InternalAncestor<Node, InternalParent<Node, Child>, Max, Increment<Depth>>
-* )} InternalAncestor
-*   Collect nodes in `Tree` that can be ancestors of `Child`.
-* @template {UnistNode} Node
-*   All node types in a tree.
-* @template {UnistNode} Child
-*   Node to search for.
-* @template {Uint} [Max=10]
-*   Max; searches up to this depth.
-* @template {Uint} [Depth=0]
-*   Current depth.
-*/
-/**
-* @typedef {(
-*   Tree extends UnistParent
-*     ? Depth extends Max
-*       ? Tree
-*       : Tree | InclusiveDescendant<Tree['children'][number], Max, Increment<Depth>>
-*     : Tree
-* )} InclusiveDescendant
-*   Collect all (inclusive) descendants of `Tree`.
-*
-*   > 👉 **Note**: for performance reasons, this seems to be the fastest way to
-*   > recurse without actually running into an infinite loop, which the
-*   > previous version did.
-*   >
-*   > Practically, a max of `2` is typically enough assuming a `Root` is
-*   > passed, but it doesn’t improve performance.
-*   > It gets higher with `List > ListItem > Table > TableRow > TableCell`.
-*   > Using up to `10` doesn’t hurt or help either.
-* @template {UnistNode} Tree
-*   Tree type.
-* @template {Uint} [Max=10]
-*   Max; searches up to this depth.
-* @template {Uint} [Depth=0]
-*   Current depth.
-*/
-/**
-* @callback Visitor
-*   Handle a node (matching `test`, if given).
-*
-*   Visitors are free to transform `node`.
-*   They can also transform `parent`.
-*
-*   Replacing `node` itself, if `SKIP` is not returned, still causes its
-*   descendants to be walked (which is a bug).
-*
-*   When adding or removing previous siblings of `node` (or next siblings, in
-*   case of reverse), the `Visitor` should return a new `Index` to specify the
-*   sibling to traverse after `node` is traversed.
-*   Adding or removing next siblings of `node` (or previous siblings, in case
-*   of reverse) is handled as expected without needing to return a new `Index`.
-*
-*   Removing the children property of `parent` still results in them being
-*   traversed.
-* @param {Visited} node
-*   Found node.
-* @param {Visited extends UnistNode ? number | undefined : never} index
-*   Index of `node` in `parent`.
-* @param {Ancestor extends UnistParent ? Ancestor | undefined : never} parent
-*   Parent of `node`.
-* @returns {VisitorResult}
-*   What to do next.
-*
-*   An `Index` is treated as a tuple of `[CONTINUE, Index]`.
-*   An `Action` is treated as a tuple of `[Action]`.
-*
-*   Passing a tuple back only makes sense if the `Action` is `SKIP`.
-*   When the `Action` is `EXIT`, that action can be returned.
-*   When the `Action` is `CONTINUE`, `Index` can be returned.
-* @template {UnistNode} [Visited=UnistNode]
-*   Visited node type.
-* @template {UnistParent} [Ancestor=UnistParent]
-*   Ancestor type.
-*/
-/**
-* @typedef {Visitor<Visited, Parent<Ancestor, Visited>>} BuildVisitorFromMatch
-*   Build a typed `Visitor` function from a node and all possible parents.
-*
-*   It will infer which values are passed as `node` and which as `parent`.
-* @template {UnistNode} Visited
-*   Node type.
-* @template {UnistParent} Ancestor
-*   Parent type.
-*/
-/**
-* @typedef {(
-*   BuildVisitorFromMatch<
-*     Matches<Descendant, Check>,
-*     Extract<Descendant, UnistParent>
-*   >
-* )} BuildVisitorFromDescendants
-*   Build a typed `Visitor` function from a list of descendants and a test.
-*
-*   It will infer which values are passed as `node` and which as `parent`.
-* @template {UnistNode} Descendant
-*   Node type.
-* @template {Test} Check
-*   Test type.
-*/
-/**
-* @typedef {(
-*   BuildVisitorFromDescendants<
-*     InclusiveDescendant<Tree>,
-*     Check
-*   >
-* )} BuildVisitor
-*   Build a typed `Visitor` function from a tree and a test.
-*
-*   It will infer which values are passed as `node` and which as `parent`.
-* @template {UnistNode} [Tree=UnistNode]
-*   Node type.
-* @template {Test} [Check=Test]
-*   Test type.
-*/
-/**
-* Visit nodes.
-*
-* This algorithm performs *depth-first* *tree traversal* in *preorder*
-* (**NLR**) or if `reverse` is given, in *reverse preorder* (**NRL**).
-*
-* You can choose for which nodes `visitor` is called by passing a `test`.
-* For complex tests, you should test yourself in `visitor`, as it will be
-* faster and will have improved type information.
-*
-* Walking the tree is an intensive task.
-* Make use of the return values of the visitor when possible.
-* Instead of walking a tree multiple times, walk it once, use `unist-util-is`
-* to check if a node matches, and then perform different operations.
-*
-* You can change the tree.
-* See `Visitor` for more info.
-*
-* @overload
-* @param {Tree} tree
-* @param {Check} check
-* @param {BuildVisitor<Tree, Check>} visitor
-* @param {boolean | null | undefined} [reverse]
-* @returns {undefined}
-*
-* @overload
-* @param {Tree} tree
-* @param {BuildVisitor<Tree>} visitor
-* @param {boolean | null | undefined} [reverse]
-* @returns {undefined}
-*
-* @param {UnistNode} tree
-*   Tree to traverse.
-* @param {Visitor | Test} testOrVisitor
-*   `unist-util-is`-compatible test (optional, omit to pass a visitor).
-* @param {Visitor | boolean | null | undefined} [visitorOrReverse]
-*   Handle each node (when test is omitted, pass `reverse`).
-* @param {boolean | null | undefined} [maybeReverse=false]
-*   Traverse in reverse preorder (NRL) instead of the default preorder (NLR).
-* @returns {undefined}
-*   Nothing.
-*
-* @template {UnistNode} Tree
-*   Node type.
-* @template {Test} Check
-*   `unist-util-is`-compatible test.
-*/
-function visit(tree, testOrVisitor, visitorOrReverse, maybeReverse) {
-	/** @type {boolean | null | undefined} */
-	let reverse;
-	/** @type {Test} */
-	let test;
-	/** @type {Visitor} */
-	let visitor;
-	if (typeof testOrVisitor === "function" && typeof visitorOrReverse !== "function") {
-		test = void 0;
-		visitor = testOrVisitor;
-		reverse = visitorOrReverse;
-	} else {
-		test = testOrVisitor;
-		visitor = visitorOrReverse;
-		reverse = maybeReverse;
-	}
-	visitParents(tree, test, overload, reverse);
-	/**
-	* @param {UnistNode} node
-	* @param {Array<UnistParent>} parents
-	*/
-	function overload(node, parents) {
-		const parent = parents[parents.length - 1];
-		const index = parent ? parent.children.indexOf(node) : void 0;
-		return visitor(node, index, parent);
-	}
-}
-//#endregion
 //#region node_modules/.pnpm/mdast-util-gfm-autolink-literal@2.0.1/node_modules/mdast-util-gfm-autolink-literal/lib/index.js
 /**
 * @import {RegExpMatchObject, ReplaceFunction} from 'mdast-util-find-and-replace'
@@ -2343,4 +2059,4 @@ function gfmToMarkdown(options) {
 	] };
 }
 //#endregion
-export { gfmToMarkdown as n, visit as r, gfmFromMarkdown as t };
+export { gfmToMarkdown as n, gfmFromMarkdown as t };

package/.output/server/_libs/mdast-util-to-hast+[...].mjs

@@ -1,8 +1,7 @@
 import "./devlop.mjs";
-import { a as pointStart, i as pointEnd, o as position } from "./hast-util-to-jsx-runtime+[...].mjs";
+import { a as pointEnd, n as visit, o as pointStart, s as position } from "./hast-util-raw+[...].mjs";
 import { s as asciiAlphanumeric } from "./mdast-util-from-markdown+[...].mjs";
 import { t as esm_default } from "./ungap__structured-clone.mjs";
-import { r as visit } from "./mdast-util-gfm+[...].mjs";
 //#region node_modules/.pnpm/micromark-util-sanitize-uri@2.0.1/node_modules/micromark-util-sanitize-uri/index.js
 /**
 * Normalize a URL.

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

@@ -2,10 +2,10 @@ import { i as __toESM } from "../_runtime.mjs";
 import { X as require_react, Y 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 { r as visit } from "./mdast-util-gfm+[...].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";

package/.output/server/_libs/rehype-raw.mjs

@@ -0,0 +1,37 @@
+import { t as raw } from "./hast-util-raw+[...].mjs";
+//#region node_modules/.pnpm/rehype-raw@7.0.0/node_modules/rehype-raw/lib/index.js
+/**
+* @typedef {import('hast').Root} Root
+* @typedef {import('hast-util-raw').Options} RawOptions
+* @typedef {import('vfile').VFile} VFile
+*/
+/**
+* @typedef {Omit<RawOptions, 'file'>} Options
+*   Configuration.
+*/
+/**
+* Parse the tree (and raw nodes) again, keeping positional info okay.
+*
+* @param {Options | null | undefined}  [options]
+*   Configuration (optional).
+* @returns
+*   Transform.
+*/
+function rehypeRaw(options) {
+	/**
+	* @param {Root} tree
+	*   Tree.
+	* @param {VFile} file
+	*   File.
+	* @returns {Root}
+	*   New tree.
+	*/
+	return function(tree, file) {
+		return raw(tree, {
+			...options,
+			file
+		});
+	};
+}
+//#endregion
+export { rehypeRaw as t };

package/.output/server/_libs/rehype-sanitize.mjs

@@ -0,0 +1,27 @@
+import { t as sanitize } from "./hast-util-sanitize.mjs";
+//#region node_modules/.pnpm/rehype-sanitize@6.0.0/node_modules/rehype-sanitize/lib/index.js
+/**
+* @typedef {import('hast').Root} Root
+* @typedef {import('hast-util-sanitize').Schema} Schema
+*/
+/**
+* Sanitize HTML.
+*
+* @param {Schema | null | undefined} [options]
+*   Configuration (optional).
+* @returns
+*   Transform.
+*/
+function rehypeSanitize(options) {
+	/**
+	* @param {Root} tree
+	*   Tree.
+	* @returns {Root}
+	*   New tree.
+	*/
+	return function(tree) {
+		return sanitize(tree, options);
+	};
+}
+//#endregion
+export { rehypeSanitize as t };