camox 0.40.0 → 0.41.1

package/dist/core/hooks/useIsEditable.js

@@ -1,22 +1,19 @@
 import { useIsAuthenticated } from "../../lib/auth.js";
-import { previewStore } from "../../features/preview/previewStore.js";
+import { previewStore, selectIsEditMode } from "../../features/preview/previewStore.js";
 import { c } from "react/compiler-runtime";
 import { useSelector } from "@xstate/store-react";
 
 //#region src/core/hooks/useIsEditable.ts
 function useIsEditable(mode) {
 	const $ = c(1);
-	if ($[0] !== "a3e376179cf3461f650a645c5d9591b7c0b2bd69400f81ba76076063ea10dffc") {
+	if ($[0] !== "baeaba7613c819c1f4460b64af1c246a057a26cf699e41daca4193d0ee512f1c") {
 		for (let $i = 0; $i < 1; $i += 1) $[$i] = Symbol.for("react.memo_cache_sentinel");
-		$[0] = "a3e376179cf3461f650a645c5d9591b7c0b2bd69400f81ba76076063ea10dffc";
+		$[0] = "baeaba7613c819c1f4460b64af1c246a057a26cf699e41daca4193d0ee512f1c";
 	}
 	const isAuthenticated = useIsAuthenticated();
-	const isEditMode = useSelector(previewStore, _temp);
+	const isEditMode = useSelector(previewStore, selectIsEditMode);
 	return isAuthenticated && (mode === "site" || mode === "layout") && isEditMode;
 }
-function _temp(state) {
-	return state.context.isEditMode;
-}
 
 //#endregion
 export { useIsEditable };

package/dist/core/hooks/useRequireDraftSource.js

@@ -1,26 +1,22 @@
-import { previewStore } from "../../features/preview/previewStore.js";
+import { previewStore, selectPreviewSource } from "../../features/preview/previewStore.js";
 import { c } from "react/compiler-runtime";
 
 //#region src/core/hooks/useRequireDraftSource.ts
 /**
-* Gate any edit attempt on the current preview source. If the studio is
-* previewing 'draft', `requireDraft()` returns true and the caller proceeds.
-* Otherwise it opens the "Switch to draft to edit?" dialog and returns false
-* so the caller aborts. The dialog's CTA only switches the source — it does
-* not retry the original attempt; the user re-issues the edit themselves.
+* Ignore stale editor callbacks after switching to live preview.
+* Draft editing is guaranteed by the store's mode; this guard also covers
+* callbacks from hidden controls and edits that finish asynchronously.
 */
 function useRequireDraftSource() {
 	const $ = c(1);
-	if ($[0] !== "0362e577777f438ffefe38cac1aa50ad433841f5f7cbde91e17cf0313273dbef") {
+	if ($[0] !== "cb874573187dc3b9520288b70786314b287b85d7bd338855d2b28db5ee7c09c2") {
 		for (let $i = 0; $i < 1; $i += 1) $[$i] = Symbol.for("react.memo_cache_sentinel");
-		$[0] = "0362e577777f438ffefe38cac1aa50ad433841f5f7cbde91e17cf0313273dbef";
+		$[0] = "cb874573187dc3b9520288b70786314b287b85d7bd338855d2b28db5ee7c09c2";
 	}
 	return _temp;
 }
 function _temp() {
-	if (previewStore.getSnapshot().context.previewSource === "draft") return true;
-	previewStore.send({ type: "requestDraftSwitch" });
-	return false;
+	return selectPreviewSource(previewStore.getSnapshot()) === "draft";
 }
 
 //#endregion

package/dist/core/lib/lexicalReact.d.ts

@@ -1,26 +1 @@
-import * as React from "react";
-
-//#region src/core/lib/lexicalReact.d.ts
-interface MarkdownLinkRenderProps {
-  href: string;
-  target?: string;
-  rel?: string;
-  children: React.ReactNode;
-}
-interface MarkdownLinkRenderData {
-  target: string;
-  href: string;
-  external: boolean;
-  pageId?: string;
-}
-interface MarkdownInlineComponents {
-  link?: (props: MarkdownLinkRenderProps, data: MarkdownLinkRenderData) => React.ReactNode;
-  strong?: (props: {
-    children: React.ReactNode;
-  }) => React.ReactNode;
-  emphasis?: (props: {
-    children: React.ReactNode;
-  }) => React.ReactNode;
-}
-//#endregion
-export { MarkdownInlineComponents, MarkdownLinkRenderData, MarkdownLinkRenderProps };
+import { InlineStyle, InlineTextStyles, TextLinkStyleData, TextStyleData } from "./textStyles.js";

package/dist/core/lib/lexicalReact.js

@@ -1,72 +1,58 @@
-import { getPageIdFromTextLinkTarget, isHttpTextLinkTarget, isValidTextLinkTarget, resolveTextLinkHref, shouldOpenTextLinkInNewTab } from "./textLinks.js";
+import { FORMAT_FLAGS } from "./modifierFormats.js";
+import { getPageIdFromTextLinkTarget, isHttpTextLinkTarget, resolveTextLinkHref, shouldOpenTextLinkInNewTab } from "./textLinks.js";
+import { isLexicalState, markdownToLexicalState } from "./lexicalState.js";
+import { getGradientStyle, getTextAppearance } from "./textStyles.js";
 import * as React from "react";
-import { Fragment, jsx } from "react/jsx-runtime";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 
 //#region src/core/lib/lexicalReact.tsx
-/**
-* Parse a markdown string with **bold**, *italic*, and text links into React nodes.
-* Falls back to rendering the raw string if it's not a string value.
-*/
 function markdownToReactNodes(value, options = {}) {
-	if (typeof value !== "string") return null;
 	if (!value) return null;
-	const parts = [];
-	let key = 0;
-	const fallbackHref = options.fallbackHref ?? "#";
-	const pushWithLineBreaks = (text) => {
-		text.split("\n").forEach((line, i) => {
-			if (i > 0) parts.push(/* @__PURE__ */ jsx("br", {}, key++));
-			if (line) parts.push(line);
-		});
-	};
-	const pushFormatted = (text) => {
-		const regex = /(\*{1,3})((?:(?!\1).)+)\1/g;
-		let lastIndex = 0;
-		let match;
-		while ((match = regex.exec(text)) !== null) {
-			if (match.index > lastIndex) pushWithLineBreaks(text.slice(lastIndex, match.index));
-			const stars = match[1].length;
-			const content = match[2];
-			if (stars === 3) {
-				const emphasis = options.components?.emphasis?.({ children: content }) ?? /* @__PURE__ */ jsx("em", { children: content });
-				parts.push(/* @__PURE__ */ jsx(React.Fragment, { children: options.components?.strong?.({ children: emphasis }) ?? /* @__PURE__ */ jsx("strong", { children: emphasis }) }, key++));
-			} else if (stars === 2) parts.push(/* @__PURE__ */ jsx(React.Fragment, { children: options.components?.strong?.({ children: content }) ?? /* @__PURE__ */ jsx("strong", { children: content }) }, key++));
-			else parts.push(/* @__PURE__ */ jsx(React.Fragment, { children: options.components?.emphasis?.({ children: content }) ?? /* @__PURE__ */ jsx("em", { children: content }) }, key++));
-			lastIndex = match.index + match[0].length;
+	if (typeof value !== "string" && !isLexicalState(value)) return null;
+	const state = isLexicalState(value) ? typeof value === "string" ? JSON.parse(value) : value : markdownToLexicalState(value);
+	function render(node, key) {
+		if (node.type === "text") {
+			const format = node.format ?? 0;
+			let tag = "span";
+			if (format & FORMAT_FLAGS.bold) tag = "strong";
+			else if (format & FORMAT_FLAGS.italic) tag = "em";
+			return React.createElement(tag, {
+				key,
+				...getTextAppearance(format, options)
+			}, node.text);
 		}
-		if (lastIndex < text.length) pushWithLineBreaks(text.slice(lastIndex));
-	};
-	const linkRegex = /\[([^\]]+)\]\(([^)]+)\)/g;
-	let lastLinkIndex = 0;
-	let linkMatch;
-	while ((linkMatch = linkRegex.exec(value)) !== null) {
-		if (linkMatch.index > lastLinkIndex) pushFormatted(value.slice(lastLinkIndex, linkMatch.index));
-		const [, label, target] = linkMatch;
-		const href = isValidTextLinkTarget(target) ? resolveTextLinkHref(target, options.pages, fallbackHref) : null;
-		if (href) {
-			const openInNewTab = shouldOpenTextLinkInNewTab(target);
-			const linkProps = {
+		if (node.type === "linebreak") return /* @__PURE__ */ jsx("br", {}, key);
+		const children = (node.children ?? []).map(render);
+		if (node.type === "gradient") return /* @__PURE__ */ jsx("span", {
+			"data-camox-gradient": "",
+			...getGradientStyle(options),
+			children
+		}, key);
+		if (node.type === "link") {
+			const href = resolveTextLinkHref(node.url, options.pages, options.fallbackHref ?? "#");
+			if (!href) return /* @__PURE__ */ jsx(React.Fragment, { children }, key);
+			const appearance = options.linkStyle?.({
+				target: node.url,
 				href,
-				target: openInNewTab ? "_blank" : void 0,
-				rel: openInNewTab ? "noreferrer" : void 0,
-				children: label
-			};
-			const linkData = {
-				target,
+				external: isHttpTextLinkTarget(node.url),
+				pageId: getPageIdFromTextLinkTarget(node.url) ?? void 0
+			});
+			const newTab = shouldOpenTextLinkInNewTab(node.url);
+			return /* @__PURE__ */ jsx("a", {
 				href,
-				external: isHttpTextLinkTarget(target),
-				pageId: getPageIdFromTextLinkTarget(target) ?? void 0
-			};
-			parts.push(/* @__PURE__ */ jsx(React.Fragment, { children: options.components?.link?.(linkProps, linkData) ?? /* @__PURE__ */ jsx("a", {
-				...linkProps,
-				style: { textDecorationLine: "underline" }
-			}) }, key++));
-		} else pushFormatted(label);
-		lastLinkIndex = linkMatch.index + linkMatch[0].length;
+				target: newTab ? "_blank" : void 0,
+				rel: newTab ? "noreferrer" : void 0,
+				className: appearance?.className,
+				style: {
+					textDecorationLine: "underline",
+					...appearance?.style
+				},
+				children
+			}, key);
+		}
+		return /* @__PURE__ */ jsx(React.Fragment, { children }, key);
 	}
-	if (lastLinkIndex < value.length) pushFormatted(value.slice(lastLinkIndex));
-	if (parts.length === 0) return value;
-	return /* @__PURE__ */ jsx(Fragment, { children: parts });
+	return /* @__PURE__ */ jsx(Fragment, { children: state.root.children.map((node, index) => /* @__PURE__ */ jsxs(React.Fragment, { children: [index > 0 && /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx("br", {}), /* @__PURE__ */ jsx("br", {})] }), render(node, index)] }, index)) });
 }
 
 //#endregion

