react-router 7.16.0 → 8.0.0-pre.0

package/dist/development/lib/rsc/server.ssr.js

@@ -0,0 +1,388 @@
+/**
+ * react-router v8.0.0-pre.0
+ *
+ * Copyright (c) Remix Software Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE.md file in the root directory of this source tree.
+ *
+ * @license MIT
+ */
+import { isRouteErrorResponse } from "../router/utils.js";
+import { RSCRouterContext } from "../context.js";
+import { decodeRedirectErrorDigest, decodeRouteErrorResponseDigest } from "../errors.js";
+import { escapeHtml } from "../dom/ssr/markup.js";
+import { shouldHydrateRouteLoader } from "../dom/ssr/routes.js";
+import { FrameworkContext } from "../dom/ssr/components.js";
+import { StaticRouterProvider, createStaticRouter } from "../dom/server.js";
+import { injectRSCPayload } from "./html-stream/server.js";
+import { RSCRouterGlobalErrorBoundary } from "./errorBoundaries.js";
+import { createRSCRouteModules } from "./route-modules.js";
+import * as React$1 from "react";
+//#region lib/rsc/server.ssr.tsx
+const defaultManifestPath = "/__manifest";
+/**
+* Routes the incoming [`Request`](https://developer.mozilla.org/en-US/docs/Web/API/Request)
+* to the [RSC](https://react.dev/reference/rsc/server-components) server and
+* appropriately proxies the server response for data / resource requests, or
+* renders to HTML for a document request.
+*
+* @example
+* import { createFromReadableStream } from "@vitejs/plugin-rsc/ssr";
+* import * as ReactDomServer from "react-dom/server.edge";
+* import {
+*   unstable_RSCStaticRouter as RSCStaticRouter,
+*   unstable_routeRSCServerRequest as routeRSCServerRequest,
+* } from "react-router";
+*
+* routeRSCServerRequest({
+*   request,
+*   serverResponse,
+*   createFromReadableStream,
+*   async renderHTML(getPayload) {
+*     const payload = getPayload();
+*
+*     return await renderHTMLToReadableStream(
+*       <RSCStaticRouter getPayload={getPayload} />,
+*       {
+*         bootstrapScriptContent,
+*         formState: await payload.formState,
+*       }
+*     );
+*   },
+* });
+*
+* @name unstable_routeRSCServerRequest
+* @public
+* @category RSC
+* @mode data
+* @param opts Options
+* @param opts.createFromReadableStream Your `react-server-dom-xyz/client`'s
+* `createFromReadableStream` function, used to decode payloads from the server.
+* @param opts.serverResponse A Response or partial response generated by the [RSC](https://react.dev/reference/rsc/server-components) handler containing a serialized {@link unstable_RSCPayload}.
+* @param opts.hydrate Whether to hydrate the server response with the RSC payload.
+* Defaults to `true`.
+* @param opts.renderHTML A function that renders the {@link unstable_RSCPayload} to
+* HTML, usually using a {@link unstable_RSCStaticRouter | `<RSCStaticRouter>`}.
+* @param opts.request The request to route.
+* @returns A [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response)
+* that either contains the [RSC](https://react.dev/reference/rsc/server-components)
+* payload for data requests, or renders the HTML for document requests.
+*/
+async function routeRSCServerRequest({ request, serverResponse, createFromReadableStream, renderHTML, hydrate = true }) {
+	const url = new URL(request.url);
+	if (isReactServerRequest(url) || isManifestRequest(url) || request.headers.has("rsc-action-id") || serverResponse.headers.get("React-Router-Resource") === "true") return serverResponse;
+	if (!serverResponse.body) throw new Error("Missing body in server response");
+	const detectRedirectResponse = serverResponse.clone();
+	let serverResponseB = null;
+	if (hydrate) serverResponseB = serverResponse.clone();
+	const body = serverResponse.body;
+	let buffer;
+	let streamControllers = [];
+	const createStream = () => {
+		if (!buffer) {
+			buffer = [];
+			return body.pipeThrough(new TransformStream({
+				transform(chunk, controller) {
+					buffer.push(chunk);
+					controller.enqueue(chunk);
+					streamControllers.forEach((c) => c.enqueue(chunk));
+				},
+				flush() {
+					streamControllers.forEach((c) => c.close());
+					streamControllers = [];
+				}
+			}));
+		}
+		return new ReadableStream({ start(controller) {
+			buffer.forEach((chunk) => controller.enqueue(chunk));
+			streamControllers.push(controller);
+		} });
+	};
+	let deepestRenderedBoundaryId = null;
+	const getPayload = () => {
+		const payloadPromise = Promise.resolve(createFromReadableStream(createStream()));
+		return Object.defineProperties(payloadPromise, {
+			_deepestRenderedBoundaryId: {
+				get() {
+					return deepestRenderedBoundaryId;
+				},
+				set(boundaryId) {
+					deepestRenderedBoundaryId = boundaryId;
+				}
+			},
+			formState: { get() {
+				return payloadPromise.then((payload) => payload.type === "render" ? payload.formState : void 0);
+			} }
+		});
+	};
+	let renderRedirect;
+	let renderError;
+	try {
+		if (!detectRedirectResponse.body) throw new Error("Failed to clone server response");
+		const payload = await createFromReadableStream(detectRedirectResponse.body);
+		if (serverResponse.status === 202 && payload.type === "redirect") {
+			const headers = new Headers(serverResponse.headers);
+			headers.delete("Content-Encoding");
+			headers.delete("Content-Length");
+			headers.delete("Content-Type");
+			headers.delete("X-Remix-Response");
+			headers.set("Location", payload.location);
+			return new Response(serverResponseB?.body || "", {
+				headers,
+				status: payload.status,
+				statusText: serverResponse.statusText
+			});
+		}
+		let reactHeaders = new Headers();
+		let status = serverResponse.status;
+		let statusText = serverResponse.statusText;
+		let html = await renderHTML(getPayload, {
+			onError(error) {
+				if (typeof error === "object" && error && "digest" in error && typeof error.digest === "string") {
+					renderRedirect = decodeRedirectErrorDigest(error.digest);
+					if (renderRedirect) return error.digest;
+					let routeErrorResponse = decodeRouteErrorResponseDigest(error.digest);
+					if (routeErrorResponse) {
+						renderError = routeErrorResponse;
+						status = routeErrorResponse.status;
+						statusText = routeErrorResponse.statusText;
+						return error.digest;
+					}
+				}
+			},
+			onHeaders(headers) {
+				for (const [key, value] of headers) reactHeaders.append(key, value);
+			}
+		});
+		const headers = new Headers(reactHeaders);
+		for (const [key, value] of serverResponse.headers) headers.append(key, value);
+		headers.set("Content-Type", "text/html; charset=utf-8");
+		if (renderRedirect) {
+			headers.set("Location", renderRedirect.location);
+			return new Response(html, {
+				status: renderRedirect.status,
+				headers
+			});
+		}
+		const redirectTransform = new TransformStream({ flush(controller) {
+			if (renderRedirect) controller.enqueue(new TextEncoder().encode(`<meta http-equiv="refresh" content="0;url=${escapeHtml(renderRedirect.location)}"/>`));
+		} });
+		if (!hydrate) return new Response(html.pipeThrough(redirectTransform), {
+			status,
+			statusText,
+			headers
+		});
+		if (!serverResponseB?.body) throw new Error("Failed to clone server response");
+		const body = html.pipeThrough(injectRSCPayload(serverResponseB.body)).pipeThrough(redirectTransform);
+		return new Response(body, {
+			status,
+			statusText,
+			headers
+		});
+	} catch (error) {
+		if (error instanceof Response) return error;
+		if (renderRedirect) return new Response(`Redirect: ${renderRedirect.location}`, {
+			status: renderRedirect.status,
+			headers: { Location: renderRedirect.location }
+		});
+		try {
+			let normalizedError = renderError ?? error;
+			let [status, statusText] = isRouteErrorResponse(normalizedError) ? [normalizedError.status, normalizedError.statusText] : [500, ""];
+			let retryRedirect;
+			let reactHeaders = new Headers();
+			const html = await renderHTML(() => {
+				const payloadPromise = Promise.resolve(createFromReadableStream(createStream())).then((payload) => Object.assign(payload, {
+					status,
+					errors: deepestRenderedBoundaryId ? { [deepestRenderedBoundaryId]: normalizedError } : {}
+				}));
+				return Object.defineProperties(payloadPromise, {
+					_deepestRenderedBoundaryId: {
+						get() {
+							return deepestRenderedBoundaryId;
+						},
+						set(boundaryId) {
+							deepestRenderedBoundaryId = boundaryId;
+						}
+					},
+					formState: { get() {
+						return payloadPromise.then((payload) => payload.type === "render" ? payload.formState : void 0);
+					} }
+				});
+			}, {
+				onError(error) {
+					if (typeof error === "object" && error && "digest" in error && typeof error.digest === "string") {
+						retryRedirect = decodeRedirectErrorDigest(error.digest);
+						if (retryRedirect) return error.digest;
+						let routeErrorResponse = decodeRouteErrorResponseDigest(error.digest);
+						if (routeErrorResponse) {
+							status = routeErrorResponse.status;
+							statusText = routeErrorResponse.statusText;
+							return error.digest;
+						}
+					}
+				},
+				onHeaders(headers) {
+					for (const [key, value] of headers) reactHeaders.append(key, value);
+				}
+			});
+			const headers = new Headers(reactHeaders);
+			for (const [key, value] of serverResponse.headers) headers.append(key, value);
+			headers.set("Content-Type", "text/html; charset=utf-8");
+			if (retryRedirect) {
+				headers.set("Location", retryRedirect.location);
+				return new Response(html, {
+					status: retryRedirect.status,
+					headers
+				});
+			}
+			const retryRedirectTransform = new TransformStream({ flush(controller) {
+				if (retryRedirect) controller.enqueue(new TextEncoder().encode(`<meta http-equiv="refresh" content="0;url=${escapeHtml(retryRedirect.location)}"/>`));
+			} });
+			if (!hydrate) return new Response(html.pipeThrough(retryRedirectTransform), {
+				status,
+				statusText,
+				headers
+			});
+			if (!serverResponseB?.body) throw new Error("Failed to clone server response");
+			const body = html.pipeThrough(injectRSCPayload(serverResponseB.body)).pipeThrough(retryRedirectTransform);
+			return new Response(body, {
+				status,
+				statusText,
+				headers
+			});
+		} catch (error2) {}
+		throw error;
+	}
+}
+/**
+* Pre-renders an {@link unstable_RSCPayload} to HTML. Usually used in
+* {@link unstable_routeRSCServerRequest}'s `renderHTML` callback.
+*
+* @example
+* import { createFromReadableStream } from "@vitejs/plugin-rsc/ssr";
+* import * as ReactDomServer from "react-dom/server.edge";
+* import {
+*   unstable_RSCStaticRouter as RSCStaticRouter,
+*   unstable_routeRSCServerRequest as routeRSCServerRequest,
+* } from "react-router";
+*
+* routeRSCServerRequest({
+*   request,
+*   serverResponse,
+*   createFromReadableStream,
+*   async renderHTML(getPayload) {
+*     const payload = getPayload();
+*
+*     return await renderHTMLToReadableStream(
+*       <RSCStaticRouter getPayload={getPayload} />,
+*       {
+*         bootstrapScriptContent,
+*         formState: await payload.formState,
+*       }
+*     );
+*   },
+* });
+*
+* @name unstable_RSCStaticRouter
+* @public
+* @category RSC
+* @mode data
+* @param props Props
+* @param {unstable_RSCStaticRouterProps.getPayload} props.getPayload n/a
+* @returns A React component that renders the {@link unstable_RSCPayload} as HTML.
+*/
+function RSCStaticRouter({ getPayload }) {
+	const decoded = getPayload();
+	const payload = React$1.use(decoded);
+	if (payload.type === "redirect") throw new Response(null, {
+		status: payload.status,
+		headers: { Location: payload.location }
+	});
+	if (payload.type !== "render") return null;
+	let patchedLoaderData = { ...payload.loaderData };
+	for (const match of payload.matches) if (shouldHydrateRouteLoader(match.id, match.clientLoader, match.hasLoader, false) && (match.hydrateFallbackElement || !match.hasLoader)) delete patchedLoaderData[match.id];
+	const context = {
+		get _deepestRenderedBoundaryId() {
+			return decoded._deepestRenderedBoundaryId ?? null;
+		},
+		set _deepestRenderedBoundaryId(boundaryId) {
+			decoded._deepestRenderedBoundaryId = boundaryId;
+		},
+		actionData: payload.actionData,
+		actionHeaders: {},
+		basename: payload.basename,
+		errors: payload.errors,
+		loaderData: patchedLoaderData,
+		loaderHeaders: {},
+		location: payload.location,
+		statusCode: 200,
+		matches: payload.matches.map((match) => ({
+			params: match.params,
+			pathname: match.pathname,
+			pathnameBase: match.pathnameBase,
+			route: {
+				id: match.id,
+				action: match.hasAction || !!match.clientAction,
+				handle: match.handle,
+				loader: match.hasLoader || !!match.clientLoader,
+				index: match.index,
+				path: match.path,
+				shouldRevalidate: match.shouldRevalidate
+			}
+		}))
+	};
+	const router = createStaticRouter(payload.matches.reduceRight((previous, match) => {
+		const route = {
+			id: match.id,
+			action: match.hasAction || !!match.clientAction,
+			element: match.element,
+			errorElement: match.errorElement,
+			handle: match.handle,
+			hydrateFallbackElement: match.hydrateFallbackElement,
+			index: match.index,
+			loader: match.hasLoader || !!match.clientLoader,
+			path: match.path,
+			shouldRevalidate: match.shouldRevalidate
+		};
+		if (previous.length > 0) route.children = previous;
+		return [route];
+	}, []), context);
+	const frameworkContext = {
+		future: {},
+		isSpaMode: false,
+		ssr: true,
+		criticalCss: "",
+		manifest: {
+			routes: {},
+			version: "1",
+			url: "",
+			entry: {
+				module: "",
+				imports: []
+			}
+		},
+		routeDiscovery: payload.routeDiscovery.mode === "initial" ? {
+			mode: "initial",
+			manifestPath: defaultManifestPath
+		} : {
+			mode: "lazy",
+			manifestPath: payload.routeDiscovery.manifestPath || defaultManifestPath
+		},
+		routeModules: createRSCRouteModules(payload)
+	};
+	return /* @__PURE__ */ React$1.createElement(RSCRouterContext.Provider, { value: true }, /* @__PURE__ */ React$1.createElement(RSCRouterGlobalErrorBoundary, { location: payload.location }, /* @__PURE__ */ React$1.createElement(FrameworkContext.Provider, { value: frameworkContext }, /* @__PURE__ */ React$1.createElement(StaticRouterProvider, {
+		context,
+		router,
+		hydrate: false,
+		nonce: payload.nonce
+	}))));
+}
+function isReactServerRequest(url) {
+	return url.pathname.endsWith(".rsc");
+}
+function isManifestRequest(url) {
+	return url.pathname.endsWith(".manifest");
+}
+//#endregion
+export { RSCStaticRouter, routeRSCServerRequest };

