@blacklizard/inertia-express 1.2.0 → 3.0.0

package/dist/core/index.js

@@ -1,646 +1,2 @@
-import { createHash } from "node:crypto";
-//#region src/core/cache.ts
-/**
-* Recursively normalize a value so equal-by-value inputs serialize identically:
-* object keys are sorted, `undefined` properties are dropped, and non-finite
-* numbers collapse to `null`.
-*
-* @param value Arbitrary JSON-shaped input.
-*/
-function canonicalize(value) {
-	if (value === null) return null;
-	if (typeof value !== "object") {
-		if (typeof value === "number" && !Number.isFinite(value)) return null;
-		return value;
-	}
-	if (Array.isArray(value)) return value.map(canonicalize);
-	const obj = value;
-	return Object.fromEntries(Object.keys(obj).sort().filter((key) => obj[key] !== void 0).map((key) => [key, canonicalize(obj[key])]));
-}
-/**
-* Stable JSON encoding: keys sorted recursively, undefined dropped, NaN/Inf
-* normalized. Two equal-by-value objects always produce the same string,
-* so they hash to the same cache key.
-*
-* @param value Arbitrary JSON-shaped input.
-*/
-function canonicalStringify(value) {
-	return JSON.stringify(canonicalize(value));
-}
-/**
-* Build the cache key for an SSR cache entry.
-*
-* Shape: `${prefix}:${version}:${component}:${sha256(props[+discriminator])}`
-*
-* Including `version` in the key namespace means a deploy that bumps the
-* asset version atomically retires every old key — no flush, no race.
-*
-* @param input Prefix, version, component, resolved props, optional discriminator.
-*/
-function computeSsrCacheKey(input) {
-	const versionPart = input.version ?? "_";
-	const propsHash = createHash("sha256").update(canonicalStringify(input.props)).update(input.discriminator ?? "").digest("hex").slice(0, 32);
-	return `${input.prefix}:${versionPart}:${input.component}:${propsHash}`;
-}
-//#endregion
-//#region src/core/errors.ts
-/**
-* Apply error-bag scoping to a flat errors object, matching the official
-* Inertia behavior. When `bag` is set, errors are namespaced under
-* `props.errors[bag]`. When `bag` is null, errors live at `props.errors`.
-*
-* @param errors Flat field-to-message map.
-* @param bag Optional error-bag name (e.g. `"createUser"`); null for top-level.
-*/
-function scopeErrors(errors, bag) {
-	if (bag) return { errors: { [bag]: errors } };
-	return { errors };
-}
-//#endregion
-//#region src/core/headers.ts
-/**
-* Canonical Inertia v3 protocol header names.
-*
-* The Inertia client sends these headers on every visit. The server uses
-* them to decide between a full HTML response and a JSON page response,
-* and to scope partial reloads.
-*/
-const INERTIA_HEADERS = {
-	inertia: "x-inertia",
-	version: "x-inertia-version",
-	partialComponent: "x-inertia-partial-component",
-	partialData: "x-inertia-partial-data",
-	partialExcept: "x-inertia-partial-except",
-	errorBag: "x-inertia-error-bag",
-	reset: "x-inertia-reset",
-	location: "x-inertia-location"
-};
-/**
-* Read a header value as a single string, looking up the lowercase variant as
-* a fallback. Returns the first entry of an array value and `null` when the
-* header is absent.
-*
-* @param headers Raw header record from the HTTP layer.
-* @param name Header name to read.
-*/
-function readHeader(headers, name) {
-	const value = headers[name] ?? headers[name.toLowerCase()];
-	if (value === void 0 || value === null) return null;
-	if (Array.isArray(value)) return value[0] ?? null;
-	return value;
-}
-/**
-* Split a comma-separated header value into a trimmed, non-empty string list.
-* Returns `null` when the input is null or yields no entries.
-*
-* @param value Raw header value, or null when absent.
-*/
-function parseList(value) {
-	if (value === null) return null;
-	const parts = value.split(",").map((part) => part.trim()).filter((part) => part.length > 0);
-	return parts.length > 0 ? parts : null;
-}
-/**
-* Parse a request's headers into a normalized {@link InertiaRequestInfo}.
-*
-* @param input Headers, HTTP method, and request URL. Method is uppercased in
-*   the returned object; the URL is passed through unchanged.
-*/
-function parseInertiaRequest(input) {
-	const { headers } = input;
-	const inertia = readHeader(headers, INERTIA_HEADERS.inertia);
-	const version = readHeader(headers, INERTIA_HEADERS.version);
-	const partialComponent = readHeader(headers, INERTIA_HEADERS.partialComponent);
-	const partialOnly = parseList(readHeader(headers, INERTIA_HEADERS.partialData));
-	const partialExcept = parseList(readHeader(headers, INERTIA_HEADERS.partialExcept));
-	const errorBag = readHeader(headers, INERTIA_HEADERS.errorBag);
-	const resetKeys = parseList(readHeader(headers, INERTIA_HEADERS.reset));
-	return {
-		isInertia: inertia === "true" || inertia === "1",
-		version,
-		partialComponent,
-		partialOnly,
-		partialExcept,
-		errorBag,
-		resetKeys,
-		method: input.method.toUpperCase(),
-		url: input.url
-	};
-}
-//#endregion
-//#region src/core/html.ts
-const HTML_ESCAPES = {
-	"&": "&",
-	"<": "&lt;",
-	">": "&gt;",
-	"\"": "&quot;",
-	"'": "&#39;"
-};
-/**
-* Escape characters that would break out of a double-quoted HTML attribute.
-*
-* @param value Raw attribute value.
-*/
-function escapeHtmlAttribute(value) {
-	return value.replace(/[&<>"']/g, (ch) => HTML_ESCAPES[ch] ?? ch);
-}
-/**
-* Encode an Inertia page object for embedding inside a
-* `<script type="application/json" data-page="...">` tag — the Inertia v3
-* initial-page transport that the client reads via `getInitialPageFromDOM`.
-*
-* Every `<` is replaced with its JSON unicode escape so the payload cannot
-* terminate the surrounding `<\/script>` element or open an HTML comment. The
-* escape is transparent — JSON.parse decodes it back to `<`.
-*
-* @param page Resolved Inertia page object.
-*/
-function encodePageScript(page) {
-	return JSON.stringify(page).replace(/</g, "\\u003C");
-}
-/**
-* Minimal default HTML shell for use when no custom root view is provided.
-* Real apps should plug in a template engine (pug, ejs, react-dom/server,
-* etc.) and embed `encodePageScript(page)` themselves.
-*
-* The initial page object is emitted as a
-* `<script type="application/json" data-page="...">` tag, the Inertia v3
-* transport that the client reads on boot.
-*
-* @param input Page object plus optional title/head/rootId/scriptSrc/SSR markup
-*   — see {@link DefaultRootViewInput}.
-*/
-function renderDefaultHtml(input) {
-	const rootId = input.rootId ?? "app";
-	const title = input.title ?? "Inertia App";
-	const head = input.head ?? "";
-	const script = input.scriptSrc ? `<script type="module" src="${escapeHtmlAttribute(input.scriptSrc)}"><\/script>` : "";
-	let rootMarkup;
-	if (input.ssrFull) rootMarkup = input.ssrFull;
-	else {
-		const idAttr = escapeHtmlAttribute(rootId);
-		rootMarkup = `<div id="${idAttr}">${input.ssrBody ?? ""}</div>\n    ${`<script data-page="${idAttr}" type="application/json">${encodePageScript(input.page)}<\/script>`}`;
-	}
-	return `<!DOCTYPE html>
-<html>
-  <head>
-    <meta charset="utf-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1" />
-    <title>${escapeHtmlAttribute(title)}</title>
-    ${head}
-  </head>
-  <body>
-    ${rootMarkup}
-    ${script}
-  </body>
-</html>`;
-}
-/** Default user-facing messages keyed by HTTP status, used when none is given. */
-const ERROR_STATUS_MESSAGES = {
-	400: "Bad Request",
-	401: "Unauthorized",
-	403: "Forbidden",
-	404: "Page Not Found",
-	409: "Conflict",
-	419: "Page Expired",
-	422: "Unprocessable Entity",
-	429: "Too Many Requests",
-	500: "Server Error",
-	502: "Bad Gateway",
-	503: "Service Unavailable",
-	504: "Gateway Timeout"
-};
-/**
-* Render a minimal, SPA-less standalone HTML error page. Used as the hard
-* fallback when no client `Error` component can be resolved (e.g. a plain
-* browser load, or an SSR/render failure on the Inertia path), so a user
-* never receives a raw JSON error or a blank page.
-*
-* @param input HTTP status plus an optional override message — see {@link ErrorPageInput}.
-*/
-function renderErrorPage(input) {
-	const { status } = input;
-	const message = input.message ?? ERROR_STATUS_MESSAGES[status] ?? "Something went wrong";
-	const safeStatus = escapeHtmlAttribute(String(status));
-	const safeMessage = escapeHtmlAttribute(message);
-	return `<!DOCTYPE html>
-<html>
-  <head>
-    <meta charset="utf-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1" />
-    <title>${safeStatus} ${safeMessage}</title>
-    <style>
-      body { font-family: system-ui, sans-serif; display: flex; align-items: center; justify-content: center; min-height: 100vh; margin: 0; background: #f8f9fa; color: #212529; }
-      main { text-align: center; padding: 2rem; }
-      h1 { font-size: 4rem; margin: 0; font-weight: 600; }
-      p { font-size: 1.25rem; margin: 0.5rem 0 0; color: #6c757d; }
-    </style>
-  </head>
-  <body>
-    <main>
-      <h1>${safeStatus}</h1>
-      <p>${safeMessage}</p>
-    </main>
-  </body>
-</html>`;
-}
-//#endregion
-//#region src/core/page.ts
-/**
-* Build a normalized Inertia v3 page object. `clearHistory` and `encryptHistory`
-* default to `false`. Empty/absent `deferredProps` / `mergeProps` /
-* `deepMergeProps` / `matchPropsOn` are dropped so the JSON over the wire stays
-* compact.
-*
-* @param input Required page fields plus the optional v3 extras.
-*/
-function createPage(input) {
-	const page = {
-		component: input.component,
-		props: input.props,
-		url: input.url,
-		version: input.version,
-		clearHistory: input.clearHistory ?? false,
-		encryptHistory: input.encryptHistory ?? false
-	};
-	if (input.deferredProps && Object.keys(input.deferredProps).length > 0) page.deferredProps = input.deferredProps;
-	if (input.mergeProps && input.mergeProps.length > 0) page.mergeProps = input.mergeProps;
-	if (input.deepMergeProps && input.deepMergeProps.length > 0) page.deepMergeProps = input.deepMergeProps;
-	if (input.matchPropsOn && input.matchPropsOn.length > 0) page.matchPropsOn = input.matchPropsOn;
-	return page;
-}
-//#endregion
-//#region src/core/props.ts
-const LAZY = "__inertia_lazy";
-const OPTIONAL = "__inertia_optional";
-const DEFERRED = "__inertia_deferred";
-const ALWAYS = "__inertia_always";
-const MERGE = "__inertia_merge";
-const DEEP_MERGE = "__inertia_deep_merge";
-const MATCH_ON = "__inertia_match_on";
-/**
-* Attach the (non-enumerable) `MATCH_ON` symbol-key to a merge/deep-merge
-* prop value so `resolveProps` can emit the dotted `prop.field` paths.
-*
-* @param value Object being tagged (mutated in place).
-* @param matchOn Single field name or list; no-op when undefined.
-*/
-function tagMatchOn(value, matchOn) {
-	if (matchOn === void 0) return;
-	Object.defineProperty(value, MATCH_ON, {
-		value: Array.isArray(matchOn) ? matchOn : [matchOn],
-		enumerable: false
-	});
-}
-/**
-* Wrap a value-producing function as a "lazy" prop.
-*
-* Lazy props are evaluated on every visit (full or partial) when included.
-* They are NOT skipped on the initial visit — use {@link optional} for that.
-*
-* @param fn Producer called (and awaited) when the prop is included.
-*/
-function lazy(fn) {
-	const wrapped = (async () => fn());
-	Object.defineProperty(wrapped, LAZY, {
-		value: true,
-		enumerable: false
-	});
-	return wrapped;
-}
-/**
-* Wrap a value-producing function as an "optional" prop.
-*
-* Optional props are omitted from the initial response and only included
-* when explicitly requested via `X-Inertia-Partial-Data`.
-*
-* @param fn Producer called (and awaited) on partial reloads that request the key.
-*/
-function optional(fn) {
-	const wrapped = (async () => fn());
-	Object.defineProperty(wrapped, OPTIONAL, {
-		value: true,
-		enumerable: false
-	});
-	return wrapped;
-}
-/**
-* Wrap a value-producing function as a "deferred" prop.
-*
-* Deferred props are omitted from the initial visit. The client receives
-* the list of deferred prop keys (grouped by `group`) in the page object
-* and triggers an automatic partial reload to fetch them.
-*
-* @param fn Producer called (and awaited) on the deferred follow-up reload.
-* @param group Load-group name; keys in the same group are fetched in one round-trip.
-*/
-function defer(fn, group = "default") {
-	const wrapped = (async () => fn());
-	Object.defineProperty(wrapped, DEFERRED, {
-		value: true,
-		enumerable: false
-	});
-	Object.defineProperty(wrapped, "group", {
-		value: group,
-		enumerable: false
-	});
-	return wrapped;
-}
-/**
-* Wrap a value-producing function as an "always" prop.
-*
-* Always props are included on every response — full visits and partial
-* reloads alike — regardless of `X-Inertia-Partial-Data` /
-* `X-Inertia-Partial-Except` filtering.
-*
-* @param fn Producer called (and awaited) on every visit.
-*/
-function always(fn) {
-	const wrapped = (async () => fn());
-	Object.defineProperty(wrapped, ALWAYS, {
-		value: true,
-		enumerable: false
-	});
-	return wrapped;
-}
-/**
-* Mark a value as a "merge" prop. The Inertia client will append the new
-* value to the existing prop (typically used for paginated arrays).
-*
-* Pass `matchOn` (a field name or list of field names) to have the client
-* dedupe array items on that field instead of blindly appending.
-*
-* @param value Object or array to tag (mutated in place via non-enumerable properties).
-* @param matchOn Optional field name(s) to dedupe on.
-*/
-function merge(value, matchOn) {
-	const tagged = value;
-	Object.defineProperty(tagged, MERGE, {
-		value: true,
-		enumerable: false
-	});
-	tagMatchOn(tagged, matchOn);
-	return tagged;
-}
-/**
-* Mark a value as a "deep merge" prop. The Inertia client recursively merges
-* the new value into the existing prop rather than shallow-appending.
-*
-* Pass `matchOn` (a field name or list of field names) to have the client
-* dedupe array items on that field.
-*
-* @param value Object or array to tag (mutated in place via non-enumerable properties).
-* @param matchOn Optional field name(s) to dedupe on.
-*/
-function deepMerge(value, matchOn) {
-	const tagged = value;
-	Object.defineProperty(tagged, DEEP_MERGE, {
-		value: true,
-		enumerable: false
-	});
-	tagMatchOn(tagged, matchOn);
-	return tagged;
-}
-/**
-* Type guard: `true` when `v` is a {@link lazy} prop wrapper.
-*
-* @param v Value to test.
-*/
-function isLazy(v) {
-	return typeof v === "function" && v[LAZY] === true;
-}
-/**
-* Type guard: `true` when `v` is an {@link optional} prop wrapper.
-*
-* @param v Value to test.
-*/
-function isOptional(v) {
-	return typeof v === "function" && v[OPTIONAL] === true;
-}
-/**
-* Type guard: `true` when `v` is a {@link defer} prop wrapper.
-*
-* @param v Value to test.
-*/
-function isDeferred(v) {
-	return typeof v === "function" && v[DEFERRED] === true;
-}
-/**
-* Type guard: `true` when `v` is an {@link always} prop wrapper.
-*
-* @param v Value to test.
-*/
-function isAlways(v) {
-	return typeof v === "function" && v[ALWAYS] === true;
-}
-/**
-* Type guard: `true` when `v` is a {@link merge} prop wrapper.
-*
-* @param v Value to test.
-*/
-function isMerge(v) {
-	return v !== null && typeof v === "object" && v[MERGE] === true;
-}
-/**
-* Type guard: `true` when `v` is a {@link deepMerge} prop wrapper.
-*
-* @param v Value to test.
-*/
-function isDeepMerge(v) {
-	return v !== null && typeof v === "object" && v[DEEP_MERGE] === true;
-}
-/**
-* Match a prop key against a partial-reload key list. A pattern matches when
-* it equals the key, or when it is a dotted path into the key (`users.data`
-* matches the `users` prop). Mirrors the official adapter's partial filtering.
-*
-* @param patterns Key patterns from `X-Inertia-Partial-Data` / `-Partial-Except`.
-* @param key Prop key being tested.
-*/
-function partialKeyMatches(patterns, key) {
-	return patterns.some((pattern) => pattern === key || pattern.startsWith(`${key}.`));
-}
-/**
-* Read the non-enumerable `MATCH_ON` field-list off a tagged merge value,
-* returning an empty array when absent.
-*
-* @param v Possibly-tagged merge / deep-merge prop value.
-*/
-function readMatchOn(v) {
-	if (v === null || typeof v !== "object") return [];
-	const fields = v[MATCH_ON];
-	return Array.isArray(fields) ? fields : [];
-}
-/**
-* Combine shared + page props, then apply partial-reload filtering and
-* lazy/optional/deferred evaluation per the Inertia v3 protocol.
-*
-* Resolution order matches the official adapters:
-* 1. Merge shared and page props (page wins on collision).
-* 2. Determine if this is a partial reload for the same component.
-* 3. For non-partial visits: drop optional and deferred props; keep everything
-*    else (lazy props are evaluated).
-* 4. For partial visits: keep only keys in `partialOnly` (if set), then drop
-*    keys in `partialExcept`. Optional props are now eligible.
-* 5. Evaluate every remaining function-shaped prop
-*    (lazy/optional/deferred/always) by calling it and awaiting the result.
-*    Independent props are evaluated in parallel via `Promise.all`.
-* 6. Collect merge / deep-merge / match-on keys, excluding any key the client
-*    listed in `X-Inertia-Reset` — those props are reset (replaced) rather
-*    than appended.
-*
-* @param input Page + shared props, the component name, and parsed request info.
-*/
-async function resolveProps(input) {
-	const { props, shared, component, request } = input;
-	const combined = {
-		...shared,
-		...props
-	};
-	const isPartial = request.isInertia && request.partialComponent !== null && request.partialComponent === component;
-	const deferred = {};
-	const mergeKeys = [];
-	const deepMergeKeys = [];
-	const matchOnKeys = [];
-	const filtered = {};
-	const isExcludedFromPartial = (key, value) => {
-		if (!isPartial || isAlways(value)) return false;
-		if (request.partialOnly !== null && !partialKeyMatches(request.partialOnly, key)) return true;
-		return request.partialExcept !== null && partialKeyMatches(request.partialExcept, key);
-	};
-	Object.entries(combined).forEach(([key, value]) => {
-		if (isDeferred(value) && !isPartial) {
-			(deferred[value.group] ??= []).push(key);
-			return;
-		}
-		if (isOptional(value) && !isPartial) return;
-		if (isExcludedFromPartial(key, value)) return;
-		filtered[key] = value;
-	});
-	const { resetKeys } = request;
-	const evaluated = {};
-	(await Promise.all(Object.entries(filtered).map(async ([key, value]) => {
-		return [key, isLazy(value) || isOptional(value) || isDeferred(value) || isAlways(value) ? await value() : value];
-	}))).forEach(([key, resolved]) => {
-		evaluated[key] = resolved;
-		if (resetKeys?.includes(key) ?? false) return;
-		const merging = isMerge(resolved);
-		const deepMerging = isDeepMerge(resolved);
-		if (merging) mergeKeys.push(key);
-		else if (deepMerging) deepMergeKeys.push(key);
-		if (merging || deepMerging) readMatchOn(resolved).forEach((field) => {
-			matchOnKeys.push(`${key}.${field}`);
-		});
-	});
-	return {
-		props: evaluated,
-		deferred,
-		merge: mergeKeys,
-		deepMerge: deepMergeKeys,
-		matchOn: matchOnKeys
-	};
-}
-//#endregion
-//#region src/core/redirects.ts
-/**
-* Status code Inertia uses for "soft" redirects after PUT/PATCH/DELETE so the
-* follow-up GET is forced to also be a GET on every browser.
-*/
-const INERTIA_REDIRECT_STATUS = 303;
-/**
-* Status code used for the `X-Inertia-Location` external redirect
-* mechanism. The client intercepts the 409 and performs a window.location
-* navigation rather than a fetch.
-*/
-const INERTIA_LOCATION_STATUS = 409;
-/**
-* Decide which status code to use for a redirect produced by an Inertia
-* request. After a non-GET/HEAD form submission the response must be 303
-* so the client's follow-up request becomes a GET.
-*
-* @param method HTTP method of the inbound request (case-insensitive).
-* @param fallback Status code to use for GET/HEAD/POST. Defaults to 302.
-*/
-function inertiaRedirectStatus(method, fallback = 302) {
-	const m = method.toUpperCase();
-	if (m === "PUT" || m === "PATCH" || m === "DELETE") return 303;
-	return fallback;
-}
-//#endregion
-//#region src/core/render.ts
-/**
-* Resolve a `SharedPropsInput` to a plain props object. Returns `{}` for
-* undefined/null inputs or when the resolver returns nullish.
-*
-* @param shared Static props object, a (possibly async) function, or undefined.
-* @param req Request passed to the resolver when `shared` is a function.
-*/
-async function evaluateShared(shared, req) {
-	if (shared === void 0 || shared === null) return {};
-	if (typeof shared === "function") return await shared(req) ?? {};
-	return shared;
-}
-/**
-* Build the final {@link InertiaPage} object given a controller's component
-* + props, the request info, and configured shared props / version.
-*
-* Returned page is suitable for either:
-*   - JSON serialization on `X-Inertia` requests, or
-*   - embedding into the root HTML view via a `<script>` page tag.
-*
-* @param input Component, props, parsed request, shared resolver, version, and
-*   optional `clearHistory` / `encryptHistory` flags.
-*/
-async function buildPage(input) {
-	const sharedProps = await evaluateShared(input.shared, input.req);
-	const resolved = await resolveProps({
-		props: input.props,
-		shared: sharedProps,
-		component: input.component,
-		request: input.request
-	});
-	return createPage({
-		component: input.component,
-		props: resolved.props,
-		url: input.request.url,
-		version: input.version,
-		clearHistory: input.options?.clearHistory,
-		encryptHistory: input.options?.encryptHistory,
-		deferredProps: resolved.deferred,
-		mergeProps: resolved.merge,
-		deepMergeProps: resolved.deepMerge,
-		matchPropsOn: resolved.matchOn
-	});
-}
-//#endregion
-//#region src/core/versioning.ts
-/**
-* Resolve a version value (string, async function, or null) against a request.
-*
-* Returns `null` when no version is configured — in which case asset version
-* mismatch detection is disabled.
-*
-* @param resolver Static version string, a (possibly async) function, or undefined.
-* @param req Request passed to the resolver when it is a function.
-*/
-async function resolveVersion(resolver, req) {
-	if (resolver === void 0 || resolver === null) return null;
-	if (typeof resolver === "string") return resolver;
-	return await resolver(req) ?? null;
-}
-/**
-* Returns true if the client's version (`X-Inertia-Version`) does not match
-* the server's current version. Mismatches on GET requests should trigger a
-* full reload via the `X-Inertia-Location` mechanism.
-*
-* @param serverVersion Currently configured server version; `null` disables checks.
-* @param clientVersion Value of the `X-Inertia-Version` header; `null` is treated as empty.
-*/
-function isVersionMismatch(serverVersion, clientVersion) {
-	if (serverVersion === null) return false;
-	return serverVersion !== (clientVersion ?? "");
-}
-//#endregion
-export { INERTIA_HEADERS, INERTIA_LOCATION_STATUS, INERTIA_REDIRECT_STATUS, always, buildPage, canonicalStringify, computeSsrCacheKey, createPage, deepMerge, defer, encodePageScript, inertiaRedirectStatus, isVersionMismatch, lazy, merge, optional, parseInertiaRequest, renderDefaultHtml, renderErrorPage, resolveProps, resolveVersion, scopeErrors };
-
-//# sourceMappingURL=index.js.map
+import { A as canonicalStringify, C as defer, D as optional, E as once, O as scroll, S as deepMerge, T as merge, _ as INERTIA_HEADERS, a as INERTIA_REDIRECT_STATUS, b as unpackDotProps, c as resolveProps, d as matchesOnly, f as pathIsSameOrDescendant, g as renderErrorPage, h as renderDefaultHtml, i as INERTIA_LOCATION_STATUS, j as computeSsrCacheKey, k as PropDescriptor, l as leadsToOnly, m as encodePageScript, n as resolveVersion, o as inertiaRedirectStatus, p as createPage, r as buildPage, s as PropsResolver, t as isVersionMismatch, u as matchesExcept, v as parseInertiaRequest, w as isPropDescriptor, x as always, y as scopeErrors } from "../core-ChQbBw-k.js";
+export { INERTIA_HEADERS, INERTIA_LOCATION_STATUS, INERTIA_REDIRECT_STATUS, PropDescriptor, PropsResolver, always, buildPage, canonicalStringify, computeSsrCacheKey, createPage, deepMerge, defer, encodePageScript, inertiaRedirectStatus, isPropDescriptor, isVersionMismatch, leadsToOnly, matchesExcept, matchesOnly, merge, once, optional, parseInertiaRequest, pathIsSameOrDescendant, renderDefaultHtml, renderErrorPage, resolveProps, resolveVersion, scopeErrors, scroll, unpackDotProps };