package/dist/core/lib/lexicalState.js

@@ -1,5 +1,6 @@
+import { FORMAT_FLAGS } from "./modifierFormats.js";
 import { isValidTextLinkTarget } from "./textLinks.js";
-import { FORMAT_FLAGS, lexicalTextToMarkdown } from "./modifierFormats.js";
+import { Lexer } from "marked";
 
 //#region src/core/lib/lexicalState.ts
 function isLexicalState(value) {
@@ -19,18 +20,87 @@ function lexicalStateToMarkdown(serialized) {
 	}
 }
 function extractMarkdownFromNode(node) {
-	if (node.type === "text") return lexicalTextToMarkdown(node.text ?? "", node.format ?? 0);
+	if (node.type === "gradient") return `<gradient>${serializeInlineChildren(node.children ?? [])}</gradient>`;
 	if (node.type === "link") {
-		const text = (node.children ?? []).map(extractMarkdownFromNode).join("");
+		const text = serializeInlineChildren(node.children ?? []);
 		const url = typeof node.url === "string" ? node.url : "";
 		if (!url) return text;
 		return `[${text}](${url})`;
 	}
 	if (node.type === "linebreak") return "\n";
 	if (!node.children) return "";
-	const parts = [];
-	for (const child of node.children) parts.push(extractMarkdownFromNode(child));
-	return parts.join("");
+	return serializeInlineChildren(node.children);
+}
+function serializeInlineChildren(nodes) {
+	const marks = [
+		{
+			flag: FORMAT_FLAGS.underline,
+			open: "<u>",
+			close: "</u>"
+		},
+		{
+			flag: FORMAT_FLAGS.bold,
+			open: "**",
+			close: "**"
+		},
+		{
+			flag: FORMAT_FLAGS.italic,
+			open: "*",
+			close: "*"
+		}
+	];
+	let active = [];
+	let result = "";
+	function transition(next) {
+		let common = 0;
+		while (common < active.length && common < next.length && active[common] === next[common]) common++;
+		for (let i = active.length - 1; i >= common; i--) result += active[i].close;
+		for (let i = common; i < next.length; i++) result += next[i].open;
+		active = next;
+	}
+	for (const node of nodes) {
+		if (node.type !== "text") {
+			transition([]);
+			result += extractMarkdownFromNode(node);
+			continue;
+		}
+		transition(marks.filter(({ flag }) => (node.format ?? 0) & flag));
+		result += (node.text ?? "").replace(/[\\*_[\]<>]/g, "\\$&");
+	}
+	transition([]);
+	if (inlineSignature(parseInlineMarkdown(result)) === inlineSignature(nodes)) return result;
+	return nodes.map((node) => {
+		if (node.type !== "text") return extractMarkdownFromNode(node);
+		let text = (node.text ?? "").replace(/[\\*_[\]<>]/g, "\\$&");
+		if (node.format & FORMAT_FLAGS.italic) text = `<em>${text}</em>`;
+		if (node.format & FORMAT_FLAGS.bold) text = `<strong>${text}</strong>`;
+		if (node.format & FORMAT_FLAGS.underline) text = `<u>${text}</u>`;
+		return text;
+	}).join("");
+}
+function inlineSignature(nodes) {
+	const normalized = [];
+	for (const node of nodes) {
+		if (node.type === "text") {
+			const last = normalized.at(-1);
+			if (last?.type === "text" && last.format === node.format) {
+				last.text += node.text;
+				continue;
+			}
+			normalized.push({
+				type: "text",
+				text: node.text,
+				format: node.format ?? 0
+			});
+			continue;
+		}
+		normalized.push({
+			type: node.type,
+			url: node.url,
+			children: node.children ? inlineSignature(node.children) : void 0
+		});
+	}
+	return JSON.stringify(normalized);
 }
 function extractMarkdown(node) {
 	if (!node.children) return "";
@@ -44,8 +114,8 @@ function extractMarkdown(node) {
 */
 function markdownToLexicalState(markdown) {
 	return { root: {
-		children: markdown.split(/\n\n+/).map((para) => ({
-			children: parseParagraphWithLineBreaks(para),
+		children: [{
+			children: parseInlineMarkdown(markdown),
 			direction: "ltr",
 			format: "",
 			indent: 0,
@@ -53,7 +123,7 @@ function markdownToLexicalState(markdown) {
 			version: 1,
 			textFormat: 0,
 			textStyle: ""
-		})),
+		}],
 		direction: "ltr",
 		format: "",
 		indent: 0,
@@ -61,84 +131,97 @@ function markdownToLexicalState(markdown) {
 		version: 1
 	} };
 }
-function parseParagraphWithLineBreaks(para) {
-	const lines = para.split("\n");
-	const nodes = [];
-	lines.forEach((line, index) => {
-		if (index > 0) nodes.push({
-			type: "linebreak",
-			version: 1
-		});
-		nodes.push(...parseInlineMarkdown(line));
-	});
-	return nodes;
+function inlineElement(type, children, extra = {}) {
+	return {
+		type,
+		children,
+		direction: "ltr",
+		format: "",
+		indent: 0,
+		version: 1,
+		...extra
+	};
+}
+/** Shared by the public renderer and editor. Only recognized inline syntax is interpreted. */
+function parseInlineMarkdown(text, format = 0) {
+	return parseTokens(Lexer.lexInline(text, { gfm: false }), format);
 }
-function parseInlineMarkdown(text) {
+function parseTokens(tokens, format) {
 	const nodes = [];
-	const linkRegex = /\[([^\]]+)\]\(([^)]+)\)/g;
-	let lastLinkIndex = 0;
-	let linkMatch;
-	while ((linkMatch = linkRegex.exec(text)) !== null) {
-		if (linkMatch.index > lastLinkIndex) nodes.push(...parseFormattedText(text.slice(lastLinkIndex, linkMatch.index)));
-		const [, label, target] = linkMatch;
-		if (isValidTextLinkTarget(target)) nodes.push({
-			children: parseFormattedText(label),
-			direction: "ltr",
-			format: "",
-			indent: 0,
-			rel: null,
-			target: null,
-			title: null,
-			type: "link",
-			url: target,
-			version: 1
+	const appendText = (text) => {
+		text.split("\n").forEach((line, index) => {
+			if (index) nodes.push({
+				type: "linebreak",
+				version: 1
+			});
+			if (!line) return;
+			const last = nodes.at(-1);
+			if (last?.type === "text" && last.format === format) {
+				last.text += line;
+				return;
+			}
+			nodes.push({
+				detail: 0,
+				format,
+				mode: "normal",
+				style: "",
+				text: line,
+				type: "text",
+				version: 1
+			});
 		});
-		else nodes.push(...parseFormattedText(label));
-		lastLinkIndex = linkMatch.index + linkMatch[0].length;
+	};
+	for (let i = 0; i < tokens.length; i++) {
+		const token = tokens[i];
+		if (token.type === "strong" || token.type === "em") {
+			nodes.push(...parseTokens(token.tokens ?? [], format | (token.type === "strong" ? FORMAT_FLAGS.bold : FORMAT_FLAGS.italic)));
+			continue;
+		}
+		if (token.type === "link") {
+			const children = parseTokens(token.tokens ?? [], format);
+			if (isValidTextLinkTarget(token.href)) nodes.push(inlineElement("link", children, {
+				url: token.href,
+				rel: null,
+				target: null,
+				title: null
+			}));
+			else nodes.push(...children);
+			continue;
+		}
+		const tag = token.type === "html" ? /^<(gradient|u|strong|em)>$/.exec(token.raw)?.[1] : void 0;
+		if (tag) {
+			let depth = 1;
+			let end = i + 1;
+			for (; end < tokens.length; end++) {
+				if (tokens[end].type !== "html") continue;
+				if (tokens[end].raw === `<${tag}>`) depth++;
+				if (tokens[end].raw === `</${tag}>`) depth--;
+				if (!depth) break;
+			}
+			if (!depth) {
+				const tagFlags = {
+					u: FORMAT_FLAGS.underline,
+					strong: FORMAT_FLAGS.bold,
+					em: FORMAT_FLAGS.italic
+				};
+				const children = parseTokens(tokens.slice(i + 1, end), format | (tagFlags[tag] ?? 0));
+				if (tag === "gradient") nodes.push(inlineElement("gradient", children));
+				else nodes.push(...children);
+				i = end;
+				continue;
+			}
+		}
+		if (token.type === "br") {
+			nodes.push({
+				type: "linebreak",
+				version: 1
+			});
+			continue;
+		}
+		appendText(token.type === "text" || token.type === "escape" ? token.text : token.raw);
 	}
-	if (lastLinkIndex < text.length) nodes.push(...parseFormattedText(text.slice(lastLinkIndex)));
-	if (nodes.length === 0) return parseFormattedText(text);
 	return nodes;
 }
-function parseFormattedText(text) {
-	const segments = [];
-	const regex = /(\*{1,3})((?:(?!\1).)+)\1/g;
-	let lastIndex = 0;
-	let match;
-	while ((match = regex.exec(text)) !== null) {
-		if (match.index > lastIndex) segments.push({
-			text: text.slice(lastIndex, match.index),
-			format: 0
-		});
-		const stars = match[1].length;
-		let format = 0;
-		if (stars === 1) format = FORMAT_FLAGS.italic;
-		else if (stars === 2) format = FORMAT_FLAGS.bold;
-		else if (stars === 3) format = FORMAT_FLAGS.bold | FORMAT_FLAGS.italic;
-		segments.push({
-			text: match[2],
-			format
-		});
-		lastIndex = match.index + match[0].length;
-	}
-	if (lastIndex < text.length) segments.push({
-		text: text.slice(lastIndex),
-		format: 0
-	});
-	if (segments.length === 0) segments.push({
-		text,
-		format: 0
-	});
-	return segments.map((seg) => ({
-		detail: 0,
-		format: seg.format,
-		mode: "normal",
-		style: "",
-		text: seg.text,
-		type: "text",
-		version: 1
-	}));
-}
 
 //#endregion
 export { isLexicalState, lexicalStateToMarkdown, markdownToLexicalState };

package/dist/core/lib/modifierFormats.js

@@ -2,21 +2,10 @@
 /** Format bitmask flags matching Lexical's internal constants */
 const FORMAT_FLAGS = {
 	bold: 1,
-	italic: 2
+	italic: 2,
+	underline: 8,
+	gradient: 1 << 20
 };
-/** Markdown wrappers keyed by format name */
-const MARKDOWN_WRAPPERS = {
-	bold: (text) => `**${text}**`,
-	italic: (text) => `*${text}*`
-};
-function lexicalTextToMarkdown(text, format) {
-	let result = text;
-	for (const [key, wrapper] of Object.entries(MARKDOWN_WRAPPERS)) {
-		const flag = FORMAT_FLAGS[key];
-		if (flag && format & flag) result = wrapper(result);
-	}
-	return result;
-}
 
 //#endregion
-export { FORMAT_FLAGS, lexicalTextToMarkdown };
+export { FORMAT_FLAGS };

package/dist/core/lib/textStyles.d.ts

@@ -0,0 +1,27 @@
+import { CSSProperties } from "react";
+
+//#region src/core/lib/textStyles.d.ts
+interface InlineStyle {
+  className?: string;
+  style?: CSSProperties;
+}
+interface TextStyleData {
+  /** True when styling the shared gradient wrapper. Other flags are false for this call. */
+  gradient: boolean;
+  bold: boolean;
+  italic: boolean;
+  underline: boolean;
+}
+interface TextLinkStyleData {
+  target: string;
+  href: string;
+  external: boolean;
+  pageId?: string;
+}
+/** Appearance only: Camox owns inline elements in both rendering modes. */
+interface InlineTextStyles {
+  textStyle?: (format: TextStyleData) => InlineStyle | undefined;
+  linkStyle?: (link: TextLinkStyleData) => InlineStyle | undefined;
+}
+//#endregion
+export { InlineStyle, InlineTextStyles, TextLinkStyleData, TextStyleData };

package/dist/core/lib/textStyles.js

@@ -0,0 +1,47 @@
+import { FORMAT_FLAGS } from "./modifierFormats.js";
+
+//#region src/core/lib/textStyles.ts
+function getTextStyleData(format) {
+	return {
+		gradient: false,
+		bold: !!(format & FORMAT_FLAGS.bold),
+		italic: !!(format & FORMAT_FLAGS.italic),
+		underline: !!(format & FORMAT_FLAGS.underline)
+	};
+}
+function getTextAppearance(format, styles) {
+	const flags = getTextStyleData(format);
+	const custom = styles.textStyle?.(flags);
+	return {
+		className: custom?.className,
+		style: {
+			...flags.bold && flags.italic ? { fontStyle: "italic" } : {},
+			...flags.underline ? { textDecorationLine: "underline" } : {},
+			...custom?.style
+		}
+	};
+}
+const defaultGradientStyle = {
+	backgroundImage: "linear-gradient(to right, var(--camox-gradient-from, var(--chart-1, var(--primary, currentColor))), var(--camox-gradient-to, var(--chart-2, var(--muted-foreground, currentColor))))",
+	backgroundClip: "text",
+	WebkitBackgroundClip: "text",
+	WebkitTextFillColor: "transparent"
+};
+function getGradientStyle(styles) {
+	const custom = styles.textStyle?.({
+		gradient: true,
+		bold: false,
+		italic: false,
+		underline: false
+	});
+	return {
+		className: custom?.className,
+		style: {
+			...defaultGradientStyle,
+			...custom?.style
+		}
+	};
+}
+
+//#endregion
+export { getGradientStyle, getTextAppearance };

package/dist/features/navigation/navigation.d.ts

@@ -19,11 +19,13 @@ declare function NavigationProvider({
   children,
   getLocation,
   initialLocation,
+  location: controlledLocation,
   navigate
 }: {
   children: React.ReactNode;
   getLocation?: () => LocationState;
   initialLocation?: LocationState;
+  location?: LocationState;
   navigate?: (options: NavigateOptions) => Promise<void> | void;
 }): _$react_jsx_runtime0.JSX.Element;
 declare function useLocation<T = LocationState>(options?: {