@alivault/pico 0.1.0

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

@@ -0,0 +1,1244 @@
+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 "./devlop.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/style-to-js@1.1.21/node_modules/style-to-js/cjs/index.js
+var require_cjs = /* @__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;
+}));
+//#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
+* @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/.pnpm/vfile-message@4.0.3/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/.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(require_cjs(), 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 { pointStart as a, pointEnd as i, VFileMessage as n, position$1 as o, stringifyPosition as r, toJsxRuntime as t };