palettecn 0.1.0

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

@@ -0,0 +1,853 @@
+import { i as __toESM, t as __commonJSMin } from "../_runtime.mjs";
+import { a as whitespace, f as html, h as hastToReact, l as stringify, m as find, p as svg, s as stringify$1 } from "./@shikijs/core+[...].mjs";
+import { _ as VFileMessage } from "./@streamdown/math+[...].mjs";
+import { r as pointStart } from "./hast-util-raw+[...].mjs";
+import { t as name } from "./estree-util-is-identifier-name.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;
+	var NEWLINE_REGEX = /\n/g;
+	var WHITESPACE_REGEX = /^\s*/;
+	var PROPERTY_REGEX = /^(\*?[-#/*\\\w]+(\[[0-9a-z_-]+\])?)\s*/;
+	var COLON_REGEX = /^:\s*/;
+	var VALUE_REGEX = /^((?:'(?:\\'|.)*?'|"(?:\\"|.)*?"|\([^)]*?\)|[^};])+)/;
+	var SEMICOLON_REGEX = /^[;\s]*/;
+	var TRIM_REGEX = /^\s+|\s+$/g;
+	var NEWLINE = "\n";
+	var FORWARD_SLASH = "/";
+	var ASTERISK = "*";
+	var EMPTY_STRING = "";
+	var TYPE_COMMENT = "comment";
+	var TYPE_DECLARATION = "declaration";
+	/**
+	* @param {String} style
+	* @param {Object} [options]
+	* @return {Object[]}
+	* @throws {TypeError}
+	* @throws {Error}
+	*/
+	function index(style, options) {
+		if (typeof style !== "string") throw new TypeError("First argument must be a string");
+		if (!style) return [];
+		options = options || {};
+		/**
+		* Positional.
+		*/
+		var lineno = 1;
+		var column = 1;
+		/**
+		* Update lineno and column based on `str`.
+		*
+		* @param {String} str
+		*/
+		function updatePosition(str) {
+			var lines = str.match(NEWLINE_REGEX);
+			if (lines) lineno += lines.length;
+			var i = str.lastIndexOf(NEWLINE);
+			column = ~i ? str.length - i : column + str.length;
+		}
+		/**
+		* Mark position and patch `node.position`.
+		*
+		* @return {Function}
+		*/
+		function position() {
+			var start = {
+				line: lineno,
+				column
+			};
+			return function(node) {
+				node.position = new Position(start);
+				whitespace();
+				return node;
+			};
+		}
+		/**
+		* Store position information for a node.
+		*
+		* @constructor
+		* @property {Object} start
+		* @property {Object} end
+		* @property {undefined|String} source
+		*/
+		function Position(start) {
+			this.start = start;
+			this.end = {
+				line: lineno,
+				column
+			};
+			this.source = options.source;
+		}
+		/**
+		* Non-enumerable source string.
+		*/
+		Position.prototype.content = style;
+		/**
+		* Error `msg`.
+		*
+		* @param {String} msg
+		* @throws {Error}
+		*/
+		function error(msg) {
+			var err = /* @__PURE__ */ new Error(options.source + ":" + lineno + ":" + column + ": " + msg);
+			err.reason = msg;
+			err.filename = options.source;
+			err.line = lineno;
+			err.column = column;
+			err.source = style;
+			if (options.silent);
+			else throw err;
+		}
+		/**
+		* Match `re` and return captures.
+		*
+		* @param {RegExp} re
+		* @return {undefined|Array}
+		*/
+		function match(re) {
+			var m = re.exec(style);
+			if (!m) return;
+			var str = m[0];
+			updatePosition(str);
+			style = style.slice(str.length);
+			return m;
+		}
+		/**
+		* Parse whitespace.
+		*/
+		function whitespace() {
+			match(WHITESPACE_REGEX);
+		}
+		/**
+		* Parse comments.
+		*
+		* @param {Object[]} [rules]
+		* @return {Object[]}
+		*/
+		function comments(rules) {
+			var c;
+			rules = rules || [];
+			while (c = comment()) if (c !== false) rules.push(c);
+			return rules;
+		}
+		/**
+		* Parse comment.
+		*
+		* @return {Object}
+		* @throws {Error}
+		*/
+		function comment() {
+			var pos = position();
+			if (FORWARD_SLASH != style.charAt(0) || ASTERISK != style.charAt(1)) return;
+			var i = 2;
+			while (EMPTY_STRING != style.charAt(i) && (ASTERISK != style.charAt(i) || FORWARD_SLASH != style.charAt(i + 1))) ++i;
+			i += 2;
+			if (EMPTY_STRING === style.charAt(i - 1)) return error("End of comment missing");
+			var str = style.slice(2, i - 2);
+			column += 2;
+			updatePosition(str);
+			style = style.slice(i);
+			column += 2;
+			return pos({
+				type: TYPE_COMMENT,
+				comment: str
+			});
+		}
+		/**
+		* Parse declaration.
+		*
+		* @return {Object}
+		* @throws {Error}
+		*/
+		function declaration() {
+			var pos = position();
+			var prop = match(PROPERTY_REGEX);
+			if (!prop) return;
+			comment();
+			if (!match(COLON_REGEX)) return error("property missing ':'");
+			var val = match(VALUE_REGEX);
+			var ret = pos({
+				type: TYPE_DECLARATION,
+				property: trim(prop[0].replace(COMMENT_REGEX, EMPTY_STRING)),
+				value: val ? trim(val[0].replace(COMMENT_REGEX, EMPTY_STRING)) : EMPTY_STRING
+			});
+			match(SEMICOLON_REGEX);
+			return ret;
+		}
+		/**
+		* Parse declarations.
+		*
+		* @return {Object[]}
+		*/
+		function declarations() {
+			var decls = [];
+			comments(decls);
+			var decl;
+			while (decl = declaration()) if (decl !== false) {
+				decls.push(decl);
+				comments(decls);
+			}
+			return decls;
+		}
+		whitespace();
+		return declarations();
+	}
+	/**
+	* Trim `str`.
+	*
+	* @param {String} str
+	* @return {String}
+	*/
+	function trim(str) {
+		return str ? str.replace(TRIM_REGEX, EMPTY_STRING) : EMPTY_STRING;
+	}
+	module.exports = index;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/style-to-object@1.0.14/node_modules/style-to-object/cjs/index.js
+var require_cjs$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var __importDefault = exports && exports.__importDefault || function(mod) {
+		return mod && mod.__esModule ? mod : { "default": mod };
+	};
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.default = StyleToObject;
+	var inline_style_parser_1 = __importDefault(require_cjs$2());
+	/**
+	* Parses inline style to object.
+	*
+	* @param style - Inline style.
+	* @param iterator - Iterator.
+	* @returns - Style object or null.
+	*
+	* @example Parsing inline style to object:
+	*
+	* ```js
+	* import parse from 'style-to-object';
+	* parse('line-height: 42;'); // { 'line-height': '42' }
+	* ```
+	*/
+	function StyleToObject(style, iterator) {
+		let styleObject = null;
+		if (!style || typeof style !== "string") return styleObject;
+		const declarations = (0, inline_style_parser_1.default)(style);
+		const hasIterator = typeof iterator === "function";
+		declarations.forEach((declaration) => {
+			if (declaration.type !== "declaration") return;
+			const { property, value } = declaration;
+			if (hasIterator) iterator(property, value, declaration);
+			else if (value) {
+				styleObject = styleObject || {};
+				styleObject[property] = value;
+			}
+		});
+		return styleObject;
+	}
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/style-to-js@1.1.21/node_modules/style-to-js/cjs/utilities.js
+var require_utilities = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.camelCase = void 0;
+	var CUSTOM_PROPERTY_REGEX = /^--[a-zA-Z0-9_-]+$/;
+	var HYPHEN_REGEX = /-([a-z])/g;
+	var NO_HYPHEN_REGEX = /^[^-]+$/;
+	var VENDOR_PREFIX_REGEX = /^-(webkit|moz|ms|o|khtml)-/;
+	var MS_VENDOR_PREFIX_REGEX = /^-(ms)-/;
+	/**
+	* Checks whether to skip camelCase.
+	*/
+	var skipCamelCase = function(property) {
+		return !property || NO_HYPHEN_REGEX.test(property) || CUSTOM_PROPERTY_REGEX.test(property);
+	};
+	/**
+	* Replacer that capitalizes first character.
+	*/
+	var capitalize = function(match, character) {
+		return character.toUpperCase();
+	};
+	/**
+	* Replacer that removes beginning hyphen of vendor prefix property.
+	*/
+	var trimHyphen = function(match, prefix) {
+		return "".concat(prefix, "-");
+	};
+	/**
+	* CamelCases a CSS property.
+	*/
+	var camelCase = function(property, options) {
+		if (options === void 0) options = {};
+		if (skipCamelCase(property)) return property;
+		property = property.toLowerCase();
+		if (options.reactCompat) property = property.replace(MS_VENDOR_PREFIX_REGEX, trimHyphen);
+		else property = property.replace(VENDOR_PREFIX_REGEX, trimHyphen);
+		return property.replace(HYPHEN_REGEX, capitalize);
+	};
+	exports.camelCase = camelCase;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/hast-util-to-jsx-runtime@2.3.6/node_modules/hast-util-to-jsx-runtime/lib/index.js
+/**
+* @import {Identifier, Literal, MemberExpression} from 'estree'
+* @import {Jsx, JsxDev, Options, Props} from 'hast-util-to-jsx-runtime'
+* @import {Element, Nodes, Parents, Root, Text} from 'hast'
+* @import {MdxFlowExpressionHast, MdxTextExpressionHast} from 'mdast-util-mdx-expression'
+* @import {MdxJsxFlowElementHast, MdxJsxTextElementHast} from 'mdast-util-mdx-jsx'
+* @import {MdxjsEsmHast} from 'mdast-util-mdxjs-esm'
+* @import {Position} from 'unist'
+* @import {Child, Create, Field, JsxElement, State, Style} from './types.js'
+*/
+var import_cjs = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var style_to_object_1 = (exports && exports.__importDefault || function(mod) {
+		return mod && mod.__esModule ? mod : { "default": mod };
+	})(require_cjs$1());
+	var utilities_1 = require_utilities();
+	/**
+	* Parses CSS inline style to JavaScript object (camelCased).
+	*/
+	function StyleToJS(style, options) {
+		var output = {};
+		if (!style || typeof style !== "string") return output;
+		(0, style_to_object_1.default)(style, function(property, value) {
+			if (property && value) output[(0, utilities_1.camelCase)(property, options)] = value;
+		});
+		return output;
+	}
+	StyleToJS.default = StyleToJS;
+	module.exports = StyleToJS;
+})))(), 1);
+var own = {}.hasOwnProperty;
+/** @type {Map<string, number>} */
+var emptyMap = /* @__PURE__ */ new Map();
+var cap = /[A-Z]/g;
+var tableElements = new Set([
+	"table",
+	"tbody",
+	"thead",
+	"tfoot",
+	"tr"
+]);
+var tableCellElement = new Set(["td", "th"]);
+var docs = "https://github.com/syntax-tree/hast-util-to-jsx-runtime";
+/**
+* Transform a hast tree to preact, react, solid, svelte, vue, etc.,
+* with an automatic JSX runtime.
+*
+* @param {Nodes} tree
+*   Tree to transform.
+* @param {Options} options
+*   Configuration (required).
+* @returns {JsxElement}
+*   JSX element.
+*/
+function toJsxRuntime(tree, options) {
+	if (!options || options.Fragment === void 0) throw new TypeError("Expected `Fragment` in options");
+	const filePath = options.filePath || void 0;
+	/** @type {Create} */
+	let create;
+	if (options.development) {
+		if (typeof options.jsxDEV !== "function") throw new TypeError("Expected `jsxDEV` in options when `development: true`");
+		create = developmentCreate(filePath, options.jsxDEV);
+	} else {
+		if (typeof options.jsx !== "function") throw new TypeError("Expected `jsx` in production options");
+		if (typeof options.jsxs !== "function") throw new TypeError("Expected `jsxs` in production options");
+		create = productionCreate(filePath, options.jsx, options.jsxs);
+	}
+	/** @type {State} */
+	const state = {
+		Fragment: options.Fragment,
+		ancestors: [],
+		components: options.components || {},
+		create,
+		elementAttributeNameCase: options.elementAttributeNameCase || "react",
+		evaluater: options.createEvaluater ? options.createEvaluater() : void 0,
+		filePath,
+		ignoreInvalidStyle: options.ignoreInvalidStyle || false,
+		passKeys: options.passKeys !== false,
+		passNode: options.passNode || false,
+		schema: options.space === "svg" ? svg : html,
+		stylePropertyNameCase: options.stylePropertyNameCase || "dom",
+		tableCellAlignToStyle: options.tableCellAlignToStyle !== false
+	};
+	const result = one(state, tree, void 0);
+	if (result && typeof result !== "string") return result;
+	return state.create(tree, state.Fragment, { children: result || void 0 }, void 0);
+}
+/**
+* Transform a node.
+*
+* @param {State} state
+*   Info passed around.
+* @param {Nodes} node
+*   Current node.
+* @param {string | undefined} key
+*   Key.
+* @returns {Child | undefined}
+*   Child, optional.
+*/
+function one(state, node, key) {
+	if (node.type === "element") return element(state, node, key);
+	if (node.type === "mdxFlowExpression" || node.type === "mdxTextExpression") return mdxExpression(state, node);
+	if (node.type === "mdxJsxFlowElement" || node.type === "mdxJsxTextElement") return mdxJsxElement(state, node, key);
+	if (node.type === "mdxjsEsm") return mdxEsm(state, node);
+	if (node.type === "root") return root(state, node, key);
+	if (node.type === "text") return text(state, node);
+}
+/**
+* Handle element.
+*
+* @param {State} state
+*   Info passed around.
+* @param {Element} node
+*   Current node.
+* @param {string | undefined} key
+*   Key.
+* @returns {Child | undefined}
+*   Child, optional.
+*/
+function element(state, node, key) {
+	const parentSchema = state.schema;
+	let schema = parentSchema;
+	if (node.tagName.toLowerCase() === "svg" && parentSchema.space === "html") {
+		schema = svg;
+		state.schema = schema;
+	}
+	state.ancestors.push(node);
+	const type = findComponentFromName(state, node.tagName, false);
+	const props = createElementProps(state, node);
+	let children = createChildren(state, node);
+	if (tableElements.has(node.tagName)) children = children.filter(function(child) {
+		return typeof child === "string" ? !whitespace(child) : true;
+	});
+	addNode(state, props, type, node);
+	addChildren(props, children);
+	state.ancestors.pop();
+	state.schema = parentSchema;
+	return state.create(node, type, props, key);
+}
+/**
+* Handle MDX expression.
+*
+* @param {State} state
+*   Info passed around.
+* @param {MdxFlowExpressionHast | MdxTextExpressionHast} node
+*   Current node.
+* @returns {Child | undefined}
+*   Child, optional.
+*/
+function mdxExpression(state, node) {
+	if (node.data && node.data.estree && state.evaluater) {
+		const expression = node.data.estree.body[0];
+		expression.type;
+		return state.evaluater.evaluateExpression(expression.expression);
+	}
+	crashEstree(state, node.position);
+}
+/**
+* Handle MDX ESM.
+*
+* @param {State} state
+*   Info passed around.
+* @param {MdxjsEsmHast} node
+*   Current node.
+* @returns {Child | undefined}
+*   Child, optional.
+*/
+function mdxEsm(state, node) {
+	if (node.data && node.data.estree && state.evaluater) return state.evaluater.evaluateProgram(node.data.estree);
+	crashEstree(state, node.position);
+}
+/**
+* Handle MDX JSX.
+*
+* @param {State} state
+*   Info passed around.
+* @param {MdxJsxFlowElementHast | MdxJsxTextElementHast} node
+*   Current node.
+* @param {string | undefined} key
+*   Key.
+* @returns {Child | undefined}
+*   Child, optional.
+*/
+function mdxJsxElement(state, node, key) {
+	const parentSchema = state.schema;
+	let schema = parentSchema;
+	if (node.name === "svg" && parentSchema.space === "html") {
+		schema = svg;
+		state.schema = schema;
+	}
+	state.ancestors.push(node);
+	const type = node.name === null ? state.Fragment : findComponentFromName(state, node.name, true);
+	const props = createJsxElementProps(state, node);
+	const children = createChildren(state, node);
+	addNode(state, props, type, node);
+	addChildren(props, children);
+	state.ancestors.pop();
+	state.schema = parentSchema;
+	return state.create(node, type, props, key);
+}
+/**
+* Handle root.
+*
+* @param {State} state
+*   Info passed around.
+* @param {Root} node
+*   Current node.
+* @param {string | undefined} key
+*   Key.
+* @returns {Child | undefined}
+*   Child, optional.
+*/
+function root(state, node, key) {
+	/** @type {Props} */
+	const props = {};
+	addChildren(props, createChildren(state, node));
+	return state.create(node, state.Fragment, props, key);
+}
+/**
+* Handle text.
+*
+* @param {State} _
+*   Info passed around.
+* @param {Text} node
+*   Current node.
+* @returns {Child | undefined}
+*   Child, optional.
+*/
+function text(_, node) {
+	return node.value;
+}
+/**
+* Add `node` to props.
+*
+* @param {State} state
+*   Info passed around.
+* @param {Props} props
+*   Props.
+* @param {unknown} type
+*   Type.
+* @param {Element | MdxJsxFlowElementHast | MdxJsxTextElementHast} node
+*   Node.
+* @returns {undefined}
+*   Nothing.
+*/
+function addNode(state, props, type, node) {
+	if (typeof type !== "string" && type !== state.Fragment && state.passNode) props.node = node;
+}
+/**
+* Add children to props.
+*
+* @param {Props} props
+*   Props.
+* @param {Array<Child>} children
+*   Children.
+* @returns {undefined}
+*   Nothing.
+*/
+function addChildren(props, children) {
+	if (children.length > 0) {
+		const value = children.length > 1 ? children : children[0];
+		if (value) props.children = value;
+	}
+}
+/**
+* @param {string | undefined} _
+*   Path to file.
+* @param {Jsx} jsx
+*   Dynamic.
+* @param {Jsx} jsxs
+*   Static.
+* @returns {Create}
+*   Create a production element.
+*/
+function productionCreate(_, jsx, jsxs) {
+	return create;
+	/** @type {Create} */
+	function create(_, type, props, key) {
+		const fn = Array.isArray(props.children) ? jsxs : jsx;
+		return key ? fn(type, props, key) : fn(type, props);
+	}
+}
+/**
+* @param {string | undefined} filePath
+*   Path to file.
+* @param {JsxDev} jsxDEV
+*   Development.
+* @returns {Create}
+*   Create a development element.
+*/
+function developmentCreate(filePath, jsxDEV) {
+	return create;
+	/** @type {Create} */
+	function create(node, type, props, key) {
+		const isStaticChildren = Array.isArray(props.children);
+		const point = pointStart(node);
+		return jsxDEV(type, props, key, isStaticChildren, {
+			columnNumber: point ? point.column - 1 : void 0,
+			fileName: filePath,
+			lineNumber: point ? point.line : void 0
+		}, void 0);
+	}
+}
+/**
+* Create props from an element.
+*
+* @param {State} state
+*   Info passed around.
+* @param {Element} node
+*   Current element.
+* @returns {Props}
+*   Props.
+*/
+function createElementProps(state, node) {
+	/** @type {Props} */
+	const props = {};
+	/** @type {string | undefined} */
+	let alignValue;
+	/** @type {string} */
+	let prop;
+	for (prop in node.properties) if (prop !== "children" && own.call(node.properties, prop)) {
+		const result = createProperty(state, prop, node.properties[prop]);
+		if (result) {
+			const [key, value] = result;
+			if (state.tableCellAlignToStyle && key === "align" && typeof value === "string" && tableCellElement.has(node.tagName)) alignValue = value;
+			else props[key] = value;
+		}
+	}
+	if (alignValue) {
+		const style = props.style || (props.style = {});
+		style[state.stylePropertyNameCase === "css" ? "text-align" : "textAlign"] = alignValue;
+	}
+	return props;
+}
+/**
+* Create props from a JSX element.
+*
+* @param {State} state
+*   Info passed around.
+* @param {MdxJsxFlowElementHast | MdxJsxTextElementHast} node
+*   Current JSX element.
+* @returns {Props}
+*   Props.
+*/
+function createJsxElementProps(state, node) {
+	/** @type {Props} */
+	const props = {};
+	for (const attribute of node.attributes) if (attribute.type === "mdxJsxExpressionAttribute") if (attribute.data && attribute.data.estree && state.evaluater) {
+		const expression = attribute.data.estree.body[0];
+		expression.type;
+		const objectExpression = expression.expression;
+		objectExpression.type;
+		const property = objectExpression.properties[0];
+		property.type;
+		Object.assign(props, state.evaluater.evaluateExpression(property.argument));
+	} else crashEstree(state, node.position);
+	else {
+		const name = attribute.name;
+		/** @type {unknown} */
+		let value;
+		if (attribute.value && typeof attribute.value === "object") if (attribute.value.data && attribute.value.data.estree && state.evaluater) {
+			const expression = attribute.value.data.estree.body[0];
+			expression.type;
+			value = state.evaluater.evaluateExpression(expression.expression);
+		} else crashEstree(state, node.position);
+		else value = attribute.value === null ? true : attribute.value;
+		props[name] = value;
+	}
+	return props;
+}
+/**
+* Create children.
+*
+* @param {State} state
+*   Info passed around.
+* @param {Parents} node
+*   Current element.
+* @returns {Array<Child>}
+*   Children.
+*/
+function createChildren(state, node) {
+	/** @type {Array<Child>} */
+	const children = [];
+	let index = -1;
+	/** @type {Map<string, number>} */
+	/* c8 ignore next */
+	const countsByName = state.passKeys ? /* @__PURE__ */ new Map() : emptyMap;
+	while (++index < node.children.length) {
+		const child = node.children[index];
+		/** @type {string | undefined} */
+		let key;
+		if (state.passKeys) {
+			const name = child.type === "element" ? child.tagName : child.type === "mdxJsxFlowElement" || child.type === "mdxJsxTextElement" ? child.name : void 0;
+			if (name) {
+				const count = countsByName.get(name) || 0;
+				key = name + "-" + count;
+				countsByName.set(name, count + 1);
+			}
+		}
+		const result = one(state, child, key);
+		if (result !== void 0) children.push(result);
+	}
+	return children;
+}
+/**
+* Handle a property.
+*
+* @param {State} state
+*   Info passed around.
+* @param {string} prop
+*   Key.
+* @param {Array<number | string> | boolean | number | string | null | undefined} value
+*   hast property value.
+* @returns {Field | undefined}
+*   Field for runtime, optional.
+*/
+function createProperty(state, prop, value) {
+	const info = find(state.schema, prop);
+	if (value === null || value === void 0 || typeof value === "number" && Number.isNaN(value)) return;
+	if (Array.isArray(value)) value = info.commaSeparated ? stringify(value) : stringify$1(value);
+	if (info.property === "style") {
+		let styleObject = typeof value === "object" ? value : parseStyle(state, String(value));
+		if (state.stylePropertyNameCase === "css") styleObject = transformStylesToCssCasing(styleObject);
+		return ["style", styleObject];
+	}
+	return [state.elementAttributeNameCase === "react" && info.space ? hastToReact[info.property] || info.property : info.attribute, value];
+}
+/**
+* Parse a CSS declaration to an object.
+*
+* @param {State} state
+*   Info passed around.
+* @param {string} value
+*   CSS declarations.
+* @returns {Style}
+*   Properties.
+* @throws
+*   Throws `VFileMessage` when CSS cannot be parsed.
+*/
+function parseStyle(state, value) {
+	try {
+		return (0, import_cjs.default)(value, { reactCompat: true });
+	} catch (error) {
+		if (state.ignoreInvalidStyle) return {};
+		const cause = error;
+		const message = new VFileMessage("Cannot parse `style` attribute", {
+			ancestors: state.ancestors,
+			cause,
+			ruleId: "style",
+			source: "hast-util-to-jsx-runtime"
+		});
+		message.file = state.filePath || void 0;
+		message.url = docs + "#cannot-parse-style-attribute";
+		throw message;
+	}
+}
+/**
+* Create a JSX name from a string.
+*
+* @param {State} state
+*   To do.
+* @param {string} name
+*   Name.
+* @param {boolean} allowExpression
+*   Allow member expressions and identifiers.
+* @returns {unknown}
+*   To do.
+*/
+function findComponentFromName(state, name$1, allowExpression) {
+	/** @type {Identifier | Literal | MemberExpression} */
+	let result;
+	if (!allowExpression) result = {
+		type: "Literal",
+		value: name$1
+	};
+	else if (name$1.includes(".")) {
+		const identifiers = name$1.split(".");
+		let index = -1;
+		/** @type {Identifier | Literal | MemberExpression | undefined} */
+		let node;
+		while (++index < identifiers.length) {
+			/** @type {Identifier | Literal} */
+			const prop = name(identifiers[index]) ? {
+				type: "Identifier",
+				name: identifiers[index]
+			} : {
+				type: "Literal",
+				value: identifiers[index]
+			};
+			node = node ? {
+				type: "MemberExpression",
+				object: node,
+				property: prop,
+				computed: Boolean(index && prop.type === "Literal"),
+				optional: false
+			} : prop;
+		}
+		result = node;
+	} else result = name(name$1) && !/^[a-z]/.test(name$1) ? {
+		type: "Identifier",
+		name: name$1
+	} : {
+		type: "Literal",
+		value: name$1
+	};
+	if (result.type === "Literal") {
+		const name = result.value;
+		return own.call(state.components, name) ? state.components[name] : name;
+	}
+	if (state.evaluater) return state.evaluater.evaluateExpression(result);
+	crashEstree(state);
+}
+/**
+* @param {State} state
+* @param {Position | undefined} [place]
+* @returns {never}
+*/
+function crashEstree(state, place) {
+	const message = new VFileMessage("Cannot handle MDX estrees without `createEvaluater`", {
+		ancestors: state.ancestors,
+		place,
+		ruleId: "mdx-estree",
+		source: "hast-util-to-jsx-runtime"
+	});
+	message.file = state.filePath || void 0;
+	message.url = docs + "#cannot-handle-mdx-estrees-without-createevaluater";
+	throw message;
+}
+/**
+* Transform a DOM casing style object to a CSS casing style object.
+*
+* @param {Style} domCasing
+* @returns {Style}
+*/
+function transformStylesToCssCasing(domCasing) {
+	/** @type {Style} */
+	const cssCasing = {};
+	/** @type {string} */
+	let from;
+	for (from in domCasing) if (own.call(domCasing, from)) cssCasing[transformStyleToCssCasing(from)] = domCasing[from];
+	return cssCasing;
+}
+/**
+* Transform a DOM casing style field to a CSS casing style field.
+*
+* @param {string} from
+* @returns {string}
+*/
+function transformStyleToCssCasing(from) {
+	let to = from.replace(cap, toDash);
+	if (to.slice(0, 3) === "ms-") to = "-" + to;
+	return to;
+}
+/**
+* Make `$0` dash cased.
+*
+* @param {string} $0
+*   Capitalized ASCII leter.
+* @returns {string}
+*   Dash and lower letter.
+*/
+function toDash($0) {
+	return "-" + $0.toLowerCase();
+}
+//#endregion
+export { toJsxRuntime as t };