package/dist/development/lib/server-runtime/build.d.ts

@@ -0,0 +1,66 @@
+
+import { ActionFunctionArgs, LoaderFunctionArgs, RouterContextProvider } from "../router/utils.js";
+import { AssetsManifest, CriticalCss, EntryContext, FutureConfig } from "../dom/ssr/entry.js";
+import { ServerRouteManifest } from "./routes.js";
+import { ServerInstrumentation } from "../router/instrumentation.js";
+
+//#region lib/server-runtime/build.d.ts
+type OptionalCriticalCss = CriticalCss | undefined;
+/**
+ * The output of the compiler for the server build.
+ */
+interface ServerBuild {
+  entry: {
+    module: ServerEntryModule;
+  };
+  routes: ServerRouteManifest;
+  assets: AssetsManifest;
+  basename?: string;
+  publicPath: string;
+  assetsBuildDirectory: string;
+  future: FutureConfig;
+  ssr: boolean;
+  unstable_getCriticalCss?: (args: {
+    pathname: string;
+  }) => OptionalCriticalCss | Promise<OptionalCriticalCss>;
+  /**
+   * @deprecated This is now done via a custom header during prerendering
+   */
+  isSpaMode: boolean;
+  prerender: string[];
+  routeDiscovery: {
+    mode: "lazy" | "initial";
+    manifestPath: string;
+  };
+  allowedActionOrigins?: string[] | false;
+}
+interface HandleDocumentRequestFunction {
+  (request: Request, responseStatusCode: number, responseHeaders: Headers, context: EntryContext, loadContext: RouterContextProvider): Promise<Response> | Response;
+}
+interface HandleDataRequestFunction {
+  (response: Response, args: {
+    request: LoaderFunctionArgs["request"] | ActionFunctionArgs["request"];
+    context: LoaderFunctionArgs["context"] | ActionFunctionArgs["context"];
+    params: LoaderFunctionArgs["params"] | ActionFunctionArgs["params"];
+  }): Promise<Response> | Response;
+}
+interface HandleErrorFunction {
+  (error: unknown, args: {
+    request: LoaderFunctionArgs["request"] | ActionFunctionArgs["request"];
+    context: LoaderFunctionArgs["context"] | ActionFunctionArgs["context"];
+    params: LoaderFunctionArgs["params"] | ActionFunctionArgs["params"];
+  }): void;
+}
+/**
+ * A module that serves as the entry point for a Remix app during server
+ * rendering.
+ */
+interface ServerEntryModule {
+  default: HandleDocumentRequestFunction;
+  handleDataRequest?: HandleDataRequestFunction;
+  handleError?: HandleErrorFunction;
+  instrumentations?: ServerInstrumentation[];
+  streamTimeout?: number;
+}
+//#endregion
+export { HandleDataRequestFunction, HandleDocumentRequestFunction, HandleErrorFunction, ServerBuild, ServerEntryModule };

