UNPKG

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