UNPKG

86.5 kBJavaScriptView Raw
1"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }/**
2 * react-router v7.14.1
3 *
4 * Copyright (c) Remix Software Inc.
5 *
6 * This source code is licensed under the MIT license found in the
7 * LICENSE.md file in the root directory of this source tree.
8 *
9 * @license MIT
10 */
11"use client";
12
13
14
15
16
17var _chunk7VLQJKNGjs = require('./chunk-7VLQJKNG.js');
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43var _chunk3F6IB66Ojs = require('./chunk-3F6IB66O.js');
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152var _chunkYMKMFAYZjs = require('./chunk-YMKMFAYZ.js');
153
154// lib/dom/ssr/server.tsx
155var _react = require('react'); var React = _interopRequireWildcard(_react); var React2 = _interopRequireWildcard(_react); var React3 = _interopRequireWildcard(_react);
156function ServerRouter({
157 context,
158 url,
159 nonce
160}) {
161 if (typeof url === "string") {
162 url = new URL(url);
163 }
164 let { manifest, routeModules, criticalCss, serverHandoffString } = context;
165 let routes = _chunkYMKMFAYZjs.createServerRoutes.call(void 0,
166 manifest.routes,
167 routeModules,
168 context.future,
169 context.isSpaMode
170 );
171 context.staticHandlerContext.loaderData = {
172 ...context.staticHandlerContext.loaderData
173 };
174 for (let match of context.staticHandlerContext.matches) {
175 let routeId = match.route.id;
176 let route = routeModules[routeId];
177 let manifestRoute = context.manifest.routes[routeId];
178 if (route && manifestRoute && _chunkYMKMFAYZjs.shouldHydrateRouteLoader.call(void 0,
179 routeId,
180 route.clientLoader,
181 manifestRoute.hasLoader,
182 context.isSpaMode
183 ) && (route.HydrateFallback || !manifestRoute.hasLoader)) {
184 delete context.staticHandlerContext.loaderData[routeId];
185 }
186 }
187 let router = _chunk3F6IB66Ojs.createStaticRouter.call(void 0, routes, context.staticHandlerContext);
188 return /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(
189 _chunkYMKMFAYZjs.FrameworkContext.Provider,
190 {
191 value: {
192 manifest,
193 routeModules,
194 criticalCss,
195 serverHandoffString,
196 future: context.future,
197 ssr: context.ssr,
198 isSpaMode: context.isSpaMode,
199 routeDiscovery: context.routeDiscovery,
200 serializeError: context.serializeError,
201 renderMeta: context.renderMeta
202 }
203 },
204 /* @__PURE__ */ React.createElement(_chunkYMKMFAYZjs.RemixErrorBoundary, { location: router.state.location }, /* @__PURE__ */ React.createElement(
205 _chunk3F6IB66Ojs.StaticRouterProvider,
206 {
207 router,
208 context: context.staticHandlerContext,
209 hydrate: false
210 }
211 ))
212 ), context.serverHandoffStream ? /* @__PURE__ */ React.createElement(React.Suspense, null, /* @__PURE__ */ React.createElement(
213 _chunkYMKMFAYZjs.StreamTransfer,
214 {
215 context,
216 identifier: 0,
217 reader: context.serverHandoffStream.getReader(),
218 textDecoder: new TextDecoder(),
219 nonce
220 }
221 )) : null);
222}
223
224// lib/dom/ssr/routes-test-stub.tsx
225
226function createRoutesStub(routes, _context) {
227 return function RoutesTestStub({
228 initialEntries,
229 initialIndex,
230 hydrationData,
231 future
232 }) {
233 let routerRef = React2.useRef();
234 let frameworkContextRef = React2.useRef();
235 if (routerRef.current == null) {
236 frameworkContextRef.current = {
237 future: {
238 unstable_passThroughRequests: _optionalChain([future, 'optionalAccess', _2 => _2.unstable_passThroughRequests]) === true,
239 unstable_subResourceIntegrity: _optionalChain([future, 'optionalAccess', _3 => _3.unstable_subResourceIntegrity]) === true,
240 v8_middleware: _optionalChain([future, 'optionalAccess', _4 => _4.v8_middleware]) === true,
241 unstable_trailingSlashAwareDataRequests: _optionalChain([future, 'optionalAccess', _5 => _5.unstable_trailingSlashAwareDataRequests]) === true
242 },
243 manifest: {
244 routes: {},
245 entry: { imports: [], module: "" },
246 url: "",
247 version: ""
248 },
249 routeModules: {},
250 ssr: false,
251 isSpaMode: false,
252 routeDiscovery: { mode: "lazy", manifestPath: "/__manifest" }
253 };
254 let patched = processRoutes(
255 // @ts-expect-error `StubRouteObject` is stricter about `loader`/`action`
256 // types compared to `RouteObject`
257 _chunkYMKMFAYZjs.convertRoutesToDataRoutes.call(void 0, routes, (r) => r),
258 _context !== void 0 ? _context : _optionalChain([future, 'optionalAccess', _6 => _6.v8_middleware]) ? new (0, _chunkYMKMFAYZjs.RouterContextProvider)() : {},
259 frameworkContextRef.current.manifest,
260 frameworkContextRef.current.routeModules
261 );
262 routerRef.current = _chunkYMKMFAYZjs.createMemoryRouter.call(void 0, patched, {
263 initialEntries,
264 initialIndex,
265 hydrationData
266 });
267 }
268 return /* @__PURE__ */ React2.createElement(_chunkYMKMFAYZjs.FrameworkContext.Provider, { value: frameworkContextRef.current }, /* @__PURE__ */ React2.createElement(_chunkYMKMFAYZjs.RouterProvider, { router: routerRef.current }));
269 };
270}
271function processRoutes(routes, context, manifest, routeModules, parentId) {
272 return routes.map((route) => {
273 if (!route.id) {
274 throw new Error(
275 "Expected a route.id in react-router processRoutes() function"
276 );
277 }
278 let newRoute = {
279 id: route.id,
280 path: route.path,
281 index: route.index,
282 Component: route.Component ? _chunkYMKMFAYZjs.withComponentProps.call(void 0, route.Component) : void 0,
283 HydrateFallback: route.HydrateFallback ? _chunkYMKMFAYZjs.withHydrateFallbackProps.call(void 0, route.HydrateFallback) : void 0,
284 ErrorBoundary: route.ErrorBoundary ? _chunkYMKMFAYZjs.withErrorBoundaryProps.call(void 0, route.ErrorBoundary) : void 0,
285 action: route.action ? (args) => route.action({ ...args, context }) : void 0,
286 loader: route.loader ? (args) => route.loader({ ...args, context }) : void 0,
287 middleware: route.middleware ? route.middleware.map(
288 (mw) => (...args) => mw(
289 { ...args[0], context },
290 args[1]
291 )
292 ) : void 0,
293 handle: route.handle,
294 shouldRevalidate: route.shouldRevalidate
295 };
296 let entryRoute = {
297 id: route.id,
298 path: route.path,
299 index: route.index,
300 parentId,
301 hasAction: route.action != null,
302 hasLoader: route.loader != null,
303 // When testing routes, you should be stubbing loader/action/middleware,
304 // not trying to re-implement the full loader/clientLoader/SSR/hydration
305 // flow. That is better tested via E2E tests.
306 hasClientAction: false,
307 hasClientLoader: false,
308 hasClientMiddleware: false,
309 hasErrorBoundary: route.ErrorBoundary != null,
310 // any need for these?
311 module: "build/stub-path-to-module.js",
312 clientActionModule: void 0,
313 clientLoaderModule: void 0,
314 clientMiddlewareModule: void 0,
315 hydrateFallbackModule: void 0
316 };
317 manifest.routes[newRoute.id] = entryRoute;
318 routeModules[route.id] = {
319 default: newRoute.Component || _chunkYMKMFAYZjs.Outlet,
320 ErrorBoundary: newRoute.ErrorBoundary || void 0,
321 handle: route.handle,
322 links: route.links,
323 meta: route.meta,
324 shouldRevalidate: route.shouldRevalidate
325 };
326 if (route.children) {
327 newRoute.children = processRoutes(
328 route.children,
329 context,
330 manifest,
331 routeModules,
332 newRoute.id
333 );
334 }
335 return newRoute;
336 });
337}
338
339// lib/server-runtime/cookies.ts
340var _cookie = require('cookie');
341
342// lib/server-runtime/crypto.ts
343var encoder = /* @__PURE__ */ new TextEncoder();
344var sign = async (value, secret) => {
345 let data2 = encoder.encode(value);
346 let key = await createKey(secret, ["sign"]);
347 let signature = await crypto.subtle.sign("HMAC", key, data2);
348 let hash = btoa(String.fromCharCode(...new Uint8Array(signature))).replace(
349 /=+$/,
350 ""
351 );
352 return value + "." + hash;
353};
354var unsign = async (cookie, secret) => {
355 let index = cookie.lastIndexOf(".");
356 let value = cookie.slice(0, index);
357 let hash = cookie.slice(index + 1);
358 let data2 = encoder.encode(value);
359 let key = await createKey(secret, ["verify"]);
360 try {
361 let signature = byteStringToUint8Array(atob(hash));
362 let valid = await crypto.subtle.verify("HMAC", key, signature, data2);
363 return valid ? value : false;
364 } catch (error) {
365 return false;
366 }
367};
368var createKey = async (secret, usages) => crypto.subtle.importKey(
369 "raw",
370 encoder.encode(secret),
371 { name: "HMAC", hash: "SHA-256" },
372 false,
373 usages
374);
375function byteStringToUint8Array(byteString) {
376 let array = new Uint8Array(byteString.length);
377 for (let i = 0; i < byteString.length; i++) {
378 array[i] = byteString.charCodeAt(i);
379 }
380 return array;
381}
382
383// lib/server-runtime/cookies.ts
384var createCookie = (name, cookieOptions = {}) => {
385 let { secrets = [], ...options } = {
386 path: "/",
387 sameSite: "lax",
388 ...cookieOptions
389 };
390 warnOnceAboutExpiresCookie(name, options.expires);
391 return {
392 get name() {
393 return name;
394 },
395 get isSigned() {
396 return secrets.length > 0;
397 },
398 get expires() {
399 return typeof options.maxAge !== "undefined" ? new Date(Date.now() + options.maxAge * 1e3) : options.expires;
400 },
401 async parse(cookieHeader, parseOptions) {
402 if (!cookieHeader) return null;
403 let cookies = _cookie.parse.call(void 0, cookieHeader, { ...options, ...parseOptions });
404 if (name in cookies) {
405 let value = cookies[name];
406 if (typeof value === "string" && value !== "") {
407 let decoded = await decodeCookieValue(value, secrets);
408 return decoded;
409 } else {
410 return "";
411 }
412 } else {
413 return null;
414 }
415 },
416 async serialize(value, serializeOptions) {
417 return _cookie.serialize.call(void 0,
418 name,
419 value === "" ? "" : await encodeCookieValue(value, secrets),
420 {
421 ...options,
422 ...serializeOptions
423 }
424 );
425 }
426 };
427};
428var isCookie = (object) => {
429 return object != null && typeof object.name === "string" && typeof object.isSigned === "boolean" && typeof object.parse === "function" && typeof object.serialize === "function";
430};
431async function encodeCookieValue(value, secrets) {
432 let encoded = encodeData(value);
433 if (secrets.length > 0) {
434 encoded = await sign(encoded, secrets[0]);
435 }
436 return encoded;
437}
438async function decodeCookieValue(value, secrets) {
439 if (secrets.length > 0) {
440 for (let secret of secrets) {
441 let unsignedValue = await unsign(value, secret);
442 if (unsignedValue !== false) {
443 return decodeData(unsignedValue);
444 }
445 }
446 return null;
447 }
448 return decodeData(value);
449}
450function encodeData(value) {
451 return btoa(myUnescape(encodeURIComponent(JSON.stringify(value))));
452}
453function decodeData(value) {
454 try {
455 return JSON.parse(decodeURIComponent(myEscape(atob(value))));
456 } catch (error) {
457 return {};
458 }
459}
460function myEscape(value) {
461 let str = value.toString();
462 let result = "";
463 let index = 0;
464 let chr, code;
465 while (index < str.length) {
466 chr = str.charAt(index++);
467 if (/[\w*+\-./@]/.exec(chr)) {
468 result += chr;
469 } else {
470 code = chr.charCodeAt(0);
471 if (code < 256) {
472 result += "%" + hex(code, 2);
473 } else {
474 result += "%u" + hex(code, 4).toUpperCase();
475 }
476 }
477 }
478 return result;
479}
480function hex(code, length) {
481 let result = code.toString(16);
482 while (result.length < length) result = "0" + result;
483 return result;
484}
485function myUnescape(value) {
486 let str = value.toString();
487 let result = "";
488 let index = 0;
489 let chr, part;
490 while (index < str.length) {
491 chr = str.charAt(index++);
492 if (chr === "%") {
493 if (str.charAt(index) === "u") {
494 part = str.slice(index + 1, index + 5);
495 if (/^[\da-f]{4}$/i.exec(part)) {
496 result += String.fromCharCode(parseInt(part, 16));
497 index += 5;
498 continue;
499 }
500 } else {
501 part = str.slice(index, index + 2);
502 if (/^[\da-f]{2}$/i.exec(part)) {
503 result += String.fromCharCode(parseInt(part, 16));
504 index += 2;
505 continue;
506 }
507 }
508 }
509 result += chr;
510 }
511 return result;
512}
513function warnOnceAboutExpiresCookie(name, expires) {
514 _chunkYMKMFAYZjs.warnOnce.call(void 0,
515 !expires,
516 `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.`
517 );
518}
519
520// lib/server-runtime/entry.ts
521function createEntryRouteModules(manifest) {
522 return Object.keys(manifest).reduce((memo, routeId) => {
523 let route = manifest[routeId];
524 if (route) {
525 memo[routeId] = route.module;
526 }
527 return memo;
528 }, {});
529}
530
531// lib/server-runtime/mode.ts
532var ServerMode = /* @__PURE__ */ ((ServerMode2) => {
533 ServerMode2["Development"] = "development";
534 ServerMode2["Production"] = "production";
535 ServerMode2["Test"] = "test";
536 return ServerMode2;
537})(ServerMode || {});
538function isServerMode(value) {
539 return value === "development" /* Development */ || value === "production" /* Production */ || value === "test" /* Test */;
540}
541
542// lib/server-runtime/errors.ts
543function sanitizeError(error, serverMode) {
544 if (error instanceof Error && serverMode !== "development" /* Development */) {
545 let sanitized = new Error("Unexpected Server Error");
546 sanitized.stack = void 0;
547 return sanitized;
548 }
549 return error;
550}
551function sanitizeErrors(errors, serverMode) {
552 return Object.entries(errors).reduce((acc, [routeId, error]) => {
553 return Object.assign(acc, { [routeId]: sanitizeError(error, serverMode) });
554 }, {});
555}
556function serializeError(error, serverMode) {
557 let sanitized = sanitizeError(error, serverMode);
558 return {
559 message: sanitized.message,
560 stack: sanitized.stack
561 };
562}
563function serializeErrors(errors, serverMode) {
564 if (!errors) return null;
565 let entries = Object.entries(errors);
566 let serialized = {};
567 for (let [key, val] of entries) {
568 if (_chunkYMKMFAYZjs.isRouteErrorResponse.call(void 0, val)) {
569 serialized[key] = { ...val, __type: "RouteErrorResponse" };
570 } else if (val instanceof Error) {
571 let sanitized = sanitizeError(val, serverMode);
572 serialized[key] = {
573 message: sanitized.message,
574 stack: sanitized.stack,
575 __type: "Error",
576 // If this is a subclass (i.e., ReferenceError), send up the type so we
577 // can re-create the same type during hydration. This will only apply
578 // in dev mode since all production errors are sanitized to normal
579 // Error instances
580 ...sanitized.name !== "Error" ? {
581 __subType: sanitized.name
582 } : {}
583 };
584 } else {
585 serialized[key] = val;
586 }
587 }
588 return serialized;
589}
590
591// lib/server-runtime/routeMatching.ts
592function matchServerRoutes(routes, pathname, basename) {
593 let matches = _chunkYMKMFAYZjs.matchRoutes.call(void 0,
594 routes,
595 pathname,
596 basename
597 );
598 if (!matches) return null;
599 return matches.map((match) => ({
600 params: match.params,
601 pathname: match.pathname,
602 route: match.route
603 }));
604}
605
606// lib/server-runtime/data.ts
607async function callRouteHandler(handler, args, future) {
608 let result = await handler({
609 request: future.unstable_passThroughRequests ? args.request : stripRoutesParam(stripIndexParam(args.request)),
610 unstable_url: args.unstable_url,
611 params: args.params,
612 context: args.context,
613 unstable_pattern: args.unstable_pattern
614 });
615 if (_chunkYMKMFAYZjs.isDataWithResponseInit.call(void 0, result) && result.init && result.init.status && _chunkYMKMFAYZjs.isRedirectStatusCode.call(void 0, result.init.status)) {
616 throw new Response(null, result.init);
617 }
618 return result;
619}
620function stripIndexParam(request) {
621 let url = new URL(request.url);
622 let indexValues = url.searchParams.getAll("index");
623 url.searchParams.delete("index");
624 let indexValuesToKeep = [];
625 for (let indexValue of indexValues) {
626 if (indexValue) {
627 indexValuesToKeep.push(indexValue);
628 }
629 }
630 for (let toKeep of indexValuesToKeep) {
631 url.searchParams.append("index", toKeep);
632 }
633 let init = {
634 method: request.method,
635 body: request.body,
636 headers: request.headers,
637 signal: request.signal
638 };
639 if (init.body) {
640 init.duplex = "half";
641 }
642 return new Request(url.href, init);
643}
644function stripRoutesParam(request) {
645 let url = new URL(request.url);
646 url.searchParams.delete("_routes");
647 let init = {
648 method: request.method,
649 body: request.body,
650 headers: request.headers,
651 signal: request.signal
652 };
653 if (init.body) {
654 init.duplex = "half";
655 }
656 return new Request(url.href, init);
657}
658
659// lib/server-runtime/invariant.ts
660function invariant2(value, message) {
661 if (value === false || value === null || typeof value === "undefined") {
662 console.error(
663 "The following error is a bug in React Router; please open an issue! https://github.com/remix-run/react-router/issues/new/choose"
664 );
665 throw new Error(message);
666 }
667}
668
669// lib/server-runtime/dev.ts
670var globalDevServerHooksKey = "__reactRouterDevServerHooks";
671function setDevServerHooks(devServerHooks) {
672 globalThis[globalDevServerHooksKey] = devServerHooks;
673}
674function getDevServerHooks() {
675 return globalThis[globalDevServerHooksKey];
676}
677function getBuildTimeHeader(request, headerName) {
678 if (typeof process !== "undefined") {
679 try {
680 if (_optionalChain([process, 'access', _7 => _7.env, 'optionalAccess', _8 => _8.IS_RR_BUILD_REQUEST]) === "yes") {
681 return request.headers.get(headerName);
682 }
683 } catch (e) {
684 }
685 }
686 return null;
687}
688
689// lib/server-runtime/routes.ts
690function groupRoutesByParentId(manifest) {
691 let routes = {};
692 Object.values(manifest).forEach((route) => {
693 if (route) {
694 let parentId = route.parentId || "";
695 if (!routes[parentId]) {
696 routes[parentId] = [];
697 }
698 routes[parentId].push(route);
699 }
700 });
701 return routes;
702}
703function createRoutes(manifest, parentId = "", routesByParentId = groupRoutesByParentId(manifest)) {
704 return (routesByParentId[parentId] || []).map((route) => ({
705 ...route,
706 children: createRoutes(manifest, route.id, routesByParentId)
707 }));
708}
709function createStaticHandlerDataRoutes(manifest, future, parentId = "", routesByParentId = groupRoutesByParentId(manifest)) {
710 return (routesByParentId[parentId] || []).map((route) => {
711 let commonRoute = {
712 // Always include root due to default boundaries
713 hasErrorBoundary: route.id === "root" || route.module.ErrorBoundary != null,
714 id: route.id,
715 path: route.path,
716 middleware: route.module.middleware,
717 // Need to use RR's version in the param typed here to permit the optional
718 // context even though we know it'll always be provided in remix
719 loader: route.module.loader ? async (args) => {
720 let preRenderedData = getBuildTimeHeader(
721 args.request,
722 "X-React-Router-Prerender-Data"
723 );
724 if (preRenderedData != null) {
725 let encoded = preRenderedData ? decodeURI(preRenderedData) : preRenderedData;
726 invariant2(encoded, "Missing prerendered data for route");
727 let uint8array = new TextEncoder().encode(encoded);
728 let stream = new ReadableStream({
729 start(controller) {
730 controller.enqueue(uint8array);
731 controller.close();
732 }
733 });
734 let decoded = await _chunkYMKMFAYZjs.decodeViaTurboStream.call(void 0, stream, global);
735 let data2 = decoded.value;
736 if (data2 && _chunkYMKMFAYZjs.SingleFetchRedirectSymbol in data2) {
737 let result = data2[_chunkYMKMFAYZjs.SingleFetchRedirectSymbol];
738 let init = { status: result.status };
739 if (result.reload) {
740 throw _chunkYMKMFAYZjs.redirectDocument.call(void 0, result.redirect, init);
741 } else if (result.replace) {
742 throw _chunkYMKMFAYZjs.replace.call(void 0, result.redirect, init);
743 } else {
744 throw _chunkYMKMFAYZjs.redirect.call(void 0, result.redirect, init);
745 }
746 } else {
747 invariant2(
748 data2 && route.id in data2,
749 "Unable to decode prerendered data"
750 );
751 let result = data2[route.id];
752 invariant2(
753 "data" in result,
754 "Unable to process prerendered data"
755 );
756 return result.data;
757 }
758 }
759 let val = await callRouteHandler(
760 route.module.loader,
761 args,
762 future
763 );
764 return val;
765 } : void 0,
766 action: route.module.action ? (args) => callRouteHandler(route.module.action, args, future) : void 0,
767 handle: route.module.handle
768 };
769 return route.index ? {
770 index: true,
771 ...commonRoute
772 } : {
773 caseSensitive: route.caseSensitive,
774 children: createStaticHandlerDataRoutes(
775 manifest,
776 future,
777 route.id,
778 routesByParentId
779 ),
780 ...commonRoute
781 };
782 });
783}
784
785// lib/server-runtime/serverHandoff.ts
786function createServerHandoffString(serverHandoff) {
787 return _chunkYMKMFAYZjs.escapeHtml.call(void 0, JSON.stringify(serverHandoff));
788}
789
790// lib/server-runtime/headers.ts
791var _setcookieparser = require('set-cookie-parser');
792function getDocumentHeaders(context, build) {
793 return getDocumentHeadersImpl(context, (m) => {
794 let route = build.routes[m.route.id];
795 invariant2(route, `Route with id "${m.route.id}" not found in build`);
796 return route.module.headers;
797 });
798}
799function getDocumentHeadersImpl(context, getRouteHeadersFn, _defaultHeaders) {
800 let boundaryIdx = context.errors ? context.matches.findIndex((m) => context.errors[m.route.id]) : -1;
801 let matches = boundaryIdx >= 0 ? context.matches.slice(0, boundaryIdx + 1) : context.matches;
802 let errorHeaders;
803 if (boundaryIdx >= 0) {
804 let { actionHeaders, actionData, loaderHeaders, loaderData } = context;
805 context.matches.slice(boundaryIdx).some((match) => {
806 let id = match.route.id;
807 if (actionHeaders[id] && (!actionData || !actionData.hasOwnProperty(id))) {
808 errorHeaders = actionHeaders[id];
809 } else if (loaderHeaders[id] && !loaderData.hasOwnProperty(id)) {
810 errorHeaders = loaderHeaders[id];
811 }
812 return errorHeaders != null;
813 });
814 }
815 const defaultHeaders = new Headers(_defaultHeaders);
816 return matches.reduce((parentHeaders, match, idx) => {
817 let { id } = match.route;
818 let loaderHeaders = context.loaderHeaders[id] || new Headers();
819 let actionHeaders = context.actionHeaders[id] || new Headers();
820 let includeErrorHeaders = errorHeaders != null && idx === matches.length - 1;
821 let includeErrorCookies = includeErrorHeaders && errorHeaders !== loaderHeaders && errorHeaders !== actionHeaders;
822 let headersFn = getRouteHeadersFn(match);
823 if (headersFn == null) {
824 let headers2 = new Headers(parentHeaders);
825 if (includeErrorCookies) {
826 prependCookies(errorHeaders, headers2);
827 }
828 prependCookies(actionHeaders, headers2);
829 prependCookies(loaderHeaders, headers2);
830 return headers2;
831 }
832 let headers = new Headers(
833 typeof headersFn === "function" ? headersFn({
834 loaderHeaders,
835 parentHeaders,
836 actionHeaders,
837 errorHeaders: includeErrorHeaders ? errorHeaders : void 0
838 }) : headersFn
839 );
840 if (includeErrorCookies) {
841 prependCookies(errorHeaders, headers);
842 }
843 prependCookies(actionHeaders, headers);
844 prependCookies(loaderHeaders, headers);
845 prependCookies(parentHeaders, headers);
846 return headers;
847 }, new Headers(defaultHeaders));
848}
849function prependCookies(parentHeaders, childHeaders) {
850 let parentSetCookieString = parentHeaders.get("Set-Cookie");
851 if (parentSetCookieString) {
852 let cookies = _setcookieparser.splitCookiesString.call(void 0, parentSetCookieString);
853 let childCookies = new Set(childHeaders.getSetCookie());
854 cookies.forEach((cookie) => {
855 if (!childCookies.has(cookie)) {
856 childHeaders.append("Set-Cookie", cookie);
857 }
858 });
859 }
860}
861
862// lib/actions.ts
863function throwIfPotentialCSRFAttack(headers, allowedActionOrigins) {
864 let originHeader = headers.get("origin");
865 let originDomain = null;
866 try {
867 originDomain = typeof originHeader === "string" && originHeader !== "null" ? new URL(originHeader).host : originHeader;
868 } catch (e2) {
869 throw new Error(
870 `\`origin\` header is not a valid URL. Aborting the action.`
871 );
872 }
873 let host = parseHostHeader(headers);
874 if (originDomain && (!host || originDomain !== host.value)) {
875 if (!isAllowedOrigin(originDomain, allowedActionOrigins)) {
876 if (host) {
877 throw new Error(
878 `${host.type} header does not match \`origin\` header from a forwarded action request. Aborting the action.`
879 );
880 } else {
881 throw new Error(
882 "`x-forwarded-host` or `host` headers are not provided. One of these is needed to compare the `origin` header from a forwarded action request. Aborting the action."
883 );
884 }
885 }
886 }
887}
888function matchWildcardDomain(domain, pattern) {
889 const domainParts = domain.split(".");
890 const patternParts = pattern.split(".");
891 if (patternParts.length < 1) {
892 return false;
893 }
894 if (domainParts.length < patternParts.length) {
895 return false;
896 }
897 while (patternParts.length) {
898 const patternPart = patternParts.pop();
899 const domainPart = domainParts.pop();
900 switch (patternPart) {
901 case "": {
902 return false;
903 }
904 case "*": {
905 if (domainPart) {
906 continue;
907 } else {
908 return false;
909 }
910 }
911 case "**": {
912 if (patternParts.length > 0) {
913 return false;
914 }
915 return domainPart !== void 0;
916 }
917 case void 0:
918 default: {
919 if (domainPart !== patternPart) {
920 return false;
921 }
922 }
923 }
924 }
925 return domainParts.length === 0;
926}
927function isAllowedOrigin(originDomain, allowedActionOrigins = []) {
928 return allowedActionOrigins.some(
929 (allowedOrigin) => allowedOrigin && (allowedOrigin === originDomain || matchWildcardDomain(originDomain, allowedOrigin))
930 );
931}
932function parseHostHeader(headers) {
933 let forwardedHostHeader = headers.get("x-forwarded-host");
934 let forwardedHostValue = _optionalChain([forwardedHostHeader, 'optionalAccess', _9 => _9.split, 'call', _10 => _10(","), 'access', _11 => _11[0], 'optionalAccess', _12 => _12.trim, 'call', _13 => _13()]);
935 let hostHeader = headers.get("host");
936 return forwardedHostValue ? {
937 type: "x-forwarded-host",
938 value: forwardedHostValue
939 } : hostHeader ? {
940 type: "host",
941 value: hostHeader
942 } : void 0;
943}
944
945// lib/server-runtime/urls.ts
946function getNormalizedPath(request, basename, future) {
947 basename = basename || "/";
948 let url = new URL(request.url);
949 let pathname = url.pathname;
950 if (_optionalChain([future, 'optionalAccess', _14 => _14.unstable_trailingSlashAwareDataRequests])) {
951 if (pathname.endsWith("/_.data")) {
952 pathname = pathname.replace(/_\.data$/, "");
953 } else {
954 pathname = pathname.replace(/\.data$/, "");
955 }
956 } else {
957 if (_chunkYMKMFAYZjs.stripBasename.call(void 0, pathname, basename) === "/_root.data") {
958 pathname = basename;
959 } else if (pathname.endsWith(".data")) {
960 pathname = pathname.replace(/\.data$/, "");
961 }
962 if (_chunkYMKMFAYZjs.stripBasename.call(void 0, pathname, basename) !== "/" && pathname.endsWith("/")) {
963 pathname = pathname.slice(0, -1);
964 }
965 }
966 let searchParams = new URLSearchParams(url.search);
967 searchParams.delete("_routes");
968 let search = searchParams.toString();
969 if (search) {
970 search = `?${search}`;
971 }
972 return {
973 pathname,
974 search,
975 // No hashes on the server
976 hash: ""
977 };
978}
979
980// lib/server-runtime/single-fetch.ts
981var SERVER_NO_BODY_STATUS_CODES = /* @__PURE__ */ new Set([
982 ..._chunkYMKMFAYZjs.NO_BODY_STATUS_CODES,
983 304
984]);
985async function singleFetchAction(build, serverMode, staticHandler, request, handlerUrl, loadContext, handleError) {
986 try {
987 try {
988 throwIfPotentialCSRFAttack(
989 request.headers,
990 Array.isArray(build.allowedActionOrigins) ? build.allowedActionOrigins : []
991 );
992 } catch (e) {
993 return handleQueryError(new Error("Bad Request"), 400);
994 }
995 let handlerRequest = build.future.unstable_passThroughRequests ? request : new Request(handlerUrl, {
996 method: request.method,
997 body: request.body,
998 headers: request.headers,
999 signal: request.signal,
1000 ...request.body ? { duplex: "half" } : void 0
1001 });
1002 let result = await staticHandler.query(handlerRequest, {
1003 requestContext: loadContext,
1004 skipLoaderErrorBubbling: true,
1005 skipRevalidation: true,
1006 generateMiddlewareResponse: build.future.v8_middleware ? async (query) => {
1007 try {
1008 let innerResult = await query(handlerRequest);
1009 return handleQueryResult(innerResult);
1010 } catch (error) {
1011 return handleQueryError(error);
1012 }
1013 } : void 0,
1014 unstable_normalizePath: (r) => getNormalizedPath(r, build.basename, build.future)
1015 });
1016 return handleQueryResult(result);
1017 } catch (error) {
1018 return handleQueryError(error);
1019 }
1020 function handleQueryResult(result) {
1021 return _chunkYMKMFAYZjs.isResponse.call(void 0, result) ? result : staticContextToResponse(result);
1022 }
1023 function handleQueryError(error, status = 500) {
1024 handleError(error);
1025 return generateSingleFetchResponse(request, build, serverMode, {
1026 result: { error },
1027 headers: new Headers(),
1028 status
1029 });
1030 }
1031 function staticContextToResponse(context) {
1032 let headers = getDocumentHeaders(context, build);
1033 if (_chunkYMKMFAYZjs.isRedirectStatusCode.call(void 0, context.statusCode) && headers.has("Location")) {
1034 return new Response(null, { status: context.statusCode, headers });
1035 }
1036 if (context.errors) {
1037 Object.values(context.errors).forEach((err) => {
1038 if (!_chunkYMKMFAYZjs.isRouteErrorResponse.call(void 0, err) || err.error) {
1039 handleError(err);
1040 }
1041 });
1042 context.errors = sanitizeErrors(context.errors, serverMode);
1043 }
1044 let singleFetchResult;
1045 if (context.errors) {
1046 singleFetchResult = { error: Object.values(context.errors)[0] };
1047 } else {
1048 singleFetchResult = {
1049 data: Object.values(context.actionData || {})[0]
1050 };
1051 }
1052 return generateSingleFetchResponse(request, build, serverMode, {
1053 result: singleFetchResult,
1054 headers,
1055 status: context.statusCode
1056 });
1057 }
1058}
1059async function singleFetchLoaders(build, serverMode, staticHandler, request, handlerUrl, loadContext, handleError) {
1060 let routesParam = new URL(request.url).searchParams.get("_routes");
1061 let loadRouteIds = routesParam ? new Set(routesParam.split(",")) : null;
1062 try {
1063 let handlerRequest = build.future.unstable_passThroughRequests ? request : new Request(handlerUrl, {
1064 headers: request.headers,
1065 signal: request.signal
1066 });
1067 let result = await staticHandler.query(handlerRequest, {
1068 requestContext: loadContext,
1069 filterMatchesToLoad: (m) => !loadRouteIds || loadRouteIds.has(m.route.id),
1070 skipLoaderErrorBubbling: true,
1071 generateMiddlewareResponse: build.future.v8_middleware ? async (query) => {
1072 try {
1073 let innerResult = await query(handlerRequest);
1074 return handleQueryResult(innerResult);
1075 } catch (error) {
1076 return handleQueryError(error);
1077 }
1078 } : void 0,
1079 unstable_normalizePath: (r) => getNormalizedPath(r, build.basename, build.future)
1080 });
1081 return handleQueryResult(result);
1082 } catch (error) {
1083 return handleQueryError(error);
1084 }
1085 function handleQueryResult(result) {
1086 return _chunkYMKMFAYZjs.isResponse.call(void 0, result) ? result : staticContextToResponse(result);
1087 }
1088 function handleQueryError(error) {
1089 handleError(error);
1090 return generateSingleFetchResponse(request, build, serverMode, {
1091 result: { error },
1092 headers: new Headers(),
1093 status: 500
1094 });
1095 }
1096 function staticContextToResponse(context) {
1097 let headers = getDocumentHeaders(context, build);
1098 if (_chunkYMKMFAYZjs.isRedirectStatusCode.call(void 0, context.statusCode) && headers.has("Location")) {
1099 return new Response(null, { status: context.statusCode, headers });
1100 }
1101 if (context.errors) {
1102 Object.values(context.errors).forEach((err) => {
1103 if (!_chunkYMKMFAYZjs.isRouteErrorResponse.call(void 0, err) || err.error) {
1104 handleError(err);
1105 }
1106 });
1107 context.errors = sanitizeErrors(context.errors, serverMode);
1108 }
1109 let results = {};
1110 let loadedMatches = new Set(
1111 context.matches.filter(
1112 (m) => loadRouteIds ? loadRouteIds.has(m.route.id) : m.route.loader != null
1113 ).map((m) => m.route.id)
1114 );
1115 if (context.errors) {
1116 for (let [id, error] of Object.entries(context.errors)) {
1117 results[id] = { error };
1118 }
1119 }
1120 for (let [id, data2] of Object.entries(context.loaderData)) {
1121 if (!(id in results) && loadedMatches.has(id)) {
1122 results[id] = { data: data2 };
1123 }
1124 }
1125 return generateSingleFetchResponse(request, build, serverMode, {
1126 result: results,
1127 headers,
1128 status: context.statusCode
1129 });
1130 }
1131}
1132function generateSingleFetchResponse(request, build, serverMode, {
1133 result,
1134 headers,
1135 status
1136}) {
1137 let resultHeaders = new Headers(headers);
1138 resultHeaders.set("X-Remix-Response", "yes");
1139 if (SERVER_NO_BODY_STATUS_CODES.has(status)) {
1140 return new Response(null, { status, headers: resultHeaders });
1141 }
1142 resultHeaders.set("Content-Type", "text/x-script");
1143 resultHeaders.delete("Content-Length");
1144 return new Response(
1145 encodeViaTurboStream(
1146 result,
1147 request.signal,
1148 build.entry.module.streamTimeout,
1149 serverMode
1150 ),
1151 {
1152 status: status || 200,
1153 headers: resultHeaders
1154 }
1155 );
1156}
1157function generateSingleFetchRedirectResponse(redirectResponse, request, build, serverMode) {
1158 let redirect2 = getSingleFetchRedirect(
1159 redirectResponse.status,
1160 redirectResponse.headers,
1161 build.basename
1162 );
1163 let headers = new Headers(redirectResponse.headers);
1164 headers.delete("Location");
1165 headers.set("Content-Type", "text/x-script");
1166 return generateSingleFetchResponse(request, build, serverMode, {
1167 result: request.method === "GET" ? { [_chunkYMKMFAYZjs.SingleFetchRedirectSymbol]: redirect2 } : redirect2,
1168 headers,
1169 status: _chunkYMKMFAYZjs.SINGLE_FETCH_REDIRECT_STATUS
1170 });
1171}
1172function getSingleFetchRedirect(status, headers, basename) {
1173 let redirect2 = headers.get("Location");
1174 if (basename) {
1175 redirect2 = _chunkYMKMFAYZjs.stripBasename.call(void 0, redirect2, basename) || redirect2;
1176 }
1177 return {
1178 redirect: redirect2,
1179 status,
1180 revalidate: (
1181 // Technically X-Remix-Revalidate isn't needed here - that was an implementation
1182 // detail of ?_data requests as our way to tell the front end to revalidate when
1183 // we didn't have a response body to include that information in.
1184 // With single fetch, we tell the front end via this revalidate boolean field.
1185 // However, we're respecting it for now because it may be something folks have
1186 // used in their own responses
1187 // TODO(v3): Consider removing or making this official public API
1188 headers.has("X-Remix-Revalidate") || headers.has("Set-Cookie")
1189 ),
1190 reload: headers.has("X-Remix-Reload-Document"),
1191 replace: headers.has("X-Remix-Replace")
1192 };
1193}
1194function encodeViaTurboStream(data2, requestSignal, streamTimeout, serverMode) {
1195 let controller = new AbortController();
1196 let timeoutId = setTimeout(
1197 () => {
1198 controller.abort(new Error("Server Timeout"));
1199 cleanupCallbacks();
1200 },
1201 typeof streamTimeout === "number" ? streamTimeout : 4950
1202 );
1203 let abortControllerOnRequestAbort = () => {
1204 controller.abort(requestSignal.reason);
1205 cleanupCallbacks();
1206 };
1207 requestSignal.addEventListener("abort", abortControllerOnRequestAbort);
1208 let cleanupCallbacks = () => {
1209 clearTimeout(timeoutId);
1210 requestSignal.removeEventListener("abort", abortControllerOnRequestAbort);
1211 };
1212 return _chunkYMKMFAYZjs.encode.call(void 0, data2, {
1213 signal: controller.signal,
1214 onComplete: cleanupCallbacks,
1215 plugins: [
1216 (value) => {
1217 if (value instanceof Error) {
1218 let { name, message, stack } = serverMode === "production" /* Production */ ? sanitizeError(value, serverMode) : value;
1219 return ["SanitizedError", name, message, stack];
1220 }
1221 if (value instanceof _chunkYMKMFAYZjs.ErrorResponseImpl) {
1222 let { data: data3, status, statusText } = value;
1223 return ["ErrorResponse", data3, status, statusText];
1224 }
1225 if (value && typeof value === "object" && _chunkYMKMFAYZjs.SingleFetchRedirectSymbol in value) {
1226 return ["SingleFetchRedirect", value[_chunkYMKMFAYZjs.SingleFetchRedirectSymbol]];
1227 }
1228 }
1229 ],
1230 postPlugins: [
1231 (value) => {
1232 if (!value) return;
1233 if (typeof value !== "object") return;
1234 return [
1235 "SingleFetchClassInstance",
1236 Object.fromEntries(Object.entries(value))
1237 ];
1238 },
1239 () => ["SingleFetchFallback"]
1240 ]
1241 });
1242}
1243
1244// lib/server-runtime/server.ts
1245function derive(build, mode) {
1246 let routes = createRoutes(build.routes);
1247 let dataRoutes = createStaticHandlerDataRoutes(build.routes, build.future);
1248 let serverMode = isServerMode(mode) ? mode : "production" /* Production */;
1249 let staticHandler = _chunkYMKMFAYZjs.createStaticHandler.call(void 0, dataRoutes, {
1250 basename: build.basename,
1251 unstable_instrumentations: build.entry.module.unstable_instrumentations
1252 });
1253 let errorHandler = build.entry.module.handleError || ((error, { request }) => {
1254 if (serverMode !== "test" /* Test */ && !request.signal.aborted) {
1255 console.error(
1256 // @ts-expect-error This is "private" from users but intended for internal use
1257 _chunkYMKMFAYZjs.isRouteErrorResponse.call(void 0, error) && error.error ? error.error : error
1258 );
1259 }
1260 });
1261 let requestHandler = async (request, initialContext) => {
1262 let params = {};
1263 let loadContext;
1264 let handleError = (error) => {
1265 if (mode === "development" /* Development */) {
1266 _optionalChain([getDevServerHooks, 'call', _15 => _15(), 'optionalAccess', _16 => _16.processRequestError, 'optionalCall', _17 => _17(error)]);
1267 }
1268 errorHandler(error, {
1269 context: loadContext,
1270 params,
1271 request
1272 });
1273 };
1274 if (build.future.v8_middleware) {
1275 if (initialContext && !(initialContext instanceof _chunkYMKMFAYZjs.RouterContextProvider)) {
1276 let error = new Error(
1277 "Invalid `context` value provided to `handleRequest`. When middleware is enabled you must return an instance of `RouterContextProvider` from your `getLoadContext` function."
1278 );
1279 handleError(error);
1280 return returnLastResortErrorResponse(error, serverMode);
1281 }
1282 loadContext = initialContext || new (0, _chunkYMKMFAYZjs.RouterContextProvider)();
1283 } else {
1284 loadContext = initialContext || {};
1285 }
1286 let requestUrl = new URL(request.url);
1287 let normalizedPathname = getNormalizedPath(
1288 request,
1289 build.basename,
1290 build.future
1291 ).pathname;
1292 let isSpaMode = getBuildTimeHeader(request, "X-React-Router-SPA-Mode") === "yes";
1293 if (!build.ssr) {
1294 let decodedPath = decodeURI(normalizedPathname);
1295 if (build.basename && build.basename !== "/") {
1296 let strippedPath = _chunkYMKMFAYZjs.stripBasename.call(void 0, decodedPath, build.basename);
1297 if (strippedPath == null) {
1298 errorHandler(
1299 new (0, _chunkYMKMFAYZjs.ErrorResponseImpl)(
1300 404,
1301 "Not Found",
1302 `Refusing to prerender the \`${decodedPath}\` path because it does not start with the basename \`${build.basename}\``
1303 ),
1304 {
1305 context: loadContext,
1306 params,
1307 request
1308 }
1309 );
1310 return new Response("Not Found", {
1311 status: 404,
1312 statusText: "Not Found"
1313 });
1314 }
1315 decodedPath = strippedPath;
1316 }
1317 if (build.prerender.length === 0) {
1318 isSpaMode = true;
1319 } else if (!build.prerender.includes(decodedPath) && !build.prerender.includes(decodedPath + "/")) {
1320 if (requestUrl.pathname.endsWith(".data")) {
1321 errorHandler(
1322 new (0, _chunkYMKMFAYZjs.ErrorResponseImpl)(
1323 404,
1324 "Not Found",
1325 `Refusing to SSR the path \`${decodedPath}\` because \`ssr:false\` is set and the path is not included in the \`prerender\` config, so in production the path will be a 404.`
1326 ),
1327 {
1328 context: loadContext,
1329 params,
1330 request
1331 }
1332 );
1333 return new Response("Not Found", {
1334 status: 404,
1335 statusText: "Not Found"
1336 });
1337 } else {
1338 isSpaMode = true;
1339 }
1340 }
1341 }
1342 let manifestUrl = _chunkYMKMFAYZjs.getManifestPath.call(void 0,
1343 build.routeDiscovery.manifestPath,
1344 build.basename
1345 );
1346 if (requestUrl.pathname === manifestUrl) {
1347 try {
1348 let res = await handleManifestRequest(build, routes, requestUrl);
1349 return res;
1350 } catch (e) {
1351 handleError(e);
1352 return new Response("Unknown Server Error", { status: 500 });
1353 }
1354 }
1355 let matches = matchServerRoutes(routes, normalizedPathname, build.basename);
1356 if (matches && matches.length > 0) {
1357 Object.assign(params, matches[0].params);
1358 }
1359 let response;
1360 if (requestUrl.pathname.endsWith(".data")) {
1361 let singleFetchMatches = matchServerRoutes(
1362 routes,
1363 normalizedPathname,
1364 build.basename
1365 );
1366 response = await handleSingleFetchRequest(
1367 serverMode,
1368 build,
1369 staticHandler,
1370 request,
1371 normalizedPathname,
1372 loadContext,
1373 handleError
1374 );
1375 if (_chunkYMKMFAYZjs.isRedirectResponse.call(void 0, response)) {
1376 response = generateSingleFetchRedirectResponse(
1377 response,
1378 request,
1379 build,
1380 serverMode
1381 );
1382 }
1383 if (build.entry.module.handleDataRequest) {
1384 response = await build.entry.module.handleDataRequest(response, {
1385 context: loadContext,
1386 params: singleFetchMatches ? singleFetchMatches[0].params : {},
1387 request
1388 });
1389 if (_chunkYMKMFAYZjs.isRedirectResponse.call(void 0, response)) {
1390 response = generateSingleFetchRedirectResponse(
1391 response,
1392 request,
1393 build,
1394 serverMode
1395 );
1396 }
1397 }
1398 } else if (!isSpaMode && matches && matches[matches.length - 1].route.module.default == null && matches[matches.length - 1].route.module.ErrorBoundary == null) {
1399 response = await handleResourceRequest(
1400 serverMode,
1401 build,
1402 staticHandler,
1403 matches.slice(-1)[0].route.id,
1404 request,
1405 loadContext,
1406 handleError
1407 );
1408 } else {
1409 let { pathname } = requestUrl;
1410 let criticalCss = void 0;
1411 if (build.unstable_getCriticalCss) {
1412 criticalCss = await build.unstable_getCriticalCss({ pathname });
1413 } else if (mode === "development" /* Development */ && _optionalChain([getDevServerHooks, 'call', _18 => _18(), 'optionalAccess', _19 => _19.getCriticalCss])) {
1414 criticalCss = await _optionalChain([getDevServerHooks, 'call', _20 => _20(), 'optionalAccess', _21 => _21.getCriticalCss, 'optionalCall', _22 => _22(pathname)]);
1415 }
1416 response = await handleDocumentRequest(
1417 serverMode,
1418 build,
1419 staticHandler,
1420 request,
1421 loadContext,
1422 handleError,
1423 isSpaMode,
1424 criticalCss
1425 );
1426 }
1427 if (request.method === "HEAD") {
1428 return new Response(null, {
1429 headers: response.headers,
1430 status: response.status,
1431 statusText: response.statusText
1432 });
1433 }
1434 return response;
1435 };
1436 if (build.entry.module.unstable_instrumentations) {
1437 requestHandler = _chunkYMKMFAYZjs.instrumentHandler.call(void 0,
1438 requestHandler,
1439 build.entry.module.unstable_instrumentations.map((i) => i.handler).filter(Boolean)
1440 );
1441 }
1442 return {
1443 routes,
1444 dataRoutes,
1445 serverMode,
1446 staticHandler,
1447 errorHandler,
1448 requestHandler
1449 };
1450}
1451var createRequestHandler = (build, mode) => {
1452 let _build;
1453 let routes;
1454 let serverMode;
1455 let staticHandler;
1456 let errorHandler;
1457 let _requestHandler;
1458 return async function requestHandler(request, initialContext) {
1459 _build = typeof build === "function" ? await build() : build;
1460 if (typeof build === "function") {
1461 let derived = derive(_build, mode);
1462 routes = derived.routes;
1463 serverMode = derived.serverMode;
1464 staticHandler = derived.staticHandler;
1465 errorHandler = derived.errorHandler;
1466 _requestHandler = derived.requestHandler;
1467 } else if (!routes || !serverMode || !staticHandler || !errorHandler || !_requestHandler) {
1468 let derived = derive(_build, mode);
1469 routes = derived.routes;
1470 serverMode = derived.serverMode;
1471 staticHandler = derived.staticHandler;
1472 errorHandler = derived.errorHandler;
1473 _requestHandler = derived.requestHandler;
1474 }
1475 return _requestHandler(request, initialContext);
1476 };
1477};
1478async function handleManifestRequest(build, routes, url) {
1479 if (build.assets.version !== url.searchParams.get("version")) {
1480 return new Response(null, {
1481 status: 204,
1482 headers: {
1483 "X-Remix-Reload-Document": "true"
1484 }
1485 });
1486 }
1487 let patches = {};
1488 if (url.searchParams.has("paths")) {
1489 let paths = /* @__PURE__ */ new Set();
1490 let pathParam = url.searchParams.get("paths") || "";
1491 let requestedPaths = pathParam.split(",").filter(Boolean);
1492 requestedPaths.forEach((path) => {
1493 if (!path.startsWith("/")) {
1494 path = `/${path}`;
1495 }
1496 let segments = path.split("/").slice(1);
1497 segments.forEach((_, i) => {
1498 let partialPath = segments.slice(0, i + 1).join("/");
1499 paths.add(`/${partialPath}`);
1500 });
1501 });
1502 for (let path of paths) {
1503 let matches = matchServerRoutes(routes, path, build.basename);
1504 if (matches) {
1505 for (let match of matches) {
1506 let routeId = match.route.id;
1507 let route = build.assets.routes[routeId];
1508 if (route) {
1509 patches[routeId] = route;
1510 }
1511 }
1512 }
1513 }
1514 return Response.json(patches, {
1515 headers: {
1516 "Cache-Control": "public, max-age=31536000, immutable"
1517 }
1518 });
1519 }
1520 return new Response("Invalid Request", { status: 400 });
1521}
1522async function handleSingleFetchRequest(serverMode, build, staticHandler, request, normalizedPath, loadContext, handleError) {
1523 let handlerUrl = new URL(request.url);
1524 handlerUrl.pathname = normalizedPath;
1525 let response = request.method !== "GET" ? await singleFetchAction(
1526 build,
1527 serverMode,
1528 staticHandler,
1529 request,
1530 handlerUrl,
1531 loadContext,
1532 handleError
1533 ) : await singleFetchLoaders(
1534 build,
1535 serverMode,
1536 staticHandler,
1537 request,
1538 handlerUrl,
1539 loadContext,
1540 handleError
1541 );
1542 return response;
1543}
1544async function handleDocumentRequest(serverMode, build, staticHandler, request, loadContext, handleError, isSpaMode, criticalCss) {
1545 try {
1546 if (request.method === "POST") {
1547 try {
1548 throwIfPotentialCSRFAttack(
1549 request.headers,
1550 Array.isArray(build.allowedActionOrigins) ? build.allowedActionOrigins : []
1551 );
1552 } catch (e) {
1553 handleError(e);
1554 return new Response("Bad Request", { status: 400 });
1555 }
1556 }
1557 let result = await staticHandler.query(request, {
1558 requestContext: loadContext,
1559 generateMiddlewareResponse: build.future.v8_middleware ? async (query) => {
1560 try {
1561 let innerResult = await query(request);
1562 if (!_chunkYMKMFAYZjs.isResponse.call(void 0, innerResult)) {
1563 innerResult = await renderHtml(innerResult, isSpaMode);
1564 }
1565 return innerResult;
1566 } catch (error) {
1567 handleError(error);
1568 return new Response(null, { status: 500 });
1569 }
1570 } : void 0,
1571 unstable_normalizePath: (r) => getNormalizedPath(r, build.basename, build.future)
1572 });
1573 if (!_chunkYMKMFAYZjs.isResponse.call(void 0, result)) {
1574 result = await renderHtml(result, isSpaMode);
1575 }
1576 return result;
1577 } catch (error) {
1578 handleError(error);
1579 return new Response(null, { status: 500 });
1580 }
1581 async function renderHtml(context, isSpaMode2) {
1582 let headers = getDocumentHeaders(context, build);
1583 if (SERVER_NO_BODY_STATUS_CODES.has(context.statusCode)) {
1584 return new Response(null, { status: context.statusCode, headers });
1585 }
1586 if (context.errors) {
1587 Object.values(context.errors).forEach((err) => {
1588 if (!_chunkYMKMFAYZjs.isRouteErrorResponse.call(void 0, err) || err.error) {
1589 handleError(err);
1590 }
1591 });
1592 context.errors = sanitizeErrors(context.errors, serverMode);
1593 }
1594 let state = {
1595 loaderData: context.loaderData,
1596 actionData: context.actionData,
1597 errors: serializeErrors(context.errors, serverMode)
1598 };
1599 let baseServerHandoff = {
1600 basename: build.basename,
1601 future: build.future,
1602 routeDiscovery: build.routeDiscovery,
1603 ssr: build.ssr,
1604 isSpaMode: isSpaMode2
1605 };
1606 let entryContext = {
1607 manifest: build.assets,
1608 routeModules: createEntryRouteModules(build.routes),
1609 staticHandlerContext: context,
1610 criticalCss,
1611 serverHandoffString: createServerHandoffString({
1612 ...baseServerHandoff,
1613 criticalCss
1614 }),
1615 serverHandoffStream: encodeViaTurboStream(
1616 state,
1617 request.signal,
1618 build.entry.module.streamTimeout,
1619 serverMode
1620 ),
1621 renderMeta: {},
1622 future: build.future,
1623 ssr: build.ssr,
1624 routeDiscovery: build.routeDiscovery,
1625 isSpaMode: isSpaMode2,
1626 serializeError: (err) => serializeError(err, serverMode)
1627 };
1628 let handleDocumentRequestFunction = build.entry.module.default;
1629 try {
1630 return await handleDocumentRequestFunction(
1631 request,
1632 context.statusCode,
1633 headers,
1634 entryContext,
1635 loadContext
1636 );
1637 } catch (error) {
1638 handleError(error);
1639 let errorForSecondRender = error;
1640 if (_chunkYMKMFAYZjs.isResponse.call(void 0, error)) {
1641 try {
1642 let data2 = await unwrapResponse(error);
1643 errorForSecondRender = new (0, _chunkYMKMFAYZjs.ErrorResponseImpl)(
1644 error.status,
1645 error.statusText,
1646 data2
1647 );
1648 } catch (e) {
1649 }
1650 }
1651 context = _chunkYMKMFAYZjs.getStaticContextFromError.call(void 0,
1652 staticHandler.dataRoutes,
1653 context,
1654 errorForSecondRender
1655 );
1656 if (context.errors) {
1657 context.errors = sanitizeErrors(context.errors, serverMode);
1658 }
1659 let state2 = {
1660 loaderData: context.loaderData,
1661 actionData: context.actionData,
1662 errors: serializeErrors(context.errors, serverMode)
1663 };
1664 entryContext = {
1665 ...entryContext,
1666 staticHandlerContext: context,
1667 serverHandoffString: createServerHandoffString(baseServerHandoff),
1668 serverHandoffStream: encodeViaTurboStream(
1669 state2,
1670 request.signal,
1671 build.entry.module.streamTimeout,
1672 serverMode
1673 ),
1674 renderMeta: {}
1675 };
1676 try {
1677 return await handleDocumentRequestFunction(
1678 request,
1679 context.statusCode,
1680 headers,
1681 entryContext,
1682 loadContext
1683 );
1684 } catch (error2) {
1685 handleError(error2);
1686 return returnLastResortErrorResponse(error2, serverMode);
1687 }
1688 }
1689 }
1690}
1691async function handleResourceRequest(serverMode, build, staticHandler, routeId, request, loadContext, handleError) {
1692 try {
1693 let result = await staticHandler.queryRoute(request, {
1694 routeId,
1695 requestContext: loadContext,
1696 generateMiddlewareResponse: build.future.v8_middleware ? async (queryRoute) => {
1697 try {
1698 let innerResult = await queryRoute(request);
1699 return handleQueryRouteResult(innerResult);
1700 } catch (error) {
1701 return handleQueryRouteError(error);
1702 }
1703 } : void 0,
1704 unstable_normalizePath: (r) => getNormalizedPath(r, build.basename, build.future)
1705 });
1706 return handleQueryRouteResult(result);
1707 } catch (error) {
1708 return handleQueryRouteError(error);
1709 }
1710 function handleQueryRouteResult(result) {
1711 if (_chunkYMKMFAYZjs.isResponse.call(void 0, result)) {
1712 return result;
1713 }
1714 if (typeof result === "string") {
1715 return new Response(result);
1716 }
1717 return Response.json(result);
1718 }
1719 function handleQueryRouteError(error) {
1720 if (_chunkYMKMFAYZjs.isResponse.call(void 0, error)) {
1721 return error;
1722 }
1723 if (_chunkYMKMFAYZjs.isRouteErrorResponse.call(void 0, error)) {
1724 handleError(error);
1725 return errorResponseToJson(error, serverMode);
1726 }
1727 if (error instanceof Error && error.message === "Expected a response from queryRoute") {
1728 let newError = new Error(
1729 "Expected a Response to be returned from resource route handler"
1730 );
1731 handleError(newError);
1732 return returnLastResortErrorResponse(newError, serverMode);
1733 }
1734 handleError(error);
1735 return returnLastResortErrorResponse(error, serverMode);
1736 }
1737}
1738function errorResponseToJson(errorResponse, serverMode) {
1739 return Response.json(
1740 serializeError(
1741 // @ts-expect-error This is "private" from users but intended for internal use
1742 errorResponse.error || new Error("Unexpected Server Error"),
1743 serverMode
1744 ),
1745 {
1746 status: errorResponse.status,
1747 statusText: errorResponse.statusText
1748 }
1749 );
1750}
1751function returnLastResortErrorResponse(error, serverMode) {
1752 let message = "Unexpected Server Error";
1753 if (serverMode !== "production" /* Production */) {
1754 message += `
1755
1756${String(error)}`;
1757 }
1758 return new Response(message, {
1759 status: 500,
1760 headers: {
1761 "Content-Type": "text/plain"
1762 }
1763 });
1764}
1765function unwrapResponse(response) {
1766 let contentType = response.headers.get("Content-Type");
1767 return contentType && /\bapplication\/json\b/.test(contentType) ? response.body == null ? null : response.json() : response.text();
1768}
1769
1770// lib/server-runtime/sessions.ts
1771function flash(name) {
1772 return `__flash_${name}__`;
1773}
1774var createSession = (initialData = {}, id = "") => {
1775 let map = new Map(Object.entries(initialData));
1776 return {
1777 get id() {
1778 return id;
1779 },
1780 get data() {
1781 return Object.fromEntries(map);
1782 },
1783 has(name) {
1784 return map.has(name) || map.has(flash(name));
1785 },
1786 get(name) {
1787 if (map.has(name)) return map.get(name);
1788 let flashName = flash(name);
1789 if (map.has(flashName)) {
1790 let value = map.get(flashName);
1791 map.delete(flashName);
1792 return value;
1793 }
1794 return void 0;
1795 },
1796 set(name, value) {
1797 map.set(name, value);
1798 },
1799 flash(name, value) {
1800 map.set(flash(name), value);
1801 },
1802 unset(name) {
1803 map.delete(name);
1804 }
1805 };
1806};
1807var isSession = (object) => {
1808 return object != null && typeof object.id === "string" && typeof object.data !== "undefined" && typeof object.has === "function" && typeof object.get === "function" && typeof object.set === "function" && typeof object.flash === "function" && typeof object.unset === "function";
1809};
1810function createSessionStorage({
1811 cookie: cookieArg,
1812 createData,
1813 readData,
1814 updateData,
1815 deleteData
1816}) {
1817 let cookie = isCookie(cookieArg) ? cookieArg : createCookie(_optionalChain([cookieArg, 'optionalAccess', _23 => _23.name]) || "__session", cookieArg);
1818 warnOnceAboutSigningSessionCookie(cookie);
1819 return {
1820 async getSession(cookieHeader, options) {
1821 let id = cookieHeader && await cookie.parse(cookieHeader, options);
1822 let data2 = id && await readData(id);
1823 return createSession(data2 || {}, id || "");
1824 },
1825 async commitSession(session, options) {
1826 let { id, data: data2 } = session;
1827 let expires = _optionalChain([options, 'optionalAccess', _24 => _24.maxAge]) != null ? new Date(Date.now() + options.maxAge * 1e3) : _optionalChain([options, 'optionalAccess', _25 => _25.expires]) != null ? options.expires : cookie.expires;
1828 if (id) {
1829 await updateData(id, data2, expires);
1830 } else {
1831 id = await createData(data2, expires);
1832 }
1833 return cookie.serialize(id, options);
1834 },
1835 async destroySession(session, options) {
1836 await deleteData(session.id);
1837 return cookie.serialize("", {
1838 ...options,
1839 maxAge: void 0,
1840 expires: /* @__PURE__ */ new Date(0)
1841 });
1842 }
1843 };
1844}
1845function warnOnceAboutSigningSessionCookie(cookie) {
1846 _chunkYMKMFAYZjs.warnOnce.call(void 0,
1847 cookie.isSigned,
1848 `The "${cookie.name}" cookie is not signed, but session cookies should be signed to prevent tampering on the client before they are sent back to the server. See https://reactrouter.com/explanation/sessions-and-cookies#signing-cookies for more information.`
1849 );
1850}
1851
1852// lib/server-runtime/sessions/cookieStorage.ts
1853function createCookieSessionStorage({ cookie: cookieArg } = {}) {
1854 let cookie = isCookie(cookieArg) ? cookieArg : createCookie(_optionalChain([cookieArg, 'optionalAccess', _26 => _26.name]) || "__session", cookieArg);
1855 warnOnceAboutSigningSessionCookie(cookie);
1856 return {
1857 async getSession(cookieHeader, options) {
1858 return createSession(
1859 cookieHeader && await cookie.parse(cookieHeader, options) || {}
1860 );
1861 },
1862 async commitSession(session, options) {
1863 let serializedCookie = await cookie.serialize(session.data, options);
1864 if (serializedCookie.length > 4096) {
1865 throw new Error(
1866 "Cookie length will exceed browser maximum. Length: " + serializedCookie.length
1867 );
1868 }
1869 return serializedCookie;
1870 },
1871 async destroySession(_session, options) {
1872 return cookie.serialize("", {
1873 ...options,
1874 maxAge: void 0,
1875 expires: /* @__PURE__ */ new Date(0)
1876 });
1877 }
1878 };
1879}
1880
1881// lib/server-runtime/sessions/memoryStorage.ts
1882function createMemorySessionStorage({ cookie } = {}) {
1883 let map = /* @__PURE__ */ new Map();
1884 return createSessionStorage({
1885 cookie,
1886 async createData(data2, expires) {
1887 let id = Math.random().toString(36).substring(2, 10);
1888 map.set(id, { data: data2, expires });
1889 return id;
1890 },
1891 async readData(id) {
1892 if (map.has(id)) {
1893 let { data: data2, expires } = map.get(id);
1894 if (!expires || expires > /* @__PURE__ */ new Date()) {
1895 return data2;
1896 }
1897 if (expires) map.delete(id);
1898 }
1899 return null;
1900 },
1901 async updateData(id, data2, expires) {
1902 map.set(id, { data: data2, expires });
1903 },
1904 async deleteData(id) {
1905 map.delete(id);
1906 }
1907 });
1908}
1909
1910// lib/href.ts
1911function href(path, ...args) {
1912 let params = args[0];
1913 let result = trimTrailingSplat(path).replace(
1914 /\/:([\w-]+)(\?)?/g,
1915 // same regex as in .\router\utils.ts: compilePath().
1916 (_, param, questionMark) => {
1917 const isRequired = questionMark === void 0;
1918 const value = _optionalChain([params, 'optionalAccess', _27 => _27[param]]);
1919 if (isRequired && value === void 0) {
1920 throw new Error(
1921 `Path '${path}' requires param '${param}' but it was not provided`
1922 );
1923 }
1924 return value === void 0 ? "" : "/" + value;
1925 }
1926 );
1927 if (path.endsWith("*")) {
1928 const value = _optionalChain([params, 'optionalAccess', _28 => _28["*"]]);
1929 if (value !== void 0) {
1930 result += "/" + value;
1931 }
1932 }
1933 return result || "/";
1934}
1935function trimTrailingSplat(path) {
1936 let i = path.length - 1;
1937 let char = path[i];
1938 if (char !== "*" && char !== "/") return path;
1939 i--;
1940 for (; i >= 0; i--) {
1941 if (path[i] !== "/") break;
1942 }
1943 return path.slice(0, i + 1);
1944}
1945
1946// lib/rsc/server.ssr.tsx
1947
1948
1949// lib/rsc/html-stream/server.ts
1950var encoder2 = new TextEncoder();
1951var trailer = "</body></html>";
1952function injectRSCPayload(rscStream) {
1953 let decoder = new TextDecoder();
1954 let resolveFlightDataPromise;
1955 let flightDataPromise = new Promise(
1956 (resolve) => resolveFlightDataPromise = resolve
1957 );
1958 let startedRSC = false;
1959 let buffered = [];
1960 let timeout = null;
1961 function flushBufferedChunks(controller) {
1962 for (let chunk of buffered) {
1963 let buf = decoder.decode(chunk, { stream: true });
1964 if (buf.endsWith(trailer)) {
1965 buf = buf.slice(0, -trailer.length);
1966 }
1967 controller.enqueue(encoder2.encode(buf));
1968 }
1969 buffered.length = 0;
1970 timeout = null;
1971 }
1972 return new TransformStream({
1973 transform(chunk, controller) {
1974 buffered.push(chunk);
1975 if (timeout) {
1976 return;
1977 }
1978 timeout = setTimeout(async () => {
1979 flushBufferedChunks(controller);
1980 if (!startedRSC) {
1981 startedRSC = true;
1982 writeRSCStream(rscStream, controller).catch((err) => controller.error(err)).then(resolveFlightDataPromise);
1983 }
1984 }, 0);
1985 },
1986 async flush(controller) {
1987 await flightDataPromise;
1988 if (timeout) {
1989 clearTimeout(timeout);
1990 flushBufferedChunks(controller);
1991 }
1992 controller.enqueue(encoder2.encode("</body></html>"));
1993 }
1994 });
1995}
1996async function writeRSCStream(rscStream, controller) {
1997 let decoder = new TextDecoder("utf-8", { fatal: true });
1998 const reader = rscStream.getReader();
1999 try {
2000 let read;
2001 while ((read = await reader.read()) && !read.done) {
2002 const chunk = read.value;
2003 try {
2004 writeChunk(
2005 JSON.stringify(decoder.decode(chunk, { stream: true })),
2006 controller
2007 );
2008 } catch (err) {
2009 let base64 = JSON.stringify(btoa(String.fromCodePoint(...chunk)));
2010 writeChunk(
2011 `Uint8Array.from(atob(${base64}), m => m.codePointAt(0))`,
2012 controller
2013 );
2014 }
2015 }
2016 } finally {
2017 reader.releaseLock();
2018 }
2019 let remaining = decoder.decode();
2020 if (remaining.length) {
2021 writeChunk(JSON.stringify(remaining), controller);
2022 }
2023}
2024function writeChunk(chunk, controller) {
2025 controller.enqueue(
2026 encoder2.encode(
2027 `<script>${escapeScript(
2028 `(self.__FLIGHT_DATA||=[]).push(${chunk})`
2029 )}</script>`
2030 )
2031 );
2032}
2033function escapeScript(script) {
2034 return script.replace(/<!--/g, "<\\!--").replace(/<\/(script)/gi, "</\\$1");
2035}
2036
2037// lib/rsc/server.ssr.tsx
2038var defaultManifestPath = "/__manifest";
2039var REACT_USE = "use";
2040var useImpl = React3[REACT_USE];
2041function useSafe(promise) {
2042 if (useImpl) {
2043 return useImpl(promise);
2044 }
2045 throw new Error("React Router v7 requires React 19+ for RSC features.");
2046}
2047async function routeRSCServerRequest({
2048 request,
2049 serverResponse,
2050 createFromReadableStream,
2051 renderHTML,
2052 hydrate = true
2053}) {
2054 const url = new URL(request.url);
2055 const isDataRequest = isReactServerRequest(url);
2056 const respondWithRSCPayload = isDataRequest || isManifestRequest(url) || request.headers.has("rsc-action-id");
2057 if (respondWithRSCPayload || serverResponse.headers.get("React-Router-Resource") === "true") {
2058 return serverResponse;
2059 }
2060 if (!serverResponse.body) {
2061 throw new Error("Missing body in server response");
2062 }
2063 const detectRedirectResponse = serverResponse.clone();
2064 let serverResponseB = null;
2065 if (hydrate) {
2066 serverResponseB = serverResponse.clone();
2067 }
2068 const body = serverResponse.body;
2069 let buffer;
2070 let streamControllers = [];
2071 const createStream = () => {
2072 if (!buffer) {
2073 buffer = [];
2074 return body.pipeThrough(
2075 new TransformStream({
2076 transform(chunk, controller) {
2077 buffer.push(chunk);
2078 controller.enqueue(chunk);
2079 streamControllers.forEach((c) => c.enqueue(chunk));
2080 },
2081 flush() {
2082 streamControllers.forEach((c) => c.close());
2083 streamControllers = [];
2084 }
2085 })
2086 );
2087 }
2088 return new ReadableStream({
2089 start(controller) {
2090 buffer.forEach((chunk) => controller.enqueue(chunk));
2091 streamControllers.push(controller);
2092 }
2093 });
2094 };
2095 let deepestRenderedBoundaryId = null;
2096 const getPayload = () => {
2097 const payloadPromise = Promise.resolve(
2098 createFromReadableStream(createStream())
2099 );
2100 return Object.defineProperties(payloadPromise, {
2101 _deepestRenderedBoundaryId: {
2102 get() {
2103 return deepestRenderedBoundaryId;
2104 },
2105 set(boundaryId) {
2106 deepestRenderedBoundaryId = boundaryId;
2107 }
2108 },
2109 formState: {
2110 get() {
2111 return payloadPromise.then(
2112 (payload) => payload.type === "render" ? payload.formState : void 0
2113 );
2114 }
2115 }
2116 });
2117 };
2118 let renderRedirect;
2119 let renderError;
2120 try {
2121 if (!detectRedirectResponse.body) {
2122 throw new Error("Failed to clone server response");
2123 }
2124 const payload = await createFromReadableStream(
2125 detectRedirectResponse.body
2126 );
2127 if (serverResponse.status === _chunkYMKMFAYZjs.SINGLE_FETCH_REDIRECT_STATUS && payload.type === "redirect") {
2128 const headers2 = new Headers(serverResponse.headers);
2129 headers2.delete("Content-Encoding");
2130 headers2.delete("Content-Length");
2131 headers2.delete("Content-Type");
2132 headers2.delete("X-Remix-Response");
2133 headers2.set("Location", payload.location);
2134 return new Response(_optionalChain([serverResponseB, 'optionalAccess', _29 => _29.body]) || "", {
2135 headers: headers2,
2136 status: payload.status,
2137 statusText: serverResponse.statusText
2138 });
2139 }
2140 let reactHeaders = new Headers();
2141 let status = serverResponse.status;
2142 let statusText = serverResponse.statusText;
2143 let html = await renderHTML(getPayload, {
2144 onError(error) {
2145 if (typeof error === "object" && error && "digest" in error && typeof error.digest === "string") {
2146 renderRedirect = _chunkYMKMFAYZjs.decodeRedirectErrorDigest.call(void 0, error.digest);
2147 if (renderRedirect) {
2148 return error.digest;
2149 }
2150 let routeErrorResponse = _chunkYMKMFAYZjs.decodeRouteErrorResponseDigest.call(void 0, error.digest);
2151 if (routeErrorResponse) {
2152 renderError = routeErrorResponse;
2153 status = routeErrorResponse.status;
2154 statusText = routeErrorResponse.statusText;
2155 return error.digest;
2156 }
2157 }
2158 },
2159 onHeaders(headers2) {
2160 for (const [key, value] of headers2) {
2161 reactHeaders.append(key, value);
2162 }
2163 }
2164 });
2165 const headers = new Headers(reactHeaders);
2166 for (const [key, value] of serverResponse.headers) {
2167 headers.append(key, value);
2168 }
2169 headers.set("Content-Type", "text/html; charset=utf-8");
2170 if (renderRedirect) {
2171 headers.set("Location", renderRedirect.location);
2172 return new Response(html, {
2173 status: renderRedirect.status,
2174 headers
2175 });
2176 }
2177 const redirectTransform = new TransformStream({
2178 flush(controller) {
2179 if (renderRedirect) {
2180 controller.enqueue(
2181 new TextEncoder().encode(
2182 `<meta http-equiv="refresh" content="0;url=${_chunkYMKMFAYZjs.escapeHtml.call(void 0, renderRedirect.location)}"/>`
2183 )
2184 );
2185 }
2186 }
2187 });
2188 if (!hydrate) {
2189 return new Response(html.pipeThrough(redirectTransform), {
2190 status,
2191 statusText,
2192 headers
2193 });
2194 }
2195 if (!_optionalChain([serverResponseB, 'optionalAccess', _30 => _30.body])) {
2196 throw new Error("Failed to clone server response");
2197 }
2198 const body2 = html.pipeThrough(injectRSCPayload(serverResponseB.body)).pipeThrough(redirectTransform);
2199 return new Response(body2, {
2200 status,
2201 statusText,
2202 headers
2203 });
2204 } catch (reason) {
2205 if (reason instanceof Response) {
2206 return reason;
2207 }
2208 if (renderRedirect) {
2209 return new Response(`Redirect: ${renderRedirect.location}`, {
2210 status: renderRedirect.status,
2211 headers: {
2212 Location: renderRedirect.location
2213 }
2214 });
2215 }
2216 try {
2217 reason = _nullishCoalesce(renderError, () => ( reason));
2218 let [status, statusText] = _chunkYMKMFAYZjs.isRouteErrorResponse.call(void 0, reason) ? [reason.status, reason.statusText] : [500, ""];
2219 let retryRedirect;
2220 let reactHeaders = new Headers();
2221 const html = await renderHTML(
2222 () => {
2223 const decoded = Promise.resolve(
2224 createFromReadableStream(createStream())
2225 );
2226 const payloadPromise = decoded.then(
2227 (payload) => Object.assign(payload, {
2228 status,
2229 errors: deepestRenderedBoundaryId ? {
2230 [deepestRenderedBoundaryId]: reason
2231 } : {}
2232 })
2233 );
2234 return Object.defineProperties(payloadPromise, {
2235 _deepestRenderedBoundaryId: {
2236 get() {
2237 return deepestRenderedBoundaryId;
2238 },
2239 set(boundaryId) {
2240 deepestRenderedBoundaryId = boundaryId;
2241 }
2242 },
2243 formState: {
2244 get() {
2245 return payloadPromise.then(
2246 (payload) => payload.type === "render" ? payload.formState : void 0
2247 );
2248 }
2249 }
2250 });
2251 },
2252 {
2253 onError(error) {
2254 if (typeof error === "object" && error && "digest" in error && typeof error.digest === "string") {
2255 retryRedirect = _chunkYMKMFAYZjs.decodeRedirectErrorDigest.call(void 0, error.digest);
2256 if (retryRedirect) {
2257 return error.digest;
2258 }
2259 let routeErrorResponse = _chunkYMKMFAYZjs.decodeRouteErrorResponseDigest.call(void 0,
2260 error.digest
2261 );
2262 if (routeErrorResponse) {
2263 status = routeErrorResponse.status;
2264 statusText = routeErrorResponse.statusText;
2265 return error.digest;
2266 }
2267 }
2268 },
2269 onHeaders(headers2) {
2270 for (const [key, value] of headers2) {
2271 reactHeaders.append(key, value);
2272 }
2273 }
2274 }
2275 );
2276 const headers = new Headers(reactHeaders);
2277 for (const [key, value] of serverResponse.headers) {
2278 headers.append(key, value);
2279 }
2280 headers.set("Content-Type", "text/html; charset=utf-8");
2281 if (retryRedirect) {
2282 headers.set("Location", retryRedirect.location);
2283 return new Response(html, {
2284 status: retryRedirect.status,
2285 headers
2286 });
2287 }
2288 const retryRedirectTransform = new TransformStream({
2289 flush(controller) {
2290 if (retryRedirect) {
2291 controller.enqueue(
2292 new TextEncoder().encode(
2293 `<meta http-equiv="refresh" content="0;url=${_chunkYMKMFAYZjs.escapeHtml.call(void 0, retryRedirect.location)}"/>`
2294 )
2295 );
2296 }
2297 }
2298 });
2299 if (!hydrate) {
2300 return new Response(html.pipeThrough(retryRedirectTransform), {
2301 status,
2302 statusText,
2303 headers
2304 });
2305 }
2306 if (!_optionalChain([serverResponseB, 'optionalAccess', _31 => _31.body])) {
2307 throw new Error("Failed to clone server response");
2308 }
2309 const body2 = html.pipeThrough(injectRSCPayload(serverResponseB.body)).pipeThrough(retryRedirectTransform);
2310 return new Response(body2, {
2311 status,
2312 statusText,
2313 headers
2314 });
2315 } catch (e3) {
2316 }
2317 throw reason;
2318 }
2319}
2320function RSCStaticRouter({ getPayload }) {
2321 const decoded = getPayload();
2322 const payload = useSafe(decoded);
2323 if (payload.type === "redirect") {
2324 throw new Response(null, {
2325 status: payload.status,
2326 headers: {
2327 Location: payload.location
2328 }
2329 });
2330 }
2331 if (payload.type !== "render") return null;
2332 let patchedLoaderData = { ...payload.loaderData };
2333 for (const match of payload.matches) {
2334 if (_chunkYMKMFAYZjs.shouldHydrateRouteLoader.call(void 0,
2335 match.id,
2336 match.clientLoader,
2337 match.hasLoader,
2338 false
2339 ) && (match.hydrateFallbackElement || !match.hasLoader)) {
2340 delete patchedLoaderData[match.id];
2341 }
2342 }
2343 const context = {
2344 get _deepestRenderedBoundaryId() {
2345 return _nullishCoalesce(decoded._deepestRenderedBoundaryId, () => ( null));
2346 },
2347 set _deepestRenderedBoundaryId(boundaryId) {
2348 decoded._deepestRenderedBoundaryId = boundaryId;
2349 },
2350 actionData: payload.actionData,
2351 actionHeaders: {},
2352 basename: payload.basename,
2353 errors: payload.errors,
2354 loaderData: patchedLoaderData,
2355 loaderHeaders: {},
2356 location: payload.location,
2357 statusCode: 200,
2358 matches: payload.matches.map((match) => ({
2359 params: match.params,
2360 pathname: match.pathname,
2361 pathnameBase: match.pathnameBase,
2362 route: {
2363 id: match.id,
2364 action: match.hasAction || !!match.clientAction,
2365 handle: match.handle,
2366 hasErrorBoundary: match.hasErrorBoundary,
2367 loader: match.hasLoader || !!match.clientLoader,
2368 index: match.index,
2369 path: match.path,
2370 shouldRevalidate: match.shouldRevalidate
2371 }
2372 }))
2373 };
2374 const router = _chunk3F6IB66Ojs.createStaticRouter.call(void 0,
2375 payload.matches.reduceRight((previous, match) => {
2376 const route = {
2377 id: match.id,
2378 action: match.hasAction || !!match.clientAction,
2379 element: match.element,
2380 errorElement: match.errorElement,
2381 handle: match.handle,
2382 hasErrorBoundary: !!match.errorElement,
2383 hydrateFallbackElement: match.hydrateFallbackElement,
2384 index: match.index,
2385 loader: match.hasLoader || !!match.clientLoader,
2386 path: match.path,
2387 shouldRevalidate: match.shouldRevalidate
2388 };
2389 if (previous.length > 0) {
2390 route.children = previous;
2391 }
2392 return [route];
2393 }, []),
2394 context
2395 );
2396 const frameworkContext = {
2397 future: {
2398 // These flags have no runtime impact so can always be false. If we add
2399 // flags that drive runtime behavior they'll need to be proxied through.
2400 v8_middleware: false,
2401 unstable_subResourceIntegrity: false,
2402 unstable_trailingSlashAwareDataRequests: true,
2403 // always on for RSC
2404 unstable_passThroughRequests: true
2405 // always on for RSC
2406 },
2407 isSpaMode: false,
2408 ssr: true,
2409 criticalCss: "",
2410 manifest: {
2411 routes: {},
2412 version: "1",
2413 url: "",
2414 entry: {
2415 module: "",
2416 imports: []
2417 }
2418 },
2419 routeDiscovery: payload.routeDiscovery.mode === "initial" ? { mode: "initial", manifestPath: defaultManifestPath } : {
2420 mode: "lazy",
2421 manifestPath: payload.routeDiscovery.manifestPath || defaultManifestPath
2422 },
2423 routeModules: _chunk7VLQJKNGjs.createRSCRouteModules.call(void 0, payload)
2424 };
2425 return /* @__PURE__ */ React3.createElement(_chunkYMKMFAYZjs.RSCRouterContext.Provider, { value: true }, /* @__PURE__ */ React3.createElement(_chunk7VLQJKNGjs.RSCRouterGlobalErrorBoundary, { location: payload.location }, /* @__PURE__ */ React3.createElement(_chunkYMKMFAYZjs.FrameworkContext.Provider, { value: frameworkContext }, /* @__PURE__ */ React3.createElement(
2426 _chunk3F6IB66Ojs.StaticRouterProvider,
2427 {
2428 context,
2429 router,
2430 hydrate: false,
2431 nonce: payload.nonce
2432 }
2433 ))));
2434}
2435function isReactServerRequest(url) {
2436 return url.pathname.endsWith(".rsc");
2437}
2438function isManifestRequest(url) {
2439 return url.pathname.endsWith(".manifest");
2440}
2441
2442// lib/dom/ssr/errors.ts
2443function deserializeErrors(errors) {
2444 if (!errors) return null;
2445 let entries = Object.entries(errors);
2446 let serialized = {};
2447 for (let [key, val] of entries) {
2448 if (val && val.__type === "RouteErrorResponse") {
2449 serialized[key] = new (0, _chunkYMKMFAYZjs.ErrorResponseImpl)(
2450 val.status,
2451 val.statusText,
2452 val.data,
2453 val.internal === true
2454 );
2455 } else if (val && val.__type === "Error") {
2456 if (val.__subType) {
2457 let ErrorConstructor = window[val.__subType];
2458 if (typeof ErrorConstructor === "function") {
2459 try {
2460 let error = new ErrorConstructor(val.message);
2461 error.stack = val.stack;
2462 serialized[key] = error;
2463 } catch (e) {
2464 }
2465 }
2466 }
2467 if (serialized[key] == null) {
2468 let error = new Error(val.message);
2469 error.stack = val.stack;
2470 serialized[key] = error;
2471 }
2472 } else {
2473 serialized[key] = val;
2474 }
2475 }
2476 return serialized;
2477}
2478
2479
2480
2481
2482
2483
2484
2485
2486
2487
2488
2489
2490
2491
2492
2493
2494
2495
2496
2497
2498
2499
2500
2501
2502
2503
2504
2505
2506
2507
2508
2509
2510
2511
2512
2513
2514
2515
2516
2517
2518
2519
2520
2521
2522
2523
2524
2525
2526
2527
2528
2529
2530
2531
2532
2533
2534
2535
2536
2537
2538
2539
2540
2541
2542
2543
2544
2545
2546
2547
2548
2549
2550
2551
2552
2553
2554
2555
2556
2557
2558
2559
2560
2561
2562
2563
2564
2565
2566
2567
2568
2569
2570
2571
2572
2573
2574
2575
2576
2577
2578
2579
2580
2581
2582
2583
2584
2585
2586
2587
2588
2589
2590
2591
2592
2593
2594
2595
2596
2597
2598
2599
2600
2601
2602
2603
2604
2605
2606
2607
2608exports.Await = _chunkYMKMFAYZjs.Await; exports.BrowserRouter = _chunk3F6IB66Ojs.BrowserRouter; exports.Form = _chunk3F6IB66Ojs.Form; exports.HashRouter = _chunk3F6IB66Ojs.HashRouter; exports.IDLE_BLOCKER = _chunkYMKMFAYZjs.IDLE_BLOCKER; exports.IDLE_FETCHER = _chunkYMKMFAYZjs.IDLE_FETCHER; exports.IDLE_NAVIGATION = _chunkYMKMFAYZjs.IDLE_NAVIGATION; exports.Link = _chunk3F6IB66Ojs.Link; exports.Links = _chunkYMKMFAYZjs.Links; exports.MemoryRouter = _chunkYMKMFAYZjs.MemoryRouter; exports.Meta = _chunkYMKMFAYZjs.Meta; exports.NavLink = _chunk3F6IB66Ojs.NavLink; exports.Navigate = _chunkYMKMFAYZjs.Navigate; exports.NavigationType = _chunkYMKMFAYZjs.Action; exports.Outlet = _chunkYMKMFAYZjs.Outlet; exports.PrefetchPageLinks = _chunkYMKMFAYZjs.PrefetchPageLinks; exports.Route = _chunkYMKMFAYZjs.Route; exports.Router = _chunkYMKMFAYZjs.Router; exports.RouterContextProvider = _chunkYMKMFAYZjs.RouterContextProvider; exports.RouterProvider = _chunkYMKMFAYZjs.RouterProvider; exports.Routes = _chunkYMKMFAYZjs.Routes; exports.Scripts = _chunkYMKMFAYZjs.Scripts; exports.ScrollRestoration = _chunk3F6IB66Ojs.ScrollRestoration; exports.ServerRouter = ServerRouter; exports.StaticRouter = _chunk3F6IB66Ojs.StaticRouter; exports.StaticRouterProvider = _chunk3F6IB66Ojs.StaticRouterProvider; exports.UNSAFE_AwaitContextProvider = _chunkYMKMFAYZjs.AwaitContextProvider; exports.UNSAFE_DataRouterContext = _chunkYMKMFAYZjs.DataRouterContext; exports.UNSAFE_DataRouterStateContext = _chunkYMKMFAYZjs.DataRouterStateContext; exports.UNSAFE_ErrorResponseImpl = _chunkYMKMFAYZjs.ErrorResponseImpl; exports.UNSAFE_FetchersContext = _chunkYMKMFAYZjs.FetchersContext; exports.UNSAFE_FrameworkContext = _chunkYMKMFAYZjs.FrameworkContext; exports.UNSAFE_LocationContext = _chunkYMKMFAYZjs.LocationContext; exports.UNSAFE_NavigationContext = _chunkYMKMFAYZjs.NavigationContext; exports.UNSAFE_RSCDefaultRootErrorBoundary = _chunk7VLQJKNGjs.RSCDefaultRootErrorBoundary; exports.UNSAFE_RemixErrorBoundary = _chunkYMKMFAYZjs.RemixErrorBoundary; exports.UNSAFE_RouteContext = _chunkYMKMFAYZjs.RouteContext; exports.UNSAFE_ServerMode = ServerMode; exports.UNSAFE_SingleFetchRedirectSymbol = _chunkYMKMFAYZjs.SingleFetchRedirectSymbol; exports.UNSAFE_ViewTransitionContext = _chunkYMKMFAYZjs.ViewTransitionContext; exports.UNSAFE_WithComponentProps = _chunkYMKMFAYZjs.WithComponentProps; exports.UNSAFE_WithErrorBoundaryProps = _chunkYMKMFAYZjs.WithErrorBoundaryProps; exports.UNSAFE_WithHydrateFallbackProps = _chunkYMKMFAYZjs.WithHydrateFallbackProps; exports.UNSAFE_createBrowserHistory = _chunkYMKMFAYZjs.createBrowserHistory; exports.UNSAFE_createClientRoutes = _chunkYMKMFAYZjs.createClientRoutes; exports.UNSAFE_createClientRoutesWithHMRRevalidationOptOut = _chunkYMKMFAYZjs.createClientRoutesWithHMRRevalidationOptOut; exports.UNSAFE_createHashHistory = _chunkYMKMFAYZjs.createHashHistory; exports.UNSAFE_createMemoryHistory = _chunkYMKMFAYZjs.createMemoryHistory; exports.UNSAFE_createRouter = _chunkYMKMFAYZjs.createRouter; exports.UNSAFE_decodeViaTurboStream = _chunkYMKMFAYZjs.decodeViaTurboStream; exports.UNSAFE_deserializeErrors = deserializeErrors; exports.UNSAFE_getHydrationData = _chunk7VLQJKNGjs.getHydrationData; exports.UNSAFE_getPatchRoutesOnNavigationFunction = _chunkYMKMFAYZjs.getPatchRoutesOnNavigationFunction; exports.UNSAFE_getTurboStreamSingleFetchDataStrategy = _chunkYMKMFAYZjs.getTurboStreamSingleFetchDataStrategy; exports.UNSAFE_hydrationRouteProperties = _chunkYMKMFAYZjs.hydrationRouteProperties; exports.UNSAFE_invariant = _chunkYMKMFAYZjs.invariant; exports.UNSAFE_mapRouteProperties = _chunkYMKMFAYZjs.mapRouteProperties; exports.UNSAFE_shouldHydrateRouteLoader = _chunkYMKMFAYZjs.shouldHydrateRouteLoader; exports.UNSAFE_useFogOFWarDiscovery = _chunkYMKMFAYZjs.useFogOFWarDiscovery; exports.UNSAFE_useScrollRestoration = _chunk3F6IB66Ojs.useScrollRestoration; exports.UNSAFE_withComponentProps = _chunkYMKMFAYZjs.withComponentProps; exports.UNSAFE_withErrorBoundaryProps = _chunkYMKMFAYZjs.withErrorBoundaryProps; exports.UNSAFE_withHydrateFallbackProps = _chunkYMKMFAYZjs.withHydrateFallbackProps; exports.createBrowserRouter = _chunk3F6IB66Ojs.createBrowserRouter; exports.createContext = _chunkYMKMFAYZjs.createContext; exports.createCookie = createCookie; exports.createCookieSessionStorage = createCookieSessionStorage; exports.createHashRouter = _chunk3F6IB66Ojs.createHashRouter; exports.createMemoryRouter = _chunkYMKMFAYZjs.createMemoryRouter; exports.createMemorySessionStorage = createMemorySessionStorage; exports.createPath = _chunkYMKMFAYZjs.createPath; exports.createRequestHandler = createRequestHandler; exports.createRoutesFromChildren = _chunkYMKMFAYZjs.createRoutesFromChildren; exports.createRoutesFromElements = _chunkYMKMFAYZjs.createRoutesFromElements; exports.createRoutesStub = createRoutesStub; exports.createSearchParams = _chunk3F6IB66Ojs.createSearchParams; exports.createSession = createSession; exports.createSessionStorage = createSessionStorage; exports.createStaticHandler = _chunk3F6IB66Ojs.createStaticHandler; exports.createStaticRouter = _chunk3F6IB66Ojs.createStaticRouter; exports.data = _chunkYMKMFAYZjs.data; exports.generatePath = _chunkYMKMFAYZjs.generatePath; exports.href = href; exports.isCookie = isCookie; exports.isRouteErrorResponse = _chunkYMKMFAYZjs.isRouteErrorResponse; exports.isSession = isSession; exports.matchPath = _chunkYMKMFAYZjs.matchPath; exports.matchRoutes = _chunkYMKMFAYZjs.matchRoutes; exports.parsePath = _chunkYMKMFAYZjs.parsePath; exports.redirect = _chunkYMKMFAYZjs.redirect; exports.redirectDocument = _chunkYMKMFAYZjs.redirectDocument; exports.renderMatches = _chunkYMKMFAYZjs.renderMatches; exports.replace = _chunkYMKMFAYZjs.replace; exports.resolvePath = _chunkYMKMFAYZjs.resolvePath; exports.unstable_HistoryRouter = _chunk3F6IB66Ojs.HistoryRouter; exports.unstable_RSCStaticRouter = RSCStaticRouter; exports.unstable_routeRSCServerRequest = routeRSCServerRequest; exports.unstable_setDevServerHooks = setDevServerHooks; exports.unstable_usePrompt = _chunk3F6IB66Ojs.usePrompt; exports.unstable_useRoute = _chunkYMKMFAYZjs.useRoute; exports.useActionData = _chunkYMKMFAYZjs.useActionData; exports.useAsyncError = _chunkYMKMFAYZjs.useAsyncError; exports.useAsyncValue = _chunkYMKMFAYZjs.useAsyncValue; exports.useBeforeUnload = _chunk3F6IB66Ojs.useBeforeUnload; exports.useBlocker = _chunkYMKMFAYZjs.useBlocker; exports.useFetcher = _chunk3F6IB66Ojs.useFetcher; exports.useFetchers = _chunk3F6IB66Ojs.useFetchers; exports.useFormAction = _chunk3F6IB66Ojs.useFormAction; exports.useHref = _chunkYMKMFAYZjs.useHref; exports.useInRouterContext = _chunkYMKMFAYZjs.useInRouterContext; exports.useLinkClickHandler = _chunk3F6IB66Ojs.useLinkClickHandler; exports.useLoaderData = _chunkYMKMFAYZjs.useLoaderData; exports.useLocation = _chunkYMKMFAYZjs.useLocation; exports.useMatch = _chunkYMKMFAYZjs.useMatch; exports.useMatches = _chunkYMKMFAYZjs.useMatches; exports.useNavigate = _chunkYMKMFAYZjs.useNavigate; exports.useNavigation = _chunkYMKMFAYZjs.useNavigation; exports.useNavigationType = _chunkYMKMFAYZjs.useNavigationType; exports.useOutlet = _chunkYMKMFAYZjs.useOutlet; exports.useOutletContext = _chunkYMKMFAYZjs.useOutletContext; exports.useParams = _chunkYMKMFAYZjs.useParams; exports.useResolvedPath = _chunkYMKMFAYZjs.useResolvedPath; exports.useRevalidator = _chunkYMKMFAYZjs.useRevalidator; exports.useRouteError = _chunkYMKMFAYZjs.useRouteError; exports.useRouteLoaderData = _chunkYMKMFAYZjs.useRouteLoaderData; exports.useRoutes = _chunkYMKMFAYZjs.useRoutes; exports.useSearchParams = _chunk3F6IB66Ojs.useSearchParams; exports.useSubmit = _chunk3F6IB66Ojs.useSubmit; exports.useViewTransitionState = _chunk3F6IB66Ojs.useViewTransitionState;