package/dist/development/lib/server-runtime/cookies.d.ts

@@ -0,0 +1,66 @@
+
+import { CookieParseOptions as CookieParseOptions$1, CookieSerializeOptions as CookieSerializeOptions$1 } from "cookie-es";
+
+//#region lib/server-runtime/cookies.d.ts
+interface CookieSignatureOptions {
+  /**
+   * An array of secrets that may be used to sign/unsign the value of a cookie.
+   *
+   * The array makes it easy to rotate secrets. New secrets should be added to
+   * the beginning of the array. `cookie.serialize()` will always use the first
+   * value in the array, but `cookie.parse()` may use any of them so that
+   * cookies that were signed with older secrets still work.
+   */
+  secrets?: string[];
+}
+type CookieOptions = CookieParseOptions$1 & CookieSerializeOptions$1 & CookieSignatureOptions;
+/**
+ * A HTTP cookie.
+ *
+ * A Cookie is a logical container for metadata about a HTTP cookie; its name
+ * and options. But it doesn't contain a value. Instead, it has `parse()` and
+ * `serialize()` methods that allow a single instance to be reused for
+ * parsing/encoding multiple different values.
+ *
+ * @see https://remix.run/utils/cookies#cookie-api
+ */
+interface Cookie {
+  /**
+   * The name of the cookie, used in the `Cookie` and `Set-Cookie` headers.
+   */
+  readonly name: string;
+  /**
+   * True if this cookie uses one or more secrets for verification.
+   */
+  readonly isSigned: boolean;
+  /**
+   * The Date this cookie expires.
+   *
+   * Note: This is calculated at access time using `maxAge` when no `expires`
+   * option is provided to `createCookie()`.
+   */
+  readonly expires?: Date;
+  /**
+   * Parses a raw `Cookie` header and returns the value of this cookie or
+   * `null` if it's not present.
+   */
+  parse(cookieHeader: string | null, options?: CookieParseOptions$1): Promise<any>;
+  /**
+   * Serializes the given value to a string and returns the `Set-Cookie`
+   * header.
+   */
+  serialize(value: any, options?: CookieSerializeOptions$1): Promise<string>;
+}
+/**
+ * Creates a logical container for managing a browser cookie from the server.
+ */
+declare const createCookie: (name: string, cookieOptions?: CookieOptions) => Cookie;
+type IsCookieFunction = (object: any) => object is Cookie;
+/**
+ * Returns true if an object is a Remix cookie container.
+ *
+ * @see https://remix.run/utils/cookies#iscookie
+ */
+declare const isCookie: IsCookieFunction;
+//#endregion
+export { Cookie, CookieOptions, type CookieParseOptions$1 as CookieParseOptions, type CookieSerializeOptions$1 as CookieSerializeOptions, CookieSignatureOptions, IsCookieFunction, createCookie, isCookie };

