@aws/nx-plugin-mcp 1.3.4 → 1.3.5

package/bin/aws-nx-mcp.js

@@ -15,14 +15,14 @@ var __esmMin = (fn, res, err) => () => {
 	}
 };
 var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod, mod.exports), cb = null), mod.exports);
-var __exportAll = (all, no_symbols) => {
-	let target = {};
+var __exportAll = (all, flags) => {
+	let target = Object.setPrototypeOf({}, null);
 	for (var name in all) __defProp(target, name, {
 		get: all[name],
 		enumerable: true
 	});
-	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
-	return target;
+	if (!(flags & 1)) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return flags & 2 ? target : Object.preventExtensions(target);
 };
 var __copyProps = (to, from, except, desc) => {
 	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
@@ -16174,12 +16174,34 @@ var require_data = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		"additionalProperties": false
 	};
 }));
-// ../../node_modules/.pnpm/fast-uri@3.1.0/node_modules/fast-uri/lib/utils.js
+// ../../node_modules/.pnpm/fast-uri@3.1.9/node_modules/fast-uri/lib/utils.js
 var require_utils = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	/** @type {(value: string) => boolean} */
 	const isUUID = RegExp.prototype.test.bind(/^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/iu);
 	/** @type {(value: string) => boolean} */
 	const isIPv4 = RegExp.prototype.test.bind(/^(?:(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)$/u);
+	/** @type {(value: string) => boolean} */
+	const isPort = RegExp.prototype.test.bind(/^\d*$/u);
+	/** @type {(value: string) => boolean} */
+	const isHexPair = RegExp.prototype.test.bind(/^[\da-f]{2}$/iu);
+	/** @type {(value: string) => boolean} */
+	const isUnreserved = RegExp.prototype.test.bind(/^[\da-z\-._~]$/iu);
+	/** @type {(value: string) => boolean} */
+	const isPathCharacter = RegExp.prototype.test.bind(/^[A-Za-z0-9\-._~!$&'()*+,;=:@/]$/u);
+	/** @type {(value: string) => boolean} */
+	const isQueryFragmentCharacter = RegExp.prototype.test.bind(/^[A-Za-z0-9\-._~!$&'()*+,;=:@/?]$/u);
+	/** @type {(value: string) => boolean} */
+	const isUserinfoCharacter = RegExp.prototype.test.bind(/^[A-Za-z0-9\-._~!$&'()*+,;=:]$/u);
+	const BYTE_HEX = new Array(256);
+	{
+		const HEX_DIGITS = "0123456789ABCDEF";
+		for (let i = 0; i < 256; i++) BYTE_HEX[i] = "%" + HEX_DIGITS[i >> 4] + HEX_DIGITS[i & 15];
+	}
+	function percentEncodeNonAscii(cp) {
+		if (cp < 2048) return BYTE_HEX[192 | cp >> 6] + BYTE_HEX[128 | cp & 63];
+		if (cp < 65536) return BYTE_HEX[224 | cp >> 12] + BYTE_HEX[128 | cp >> 6 & 63] + BYTE_HEX[128 | cp & 63];
+		return BYTE_HEX[240 | cp >> 18] + BYTE_HEX[128 | cp >> 12 & 63] + BYTE_HEX[128 | cp >> 6 & 63] + BYTE_HEX[128 | cp & 63];
+	}
 	/**
 	* @param {Array<string>} input
 	* @returns {string}
@@ -16202,121 +16224,162 @@ var require_utils = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		}
 		return acc;
 	}
-	/**
-	* @typedef {Object} GetIPV6Result
-	* @property {boolean} error - Indicates if there was an error parsing the IPv6 address.
-	* @property {string} address - The parsed IPv6 address.
-	* @property {string} [zone] - The zone identifier, if present.
-	*/
+	/** @type {(value: string) => boolean} */
+	const isHextet = RegExp.prototype.test.bind(/^[\dA-Fa-f]{1,4}$/);
+	/** @type {(value: string) => boolean} */
+	const isIPvFuture = RegExp.prototype.test.bind(/^[vV][\dA-Fa-f]+\.[A-Za-z\d\-._~!$&'()*+,;=:]+$/);
+	/** @type {(value: string) => boolean} */
+	const isZoneCharacter = RegExp.prototype.test.bind(/^[A-Za-z\d\-._~]$/);
 	/**
 	* @param {string} value
 	* @returns {boolean}
 	*/
 	const nonSimpleDomain = RegExp.prototype.test.bind(/[^!"$&'()*+,\-.;=_`a-z{}~]/u);
 	/**
-	* @param {Array<string>} buffer
+	* @param {string} zone
 	* @returns {boolean}
 	*/
-	function consumeIsZone(buffer) {
-		buffer.length = 0;
+	function isZoneIdentifier(zone) {
+		if (zone.length === 0) return false;
+		for (let i = 0; i < zone.length; i++) {
+			if (isZoneCharacter(zone[i])) continue;
+			if (zone[i] === "%" && i + 2 < zone.length && isHexPair(zone.slice(i + 1, i + 3))) {
+				i += 2;
+				continue;
+			}
+			return false;
+		}
 		return true;
 	}
 	/**
-	* @param {Array<string>} buffer
-	* @param {Array<string>} address
-	* @param {GetIPV6Result} output
-	* @returns {boolean}
+	* Compresses the longest run of zero hextets to "::" per RFC 5952. A run of a
+	* single zero hextet is left uncompressed. On ties the leftmost run wins.
+	*
+	* @param {string[]} hextets
+	* @returns {string}
 	*/
-	function consumeHextets(buffer, address, output) {
-		if (buffer.length) {
-			const hex = stringArrayToHexStripped(buffer);
-			if (hex !== "") address.push(hex);
-			else {
-				output.error = true;
-				return false;
+	function compressIPv6ZeroRun(hextets) {
+		let bestStart = -1;
+		let bestLength = 0;
+		let runStart = -1;
+		let runLength = 0;
+		for (let i = 0; i < hextets.length; i++) if (hextets[i] === "0") {
+			if (runStart === -1) runStart = i;
+			runLength++;
+			if (runLength > bestLength) {
+				bestLength = runLength;
+				bestStart = runStart;
 			}
-			buffer.length = 0;
+		} else {
+			runStart = -1;
+			runLength = 0;
 		}
-		return true;
+		if (bestLength < 2) return hextets.join(":");
+		const head = hextets.slice(0, bestStart).join(":");
+		const tail = hextets.slice(bestStart + bestLength).join(":");
+		return head + "::" + tail;
 	}
 	/**
+	* Validates an IPv6 address against the alternatives in RFC 3986 section
+	* 3.2.2 and returns the same address with leading hextet zeroes removed.
+	* An embedded IPv4 address counts as two hextets and is only valid at the end.
+	*
 	* @param {string} input
-	* @returns {GetIPV6Result}
+	* @returns {string|undefined}
 	*/
-	function getIPV6(input) {
-		let tokenCount = 0;
-		const output = {
-			error: false,
-			address: "",
-			zone: ""
-		};
-		/** @type {Array<string>} */
-		const address = [];
-		/** @type {Array<string>} */
-		const buffer = [];
-		let endipv6Encountered = false;
-		let endIpv6 = false;
-		let consume = consumeHextets;
-		for (let i = 0; i < input.length; i++) {
-			const cursor = input[i];
-			if (cursor === "[" || cursor === "]") continue;
-			if (cursor === ":") {
-				if (endipv6Encountered === true) endIpv6 = true;
-				if (!consume(buffer, address, output)) break;
-				if (++tokenCount > 7) {
-					output.error = true;
-					break;
-				}
-				if (i > 0 && input[i - 1] === ":") endipv6Encountered = true;
-				address.push(":");
-				continue;
-			} else if (cursor === "%") {
-				if (!consume(buffer, address, output)) break;
-				consume = consumeIsZone;
-			} else {
-				buffer.push(cursor);
+	function normalizeIPv6Address(input) {
+		const compression = input.indexOf("::");
+		if (compression !== -1 && input.indexOf("::", compression + 1) !== -1) return void 0;
+		const left = compression === -1 ? input.split(":") : input.slice(0, compression).split(":");
+		const right = compression === -1 ? [] : input.slice(compression + 2).split(":");
+		if (compression !== -1) {
+			if (left.length === 1 && left[0] === "") left.length = 0;
+			if (right.length === 1 && right[0] === "") right.length = 0;
+		}
+		const parts = left.concat(right);
+		let hextetCount = 0;
+		for (let i = 0; i < parts.length; i++) {
+			const part = parts[i];
+			if (part === "") return void 0;
+			if (part.indexOf(".") !== -1) {
+				if (i !== parts.length - 1 || compression !== -1 && right.length === 0 || !isIPv4(part)) return void 0;
+				hextetCount += 2;
 				continue;
 			}
+			if (!isHextet(part)) return void 0;
+			parts[i] = parseInt(part, 16).toString(16);
+			hextetCount++;
 		}
-		if (buffer.length) {
-			if (consume === consumeIsZone) output.zone = buffer.join("");
-			else if (endIpv6) address.push(buffer.join(""));
-			else address.push(stringArrayToHexStripped(buffer));
+		if (compression === -1) {
+			if (hextetCount !== 8) return void 0;
+			return compressIPv6ZeroRun(parts);
 		}
-		output.address = address.join("");
-		return output;
+		if (hextetCount >= 8) return void 0;
+		const expanded = parts.slice(0, left.length);
+		for (let i = hextetCount; i < 8; i++) expanded.push("0");
+		for (let i = left.length; i < parts.length; i++) expanded.push(parts[i]);
+		return compressIPv6ZeroRun(expanded);
 	}
 	/**
 	* @typedef {Object} NormalizeIPv6Result
 	* @property {string} host - The normalized host.
 	* @property {string} [escapedHost] - The escaped host.
 	* @property {boolean} isIPV6 - Indicates if the host is an IPv6 address.
+	* @property {boolean} [isIPVFuture] - Indicates if the host is an IPvFuture literal.
+	* @property {boolean} [error] - Indicates if a bracketed IP literal is malformed.
 	*/
 	/**
+	* Validates and normalizes a bracketed IP literal. Raw zone separators remain
+	* accepted for backwards compatibility, while encoded separators and zone
+	* contents follow RFC 6874.
+	*
 	* @param {string} host
 	* @returns {NormalizeIPv6Result}
 	*/
 	function normalizeIPv6(host) {
-		if (findToken(host, ":") < 2) return {
+		const bracketed = host[0] === "[" && host[host.length - 1] === "]";
+		if ((host[0] === "[" || host[host.length - 1] === "]") && !bracketed) return {
 			host,
-			isIPV6: false
+			isIPV6: false,
+			error: true
 		};
-		const ipv6 = getIPV6(host);
-		if (!ipv6.error) {
-			let newHost = ipv6.address;
-			let escapedHost = ipv6.address;
-			if (ipv6.zone) {
-				newHost += "%" + ipv6.zone;
-				escapedHost += "%25" + ipv6.zone;
-			}
+		let input = bracketed ? host.slice(1, -1) : host;
+		if (bracketed && isIPvFuture(input)) {
+			input = input.toLowerCase();
 			return {
-				host: newHost,
-				isIPV6: true,
-				escapedHost
+				host: `[${input}]`,
+				escapedHost: input,
+				isIPV6: false,
+				isIPVFuture: true
 			};
-		} else return {
+		}
+		if (findToken(input, ":") < 2) return {
 			host,
-			isIPV6: false
+			isIPV6: false,
+			error: bracketed
+		};
+		let zoneIdentifier = "";
+		const zoneSeparator = input.indexOf("%");
+		if (zoneSeparator !== -1) {
+			const separatorLength = input.slice(zoneSeparator, zoneSeparator + 3).toLowerCase() === "%25" ? 3 : 1;
+			zoneIdentifier = input.slice(zoneSeparator + separatorLength);
+			if (!isZoneIdentifier(zoneIdentifier)) return {
+				host,
+				isIPV6: false,
+				error: true
+			};
+			input = input.slice(0, zoneSeparator);
+		}
+		const address = normalizeIPv6Address(input);
+		if (address === void 0) return {
+			host,
+			isIPV6: false,
+			error: true
+		};
+		return {
+			host: address + (zoneIdentifier ? "%" + zoneIdentifier : ""),
+			escapedHost: address + (zoneIdentifier ? "%25" + zoneIdentifier : ""),
+			isIPV6: true
 		};
 	}
 	/**
@@ -16405,19 +16468,296 @@ var require_utils = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		return output.join("");
 	}
 	/**
-	* @param {import('../types/index').URIComponent} component
-	* @param {boolean} esc
-	* @returns {import('../types/index').URIComponent}
+	* Removes dot segments from the path of a relative reference (a path that does
+	* not start with "/") without changing what it resolves to against any base.
+	* Unlike `removeDotSegments`, leading ".." segments that cannot be collapsed
+	* are kept, the result never becomes root-relative, and a result that would be
+	* empty or start with an empty segment is prefixed with "." (an empty path
+	* means "same document" and a leading "//" would introduce an authority).
+	*
+	* @param {string} path
+	* @returns {string}
 	*/
-	function normalizeComponentEncoding(component, esc) {
-		const func = esc !== true ? escape : unescape;
-		if (component.scheme !== void 0) component.scheme = func(component.scheme);
-		if (component.userinfo !== void 0) component.userinfo = func(component.userinfo);
-		if (component.host !== void 0) component.host = func(component.host);
-		if (component.path !== void 0) component.path = func(component.path);
-		if (component.query !== void 0) component.query = func(component.query);
-		if (component.fragment !== void 0) component.fragment = func(component.fragment);
-		return component;
+	function removeDotSegmentsRelative(path) {
+		if (path === "" || path[0] === "/") return removeDotSegments(path);
+		const segments = path.split("/");
+		const last = segments.length - 1;
+		/** @type {string[]} */
+		const output = [];
+		let trailingDirectory = false;
+		for (let i = 0; i <= last; i++) {
+			const segment = segments[i];
+			if (segment === "." || segment === "..") {
+				if (segment === "..") {
+					if (output.length !== 0 && output[output.length - 1] !== "..") output.pop();
+					else output.push("..");
+				}
+				trailingDirectory = i === last;
+			} else output.push(segment);
+		}
+		if (trailingDirectory && output[output.length - 1] !== "..") output.push("");
+		if (output.length === 0 || output[0] === "" || output[0].includes(":")) output.unshift(".");
+		return output.join("/");
+	}
+	/**
+	* Re-escape RFC 3986 gen-delims that must not appear literally in the host.
+	* After the URI regex parses, these characters cannot be literal in the host
+	* field, so any that appear after decoding came from percent-encoding and
+	* must be restored to prevent authority structure changes.
+	*
+	* @param {string} host
+	* @param {boolean} isIP - true for IPv4/IPv6 hosts (skip colon re-escaping)
+	* @returns {string}
+	*/
+	const HOST_DELIMS = {
+		"@": "%40",
+		"/": "%2F",
+		"?": "%3F",
+		"#": "%23",
+		":": "%3A"
+	};
+	const HOST_DELIM_RE = /[@/?#:]/g;
+	const HOST_DELIM_NO_COLON_RE = /[@/?#]/g;
+	function reescapeHostDelimiters(host, isIP) {
+		const re = isIP ? HOST_DELIM_NO_COLON_RE : HOST_DELIM_RE;
+		re.lastIndex = 0;
+		return host.replace(re, (ch) => HOST_DELIMS[ch]);
+	}
+	/**
+	* Normalizes percent escapes and optionally decodes only unreserved ASCII bytes.
+	* Reserved delimiters such as `%2F` stay escaped; `%2E` is unreserved.
+	*
+	* @param {string} input
+	* @param {boolean} [decodeUnreserved=false]
+	* @returns {string}
+	*/
+	function normalizePercentEncoding(input, decodeUnreserved = false) {
+		if (input.indexOf("%") === -1) return input;
+		let output = "";
+		for (let i = 0; i < input.length; i++) {
+			if (input[i] === "%" && i + 2 < input.length) {
+				const hex = input.slice(i + 1, i + 3);
+				if (isHexPair(hex)) {
+					const normalizedHex = hex.toUpperCase();
+					const decoded = String.fromCharCode(parseInt(normalizedHex, 16));
+					if (decodeUnreserved && isUnreserved(decoded)) output += decoded;
+					else output += "%" + normalizedHex;
+					i += 2;
+					continue;
+				}
+			}
+			output += input[i];
+		}
+		return output;
+	}
+	/**
+	* Normalizes path data without turning reserved escapes into live path syntax.
+	* Valid escapes are uppercased, raw unsafe characters are escaped, and only
+	* unreserved bytes that are not `.` are decoded.
+	*
+	* @param {string} input
+	* @returns {string}
+	*/
+	function normalizePathEncoding(input) {
+		let output = "";
+		for (let i = 0; i < input.length; i++) {
+			const ch = input[i];
+			if (ch === "%" && i + 2 < input.length) {
+				const hex = input.slice(i + 1, i + 3);
+				if (isHexPair(hex)) {
+					const normalizedHex = hex.toUpperCase();
+					const decoded = String.fromCharCode(parseInt(normalizedHex, 16));
+					if (decoded !== "." && isUnreserved(decoded)) output += decoded;
+					else output += "%" + normalizedHex;
+					i += 2;
+					continue;
+				}
+			}
+			if (isPathCharacter(ch)) output += ch;
+			else {
+				const code = input.charCodeAt(i);
+				if (code < 128) output += isEscapeSafe(code) ? ch : BYTE_HEX[code];
+				else if (code < 55296 || code > 57343) output += percentEncodeNonAscii(code);
+				else if (code <= 56319 && i + 1 < input.length) {
+					const low = input.charCodeAt(i + 1);
+					if (low >= 56320 && low <= 57343) {
+						output += percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
+						i++;
+					} else output += percentEncodeNonAscii(65533);
+				} else output += percentEncodeNonAscii(65533);
+			}
+		}
+		return output;
+	}
+	/**
+	* Serializes a path without rewriting reserved data. Raw RFC 3986 path
+	* characters remain literal, valid escapes are preserved and uppercased, and
+	* everything else is UTF-8 percent-encoded. In a path-noscheme, a colon in the
+	* first segment must be escaped so the result cannot be parsed as a scheme.
+	*
+	* @param {string} input
+	* @param {boolean} [pathNoScheme=false]
+	* @returns {string}
+	*/
+	function serializePathEncoding(input, pathNoScheme = false) {
+		let output = "";
+		let firstSegment = pathNoScheme && input[0] !== "/";
+		for (let i = 0; i < input.length; i++) {
+			const ch = input[i];
+			if (ch === "%" && i + 2 < input.length) {
+				const hex = input.slice(i + 1, i + 3);
+				if (isHexPair(hex)) {
+					output += "%" + hex.toUpperCase();
+					i += 2;
+					continue;
+				}
+			}
+			if (ch === "/") firstSegment = false;
+			if (isPathCharacter(ch) && (ch !== ":" || !firstSegment)) output += ch;
+			else {
+				const code = input.charCodeAt(i);
+				if (code < 128) output += BYTE_HEX[code];
+				else if (code < 55296 || code > 57343) output += percentEncodeNonAscii(code);
+				else if (code <= 56319 && i + 1 < input.length) {
+					const low = input.charCodeAt(i + 1);
+					if (low >= 56320 && low <= 57343) {
+						output += percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
+						i++;
+					} else output += percentEncodeNonAscii(65533);
+				} else output += percentEncodeNonAscii(65533);
+			}
+		}
+		return output;
+	}
+	/**
+	* Percent-encodes a URI component using its RFC 3986 literal character set.
+	* Existing valid escapes are preserved and normalized to uppercase hex.
+	*
+	* @param {string} input
+	* @param {(value: string) => boolean} isAllowed
+	* @returns {string}
+	*/
+	function encodeComponent(input, isAllowed) {
+		let output = "";
+		for (let i = 0; i < input.length; i++) {
+			const ch = input[i];
+			if (ch === "%" && i + 2 < input.length) {
+				const hex = input.slice(i + 1, i + 3);
+				if (isHexPair(hex)) {
+					output += "%" + hex.toUpperCase();
+					i += 2;
+					continue;
+				}
+			}
+			if (isAllowed(ch)) output += ch;
+			else {
+				const code = input.charCodeAt(i);
+				if (code < 128) output += BYTE_HEX[code];
+				else if (code < 55296 || code > 57343) output += percentEncodeNonAscii(code);
+				else if (code <= 56319 && i + 1 < input.length) {
+					const low = input.charCodeAt(i + 1);
+					if (low >= 56320 && low <= 57343) {
+						output += percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
+						i++;
+					} else output += percentEncodeNonAscii(65533);
+				} else output += percentEncodeNonAscii(65533);
+			}
+		}
+		return output;
+	}
+	/**
+	* Encodes userinfo while preserving its RFC 3986 §3.2.1 literal characters.
+	* In particular, authority delimiters such as `@`, `/`, `?`, and `#` are data.
+	*
+	* @param {string} input
+	* @returns {string}
+	*/
+	function encodeUserinfo(input) {
+		return encodeComponent(input, isUserinfoCharacter);
+	}
+	/**
+	* Encodes query data using the RFC 3986 §3.4 grammar. A literal `#` must be
+	* escaped because it would otherwise begin the fragment component.
+	*
+	* @param {string} input
+	* @returns {string}
+	*/
+	function encodeQuery(input) {
+		return encodeComponent(input, isQueryFragmentCharacter);
+	}
+	/**
+	* Encodes fragment data using the RFC 3986 §3.5 grammar.
+	*
+	* @param {string} input
+	* @returns {string}
+	*/
+	function encodeFragment(input) {
+		return encodeComponent(input, isQueryFragmentCharacter);
+	}
+	function isEscapeSafe(cp) {
+		return cp >= 48 && cp <= 57 || cp >= 65 && cp <= 90 || cp >= 97 && cp <= 122 || cp === 42 || cp === 43 || cp === 45 || cp === 46 || cp === 47 || cp === 64 || cp === 95;
+	}
+	/**
+	* Normalizes the percent-encoding of a query or fragment component.
+	*
+	* Like `normalizePathEncoding`, but uses the query/fragment character set
+	* (which additionally allows `?`) and decodes `.` since it has no dot-segment
+	* meaning outside of a path.
+	*
+	* @param {string} input
+	* @returns {string}
+	*/
+	function normalizeQueryFragmentEncoding(input) {
+		let output = "";
+		for (let i = 0; i < input.length; i++) {
+			const ch = input[i];
+			if (ch === "%" && i + 2 < input.length) {
+				const hex = input.slice(i + 1, i + 3);
+				if (isHexPair(hex)) {
+					const normalizedHex = hex.toUpperCase();
+					const decoded = String.fromCharCode(parseInt(normalizedHex, 16));
+					if (isUnreserved(decoded)) output += decoded;
+					else output += "%" + normalizedHex;
+					i += 2;
+					continue;
+				}
+			}
+			if (isQueryFragmentCharacter(ch)) output += ch;
+			else {
+				const code = input.charCodeAt(i);
+				if (code < 128) output += isEscapeSafe(code) ? ch : BYTE_HEX[code];
+				else if (code < 55296 || code > 57343) output += percentEncodeNonAscii(code);
+				else if (code <= 56319 && i + 1 < input.length) {
+					const low = input.charCodeAt(i + 1);
+					if (low >= 56320 && low <= 57343) {
+						output += percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
+						i++;
+					} else output += percentEncodeNonAscii(65533);
+				} else output += percentEncodeNonAscii(65533);
+			}
+		}
+		return output;
+	}
+	/**
+	* Escapes a component while preserving existing valid percent escapes.
+	*
+	* @param {string} input
+	* @returns {string}
+	*/
+	function escapePreservingEscapes(input) {
+		let output = "";
+		for (let i = 0; i < input.length; i++) {
+			if (input[i] === "%" && i + 2 < input.length) {
+				const hex = input.slice(i + 1, i + 3);
+				if (isHexPair(hex)) {
+					output += "%" + hex.toUpperCase();
+					i += 2;
+					continue;
+				}
+			}
+			output += escape(input[i]);
+		}
+		return output;
 	}
 	/**
 	* @param {import('../types/index').URIComponent} component
@@ -16426,39 +16766,54 @@ var require_utils = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	function recomposeAuthority(component) {
 		const uriTokens = [];
 		if (component.userinfo !== void 0) {
-			uriTokens.push(component.userinfo);
+			uriTokens.push(encodeUserinfo(component.userinfo));
 			uriTokens.push("@");
 		}
 		if (component.host !== void 0) {
-			let host = unescape(component.host);
+			let host = component.host;
 			if (!isIPv4(host)) {
-				const ipV6res = normalizeIPv6(host);
-				if (ipV6res.isIPV6 === true) host = `[${ipV6res.escapedHost}]`;
-				else host = component.host;
+				let ipV6res = normalizeIPv6(host);
+				if (ipV6res.isIPV6 !== true && ipV6res.isIPVFuture !== true) {
+					host = normalizePercentEncoding(host, true);
+					ipV6res = normalizeIPv6(host);
+				}
+				if (ipV6res.isIPV6 === true || ipV6res.isIPVFuture === true) host = `[${ipV6res.escapedHost}]`;
+				else host = reescapeHostDelimiters(host, false);
 			}
 			uriTokens.push(host);
 		}
 		if (typeof component.port === "number" || typeof component.port === "string") {
+			const port = String(component.port);
+			if (!isPort(port)) throw new TypeError("URI port is malformed.");
 			uriTokens.push(":");
-			uriTokens.push(String(component.port));
+			uriTokens.push(port);
 		}
 		return uriTokens.length ? uriTokens.join("") : void 0;
 	}
 	module.exports = {
 		nonSimpleDomain,
 		recomposeAuthority,
-		normalizeComponentEncoding,
+		reescapeHostDelimiters,
+		normalizePercentEncoding,
+		normalizePathEncoding,
+		serializePathEncoding,
+		normalizeQueryFragmentEncoding,
+		encodeUserinfo,
+		encodeQuery,
+		encodeFragment,
+		escapePreservingEscapes,
 		removeDotSegments,
+		removeDotSegmentsRelative,
 		isIPv4,
 		isUUID,
 		normalizeIPv6,
 		stringArrayToHexStripped
 	};
 }));
-// ../../node_modules/.pnpm/fast-uri@3.1.0/node_modules/fast-uri/lib/schemes.js
+// ../../node_modules/.pnpm/fast-uri@3.1.9/node_modules/fast-uri/lib/schemes.js
 var require_schemes = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const { isUUID } = require_utils();
-	const URN_REG = /([\da-z][\d\-a-z]{0,31}):((?:[\w!$'()*+,\-.:;=@]|%[\da-f]{2})+)/iu;
+	const URN_REG = /^([\da-z][\d\-a-z]{0,31}):((?:[\w!$'()*+,\-./:;=@]|%[\da-f]{2})+)$/iu;
 	const supportedSchemeNames = [
 		"http",
 		"https",
@@ -16529,9 +16884,10 @@ var require_schemes = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			wsComponent.secure = void 0;
 		}
 		if (wsComponent.resourceName) {
-			const [path, query] = wsComponent.resourceName.split("?");
+			const queryIndex = wsComponent.resourceName.indexOf("?");
+			const path = queryIndex === -1 ? wsComponent.resourceName : wsComponent.resourceName.slice(0, queryIndex);
 			wsComponent.path = path && path !== "/" ? path : void 0;
-			wsComponent.query = query;
+			wsComponent.query = queryIndex === -1 ? void 0 : wsComponent.resourceName.slice(queryIndex + 1);
 			wsComponent.resourceName = void 0;
 		}
 		wsComponent.fragment = void 0;
@@ -16544,7 +16900,7 @@ var require_schemes = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			return urnComponent;
 		}
 		const matches = urnComponent.path.match(URN_REG);
-		if (matches) {
+		if (matches && matches[0] === urnComponent.path) {
 			const scheme = options.scheme || urnComponent.scheme || "urn";
 			urnComponent.nid = matches[1].toLowerCase();
 			urnComponent.nss = matches[2];
@@ -16637,10 +16993,27 @@ var require_schemes = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		getSchemeHandler
 	};
 }));
-// ../../node_modules/.pnpm/fast-uri@3.1.0/node_modules/fast-uri/index.js
+// ../../node_modules/.pnpm/fast-uri@3.1.9/node_modules/fast-uri/index.js
 var require_fast_uri = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	const { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizeComponentEncoding, isIPv4, nonSimpleDomain } = require_utils();
+	const { normalizeIPv6, removeDotSegments, removeDotSegmentsRelative, recomposeAuthority, normalizePercentEncoding, normalizePathEncoding, serializePathEncoding, normalizeQueryFragmentEncoding, encodeQuery, encodeFragment, reescapeHostDelimiters, isIPv4, nonSimpleDomain } = require_utils();
 	const { SCHEMES, getSchemeHandler } = require_schemes();
+	const VALID_SCHEME = /^[A-Za-z][A-Za-z0-9+.-]*$/u;
+	const MALFORMED_SCHEME_ERROR = "URI scheme is malformed.";
+	const MALFORMED_HOST_ERROR = "URI host is malformed.";
+	const FORBIDDEN_DOMAIN_HOST_CHARACTER = /[\0-\x20"#/:<>?@[\\\]^`{|}\x7F]/u;
+	/**
+	* RFC 3986 section 3.1 does not allow percent-encoding in a scheme, so the
+	* scheme is validated as-is and never decoded. Decoding would let inert input
+	* such as `%6Aavascript:` become a live `javascript:` scheme.
+	*
+	* @param {string} scheme
+	* @returns {string}
+	*/
+	function validateScheme(scheme) {
+		const stringScheme = String(scheme);
+		if (!VALID_SCHEME.test(stringScheme)) throw new TypeError(MALFORMED_SCHEME_ERROR);
+		return stringScheme;
+	}
 	/**
 	* @template {import('./types/index').URIComponent|string} T
 	* @param {T} uri
@@ -16648,7 +17021,7 @@ var require_fast_uri = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	* @returns {T}
 	*/
 	function normalize(uri, options) {
-		if (typeof uri === "string") uri = serialize(parse(uri, options), options);
+		if (typeof uri === "string") uri = normalizeString(uri, options);
 		else if (typeof uri === "object") uri = parse(serialize(uri, options), options);
 		return uri;
 	}
@@ -16660,7 +17033,17 @@ var require_fast_uri = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	*/
 	function resolve(baseURI, relativeURI, options) {
 		const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
-		const resolved = resolveComponent(parse(baseURI, schemelessOptions), parse(relativeURI, schemelessOptions), schemelessOptions, true);
+		const { parsed: baseParsed, malformedAuthorityOrPort: baseMalformed, malformedPercentEncoding: baseMalformedPercentEncoding, malformedSchemeSpecific: baseMalformedSchemeSpecific, malformedHost: baseMalformedHost, malformedScheme: baseMalformedScheme } = parseWithStatus(baseURI, schemelessOptions);
+		const { parsed: relativeParsed, malformedAuthorityOrPort: relativeMalformed, malformedPercentEncoding: relativeMalformedPercentEncoding, malformedSchemeSpecific: relativeMalformedSchemeSpecific, malformedHost: relativeMalformedHost, malformedScheme: relativeMalformedScheme } = parseWithStatus(relativeURI, schemelessOptions);
+		if (baseMalformed || relativeMalformed || baseMalformedPercentEncoding || relativeMalformedPercentEncoding || baseMalformedSchemeSpecific || relativeMalformedSchemeSpecific || baseMalformedHost || relativeMalformedHost || baseMalformedScheme || relativeMalformedScheme) throw new Error(baseParsed.error || relativeParsed.error || "URI is malformed.");
+		const resolved = resolveComponent(baseParsed, relativeParsed, schemelessOptions, true);
+		const resolvedSchemeHandler = getSchemeHandler(options && options.scheme || resolved.scheme);
+		const resolvedHost = resolved.host;
+		const resolvedHostIsIP = resolvedHost !== void 0 && resolvedHost !== "" && (isIPv4(resolvedHost) || normalizeIPv6(resolvedHost).isIPV6);
+		if (hasForbiddenDomainHost(resolved, options || {}, resolvedSchemeHandler, resolvedHostIsIP)) throw new Error(MALFORMED_HOST_ERROR);
+		canonicalizeHost(resolved, options || {}, resolvedSchemeHandler, resolvedHostIsIP);
+		const encodedASCIIHost = resolvedHost && resolvedHost.indexOf("%") !== -1 && !/\P{ASCII}/u.test(resolvedHost);
+		if (resolved.error && !encodedASCIIHost) throw new Error(resolved.error);
 		schemelessOptions.skipEscape = true;
 		return serialize(resolved, schemelessOptions);
 	}
@@ -16701,10 +17084,11 @@ var require_fast_uri = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 				} else {
 					if (relative.path[0] === "/") target.path = removeDotSegments(relative.path);
 					else {
-						if ((base.userinfo !== void 0 || base.host !== void 0 || base.port !== void 0) && !base.path) target.path = "/" + relative.path;
+						const baseHasAuthority = base.userinfo !== void 0 || base.host !== void 0 || base.port !== void 0;
+						if (baseHasAuthority && !base.path) target.path = "/" + relative.path;
 						else if (!base.path) target.path = relative.path;
 						else target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative.path;
-						target.path = removeDotSegments(target.path);
+						target.path = base.scheme === void 0 && !baseHasAuthority && target.path[0] !== "/" ? removeDotSegmentsRelative(target.path) : removeDotSegments(target.path);
 					}
 					target.query = relative.query;
 				}
@@ -16724,27 +17108,9 @@ var require_fast_uri = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	* @returns {boolean}
 	*/
 	function equal(uriA, uriB, options) {
-		if (typeof uriA === "string") {
-			uriA = unescape(uriA);
-			uriA = serialize(normalizeComponentEncoding(parse(uriA, options), true), {
-				...options,
-				skipEscape: true
-			});
-		} else if (typeof uriA === "object") uriA = serialize(normalizeComponentEncoding(uriA, true), {
-			...options,
-			skipEscape: true
-		});
-		if (typeof uriB === "string") {
-			uriB = unescape(uriB);
-			uriB = serialize(normalizeComponentEncoding(parse(uriB, options), true), {
-				...options,
-				skipEscape: true
-			});
-		} else if (typeof uriB === "object") uriB = serialize(normalizeComponentEncoding(uriB, true), {
-			...options,
-			skipEscape: true
-		});
-		return uriA.toLowerCase() === uriB.toLowerCase();
+		const normalizedA = normalizeComparableURI(uriA, options);
+		const normalizedB = normalizeComparableURI(uriB, options);
+		return normalizedA !== void 0 && normalizedB !== void 0 && normalizedA === normalizedB;
 	}
 	/**
 	* @param {Readonly<import('./types/index').URIComponent>} cmpts
@@ -16770,15 +17136,20 @@ var require_fast_uri = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		};
 		const options = Object.assign({}, opts);
 		const uriTokens = [];
+		if (component.scheme) component.scheme = validateScheme(component.scheme);
 		const schemeHandler = getSchemeHandler(options.scheme || component.scheme);
 		if (schemeHandler && schemeHandler.serialize) schemeHandler.serialize(component, options);
+		const hasAuthority = component.userinfo !== void 0 || component.host !== void 0 || component.port !== void 0;
+		const schemelessReference = (component.scheme === void 0 || options.reference === "suffix") && !hasAuthority;
+		const pathNoScheme = !options.skipEscape && schemelessReference;
 		if (component.path !== void 0) {
-			if (!options.skipEscape) {
-				component.path = escape(component.path);
-				if (component.scheme !== void 0) component.path = component.path.split("%3A").join(":");
-			} else component.path = unescape(component.path);
+			if (!options.skipEscape) component.path = serializePathEncoding(component.path, pathNoScheme);
+			else component.path = normalizePercentEncoding(component.path);
+		}
+		if (options.reference !== "suffix" && component.scheme) {
+			component.scheme = validateScheme(component.scheme);
+			uriTokens.push(component.scheme, ":");
 		}
-		if (options.reference !== "suffix" && component.scheme) uriTokens.push(component.scheme, ":");
 		const authority = recomposeAuthority(component);
 		if (authority !== void 0) {
 			if (options.reference !== "suffix") uriTokens.push("//");
@@ -16787,21 +17158,120 @@ var require_fast_uri = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		}
 		if (component.path !== void 0) {
 			let s = component.path;
-			if (!options.absolutePath && (!schemeHandler || !schemeHandler.absolutePath)) s = removeDotSegments(s);
+			if (!options.absolutePath && (!schemeHandler || !schemeHandler.absolutePath)) s = schemelessReference && s[0] !== "/" ? removeDotSegmentsRelative(s) : removeDotSegments(s);
+			if (schemelessReference) s = serializePathEncoding(s, true);
 			if (authority === void 0 && s[0] === "/" && s[1] === "/") s = "/%2F" + s.slice(2);
 			uriTokens.push(s);
 		}
-		if (component.query !== void 0) uriTokens.push("?", component.query);
-		if (component.fragment !== void 0) uriTokens.push("#", component.fragment);
+		if (component.query !== void 0) uriTokens.push("?", encodeQuery(component.query));
+		if (component.fragment !== void 0) uriTokens.push("#", encodeFragment(component.fragment));
 		return uriTokens.join("");
 	}
 	const URI_PARSE = /^(?:([^#/:?]+):)?(?:\/\/((?:([^#/?@]*)@)?(\[[^#/?\]]+\]|[^#/:?]*)(?::(\d*))?))?([^#?]*)(?:\?([^#]*))?(?:#((?:.|[\n\r])*))?/u;
+	const AUTHORITY_PREFIX = /^(?:[^#/:?]+:)?\/\/([^/?#]*)/;
+	const AUTHORITY_INTRODUCER_REGION = /^(?:[^#/:?]+:)?([/\\\t\n\r]*)/;
+	/**
+	* @param {import('./types/index').URIComponent} parsed
+	* @param {RegExpMatchArray} matches
+	* @returns {string|undefined}
+	*/
+	function getParseError(parsed, matches) {
+		if (matches[2] !== void 0 && parsed.path && parsed.path[0] !== "/") return "URI path must start with \"/\" when authority is present.";
+		if (typeof parsed.port === "number" && (parsed.port < 0 || parsed.port > 65535)) return "URI port is malformed.";
+	}
+	/**
+	* Checks percent syntax without decoding the represented octets. RFC 3986
+	* percent-encoding is byte-oriented, so sequences such as `%FF` are valid even
+	* though they are not independently valid UTF-8.
+	*
+	* @param {string|undefined} component
+	* @returns {boolean}
+	*/
+	function hasMalformedPercentEncoding(component) {
+		if (component === void 0) return false;
+		let percent = component.indexOf("%");
+		while (percent !== -1) {
+			if (percent + 2 >= component.length || !/^[\da-f]{2}$/iu.test(component.slice(percent + 1, percent + 3))) return true;
+			percent = component.indexOf("%", percent + 3);
+		}
+		return false;
+	}
+	/**
+	* Whether the host is a bracketed IP literal (RFC 3986 `IP-literal`).
+	* An unterminated `[` is not a literal, so it must still be validated as a
+	* reg-name instead of being waved through as an IP.
+	*
+	* @param {string} host
+	* @returns {boolean}
+	*/
+	function isIPLiteral(host) {
+		return host[0] === "[" && host[host.length - 1] === "]";
+	}
+	/**
+	* @param {RegExpMatchArray} matches
+	* @returns {boolean}
+	*/
+	function hasMalformedComponentPercentEncoding(matches) {
+		const host = matches[4];
+		return hasMalformedPercentEncoding(matches[3]) || host !== void 0 && !isIPLiteral(host) && hasMalformedPercentEncoding(host) || hasMalformedPercentEncoding(matches[6]) || hasMalformedPercentEncoding(matches[7]) || hasMalformedPercentEncoding(matches[8]);
+	}
+	/**
+	* @param {import('./types/index').URIComponent} parsed
+	* @param {import('./types/index').Options} options
+	* @param {{ domainHost?: boolean, unicodeSupport?: boolean }|undefined} schemeHandler
+	* @param {boolean} isIP
+	* @returns {boolean} whether host conversion failed
+	*/
+	function canonicalizeHost(parsed, options, schemeHandler, isIP) {
+		if (hasForbiddenDomainHost(parsed, options, schemeHandler, isIP)) {
+			parsed.error = parsed.error || MALFORMED_HOST_ERROR;
+			return true;
+		}
+		if (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport) && parsed.host && !isIPLiteral(parsed.host) && (options.domainHost || schemeHandler && schemeHandler.domainHost) && isIP === false && nonSimpleDomain(parsed.host)) {
+			let url;
+			try {
+				url = new URL("http://" + parsed.host);
+			} catch (e) {
+				parsed.error = parsed.error || "Host's domain name can not be converted to ASCII: " + e;
+				return true;
+			}
+			if (!isHostOnlyURL(url)) {
+				parsed.error = parsed.error || MALFORMED_HOST_ERROR;
+				return true;
+			}
+			parsed.host = url.hostname;
+		}
+		return false;
+	}
+	/**
+	* Whether a domain host contains an ASCII character that RFC 3986 does not
+	* allow in a reg-name (unreserved, sub-delims, or pct-encoded). Such a host is
+	* rejected instead of being handed to the WHATWG URL parser, which would treat
+	* "@" as a userinfo delimiter (silently dropping the data before it) and strip
+	* TAB, LF, and CR. Non-ASCII characters remain allowed for IDNs.
+	*
+	* @param {import('./types/index').URIComponent} parsed
+	* @param {import('./types/index').Options} options
+	* @param {{ domainHost?: boolean }|undefined} schemeHandler
+	* @param {boolean} isIP
+	* @returns {boolean}
+	*/
+	function hasForbiddenDomainHost(parsed, options, schemeHandler, isIP) {
+		return Boolean(parsed.host && isIP === false && !isIPLiteral(parsed.host) && (options.domainHost || schemeHandler && schemeHandler.domainHost) && FORBIDDEN_DOMAIN_HOST_CHARACTER.test(parsed.host));
+	}
+	/**
+	* @param {URL} url
+	* @returns {boolean}
+	*/
+	function isHostOnlyURL(url) {
+		return url.username === "" && url.password === "" && url.port === "" && url.pathname === "/" && url.search === "" && url.hash === "" && url.hostname !== "";
+	}
 	/**
 	* @param {string} uri
 	* @param {import('./types/index').Options} [opts]
-	* @returns
+	* @returns {{ parsed: import('./types/index').URIComponent, malformedAuthorityOrPort: boolean, malformedPercentEncoding: boolean, malformedSchemeSpecific: boolean, malformedHost: boolean, malformedScheme: boolean }}
 	*/
-	function parse(uri, opts) {
+	function parseWithStatus(uri, opts) {
 		const options = Object.assign({}, opts);
 		/** @type {import('./types/index').URIComponent} */
 		const parsed = {
@@ -16813,11 +17283,36 @@ var require_fast_uri = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			query: void 0,
 			fragment: void 0
 		};
+		let malformedAuthorityOrPort = false;
+		let malformedPercentEncoding = false;
+		let malformedSchemeSpecific = false;
+		let malformedHost = false;
+		let malformedIPLiteral = false;
+		let malformedScheme = false;
 		let isIP = false;
 		if (options.reference === "suffix") {
 			if (options.scheme) uri = options.scheme + ":" + uri;
 			else uri = "//" + uri;
 		}
+		const authorityMatch = uri.match(AUTHORITY_PREFIX);
+		if (authorityMatch !== null && authorityMatch[1].indexOf("\\") !== -1) {
+			parsed.error = "URI authority must not contain a literal backslash.";
+			malformedAuthorityOrPort = true;
+		}
+		const introducerMatch = uri.match(AUTHORITY_INTRODUCER_REGION);
+		if (introducerMatch !== null) {
+			const region = introducerMatch[1];
+			const normalizedRegion = region.replace(/[\t\n\r]/g, "");
+			if (normalizedRegion.length >= 2) {
+				if (normalizedRegion.slice(0, 2) !== "//") {
+					parsed.error = parsed.error || "URI authority must not contain a literal backslash.";
+					malformedAuthorityOrPort = true;
+				} else if (region.length !== normalizedRegion.length) {
+					parsed.error = parsed.error || "URI authority introducer must not contain whitespace.";
+					malformedAuthorityOrPort = true;
+				}
+			}
+		}
 		const matches = uri.match(URI_PARSE);
 		if (matches) {
 			parsed.scheme = matches[1];
@@ -16827,12 +17322,33 @@ var require_fast_uri = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			parsed.path = matches[6] || "";
 			parsed.query = matches[7];
 			parsed.fragment = matches[8];
+			if (parsed.scheme !== void 0) {
+				if (VALID_SCHEME.test(parsed.scheme)) parsed.scheme = parsed.scheme.toLowerCase();
+				else {
+					parsed.error = parsed.error || MALFORMED_SCHEME_ERROR;
+					malformedScheme = true;
+				}
+			}
+			malformedPercentEncoding = hasMalformedComponentPercentEncoding(matches);
+			if (malformedPercentEncoding) parsed.error = parsed.error || "URI contains malformed percent-encoding.";
 			if (isNaN(parsed.port)) parsed.port = matches[5];
+			const parseError = getParseError(parsed, matches);
+			if (parseError !== void 0) {
+				parsed.error = parsed.error || parseError;
+				malformedAuthorityOrPort = true;
+			}
 			if (parsed.host) {
 				if (isIPv4(parsed.host) === false) {
+					const bracketedIPLiteral = isIPLiteral(parsed.host);
+					const hasIPLiteralBracket = parsed.host.indexOf("[") !== -1 || parsed.host.indexOf("]") !== -1;
 					const ipv6result = normalizeIPv6(parsed.host);
-					parsed.host = ipv6result.host.toLowerCase();
-					isIP = ipv6result.isIPV6;
+					isIP = ipv6result.isIPV6 || ipv6result.isIPVFuture === true;
+					malformedIPLiteral = hasIPLiteralBracket && (!bracketedIPLiteral || ipv6result.error === true);
+					parsed.host = isIP ? ipv6result.host : ipv6result.host.toLowerCase();
+					if (malformedIPLiteral) {
+						parsed.error = parsed.error || MALFORMED_HOST_ERROR;
+						malformedAuthorityOrPort = true;
+					}
 				} else isIP = true;
 			}
 			if (parsed.scheme === void 0 && parsed.userinfo === void 0 && parsed.host === void 0 && parsed.port === void 0 && parsed.query === void 0 && !parsed.path) parsed.reference = "same-document";
@@ -16841,24 +17357,78 @@ var require_fast_uri = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			else parsed.reference = "uri";
 			if (options.reference && options.reference !== "suffix" && options.reference !== parsed.reference) parsed.error = parsed.error || "URI is not a " + options.reference + " reference.";
 			const schemeHandler = getSchemeHandler(options.scheme || parsed.scheme);
-			if (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport)) {
-				if (parsed.host && (options.domainHost || schemeHandler && schemeHandler.domainHost) && isIP === false && nonSimpleDomain(parsed.host)) try {
-					parsed.host = URL.domainToASCII(parsed.host.toLowerCase());
-				} catch (e) {
-					parsed.error = parsed.error || "Host's domain name can not be converted to ASCII: " + e;
-				}
+			if (!malformedIPLiteral) malformedHost = canonicalizeHost(parsed, options, schemeHandler, isIP);
+			if (uri.indexOf("%") !== -1 && parsed.host !== void 0 && !malformedIPLiteral) {
+				let host = isIP ? parsed.host : normalizePercentEncoding(parsed.host, true);
+				if (!isIP) host = normalizePercentEncoding(host.toLowerCase());
+				parsed.host = isIP || options.scheme !== "null" ? reescapeHostDelimiters(host, isIP) : host;
 			}
 			if (!schemeHandler || schemeHandler && !schemeHandler.skipNormalize) {
-				if (uri.indexOf("%") !== -1) {
-					if (parsed.scheme !== void 0) parsed.scheme = unescape(parsed.scheme);
-					if (parsed.host !== void 0) parsed.host = unescape(parsed.host);
-				}
-				if (parsed.path) parsed.path = escape(unescape(parsed.path));
-				if (parsed.fragment) parsed.fragment = encodeURI(decodeURIComponent(parsed.fragment));
+				if (parsed.path) parsed.path = normalizePathEncoding(parsed.path);
+				if (parsed.query) parsed.query = normalizeQueryFragmentEncoding(parsed.query);
+				if (parsed.fragment) parsed.fragment = normalizeQueryFragmentEncoding(parsed.fragment);
+			}
+			if (schemeHandler && schemeHandler.parse) {
+				schemeHandler.parse(parsed, options);
+				if (schemeHandler === SCHEMES.urn && parsed.nid === void 0) malformedSchemeSpecific = true;
 			}
-			if (schemeHandler && schemeHandler.parse) schemeHandler.parse(parsed, options);
 		} else parsed.error = parsed.error || "URI can not be parsed.";
-		return parsed;
+		return {
+			parsed,
+			malformedAuthorityOrPort,
+			malformedPercentEncoding,
+			malformedSchemeSpecific,
+			malformedHost,
+			malformedScheme
+		};
+	}
+	/**
+	* @param {string} uri
+	* @param {import('./types/index').Options} [opts]
+	* @returns
+	*/
+	function parse(uri, opts) {
+		return parseWithStatus(uri, opts).parsed;
+	}
+	/**
+	* @param {string} uri
+	* @param {import('./types/index').Options} [opts]
+	* @returns {string}
+	*/
+	function normalizeString(uri, opts) {
+		return normalizeStringWithStatus(uri, opts).normalized;
+	}
+	/**
+	* @param {string} uri
+	* @param {import('./types/index').Options} [opts]
+	* @returns {{ normalized: string, malformedAuthorityOrPort: boolean, malformedPercentEncoding: boolean, malformedSchemeSpecific: boolean, malformedHost: boolean, malformedScheme: boolean }}
+	*/
+	function normalizeStringWithStatus(uri, opts) {
+		const { parsed, malformedAuthorityOrPort, malformedPercentEncoding, malformedSchemeSpecific, malformedHost, malformedScheme } = parseWithStatus(uri, opts);
+		return {
+			normalized: malformedAuthorityOrPort || malformedPercentEncoding || malformedSchemeSpecific || malformedHost || malformedScheme ? uri : serialize(parsed, opts),
+			malformedAuthorityOrPort,
+			malformedPercentEncoding,
+			malformedSchemeSpecific,
+			malformedHost,
+			malformedScheme
+		};
+	}
+	/**
+	* @param {import ('./types/index').URIComponent|string} uri
+	* @param {import('./types/index').Options} [opts]
+	* @returns {string|undefined}
+	*/
+	function normalizeComparableURI(uri, opts) {
+		if (typeof uri !== "string" && typeof uri !== "object") return;
+		let value;
+		try {
+			value = typeof uri === "string" ? uri : serialize(uri, opts);
+		} catch {
+			return;
+		}
+		const { normalized, malformedAuthorityOrPort, malformedPercentEncoding, malformedSchemeSpecific, malformedHost, malformedScheme } = normalizeStringWithStatus(value, opts);
+		return malformedAuthorityOrPort || malformedPercentEncoding || malformedSchemeSpecific || malformedHost || malformedScheme ? void 0 : normalized;
 	}
 	const fastUri = {
 		SCHEMES,
@@ -22045,22 +22615,22 @@ const NX_VERSION = {
 	"@a2a-js/sdk": "0.3.14",
 	"@aws/aws-distro-opentelemetry-node-autoinstrumentation": "0.13.0",
 	"@opentelemetry/propagator-jaeger": "2.12.0",
-	minimatch: "11.0.1",
+	minimatch: "11.0.5",
 	"deepmerge-ts": "8.0.2",
 	mysql2: "3.24.6",
-	"@aws-sdk/client-dynamodb": "3.1161.0",
-	"@aws-sdk/client-api-gateway": "3.1161.0",
-	"@aws-sdk/client-iam": "3.1161.0",
-	"@aws-sdk/client-bedrock-agentcore": "3.1161.0",
-	"@aws-sdk/client-bedrock-runtime": "3.1161.0",
-	"@aws-sdk/client-greengrassv2": "3.1161.0",
-	"@aws-sdk/client-s3": "3.1161.0",
-	"@aws-sdk/client-sts": "3.1161.0",
-	"@aws-sdk/client-cognito-identity-provider": "3.1161.0",
-	"@aws-sdk/credential-providers": "3.1161.0",
-	"@aws-sdk/credential-provider-cognito-identity": "3.972.79",
-	"@aws-sdk/client-secrets-manager": "3.1161.0",
-	"@aws-sdk/rds-signer": "3.1161.0",
+	"@aws-sdk/client-dynamodb": "3.1164.0",
+	"@aws-sdk/client-api-gateway": "3.1164.0",
+	"@aws-sdk/client-iam": "3.1164.0",
+	"@aws-sdk/client-bedrock-agentcore": "3.1164.0",
+	"@aws-sdk/client-bedrock-runtime": "3.1164.0",
+	"@aws-sdk/client-greengrassv2": "3.1164.0",
+	"@aws-sdk/client-s3": "3.1164.0",
+	"@aws-sdk/client-sts": "3.1164.0",
+	"@aws-sdk/client-cognito-identity-provider": "3.1164.0",
+	"@aws-sdk/credential-providers": "3.1164.0",
+	"@aws-sdk/credential-provider-cognito-identity": "3.972.81",
+	"@aws-sdk/client-secrets-manager": "3.1164.0",
+	"@aws-sdk/rds-signer": "3.1164.0",
 	"@smithy/server-apigateway": "0.3.5",
 	"@smithy/server-node": "0.3.5",
 	"@aws-lambda-powertools/logger": "2.36.0",
@@ -22068,7 +22638,7 @@ const NX_VERSION = {
 	"@aws-lambda-powertools/parameters": "2.36.0",
 	"@aws-lambda-powertools/tracer": "2.36.0",
 	"@aws-lambda-powertools/parser": "2.36.0",
-	"@aws-sdk/client-appconfigdata": "3.1161.0",
+	"@aws-sdk/client-appconfigdata": "3.1164.0",
 	"@middy/core": "7.9.2",
 	"@nxlv/python": "23.3.1",
 	"@nx-extend/terraform": "10.4.1",
@@ -22081,33 +22651,33 @@ const NX_VERSION = {
 	"@nx/workspace": "23.3.1",
 	"create-nx-workspace": "23.3.1",
 	"@swc-node/register": "1.12.1",
-	"@swc/core": "1.16.21",
+	"@swc/core": "1.16.22",
 	"@modelcontextprotocol/sdk": "1.32.2",
 	"@modelcontextprotocol/client": "2.4.0",
-	"@modelcontextprotocol/inspector": "2.13.0",
+	"@modelcontextprotocol/inspector": "2.14.0",
 	"@ag-ui/a2ui-toolkit": "0.0.5",
 	"@ag-ui/aws-strands": "1.0.1",
 	"@ag-ui/client": "1.0.2",
 	"@ag-ui/core": "1.0.2",
 	"@ag-ui/encoder": "1.0.2",
 	"agent-chat-cli": "0.3.0",
-	"@copilotkit/react-core": "1.83.0",
+	"@copilotkit/react-core": "1.85.0",
 	rxjs: "7.8.2",
-	"@strands-agents/sdk": "1.23.0",
+	"@strands-agents/sdk": "1.24.0",
 	"@tanstack/react-router": "1.170.46",
-	"@tanstack/router-plugin": "1.168.48",
-	"@tanstack/router-generator": "1.167.46",
+	"@tanstack/router-plugin": "1.169.0",
+	"@tanstack/router-generator": "1.168.0",
 	"@tanstack/virtual-file-routes": "1.162.0",
-	"@tanstack/router-utils": "1.162.4",
-	"@cloudscape-design/board-components": "3.0.243",
-	"@cloudscape-design/chat-components": "1.0.185",
-	"@cloudscape-design/components": "3.0.1407",
-	"@cloudscape-design/global-styles": "1.0.71",
-	"@tanstack/react-query": "5.105.0",
-	"@tanstack/react-query-devtools": "5.105.0",
-	"@trpc/tanstack-react-query": "11.22.1",
-	"@trpc/client": "11.22.1",
-	"@trpc/server": "11.22.1",
+	"@tanstack/router-utils": "1.163.0",
+	"@cloudscape-design/board-components": "3.0.245",
+	"@cloudscape-design/chat-components": "1.0.188",
+	"@cloudscape-design/components": "3.0.1410",
+	"@cloudscape-design/global-styles": "1.0.72",
+	"@tanstack/react-query": "5.107.1",
+	"@tanstack/react-query-devtools": "5.107.1",
+	"@trpc/tanstack-react-query": "11.25.0",
+	"@trpc/client": "11.25.0",
+	"@trpc/server": "11.25.0",
 	"@types/node": "26.6.6",
 	"@types/aws-lambda": "8.10.164",
 	"@types/cors": "2.8.19",
@@ -22117,16 +22687,16 @@ const NX_VERSION = {
 	"@types/express": "5.0.6",
 	"@smithy/config-resolver": "4.7.2",
 	"@smithy/node-config-provider": "4.6.2",
-	"@smithy/node-http-handler": "4.14.1",
-	"@smithy/types": "4.19.0",
-	"@vitest/coverage-v8": "5.0.5",
-	"@vitest/ui": "5.0.5",
+	"@smithy/node-http-handler": "4.14.2",
+	"@smithy/types": "4.20.0",
+	"@vitest/coverage-v8": "5.1.0",
+	"@vitest/ui": "5.1.0",
 	"@astrojs/react": "6.0.6",
-	"@astrojs/starlight": "0.42.8",
-	astro: "7.4.4",
-	cookie: "2.0.1",
+	"@astrojs/starlight": "0.42.10",
+	astro: "7.4.7",
+	cookie: "2.0.2",
 	aws4fetch: "1.0.20",
-	"aws-cdk": "2.1147.0",
+	"aws-cdk": "2.1148.0",
 	"aws-cdk-lib": "2.275.0",
 	"aws-iot-device-sdk-v2": "1.28.2",
 	"aws-xray-sdk-core": "3.12.0",
@@ -22134,13 +22704,13 @@ const NX_VERSION = {
 	cors: "2.8.6",
 	chalk: "6.0.1",
 	"class-variance-authority": "0.7.1",
-	cn: "0.5.1",
-	commander: "15.0.0",
+	cn: "0.5.2",
+	commander: "15.1.0",
 	electrodb: "3.9.3",
 	esbuild: "0.28.2",
 	"event-source-polyfill": "1.0.31",
 	"@types/event-source-polyfill": "1.0.5",
-	"@biomejs/biome": "2.6.4",
+	"@biomejs/biome": "2.6.6",
 	"@prisma/adapter-mariadb": "7.10.1",
 	"@prisma/adapter-pg": "7.10.1",
 	"@prisma/client": "7.10.1",
@@ -22153,8 +22723,8 @@ const NX_VERSION = {
 	"@types/fs-extra": "11.0.4",
 	"js-yaml": "4.3.2",
 	mariadb: "3.5.4",
-	mise: "2026.10.25",
-	npm: "12.2.1",
+	mise: "2026.11.4",
+	npm: "12.2.2",
 	"npm-check-updates": "23.1.1",
 	"oidc-client-ts": "3.5.0",
 	pg: "8.23.1",
@@ -22162,22 +22732,22 @@ const NX_VERSION = {
 	"react-oidc-context": "3.3.1",
 	react: "19.3.1",
 	"react-dom": "19.3.1",
-	rolldown: "1.2.16",
-	"rolldown-plugin-dts": "0.29.0",
+	rolldown: "1.3.0",
+	"rolldown-plugin-dts": "0.30.0",
 	shx: "0.4.0",
 	"simple-git": "4.0.2",
 	"source-map-support": "0.5.21",
 	"starlight-blog": "0.30.2",
-	tailwindcss: "4.3.3",
-	"@tailwindcss/vite": "4.3.3",
+	tailwindcss: "4.3.5",
+	"@tailwindcss/vite": "4.3.5",
 	tsx: "4.23.15",
-	"lucide-react": "1.66.0",
+	"lucide-react": "1.70.0",
 	"radix-ui": "1.8.1",
 	shadcn: "4.23.0",
 	"tw-animate-css": "1.4.0",
-	vite: "8.3.5",
+	vite: "8.3.6",
 	typescript: "6.0.3",
-	vitest: "5.0.5",
+	vitest: "5.1.0",
 	jsdom: "29.1.1",
 	zod: "4.6.7",
 	ws: "8.22.1"
@@ -37622,7 +38192,7 @@ var init_lib$16 = __esmMin((() => {
 var init_stringify_entities = __esmMin((() => {
 	init_lib$16();
 }));
-// ../../node_modules/.pnpm/mdast-util-mdx-jsx@3.2.0_supports-color@10.2.2/node_modules/mdast-util-mdx-jsx/lib/index.js
+// ../../node_modules/.pnpm/mdast-util-mdx-jsx@3.2.1_supports-color@10.2.2/node_modules/mdast-util-mdx-jsx/lib/index.js
 /**
 * Create an extension for `mdast-util-from-markdown` to enable MDX JSX.
 *
@@ -37683,6 +38253,8 @@ function mdxJsxFromMarkdown() {
 		}
 	};
 	/**
+	* Start a buffer.
+	*
 	* @this {CompileContext}
 	* @type {FromMarkdownHandle}
 	*/
@@ -37705,6 +38277,8 @@ function mdxJsxFromMarkdown() {
 		};
 	}
 	/**
+	* Handle data.
+	*
 	* @this {CompileContext}
 	* @type {FromMarkdownHandle}
 	*/
@@ -37713,6 +38287,8 @@ function mdxJsxFromMarkdown() {
 		this.config.exit.data.call(this, token);
 	}
 	/**
+	* Enter a tag.
+	*
 	* @this {CompileContext}
 	* @type {FromMarkdownHandle}
 	*/
@@ -37731,6 +38307,8 @@ function mdxJsxFromMarkdown() {
 		this.buffer();
 	}
 	/**
+	* Enter the closing marker of a tag.
+	*
 	* @this {CompileContext}
 	* @type {FromMarkdownHandle}
 	*/
@@ -37741,6 +38319,8 @@ function mdxJsxFromMarkdown() {
 		}, "mdast-util-mdx-jsx:unexpected-closing-slash");
 	}
 	/**
+	* Enter any attribute.
+	*
 	* @this {CompileContext}
 	* @type {FromMarkdownHandle}
 	*/
@@ -37751,6 +38331,8 @@ function mdxJsxFromMarkdown() {
 		}, "mdast-util-mdx-jsx:unexpected-attribute");
 	}
 	/**
+	* Enter the self-closing marker of a tag.
+	*
 	* @this {CompileContext}
 	* @type {FromMarkdownHandle}
 	*/
@@ -37761,6 +38343,8 @@ function mdxJsxFromMarkdown() {
 		}, "mdast-util-mdx-jsx:unexpected-self-closing-slash");
 	}
 	/**
+	* Exit the closing marker of a tag.
+	*
 	* @this {CompileContext}
 	* @type {FromMarkdownHandle}
 	*/
@@ -37769,6 +38353,8 @@ function mdxJsxFromMarkdown() {
 		tag.close = true;
 	}
 	/**
+	* Exit the primary name of a tag.
+	*
 	* @this {CompileContext}
 	* @type {FromMarkdownHandle}
 	*/
@@ -37777,6 +38363,8 @@ function mdxJsxFromMarkdown() {
 		tag.name = this.sliceSerialize(token);
 	}
 	/**
+	* Exit a member name of a tag.
+	*
 	* @this {CompileContext}
 	* @type {FromMarkdownHandle}
 	*/
@@ -37785,6 +38373,8 @@ function mdxJsxFromMarkdown() {
 		tag.name += "." + this.sliceSerialize(token);
 	}
 	/**
+	* Exit the local name of a tag.
+	*
 	* @this {CompileContext}
 	* @type {FromMarkdownHandle}
 	*/
@@ -37793,6 +38383,8 @@ function mdxJsxFromMarkdown() {
 		tag.name += ":" + this.sliceSerialize(token);
 	}
 	/**
+	* Enter an attribute.
+	*
 	* @this {CompileContext}
 	* @type {FromMarkdownHandle}
 	*/
@@ -37810,6 +38402,8 @@ function mdxJsxFromMarkdown() {
 		});
 	}
 	/**
+	* Enter an expression attribute.
+	*
 	* @this {CompileContext}
 	* @type {FromMarkdownHandle}
 	*/
@@ -37827,6 +38421,8 @@ function mdxJsxFromMarkdown() {
 		this.buffer();
 	}
 	/**
+	* Exit an expression attribute.
+	*
 	* @this {CompileContext}
 	* @type {FromMarkdownHandle}
 	*/
@@ -37834,13 +38430,15 @@ function mdxJsxFromMarkdown() {
 		const tag = this.data.mdxJsxTag;
 		const tail = tag.attributes[tag.attributes.length - 1];
 		tail.type;
-		const estree = token.estree;
+		const { estree } = token;
 		tail.value = this.resume();
 		tail.position;
 		tail.position.end = point(token.end);
 		if (estree) tail.data = { estree };
 	}
 	/**
+	* Exit the primary name of an attribute.
+	*
 	* @this {CompileContext}
 	* @type {FromMarkdownHandle}
 	*/
@@ -37853,6 +38451,8 @@ function mdxJsxFromMarkdown() {
 		node.position.end = point(token.end);
 	}
 	/**
+	* Exit the local name of an attribute.
+	*
 	* @this {CompileContext}
 	* @type {FromMarkdownHandle}
 	*/
@@ -37865,6 +38465,8 @@ function mdxJsxFromMarkdown() {
 		node.position.end = point(token.end);
 	}
 	/**
+	* Exit a literal attribute value.
+	*
 	* @this {CompileContext}
 	* @type {FromMarkdownHandle}
 	*/
@@ -37876,6 +38478,8 @@ function mdxJsxFromMarkdown() {
 		node.position.end = point(token.end);
 	}
 	/**
+	* Exit an expression attribute value.
+	*
 	* @this {CompileContext}
 	* @type {FromMarkdownHandle}
 	*/
@@ -37888,13 +38492,15 @@ function mdxJsxFromMarkdown() {
 			type: "mdxJsxAttributeValueExpression",
 			value: this.resume()
 		};
-		const estree = token.estree;
+		const { estree } = token;
 		if (estree) node.data = { estree };
 		tail.value = node;
 		tail.position;
 		tail.position.end = point(token.end);
 	}
 	/**
+	* Exit the self-closing marker of a tag.
+	*
 	* @this {CompileContext}
 	* @type {FromMarkdownHandle}
 	*/
@@ -37903,6 +38509,8 @@ function mdxJsxFromMarkdown() {
 		tag.selfClosing = true;
 	}
 	/**
+	* Exit a tag.
+	*
 	* @this {CompileContext}
 	* @type {FromMarkdownHandle}
 	*/
@@ -37926,6 +38534,8 @@ function mdxJsxFromMarkdown() {
 		else stack.push(tag);
 	}
 	/**
+	* Crash when a tag is not closed before its parent closes.
+	*
 	* @this {CompileContext}
 	* @type {OnEnterError}
 	*/
@@ -37943,6 +38553,8 @@ function mdxJsxFromMarkdown() {
 		}) + ")" + place, position, "mdast-util-mdx-jsx:end-tag-mismatch");
 	}
 	/**
+	* Crash when a tag is closed by a different construct.
+	*
 	* @this {CompileContext}
 	* @type {OnExitError}
 	*/
@@ -37958,7 +38570,9 @@ function mdxJsxFromMarkdown() {
 	* `self-closing` is not supported, because we don’t need it yet.
 	*
 	* @param {Tag} tag
+	*   Tag.
 	* @returns {string}
+	*   Serialized tag.
 	*/
 	function serializeAbbreviatedTag(tag) {
 		return "<" + (tag.close ? "/" : "") + (tag.name || "") + ">";
@@ -37979,11 +38593,11 @@ function mdxJsxFromMarkdown() {
 function mdxJsxToMarkdown(options) {
 	const options_ = options || {};
 	const quote = options_.quote || "\"";
+	if (quote !== "\"" && quote !== "'") throw new Error("Cannot serialize attribute values with `" + quote + "` for `options.quote`, expected `\"`, or `'`");
 	const quoteSmart = options_.quoteSmart || false;
 	const tightSelfClosing = options_.tightSelfClosing || false;
-	const printWidth = options_.printWidth || Number.POSITIVE_INFINITY;
+	const printWidth = options_.printWidth || Infinity;
 	const alternative = quote === "\"" ? "'" : "\"";
-	if (quote !== "\"" && quote !== "'") throw new Error("Cannot serialize attribute values with `" + quote + "` for `options.quote`, expected `\"`, or `'`");
 	mdxElement.peek = peekElement;
 	return {
 		handlers: {
@@ -38001,13 +38615,18 @@ function mdxJsxToMarkdown(options) {
 		resourceLink: true
 	};
 	/**
+	* Serialize an element.
+	*
 	* @type {ToMarkdownHandle}
 	* @param {MdxJsxFlowElement | MdxJsxTextElement} node
+	*   Node.
 	*/
 	function mdxElement(node, _, state, info) {
 		const flow = node.type === "mdxJsxFlowElement";
 		const selfClosing = node.name ? !node.children || node.children.length === 0 : false;
-		const currentIndent = createIndent(inferDepth(state));
+		const depth = inferDepth(state);
+		const currentIndent = createIndent(depth);
+		const expressionIndent = flow || depth === 0 ? indent : "";
 		const trackerOneLine = state.createTracker(info);
 		const trackerMultiLine = state.createTracker(info);
 		/** @type {Array<string>} */
@@ -38023,14 +38642,14 @@ function mdxJsxToMarkdown(options) {
 				const attribute = node.attributes[index];
 				/** @type {string} */
 				let result;
-				if (attribute.type === "mdxJsxExpressionAttribute") result = "{" + (attribute.value || "") + "}";
+				if (attribute.type === "mdxJsxExpressionAttribute") result = serializeExpression(state, attribute.value || "", expressionIndent);
 				else {
 					if (!attribute.name) throw new Error("Cannot serialize attribute w/o name");
-					const value = attribute.value;
+					const { value } = attribute;
 					const left = attribute.name;
 					/** @type {string} */
 					let right = "";
-					if (value === null || value === void 0) {} else if (typeof value === "object") right = "{" + (value.value || "") + "}";
+					if (value === null || value === void 0) {} else if (typeof value === "object") right = serializeExpression(state, value.value || "", expressionIndent);
 					else {
 						const appliedQuote = quoteSmart && ccount(value, quote) > ccount(value, alternative) ? alternative : quote;
 						right = appliedQuote + stringifyEntitiesLight(value, { subset: [appliedQuote] }) + appliedQuote;
@@ -38072,6 +38691,8 @@ function mdxJsxToMarkdown(options) {
 	}
 }
 /**
+* Serialize the flow children of an element.
+*
 * @param {MdxJsxFlowElement} parent
 *   Parent of flow nodes.
 * @param {State} state
@@ -38082,8 +38703,8 @@ function mdxJsxToMarkdown(options) {
 *   Serialized children, joined by (blank) lines.
 */
 function containerFlow$1(parent, state, info) {
-	const indexStack = state.indexStack;
-	const children = parent.children;
+	const { indexStack } = state;
+	const { children } = parent;
 	const tracker = state.createTracker(info);
 	const currentIndent = createIndent(inferDepth(state));
 	/** @type {Array<string>} */
@@ -38110,8 +38731,12 @@ function containerFlow$1(parent, state, info) {
 	return results.join("");
 }
 /**
+* Infer how many JSX elements we are in.
+*
 * @param {State} state
+*   Info passed around about the current state.
 * @returns {number}
+*   Depth.
 */
 function inferDepth(state) {
 	let depth = 0;
@@ -38124,18 +38749,43 @@ function inferDepth(state) {
 	return depth;
 }
 /**
+* Create an indent.
+*
 * @param {number} depth
+*   Depth.
 * @returns {string}
+*   Indent.
 */
 function createIndent(depth) {
 	return indent.repeat(depth);
 }
 /**
+* Peek an element.
+*
 * @type {ToMarkdownHandle}
 */
 function peekElement() {
 	return "<";
 }
+/**
+* Serialize an expression in an attribute.
+*
+* @param {State} state
+*   Info passed around about the current state.
+* @param {string} value
+*   Value of expression.
+* @param {string} indent
+*   Indent to add to lines after the first.
+* @returns {string}
+*   Serialized expression.
+*/
+function serializeExpression(state, value, indent) {
+	let result = value;
+	if (indent) result = state.indentLines(result, function(line, index, blank) {
+		return (index === 0 || blank ? "" : indent) + line;
+	});
+	return "{" + result + "}";
+}
 var indent;
 var init_lib$15 = __esmMin((() => {
 	init_ccount();
@@ -38146,7 +38796,7 @@ var init_lib$15 = __esmMin((() => {
 	init_vfile_message();
 	indent = "  ";
 }));
-// ../../node_modules/.pnpm/mdast-util-mdx-jsx@3.2.0_supports-color@10.2.2/node_modules/mdast-util-mdx-jsx/index.js
+// ../../node_modules/.pnpm/mdast-util-mdx-jsx@3.2.1_supports-color@10.2.2/node_modules/mdast-util-mdx-jsx/index.js
 var init_mdast_util_mdx_jsx = __esmMin((() => {
 	init_lib$15();
 }));