@qzsy/vinext 0.1.7

package/dist/shims/font-utils.js

@@ -0,0 +1,107 @@
+//#region src/shims/font-utils.ts
+/**
+* Escape a string for safe interpolation inside a CSS single-quoted string.
+*
+* Prevents CSS injection by escaping characters that could break out of
+* a `'...'` CSS string context: backslashes, single quotes, and newlines.
+*
+* Used by font-google-base.ts, font-local.ts, and fallback-metrics.ts.
+*/
+function escapeCSSString(value) {
+	return value.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/\n/g, "\\a ").replace(/\r/g, "\\d ");
+}
+/**
+* Validate a CSS custom property name (e.g. `--font-inter`).
+*
+* Custom properties must start with `--` and only contain alphanumeric
+* characters, hyphens, and underscores. Anything else could be used to
+* break out of the CSS declaration and inject arbitrary rules.
+*
+* Returns the name if valid, undefined otherwise.
+*/
+function sanitizeCSSVarName(name) {
+	if (/^--[a-zA-Z0-9_-]+$/.test(name)) return name;
+}
+/**
+* Sanitize a CSS font-family fallback name.
+*
+* Generic family names (sans-serif, serif, monospace, etc.) are used as-is.
+* Named families are wrapped in escaped quotes. This prevents injection via
+* crafted fallback values like `); } body { color: red; } .x {`.
+*/
+function sanitizeFallback(name) {
+	const generics = new Set([
+		"serif",
+		"sans-serif",
+		"monospace",
+		"cursive",
+		"fantasy",
+		"system-ui",
+		"ui-serif",
+		"ui-sans-serif",
+		"ui-monospace",
+		"ui-rounded",
+		"emoji",
+		"math",
+		"fangsong"
+	]);
+	const trimmed = name.trim();
+	if (generics.has(trimmed)) return trimmed;
+	return `'${escapeCSSString(trimmed)}'`;
+}
+function singleFontOptionValue(value) {
+	if (Array.isArray(value)) return new Set(value).size === 1 ? value[0] : void 0;
+	return value;
+}
+function sanitizeFontDescriptorValue(value) {
+	if (/[{};]|\/\*|\*\/|<\//i.test(value)) return void 0;
+	return value;
+}
+function resolveFontWeight(weight) {
+	const value = singleFontOptionValue(weight);
+	if (!value || value.includes(" ")) return void 0;
+	const numericWeight = Number(value);
+	return Number.isFinite(numericWeight) ? numericWeight : void 0;
+}
+function resolveFontStyle(style) {
+	const value = singleFontOptionValue(style);
+	if (!value || value.includes(" ")) return void 0;
+	return sanitizeFontDescriptorValue(value);
+}
+function resolveGoogleFontStyle(style) {
+	if (style === void 0) return "normal";
+	const value = singleFontOptionValue(style);
+	if (!value) return void 0;
+	if (value === "normal" || value === "italic") return value;
+}
+function resolveSingleFaceStyle(input) {
+	const fontWeight = input.internalWeight ?? resolveFontWeight(input.weight);
+	const fontStyle = (input.internalStyle ? sanitizeFontDescriptorValue(input.internalStyle) : void 0) ?? (input.google ? resolveGoogleFontStyle(input.style) : resolveFontStyle(input.style));
+	return {
+		fontFamily: input.fontFamily,
+		...fontWeight !== void 0 ? { fontWeight } : {},
+		...fontStyle ? { fontStyle } : {}
+	};
+}
+function formatFontClassRule(className, style) {
+	const fontStyle = style.fontStyle ? sanitizeFontDescriptorValue(style.fontStyle) : void 0;
+	return `.${className} { ${[
+		`font-family: ${style.fontFamily}`,
+		...style.fontWeight !== void 0 ? [`font-weight: ${style.fontWeight}`] : [],
+		...fontStyle ? [`font-style: ${fontStyle}`] : []
+	].join("; ")}; }\n`;
+}
+/**
+* Determine the MIME type for a font file based on its extension.
+* Uses endsWith() only to avoid false positives from substring matches
+* (e.g. ".woff" matching ".woff2").
+*/
+function getFontMimeType(pathOrUrl) {
+	if (pathOrUrl.endsWith(".woff2")) return "font/woff2";
+	if (pathOrUrl.endsWith(".woff")) return "font/woff";
+	if (pathOrUrl.endsWith(".ttf")) return "font/ttf";
+	if (pathOrUrl.endsWith(".otf")) return "font/opentype";
+	return "font/woff2";
+}
+//#endregion
+export { escapeCSSString, formatFontClassRule, getFontMimeType, resolveFontStyle, resolveFontWeight, resolveGoogleFontStyle, resolveSingleFaceStyle, sanitizeCSSVarName, sanitizeFallback, sanitizeFontDescriptorValue, singleFontOptionValue };

package/dist/shims/form.d.ts

@@ -0,0 +1,19 @@
+import { FormHTMLAttributes, useActionState } from "react";
+
+//#region src/shims/form.d.ts
+declare const Form: import("react").ForwardRefExoticComponent<{
+  /** Target URL for GET forms, or server action for POST forms */action: string | ((formData: FormData) => void | Promise<void>); /** Replace instead of push in history (default: false) */
+  replace?: boolean; /** Scroll to top after navigation (default: true) */
+  scroll?: boolean;
+  /**
+   * Controls whether the form's target URL is prefetched when the form enters
+   * the viewport. Only applies to App Router with a string `action`.
+   * - `null` (default): prefetch automatically (production only)
+   * - `false`: disable prefetching
+   *
+   * In pages dir, prefetch is not supported and the prop has no effect.
+   */
+  prefetch?: false | null;
+} & Omit<FormHTMLAttributes<HTMLFormElement>, "method" | "encType" | "target"> & import("react").RefAttributes<HTMLFormElement>>;
+//#endregion
+export { Form as default, useActionState };

package/dist/shims/form.js

@@ -0,0 +1,236 @@
+"use client";
+import { VINEXT_MOUNTED_SLOTS_HEADER } from "../server/headers.js";
+import { isDangerousScheme } from "./url-safety.js";
+import { AppElementsWire } from "../server/app-elements-wire.js";
+import "../server/app-elements.js";
+import { toSameOriginPath, withBasePath } from "./url-utils.js";
+import { createRscRequestHeaders, createRscRequestUrl } from "../server/app-rsc-cache-busting.js";
+import { hasAppNavigationRuntime } from "../client/navigation-runtime.js";
+import { getMountedSlotsHeader, getPrefetchInterceptionContext, getPrefetchedUrls, hasPrefetchCacheEntryForNavigation, navigateClientSide, prefetchRscResponse } from "./navigation.js";
+import { useMergedRef } from "./use-merged-ref.js";
+import { forwardRef, useActionState, useCallback, useEffect, useRef } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/shims/form.tsx
+/**
+* next/form shim
+*
+* Progressive enhancement form component. In Next.js, this replaces
+* the standard <form> element with one that intercepts submissions
+* and performs client-side navigation for GET forms (search forms).
+*
+* For POST forms with server actions, it delegates to React's built-in
+* form action handling.
+*
+* Usage:
+*   import Form from 'next/form';
+*   <Form action="/search">
+*     <input name="q" />
+*     <button type="submit">Search</button>
+*   </Form>
+*/
+const __basePath = process.env.__NEXT_ROUTER_BASEPATH ?? "";
+const DISALLOWED_FORM_PROPS = [
+	"method",
+	"encType",
+	"target"
+];
+const SUPPORTED_FORM_ENCTYPE = "application/x-www-form-urlencoded";
+const SUPPORTED_FORM_METHOD = "GET";
+const SUPPORTED_FORM_TARGET = "_self";
+function isSafeAction(action) {
+	if (isDangerousScheme(action)) return false;
+	if (action.startsWith("//")) return false;
+	if (/^https?:\/\//i.test(action)) {
+		if (typeof window !== "undefined") try {
+			return new URL(action).origin === window.location.origin;
+		} catch {
+			return false;
+		}
+		return false;
+	}
+	return true;
+}
+function getSubmitter(nativeEvent) {
+	const submitter = nativeEvent && typeof nativeEvent === "object" && "submitter" in nativeEvent && nativeEvent.submitter instanceof Element ? nativeEvent.submitter : null;
+	if (submitter instanceof HTMLButtonElement || submitter instanceof HTMLInputElement) return submitter;
+	return null;
+}
+function hasReactServerActionAttributes(submitter) {
+	const name = submitter.getAttribute("name");
+	return Boolean(name && (name.startsWith("$ACTION_ID_") || name.startsWith("$ACTION_REF_")));
+}
+function hasReactClientActionAttributes(submitter) {
+	const action = submitter.getAttribute("formAction");
+	return Boolean(action && /\s*javascript:/i.test(action));
+}
+function getEffectiveAction(submitter, formAction) {
+	return submitter?.getAttribute("formaction") ?? formAction;
+}
+function checkFormActionUrl(action, source) {
+	const aPropName = source === "action" ? "an `action`" : "a `formAction`";
+	let testUrl;
+	try {
+		testUrl = new URL(action, "http://n");
+	} catch {
+		console.error(`<Form> received ${aPropName} that cannot be parsed as a URL: "${action}".`);
+		return;
+	}
+	if (testUrl.searchParams.size) console.warn(`<Form> received ${aPropName} that contains search params: "${action}". This is not supported, and they will be ignored. If you need to pass in additional search params, use an \`<input type="hidden" />\` instead.`);
+}
+function hasUnsupportedSubmitterAttributes(submitter) {
+	const formEncType = submitter.getAttribute("formenctype");
+	if (formEncType !== null && formEncType !== SUPPORTED_FORM_ENCTYPE) {
+		if (process.env.NODE_ENV !== "production") console.error(`<Form>'s \`encType\` was set to an unsupported value via \`formEncType="${formEncType}"\`. This will disable <Form>'s navigation functionality. If you need this, use a native <form> element instead.`);
+		return true;
+	}
+	const formMethod = submitter.getAttribute("formmethod");
+	if (formMethod !== null && formMethod.toUpperCase() !== SUPPORTED_FORM_METHOD) {
+		if (process.env.NODE_ENV !== "production") console.error(`<Form>'s \`method\` was set to an unsupported value via \`formMethod="${formMethod}"\`. This will disable <Form>'s navigation functionality. If you need this, use a native <form> element instead.`);
+		return true;
+	}
+	const formTarget = submitter.getAttribute("formtarget");
+	if (formTarget !== null && formTarget !== SUPPORTED_FORM_TARGET) {
+		if (process.env.NODE_ENV !== "production") console.error(`<Form>'s \`target\` was set to an unsupported value via \`formTarget="${formTarget}"\`. This will disable <Form>'s navigation functionality. If you need this, use a native <form> element instead.`);
+		return true;
+	}
+	return false;
+}
+function createFormSubmitDestinationUrl(action, form, submitter) {
+	const targetUrl = new URL(action, window.location.href);
+	if (targetUrl.searchParams.size) targetUrl.search = "";
+	const formData = buildFormData(form, submitter);
+	for (const [name, value] of formData) if (typeof value !== "string") {
+		if (process.env.NODE_ENV !== "production") console.warn("<Form> only supports file inputs if `action` is a function. File inputs cannot be used if `action` is a string, because files cannot be encoded as search params.");
+		targetUrl.searchParams.append(name, value.name);
+	} else targetUrl.searchParams.append(name, value);
+	return toSameOriginPath(targetUrl.href) ?? targetUrl.href;
+}
+function buildFormData(form, submitter) {
+	if (!submitter) return new FormData(form);
+	try {
+		return new FormData(form, submitter);
+	} catch {
+		const formData = new FormData(form);
+		if (!submitter.disabled && submitter.name) formData.append(submitter.name, submitter.value);
+		return formData;
+	}
+}
+const Form = forwardRef(function Form(props, ref) {
+	const { action, replace = false, scroll = true, prefetch = null, onSubmit, ...rest } = props;
+	const isNavigatingForm = typeof action === "string";
+	if (process.env.NODE_ENV !== "production") {
+		if (typeof action === "string") checkFormActionUrl(action, "action");
+		if (!(props.prefetch === void 0 || props.prefetch === false || props.prefetch === null)) console.error("The `prefetch` prop of <Form> must be `false` or `null`");
+		if (props.prefetch !== void 0 && !isNavigatingForm) console.error("Passing `prefetch` to a <Form> whose `action` is a function has no effect.");
+		if (!isNavigatingForm && (props.replace !== void 0 || props.scroll !== void 0)) console.error("Passing `replace` or `scroll` to a <Form> whose `action` is a function has no effect.\nSee the relevant docs to learn how to control this behavior for navigations triggered from actions:\n  `redirect()`       - https://nextjs.org/docs/app/api-reference/functions/redirect#parameters\n  `router.replace()` - https://nextjs.org/docs/app/api-reference/functions/use-router#userouter\n");
+	}
+	const cleanRest = { ...rest };
+	for (const key of DISALLOWED_FORM_PROPS) if (key in cleanRest) {
+		if (process.env.NODE_ENV !== "production") console.error(`<Form> does not support changing \`${key}\`. ` + (isNavigatingForm ? "If you'd like to use it to perform a mutation, consider making `action` a function instead.\nLearn more: https://nextjs.org/docs/app/building-your-application/data-fetching/server-actions-and-mutations" : ""));
+		delete cleanRest[key];
+	}
+	const formRef = useRef(null);
+	const setRefs = useMergedRef(useCallback((node) => {
+		formRef.current = node;
+	}, []), ref ?? null);
+	const actionHref = typeof action === "string" ? withBasePath(action, __basePath) : "";
+	useEffect(() => {
+		if (typeof action !== "string") return;
+		if (prefetch === false || process.env.NODE_ENV !== "production") return;
+		if (!isSafeAction(action)) return;
+		if (!hasAppNavigationRuntime()) return;
+		const node = formRef.current;
+		if (!node) return;
+		if (typeof IntersectionObserver === "undefined") return;
+		const observer = new IntersectionObserver((entries) => {
+			for (const entry of entries) if (entry.isIntersecting || entry.intersectionRatio > 0) {
+				(async () => {
+					const interceptionContext = getPrefetchInterceptionContext(actionHref);
+					const mountedSlotsHeader = getMountedSlotsHeader();
+					const headers = createRscRequestHeaders({ interceptionContext });
+					if (mountedSlotsHeader) headers.set(VINEXT_MOUNTED_SLOTS_HEADER, mountedSlotsHeader);
+					const rscUrl = await createRscRequestUrl(actionHref, headers);
+					const cacheKey = AppElementsWire.encodeCacheKey(rscUrl, interceptionContext);
+					const prefetched = getPrefetchedUrls();
+					if (prefetched.has(cacheKey)) return;
+					if (hasPrefetchCacheEntryForNavigation(rscUrl, interceptionContext, mountedSlotsHeader)) return;
+					prefetched.add(cacheKey);
+					prefetchRscResponse(rscUrl, fetch(rscUrl, {
+						headers,
+						credentials: "include",
+						priority: "low",
+						purpose: "prefetch"
+					}), interceptionContext, mountedSlotsHeader, void 0, {
+						cacheForNavigation: true,
+						optimisticRouteShell: false
+					});
+				})();
+				observer.unobserve(node);
+			}
+		}, { rootMargin: "200px" });
+		observer.observe(node);
+		return () => {
+			observer.unobserve(node);
+		};
+	}, [
+		action,
+		prefetch,
+		actionHref
+	]);
+	if (typeof action === "function") return /* @__PURE__ */ jsx("form", {
+		ref: setRefs,
+		action,
+		onSubmit,
+		...cleanRest
+	});
+	if (!isSafeAction(action)) {
+		if (process.env.NODE_ENV !== "production") console.warn(`<Form> blocked unsafe action: ${action}`);
+		return /* @__PURE__ */ jsx("form", {
+			ref: setRefs,
+			onSubmit,
+			...cleanRest
+		});
+	}
+	async function handleSubmit(e) {
+		if (onSubmit) {
+			onSubmit(e);
+			if (e.defaultPrevented) return;
+		}
+		const submitter = getSubmitter(e.nativeEvent);
+		if (submitter) {
+			if (process.env.NODE_ENV !== "production" && hasReactServerActionAttributes(submitter)) return;
+			if (hasUnsupportedSubmitterAttributes(submitter)) return;
+			if (hasReactClientActionAttributes(submitter)) return;
+		}
+		const effectiveAction = getEffectiveAction(submitter, actionHref);
+		if (process.env.NODE_ENV !== "production" && submitter?.getAttribute("formaction") !== null) checkFormActionUrl(effectiveAction, "formAction");
+		if (!isSafeAction(effectiveAction)) {
+			if (process.env.NODE_ENV !== "production") console.warn(`<Form> blocked unsafe action: ${effectiveAction}`);
+			e.preventDefault();
+			return;
+		}
+		e.preventDefault();
+		const url = createFormSubmitDestinationUrl(effectiveAction, e.currentTarget, submitter);
+		if (hasAppNavigationRuntime()) await navigateClientSide(url, replace ? "replace" : "push", scroll);
+		else try {
+			const Router = (await import("./router.js")).default;
+			if (replace) await Router.replace(url, void 0, { scroll });
+			else await Router.push(url, void 0, { scroll });
+		} catch {
+			if (replace) window.history.replaceState({}, "", url);
+			else window.history.pushState({}, "", url);
+			window.dispatchEvent(new PopStateEvent("popstate"));
+			if (scroll) window.scrollTo(0, 0);
+		}
+	}
+	return /* @__PURE__ */ jsx("form", {
+		ref: setRefs,
+		action: actionHref,
+		onSubmit: (event) => {
+			handleSubmit(event);
+		},
+		...cleanRest
+	});
+});
+//#endregion
+export { Form as default, useActionState };

package/dist/shims/hash-scroll.d.ts

@@ -0,0 +1,10 @@
+//#region src/shims/hash-scroll.d.ts
+declare function decodeHashFragment(fragment: string): string;
+declare function scrollToHashTarget(hash: string): void;
+declare function scrollToHashTargetOnNextFrame(hash: string): void;
+declare function retryScrollTo(x: number, y: number, opts?: {
+  minFrames?: number;
+  shouldContinue?: () => boolean;
+}): void;
+//#endregion
+export { decodeHashFragment, retryScrollTo, scrollToHashTarget, scrollToHashTargetOnNextFrame };

package/dist/shims/hash-scroll.js

@@ -0,0 +1,47 @@
+//#region src/shims/hash-scroll.ts
+function decodeHashFragment(fragment) {
+	try {
+		return decodeURIComponent(fragment);
+	} catch {
+		return fragment;
+	}
+}
+function scrollToHashTarget(hash) {
+	const fragment = decodeHashFragment(hash.startsWith("#") ? hash.slice(1) : hash);
+	if (fragment === "" || fragment === "top") {
+		window.scrollTo(0, 0);
+		return;
+	}
+	const idElement = document.getElementById(fragment);
+	if (idElement) {
+		idElement.scrollIntoView({ behavior: "auto" });
+		return;
+	}
+	const namedElement = document.getElementsByName(fragment)[0];
+	if (namedElement) {
+		namedElement.scrollIntoView({ behavior: "auto" });
+		return;
+	}
+	window.scrollTo(0, 0);
+}
+function scrollToHashTargetOnNextFrame(hash) {
+	requestAnimationFrame(() => {
+		scrollToHashTarget(hash);
+	});
+}
+function retryScrollTo(x, y, opts) {
+	const minFrames = opts?.minFrames ?? 0;
+	const shouldContinue = opts?.shouldContinue ?? (() => true);
+	let attempts = 0;
+	const restore = () => {
+		if (!shouldContinue()) return;
+		window.scrollTo(x, y);
+		const reachedTarget = Math.abs(window.scrollY - y) <= 1;
+		if (!shouldContinue() || reachedTarget && attempts >= minFrames || attempts >= 60) return;
+		attempts += 1;
+		requestAnimationFrame(restore);
+	};
+	restore();
+}
+//#endregion
+export { decodeHashFragment, retryScrollTo, scrollToHashTarget, scrollToHashTargetOnNextFrame };

package/dist/shims/head-state.d.ts

@@ -0,0 +1,16 @@
+import React from "react";
+
+//#region src/shims/head-state.d.ts
+type HeadState = {
+  ssrHeadChildren: React.ReactNode[];
+  documentInitialHead: React.ReactNode[];
+};
+/**
+ * Run a function within a head state ALS scope.
+ * Ensures per-request isolation for Pages Router <Head> elements
+ * on concurrent runtimes.
+ */
+declare function runWithHeadState<T>(fn: () => Promise<T>): Promise<T>;
+declare function runWithHeadState<T>(fn: () => T | Promise<T>): T | Promise<T>;
+//#endregion
+export { HeadState, runWithHeadState };

package/dist/shims/head-state.js

@@ -0,0 +1,43 @@
+import { getOrCreateAls } from "./internal/als-registry.js";
+import { getRequestContext, isInsideUnifiedScope, runWithUnifiedStateMutation } from "./unified-request-context.js";
+import { _registerHeadStateAccessors } from "./head.js";
+//#region src/shims/head-state.ts
+const _FALLBACK_KEY = Symbol.for("vinext.head.fallback");
+const _g = globalThis;
+const _als = getOrCreateAls("vinext.head.als");
+const _fallbackState = _g[_FALLBACK_KEY] ??= {
+	ssrHeadChildren: [],
+	documentInitialHead: []
+};
+function _getState() {
+	if (isInsideUnifiedScope()) return getRequestContext();
+	return _als.getStore() ?? _fallbackState;
+}
+function runWithHeadState(fn) {
+	if (isInsideUnifiedScope()) return runWithUnifiedStateMutation((uCtx) => {
+		uCtx.ssrHeadChildren = [];
+		uCtx.documentInitialHead = [];
+	}, fn);
+	return _als.run({
+		ssrHeadChildren: [],
+		documentInitialHead: []
+	}, fn);
+}
+_registerHeadStateAccessors({
+	getSSRHeadChildren() {
+		return _getState().ssrHeadChildren;
+	},
+	resetSSRHead() {
+		const s = _getState();
+		s.ssrHeadChildren = [];
+		s.documentInitialHead = [];
+	},
+	getDocumentInitialHead() {
+		return _getState().documentInitialHead;
+	},
+	setDocumentInitialHead(head) {
+		_getState().documentInitialHead = head;
+	}
+});
+//#endregion
+export { runWithHeadState };

package/dist/shims/head.d.ts

@@ -0,0 +1,73 @@
+import React from "react";
+
+//#region src/shims/head.d.ts
+type HeadProps = {
+  children?: React.ReactNode;
+};
+/** @internal — exposed for unit tests of the client head projection. */
+declare const _clientHeadChildren: Map<symbol, React.ReactNode>;
+/**
+ * Register ALS-backed state accessors. Called by head-state.ts on import.
+ * @internal
+ */
+declare function _registerHeadStateAccessors(accessors: {
+  getSSRHeadChildren: () => React.ReactNode[];
+  resetSSRHead: () => void;
+  getDocumentInitialHead?: () => React.ReactNode[];
+  setDocumentInitialHead?: (head: React.ReactNode[]) => void;
+}): void;
+/** Reset the SSR head collector. Call before render. */
+declare function resetSSRHead(): void;
+/**
+ * Register head tags returned by a user `_document.getInitialProps()` call.
+ * Mirrors Next.js: `_document` may extend the head array passed to its render,
+ * and those tags are merged into the final `<head>` output. We treat them the
+ * same as `next/head` children — they go through the same dedupe pipeline so
+ * later tags (by key or meta-type) win, matching Next.js semantics.
+ *
+ * Pass an empty array (or simply don't call this) to skip the merge.
+ */
+declare function setDocumentInitialHead(head: React.ReactNode[]): void;
+/** Get collected head HTML. Call after render. */
+declare function getSSRHeadHTML(): string;
+type HeadDOMElement = Pick<HTMLElement, "innerHTML" | "setAttribute" | "textContent">;
+declare function reduceHeadChildren(headChildren: React.ReactNode[]): React.ReactElement[];
+declare function isSafeAttrName(name: string): boolean;
+declare function escapeAttr(s: string): string;
+/**
+ * Escape content that will be placed inside a raw <script> or <style> tag
+ * during SSR. The HTML parser treats `</script>` (or `</style>`) as the end
+ * of the block regardless of JavaScript string context, so any occurrence
+ * of `</` followed by the tag name must be escaped.
+ *
+ * We replace `</script` and `</style` (case-insensitive) with `<\/script`
+ * and `<\/style` respectively. The `<\/` form is harmless in JS/CSS string
+ * context but prevents the HTML parser from seeing a closing tag.
+ */
+declare function escapeInlineContent(content: string, tag: string): string;
+declare function _applyHeadPropsToElement(domEl: HeadDOMElement, props: Record<string, unknown>): void;
+/**
+ * Reconcile the document <head> against the desired projection.
+ *
+ * Mirrors Next.js's client `head-manager.ts` `updateElements()`: rather than
+ * wiping every [data-next-head] node and re-appending (which reorders the
+ * SSR-emitted tags to the end of <head> and causes flicker on each update),
+ * we diff the desired tags against the existing ones with isEqualNode(). Tags
+ * that already match are left untouched in their original DOM position, only
+ * genuinely new tags are inserted, and stale tags are removed.
+ *
+ * The desired list seeds defaultHead() (charset + viewport) ahead of user
+ * tags — matching the SSR path in getSSRHeadHTML() and Next.js's
+ * reduceComponents(), which always concatenates defaultHead() on both server
+ * and client. Without it the first <Head> mount after hydration would drop the
+ * server-rendered defaults. Users can still override via key="charset" /
+ * key="viewport" through the dedupe pipeline.
+ *
+ * @internal — exported for unit tests; called from the Head client effect.
+ */
+declare function _syncClientHead(): void;
+declare function Head({
+  children
+}: HeadProps): null;
+//#endregion
+export { _applyHeadPropsToElement, _clientHeadChildren, _registerHeadStateAccessors, _syncClientHead, Head as default, escapeAttr, escapeInlineContent, getSSRHeadHTML, isSafeAttrName, reduceHeadChildren, resetSSRHead, setDocumentInitialHead };