palettecn 0.1.0

package/dist/web/server/_libs/hast-util-raw+[...].mjs

@@ -0,0 +1,800 @@
+import { _ as htmlVoidElements, d as zwitch, f as html, l as stringify, m as find, p as svg, s as stringify$1 } from "./@shikijs/core+[...].mjs";
+import { C as fromParse5, E as visit, S as TokenType, b as TokenizerMode, w as webNamespaces, x as getTagID, y as Parser } from "./@streamdown/math+[...].mjs";
+import { t as esm_default } from "./ungap__structured-clone.mjs";
+//#region ../../node_modules/.pnpm/hast-util-to-parse5@8.0.1/node_modules/hast-util-to-parse5/lib/index.js
+/**
+* @import {Comment, Doctype, Element, Nodes, RootContent, Root, Text} from 'hast'
+* @import {DefaultTreeAdapterMap, Token} from 'parse5'
+* @import {Schema} from 'property-information'
+*/
+/**
+* @typedef {DefaultTreeAdapterMap['document']} Parse5Document
+* @typedef {DefaultTreeAdapterMap['documentFragment']} Parse5Fragment
+* @typedef {DefaultTreeAdapterMap['element']} Parse5Element
+* @typedef {DefaultTreeAdapterMap['node']} Parse5Nodes
+* @typedef {DefaultTreeAdapterMap['documentType']} Parse5Doctype
+* @typedef {DefaultTreeAdapterMap['commentNode']} Parse5Comment
+* @typedef {DefaultTreeAdapterMap['textNode']} Parse5Text
+* @typedef {DefaultTreeAdapterMap['parentNode']} Parse5Parent
+* @typedef {Token.Attribute} Parse5Attribute
+*
+* @typedef Options
+*   Configuration.
+* @property {Space | null | undefined} [space='html']
+*   Which space the document is in (default: `'html'`).
+*
+*   When an `<svg>` element is found in the HTML space, this package already
+*   automatically switches to and from the SVG space when entering and exiting
+*   it.
+*
+* @typedef {Exclude<Parse5Nodes, Parse5Document | Parse5Fragment>} Parse5Content
+*
+* @typedef {'html' | 'svg'} Space
+*/
+/** @type {Options} */
+var emptyOptions = {};
+var own = {}.hasOwnProperty;
+var one = zwitch("type", { handlers: {
+	root: root$1,
+	element: element$1,
+	text: text$1,
+	comment: comment$1,
+	doctype: doctype$1
+} });
+/**
+* Transform a hast tree to a `parse5` AST.
+*
+* @param {Nodes} tree
+*   Tree to transform.
+* @param {Options | null | undefined} [options]
+*   Configuration (optional).
+* @returns {Parse5Nodes}
+*   `parse5` node.
+*/
+function toParse5(tree, options) {
+	const space = (options || emptyOptions).space;
+	return one(tree, space === "svg" ? svg : html);
+}
+/**
+* @param {Root} node
+*   Node (hast) to transform.
+* @param {Schema} schema
+*   Current schema.
+* @returns {Parse5Document}
+*   Parse5 node.
+*/
+function root$1(node, schema) {
+	/** @type {Parse5Document} */
+	const result = {
+		nodeName: "#document",
+		mode: (node.data || {}).quirksMode ? "quirks" : "no-quirks",
+		childNodes: []
+	};
+	result.childNodes = all$1(node.children, result, schema);
+	patch(node, result);
+	return result;
+}
+/**
+* @param {Root} node
+*   Node (hast) to transform.
+* @param {Schema} schema
+*   Current schema.
+* @returns {Parse5Fragment}
+*   Parse5 node.
+*/
+function fragment(node, schema) {
+	/** @type {Parse5Fragment} */
+	const result = {
+		nodeName: "#document-fragment",
+		childNodes: []
+	};
+	result.childNodes = all$1(node.children, result, schema);
+	patch(node, result);
+	return result;
+}
+/**
+* @param {Doctype} node
+*   Node (hast) to transform.
+* @returns {Parse5Doctype}
+*   Parse5 node.
+*/
+function doctype$1(node) {
+	/** @type {Parse5Doctype} */
+	const result = {
+		nodeName: "#documentType",
+		name: "html",
+		publicId: "",
+		systemId: "",
+		parentNode: null
+	};
+	patch(node, result);
+	return result;
+}
+/**
+* @param {Text} node
+*   Node (hast) to transform.
+* @returns {Parse5Text}
+*   Parse5 node.
+*/
+function text$1(node) {
+	/** @type {Parse5Text} */
+	const result = {
+		nodeName: "#text",
+		value: node.value,
+		parentNode: null
+	};
+	patch(node, result);
+	return result;
+}
+/**
+* @param {Comment} node
+*   Node (hast) to transform.
+* @returns {Parse5Comment}
+*   Parse5 node.
+*/
+function comment$1(node) {
+	/** @type {Parse5Comment} */
+	const result = {
+		nodeName: "#comment",
+		data: node.value,
+		parentNode: null
+	};
+	patch(node, result);
+	return result;
+}
+/**
+* @param {Element} node
+*   Node (hast) to transform.
+* @param {Schema} schema
+*   Current schema.
+* @returns {Parse5Element}
+*   Parse5 node.
+*/
+function element$1(node, schema) {
+	const parentSchema = schema;
+	let currentSchema = parentSchema;
+	if (node.type === "element" && node.tagName.toLowerCase() === "svg" && parentSchema.space === "html") currentSchema = svg;
+	/** @type {Array<Parse5Attribute>} */
+	const attrs = [];
+	/** @type {string} */
+	let prop;
+	if (node.properties) {
+		for (prop in node.properties) if (prop !== "children" && own.call(node.properties, prop)) {
+			const result = createProperty(currentSchema, prop, node.properties[prop]);
+			if (result) attrs.push(result);
+		}
+	}
+	const space = currentSchema.space;
+	/** @type {Parse5Element} */
+	const result = {
+		nodeName: node.tagName,
+		tagName: node.tagName,
+		attrs,
+		namespaceURI: webNamespaces[space],
+		childNodes: [],
+		parentNode: null
+	};
+	result.childNodes = all$1(node.children, result, currentSchema);
+	patch(node, result);
+	if (node.tagName === "template" && node.content) result.content = fragment(node.content, currentSchema);
+	return result;
+}
+/**
+* Handle a property.
+*
+* @param {Schema} schema
+*   Current schema.
+* @param {string} prop
+*   Key.
+* @param {Array<number | string> | boolean | number | string | null | undefined} value
+*   hast property value.
+* @returns {Parse5Attribute | undefined}
+*   Field for runtime, optional.
+*/
+function createProperty(schema, prop, value) {
+	const info = find(schema, prop);
+	if (value === false || value === null || value === void 0 || typeof value === "number" && Number.isNaN(value) || !value && info.boolean) return;
+	if (Array.isArray(value)) value = info.commaSeparated ? stringify(value) : stringify$1(value);
+	/** @type {Parse5Attribute} */
+	const attribute = {
+		name: info.attribute,
+		value: value === true ? "" : String(value)
+	};
+	if (info.space && info.space !== "html" && info.space !== "svg") {
+		const index = attribute.name.indexOf(":");
+		if (index < 0) attribute.prefix = "";
+		else {
+			attribute.name = attribute.name.slice(index + 1);
+			attribute.prefix = info.attribute.slice(0, index);
+		}
+		attribute.namespace = webNamespaces[info.space];
+	}
+	return attribute;
+}
+/**
+* Transform all hast nodes.
+*
+* @param {Array<RootContent>} children
+*   List of children.
+* @param {Parse5Parent} parentNode
+*   `parse5` parent node.
+* @param {Schema} schema
+*   Current schema.
+* @returns {Array<Parse5Content>}
+*   Transformed children.
+*/
+function all$1(children, parentNode, schema) {
+	let index = -1;
+	/** @type {Array<Parse5Content>} */
+	const results = [];
+	if (children) while (++index < children.length) {
+		/** @type {Parse5Content} */
+		const child = one(children[index], schema);
+		child.parentNode = parentNode;
+		results.push(child);
+	}
+	return results;
+}
+/**
+* Add position info from `from` to `to`.
+*
+* @param {Nodes} from
+*   hast node.
+* @param {Parse5Nodes} to
+*   `parse5` node.
+* @returns {undefined}
+*   Nothing.
+*/
+function patch(from, to) {
+	const position = from.position;
+	if (position && position.start && position.end) {
+		position.start.offset;
+		position.end.offset;
+		to.sourceCodeLocation = {
+			startLine: position.start.line,
+			startCol: position.start.column,
+			startOffset: position.start.offset,
+			endLine: position.end.line,
+			endCol: position.end.column,
+			endOffset: position.end.offset
+		};
+	}
+}
+//#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("end");
+/**
+* Get the starting point of `node`.
+*
+* @param node
+*   Node.
+* @returns
+*   Point.
+*/
+var pointStart = point("start");
+/**
+* Get the positional info of `node`.
+*
+* @param {'end' | 'start'} type
+*   Side.
+* @returns
+*   Getter.
+*/
+function point(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(node) {
+	const start = pointStart(node);
+	const end = pointEnd(node);
+	if (start && end) return {
+		start,
+		end
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/hast-util-raw@9.1.0/node_modules/hast-util-raw/lib/index.js
+/**
+* @import {Options} from 'hast-util-raw'
+* @import {Comment, Doctype, Element, Nodes, RootContent, Root, Text} from 'hast'
+* @import {Raw} from 'mdast-util-to-hast'
+* @import {DefaultTreeAdapterMap, ParserOptions} from 'parse5'
+* @import {Point} from 'unist'
+*/
+/**
+* @typedef State
+*   Info passed around about the current state.
+* @property {(node: Nodes) => undefined} handle
+*   Add a hast node to the parser.
+* @property {Options} options
+*   User configuration.
+* @property {Parser<DefaultTreeAdapterMap>} parser
+*   Current parser.
+* @property {boolean} stitches
+*   Whether there are stitches.
+*/
+/**
+* @typedef Stitch
+*   Custom comment-like value we pass through parse5, which contains a
+*   replacement node that we’ll swap back in afterwards.
+* @property {'comment'} type
+*   Node type.
+* @property {{stitch: Nodes}} value
+*   Replacement value.
+*/
+var gfmTagfilterExpression = /<(\/?)(iframe|noembed|noframes|plaintext|script|style|textarea|title|xmp)(?=[\t\n\f\r />])/gi;
+var knownMdxNames = new Set([
+	"mdxFlowExpression",
+	"mdxJsxFlowElement",
+	"mdxJsxTextElement",
+	"mdxTextExpression",
+	"mdxjsEsm"
+]);
+/** @type {ParserOptions<DefaultTreeAdapterMap>} */
+var parseOptions = {
+	sourceCodeLocationInfo: true,
+	scriptingEnabled: false
+};
+/**
+* Pass a hast tree through an HTML parser, which will fix nesting, and turn
+* raw nodes into actual nodes.
+*
+* @param {Nodes} tree
+*   Original hast tree to transform.
+* @param {Options | null | undefined} [options]
+*   Configuration (optional).
+* @returns {Nodes}
+*   Parsed again tree.
+*/
+function raw(tree, options) {
+	const document = documentMode(tree);
+	/** @type {(node: Nodes, state: State) => undefined} */
+	const one = zwitch("type", {
+		handlers: {
+			root,
+			element,
+			text,
+			comment,
+			doctype,
+			raw: handleRaw
+		},
+		unknown
+	});
+	/** @type {State} */
+	const state = {
+		parser: document ? new Parser(parseOptions) : Parser.getFragmentParser(void 0, parseOptions),
+		handle(node) {
+			one(node, state);
+		},
+		stitches: false,
+		options: options || {}
+	};
+	one(tree, state);
+	resetTokenizer(state, pointStart());
+	const result = fromParse5(document ? state.parser.document : state.parser.getFragment(), { file: state.options.file });
+	if (state.stitches) visit(result, "comment", function(node, index, parent) {
+		const stitch = node;
+		if (stitch.value.stitch && parent && index !== void 0) {
+			/** @type {Array<RootContent>} */
+			const siblings = parent.children;
+			siblings[index] = stitch.value.stitch;
+			return index;
+		}
+	});
+	if (result.type === "root" && result.children.length === 1 && result.children[0].type === tree.type) return result.children[0];
+	return result;
+}
+/**
+* Transform all nodes
+*
+* @param {Array<RootContent>} nodes
+*   hast content.
+* @param {State} state
+*   Info passed around about the current state.
+* @returns {undefined}
+*   Nothing.
+*/
+function all(nodes, state) {
+	let index = -1;
+	/* istanbul ignore else - invalid nodes, see rehypejs/rehype-raw#7. */
+	if (nodes) while (++index < nodes.length) state.handle(nodes[index]);
+}
+/**
+* Transform a root.
+*
+* @param {Root} node
+*   hast root node.
+* @param {State} state
+*   Info passed around about the current state.
+* @returns {undefined}
+*   Nothing.
+*/
+function root(node, state) {
+	all(node.children, state);
+}
+/**
+* Transform an element.
+*
+* @param {Element} node
+*   hast element node.
+* @param {State} state
+*   Info passed around about the current state.
+* @returns {undefined}
+*   Nothing.
+*/
+function element(node, state) {
+	startTag(node, state);
+	all(node.children, state);
+	endTag(node, state);
+}
+/**
+* Transform a text.
+*
+* @param {Text} node
+*   hast text node.
+* @param {State} state
+*   Info passed around about the current state.
+* @returns {undefined}
+*   Nothing.
+*/
+function text(node, state) {
+	if (state.parser.tokenizer.state > 4) state.parser.tokenizer.state = 0;
+	/** @type {Token.CharacterToken} */
+	const token = {
+		type: TokenType.CHARACTER,
+		chars: node.value,
+		location: createParse5Location(node)
+	};
+	resetTokenizer(state, pointStart(node));
+	state.parser.currentToken = token;
+	state.parser._processToken(state.parser.currentToken);
+}
+/**
+* Transform a doctype.
+*
+* @param {Doctype} node
+*   hast doctype node.
+* @param {State} state
+*   Info passed around about the current state.
+* @returns {undefined}
+*   Nothing.
+*/
+function doctype(node, state) {
+	/** @type {Token.DoctypeToken} */
+	const token = {
+		type: TokenType.DOCTYPE,
+		name: "html",
+		forceQuirks: false,
+		publicId: "",
+		systemId: "",
+		location: createParse5Location(node)
+	};
+	resetTokenizer(state, pointStart(node));
+	state.parser.currentToken = token;
+	state.parser._processToken(state.parser.currentToken);
+}
+/**
+* Transform a stitch.
+*
+* @param {Nodes} node
+*   unknown node.
+* @param {State} state
+*   Info passed around about the current state.
+* @returns {undefined}
+*   Nothing.
+*/
+function stitch(node, state) {
+	state.stitches = true;
+	/** @type {Nodes} */
+	const clone = cloneWithoutChildren(node);
+	if ("children" in node && "children" in clone) clone.children = raw({
+		type: "root",
+		children: node.children
+	}, state.options).children;
+	comment({
+		type: "comment",
+		value: { stitch: clone }
+	}, state);
+}
+/**
+* Transform a comment (or stitch).
+*
+* @param {Comment | Stitch} node
+*   hast comment node.
+* @param {State} state
+*   Info passed around about the current state.
+* @returns {undefined}
+*   Nothing.
+*/
+function comment(node, state) {
+	/** @type {string} */
+	const data = node.value;
+	/** @type {Token.CommentToken} */
+	const token = {
+		type: TokenType.COMMENT,
+		data,
+		location: createParse5Location(node)
+	};
+	resetTokenizer(state, pointStart(node));
+	state.parser.currentToken = token;
+	state.parser._processToken(state.parser.currentToken);
+}
+/**
+* Transform a raw node.
+*
+* @param {Raw} node
+*   hast raw node.
+* @param {State} state
+*   Info passed around about the current state.
+* @returns {undefined}
+*   Nothing.
+*/
+function handleRaw(node, state) {
+	state.parser.tokenizer.preprocessor.html = "";
+	state.parser.tokenizer.preprocessor.pos = -1;
+	state.parser.tokenizer.preprocessor.lastGapPos = -2;
+	state.parser.tokenizer.preprocessor.gapStack = [];
+	state.parser.tokenizer.preprocessor.skipNextNewLine = false;
+	state.parser.tokenizer.preprocessor.lastChunkWritten = false;
+	state.parser.tokenizer.preprocessor.endOfChunkHit = false;
+	state.parser.tokenizer.preprocessor.isEol = false;
+	setPoint(state, pointStart(node));
+	state.parser.tokenizer.write(state.options.tagfilter ? node.value.replace(gfmTagfilterExpression, "&lt;$1$2") : node.value, false);
+	state.parser.tokenizer._runParsingLoop();
+	/* c8 ignore next 12 -- removed in <https://github.com/inikulin/parse5/pull/897> */
+	if (state.parser.tokenizer.state === 72 || state.parser.tokenizer.state === 78) {
+		state.parser.tokenizer.preprocessor.lastChunkWritten = true;
+		/** @type {number} */
+		const cp = state.parser.tokenizer._consume();
+		state.parser.tokenizer._callState(cp);
+	}
+}
+/**
+* Crash on an unknown node.
+*
+* @param {unknown} node_
+*   unknown node.
+* @param {State} state
+*   Info passed around about the current state.
+* @returns {undefined}
+*   Never.
+*/
+function unknown(node_, state) {
+	const node = node_;
+	if (state.options.passThrough && state.options.passThrough.includes(node.type)) stitch(node, state);
+	else {
+		let extra = "";
+		if (knownMdxNames.has(node.type)) extra = ". It looks like you are using MDX nodes with `hast-util-raw` (or `rehype-raw`). If you use this because you are using remark or rehype plugins that inject `'html'` nodes, then please raise an issue with that plugin, as its a bad and slow idea. If you use this because you are using markdown syntax, then you have to configure this utility (or plugin) to pass through these nodes (see `passThrough` in docs), but you can also migrate to use the MDX syntax";
+		throw new Error("Cannot compile `" + node.type + "` node" + extra);
+	}
+}
+/**
+* Reset the tokenizer of a parser.
+*
+* @param {State} state
+*   Info passed around about the current state.
+* @param {Point | undefined} point
+*   Point.
+* @returns {undefined}
+*   Nothing.
+*/
+function resetTokenizer(state, point) {
+	setPoint(state, point);
+	/** @type {Token.CharacterToken} */
+	const token = state.parser.tokenizer.currentCharacterToken;
+	if (token && token.location) {
+		token.location.endLine = state.parser.tokenizer.preprocessor.line;
+		token.location.endCol = state.parser.tokenizer.preprocessor.col + 1;
+		token.location.endOffset = state.parser.tokenizer.preprocessor.offset + 1;
+		state.parser.currentToken = token;
+		state.parser._processToken(state.parser.currentToken);
+	}
+	state.parser.tokenizer.paused = false;
+	state.parser.tokenizer.inLoop = false;
+	state.parser.tokenizer.active = false;
+	state.parser.tokenizer.returnState = TokenizerMode.DATA;
+	state.parser.tokenizer.charRefCode = -1;
+	state.parser.tokenizer.consumedAfterSnapshot = -1;
+	state.parser.tokenizer.currentLocation = null;
+	state.parser.tokenizer.currentCharacterToken = null;
+	state.parser.tokenizer.currentToken = null;
+	state.parser.tokenizer.currentAttr = {
+		name: "",
+		value: ""
+	};
+}
+/**
+* Set current location.
+*
+* @param {State} state
+*   Info passed around about the current state.
+* @param {Point | undefined} point
+*   Point.
+* @returns {undefined}
+*   Nothing.
+*/
+function setPoint(state, point) {
+	if (point && point.offset !== void 0) {
+		/** @type {Token.Location} */
+		const location = {
+			startLine: point.line,
+			startCol: point.column,
+			startOffset: point.offset,
+			endLine: -1,
+			endCol: -1,
+			endOffset: -1
+		};
+		state.parser.tokenizer.preprocessor.lineStartPos = -point.column + 1;
+		state.parser.tokenizer.preprocessor.droppedBufferSize = point.offset;
+		state.parser.tokenizer.preprocessor.line = point.line;
+		state.parser.tokenizer.currentLocation = location;
+	}
+}
+/**
+* Emit a start tag.
+*
+* @param {Element} node
+*   Element.
+* @param {State} state
+*   Info passed around about the current state.
+* @returns {undefined}
+*   Nothing.
+*/
+function startTag(node, state) {
+	const tagName = node.tagName.toLowerCase();
+	if (state.parser.tokenizer.state === TokenizerMode.PLAINTEXT) return;
+	resetTokenizer(state, pointStart(node));
+	const current = state.parser.openElements.current;
+	let ns = "namespaceURI" in current ? current.namespaceURI : webNamespaces.html;
+	if (ns === webNamespaces.html && tagName === "svg") ns = webNamespaces.svg;
+	const result = toParse5({
+		...node,
+		children: []
+	}, { space: ns === webNamespaces.svg ? "svg" : "html" });
+	/** @type {Token.TagToken} */
+	const tag = {
+		type: TokenType.START_TAG,
+		tagName,
+		tagID: getTagID(tagName),
+		selfClosing: false,
+		ackSelfClosing: false,
+		attrs: "attrs" in result ? result.attrs : [],
+		location: createParse5Location(node)
+	};
+	state.parser.currentToken = tag;
+	state.parser._processToken(state.parser.currentToken);
+	state.parser.tokenizer.lastStartTagName = tagName;
+}
+/**
+* Emit an end tag.
+*
+* @param {Element} node
+*   Element.
+* @param {State} state
+*   Info passed around about the current state.
+* @returns {undefined}
+*   Nothing.
+*/
+function endTag(node, state) {
+	const tagName = node.tagName.toLowerCase();
+	if (!state.parser.tokenizer.inForeignNode && htmlVoidElements.includes(tagName)) return;
+	if (state.parser.tokenizer.state === TokenizerMode.PLAINTEXT) return;
+	resetTokenizer(state, pointEnd(node));
+	/** @type {Token.TagToken} */
+	const tag = {
+		type: TokenType.END_TAG,
+		tagName,
+		tagID: getTagID(tagName),
+		selfClosing: false,
+		ackSelfClosing: false,
+		attrs: [],
+		location: createParse5Location(node)
+	};
+	state.parser.currentToken = tag;
+	state.parser._processToken(state.parser.currentToken);
+	if (tagName === state.parser.tokenizer.lastStartTagName && (state.parser.tokenizer.state === TokenizerMode.RCDATA || state.parser.tokenizer.state === TokenizerMode.RAWTEXT || state.parser.tokenizer.state === TokenizerMode.SCRIPT_DATA)) state.parser.tokenizer.state = TokenizerMode.DATA;
+}
+/**
+* Check if `node` represents a whole document or a fragment.
+*
+* @param {Nodes} node
+*   hast node.
+* @returns {boolean}
+*   Whether this represents a whole document or a fragment.
+*/
+function documentMode(node) {
+	const head = node.type === "root" ? node.children[0] : node;
+	return Boolean(head && (head.type === "doctype" || head.type === "element" && head.tagName.toLowerCase() === "html"));
+}
+/**
+* Get a `parse5` location from a node.
+*
+* @param {Nodes | Stitch} node
+*   hast node.
+* @returns {Token.Location}
+*   `parse5` location.
+*/
+function createParse5Location(node) {
+	const start = pointStart(node) || {
+		line: void 0,
+		column: void 0,
+		offset: void 0
+	};
+	const end = pointEnd(node) || {
+		line: void 0,
+		column: void 0,
+		offset: void 0
+	};
+	return {
+		startLine: start.line,
+		startCol: start.column,
+		startOffset: start.offset,
+		endLine: end.line,
+		endCol: end.column,
+		endOffset: end.offset
+	};
+}
+/**
+* @template {Nodes} NodeType
+*   Node type.
+* @param {NodeType} node
+*   Node to clone.
+* @returns {NodeType}
+*   Cloned node, without children.
+*/
+function cloneWithoutChildren(node) {
+	return "children" in node ? esm_default({
+		...node,
+		children: []
+	}) : esm_default(node);
+}
+//#endregion
+export { position as i, pointEnd as n, pointStart as r, raw as t };