package/dist/development/lib/server-runtime/cookies.js

@@ -0,0 +1,139 @@
+/**
+ * react-router v8.0.0-pre.0
+ *
+ * Copyright (c) Remix Software Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE.md file in the root directory of this source tree.
+ *
+ * @license MIT
+ */
+import { warnOnce } from "./warnings.js";
+import { sign, unsign } from "./crypto.js";
+import { parse, serialize } from "cookie-es";
+//#region lib/server-runtime/cookies.ts
+/**
+* Creates a logical container for managing a browser cookie from the server.
+*/
+const createCookie = (name, cookieOptions = {}) => {
+	let { secrets = [], ...options } = {
+		path: "/",
+		sameSite: "lax",
+		...cookieOptions
+	};
+	warnOnceAboutExpiresCookie(name, options.expires);
+	return {
+		get name() {
+			return name;
+		},
+		get isSigned() {
+			return secrets.length > 0;
+		},
+		get expires() {
+			return typeof options.maxAge !== "undefined" ? new Date(Date.now() + options.maxAge * 1e3) : options.expires;
+		},
+		async parse(cookieHeader, parseOptions) {
+			if (!cookieHeader) return null;
+			let cookies = parse(cookieHeader, {
+				...options,
+				...parseOptions
+			});
+			if (name in cookies) {
+				let value = cookies[name];
+				if (typeof value === "string" && value !== "") return await decodeCookieValue(value, secrets);
+				else return "";
+			} else return null;
+		},
+		async serialize(value, serializeOptions) {
+			return serialize(name, value === "" ? "" : await encodeCookieValue(value, secrets), {
+				...options,
+				...serializeOptions
+			});
+		}
+	};
+};
+/**
+* Returns true if an object is a Remix cookie container.
+*
+* @see https://remix.run/utils/cookies#iscookie
+*/
+const isCookie = (object) => {
+	return object != null && typeof object.name === "string" && typeof object.isSigned === "boolean" && typeof object.parse === "function" && typeof object.serialize === "function";
+};
+async function encodeCookieValue(value, secrets) {
+	let encoded = encodeData(value);
+	if (secrets.length > 0) encoded = await sign(encoded, secrets[0]);
+	return encoded;
+}
+async function decodeCookieValue(value, secrets) {
+	if (secrets.length > 0) {
+		for (let secret of secrets) {
+			let unsignedValue = await unsign(value, secret);
+			if (unsignedValue !== false) return decodeData(unsignedValue);
+		}
+		return null;
+	}
+	return decodeData(value);
+}
+function encodeData(value) {
+	return btoa(myUnescape(encodeURIComponent(JSON.stringify(value))));
+}
+function decodeData(value) {
+	try {
+		return JSON.parse(decodeURIComponent(myEscape(atob(value))));
+	} catch (e) {
+		return {};
+	}
+}
+function myEscape(value) {
+	let str = value.toString();
+	let result = "";
+	let index = 0;
+	let chr, code;
+	while (index < str.length) {
+		chr = str.charAt(index++);
+		if (/[\w*+\-./@]/.exec(chr)) result += chr;
+		else {
+			code = chr.charCodeAt(0);
+			if (code < 256) result += "%" + hex(code, 2);
+			else result += "%u" + hex(code, 4).toUpperCase();
+		}
+	}
+	return result;
+}
+function hex(code, length) {
+	let result = code.toString(16);
+	while (result.length < length) result = "0" + result;
+	return result;
+}
+function myUnescape(value) {
+	let str = value.toString();
+	let result = "";
+	let index = 0;
+	let chr, part;
+	while (index < str.length) {
+		chr = str.charAt(index++);
+		if (chr === "%") if (str.charAt(index) === "u") {
+			part = str.slice(index + 1, index + 5);
+			if (/^[\da-f]{4}$/i.exec(part)) {
+				result += String.fromCharCode(parseInt(part, 16));
+				index += 5;
+				continue;
+			}
+		} else {
+			part = str.slice(index, index + 2);
+			if (/^[\da-f]{2}$/i.exec(part)) {
+				result += String.fromCharCode(parseInt(part, 16));
+				index += 2;
+				continue;
+			}
+		}
+		result += chr;
+	}
+	return result;
+}
+function warnOnceAboutExpiresCookie(name, expires) {
+	warnOnce(!expires, `The "${name}" cookie has an "expires" property set. This will cause the expires value to not be updated when the session is committed. Instead, you should set the expires value when serializing the cookie. You can use \`commitSession(session, { expires })\` if using a session storage object, or \`cookie.serialize("value", { expires })\` if you're using the cookie directly.`);
+}
+//#endregion
+export { createCookie, isCookie };

