UNPKG

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