package/dist/development/lib/server-runtime/crypto.js

@@ -0,0 +1,43 @@
+/**
+ * react-router v8.0.0-pre.0
+ *
+ * Copyright (c) Remix Software Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE.md file in the root directory of this source tree.
+ *
+ * @license MIT
+ */
+//#region lib/server-runtime/crypto.ts
+const encoder = /* @__PURE__ */ new TextEncoder();
+const sign = async (value, secret) => {
+	let data = encoder.encode(value);
+	let key = await createKey(secret, ["sign"]);
+	let signature = await crypto.subtle.sign("HMAC", key, data);
+	let hash = btoa(String.fromCharCode(...new Uint8Array(signature))).replace(/=+$/, "");
+	return value + "." + hash;
+};
+const unsign = async (cookie, secret) => {
+	let index = cookie.lastIndexOf(".");
+	let value = cookie.slice(0, index);
+	let hash = cookie.slice(index + 1);
+	let data = encoder.encode(value);
+	let key = await createKey(secret, ["verify"]);
+	try {
+		let signature = byteStringToUint8Array(atob(hash));
+		return await crypto.subtle.verify("HMAC", key, signature, data) ? value : false;
+	} catch (e) {
+		return false;
+	}
+};
+const createKey = async (secret, usages) => crypto.subtle.importKey("raw", encoder.encode(secret), {
+	name: "HMAC",
+	hash: "SHA-256"
+}, false, usages);
+function byteStringToUint8Array(byteString) {
+	let array = new Uint8Array(byteString.length);
+	for (let i = 0; i < byteString.length; i++) array[i] = byteString.charCodeAt(i);
+	return array;
+}
+//#endregion
+export { sign, unsign };