UNPKG

84.8 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.13.1
3 *
4 * Copyright (c) Remix Software Inc.
5 *
6 * This source code is licensed under the MIT license found in the
7 * LICENSE.md file in the root directory of this source tree.
8 *
9 * @license MIT
10 */
11"use client";
12
13
14
15
16
17var _chunkZJMCM6KTjs = require('./chunk-ZJMCM6KT.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 _chunkB5UMK6O7js = require('./chunk-B5UMK6O7.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 _chunk772H4TVRjs = require('./chunk-772H4TVR.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 = _chunk772H4TVRjs.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 && _chunk772H4TVRjs.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 = _chunkB5UMK6O7js.createStaticRouter.call(void 0, routes, context.staticHandlerContext);
188 return /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(
189 _chunk772H4TVRjs.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(_chunk772H4TVRjs.RemixErrorBoundary, { location: router.state.location }, /* @__PURE__ */ React.createElement(
205 _chunkB5UMK6O7js.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 _chunk772H4TVRjs.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 _chunk772H4TVRjs.convertRoutesToDataRoutes.call(void 0, routes, (r) => r),
257 _context !== void 0 ? _context : _optionalChain([future, 'optionalAccess', _5 => _5.v8_middleware]) ? new (0, _chunk772H4TVRjs.RouterContextProvider)() : {},
258 frameworkContextRef.current.manifest,
259 frameworkContextRef.current.routeModules
260 );
261 routerRef.current = _chunk772H4TVRjs.createMemoryRouter.call(void 0, patched, {
262 initialEntries,
263 initialIndex,
264 hydrationData
265 });
266 }
267 return /* @__PURE__ */ React2.createElement(_chunk772H4TVRjs.FrameworkContext.Provider, { value: frameworkContextRef.current }, /* @__PURE__ */ React2.createElement(_chunk772H4TVRjs.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 ? _chunk772H4TVRjs.withComponentProps.call(void 0, route.Component) : void 0,
282 HydrateFallback: route.HydrateFallback ? _chunk772H4TVRjs.withHydrateFallbackProps.call(void 0, route.HydrateFallback) : void 0,
283 ErrorBoundary: route.ErrorBoundary ? _chunk772H4TVRjs.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 || _chunk772H4TVRjs.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 _chunk772H4TVRjs.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 (_chunk772H4TVRjs.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 = _chunk772H4TVRjs.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 (_chunk772H4TVRjs.isDataWithResponseInit.call(void 0, result) && result.init && result.init.status && _chunk772H4TVRjs.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 _chunk772H4TVRjs.decodeViaTurboStream.call(void 0, stream, global);
733 let data2 = decoded.value;
734 if (data2 && _chunk772H4TVRjs.SingleFetchRedirectSymbol in data2) {
735 let result = data2[_chunk772H4TVRjs.SingleFetchRedirectSymbol];
736 let init = { status: result.status };
737 if (result.reload) {
738 throw _chunk772H4TVRjs.redirectDocument.call(void 0, result.redirect, init);
739 } else if (result.replace) {
740 throw _chunk772H4TVRjs.replace.call(void 0, result.redirect, init);
741 } else {
742 throw _chunk772H4TVRjs.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 _chunk772H4TVRjs.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 = null;
860 try {
861 originDomain = typeof originHeader === "string" && originHeader !== "null" ? new URL(originHeader).host : originHeader;
862 } catch (e2) {
863 throw new Error(
864 `\`origin\` header is not a valid URL. Aborting the action.`
865 );
866 }
867 let host = parseHostHeader(headers);
868 if (originDomain && (!host || originDomain !== host.value)) {
869 if (!isAllowedOrigin(originDomain, allowedActionOrigins)) {
870 if (host) {
871 throw new Error(
872 `${host.type} header does not match \`origin\` header from a forwarded action request. Aborting the action.`
873 );
874 } else {
875 throw new Error(
876 "`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."
877 );
878 }
879 }
880 }
881}
882function matchWildcardDomain(domain, pattern) {
883 const domainParts = domain.split(".");
884 const patternParts = pattern.split(".");
885 if (patternParts.length < 1) {
886 return false;
887 }
888 if (domainParts.length < patternParts.length) {
889 return false;
890 }
891 while (patternParts.length) {
892 const patternPart = patternParts.pop();
893 const domainPart = domainParts.pop();
894 switch (patternPart) {
895 case "": {
896 return false;
897 }
898 case "*": {
899 if (domainPart) {
900 continue;
901 } else {
902 return false;
903 }
904 }
905 case "**": {
906 if (patternParts.length > 0) {
907 return false;
908 }
909 return domainPart !== void 0;
910 }
911 case void 0:
912 default: {
913 if (domainPart !== patternPart) {
914 return false;
915 }
916 }
917 }
918 }
919 return domainParts.length === 0;
920}
921function isAllowedOrigin(originDomain, allowedActionOrigins = []) {
922 return allowedActionOrigins.some(
923 (allowedOrigin) => allowedOrigin && (allowedOrigin === originDomain || matchWildcardDomain(originDomain, allowedOrigin))
924 );
925}
926function parseHostHeader(headers) {
927 let forwardedHostHeader = headers.get("x-forwarded-host");
928 let forwardedHostValue = _optionalChain([forwardedHostHeader, 'optionalAccess', _8 => _8.split, 'call', _9 => _9(","), 'access', _10 => _10[0], 'optionalAccess', _11 => _11.trim, 'call', _12 => _12()]);
929 let hostHeader = headers.get("host");
930 return forwardedHostValue ? {
931 type: "x-forwarded-host",
932 value: forwardedHostValue
933 } : hostHeader ? {
934 type: "host",
935 value: hostHeader
936 } : void 0;
937}
938
939// lib/server-runtime/single-fetch.ts
940var SERVER_NO_BODY_STATUS_CODES = /* @__PURE__ */ new Set([
941 ..._chunk772H4TVRjs.NO_BODY_STATUS_CODES,
942 304
943]);
944async function singleFetchAction(build, serverMode, staticHandler, request, handlerUrl, loadContext, handleError) {
945 try {
946 try {
947 throwIfPotentialCSRFAttack(
948 request.headers,
949 Array.isArray(build.allowedActionOrigins) ? build.allowedActionOrigins : []
950 );
951 } catch (e) {
952 return handleQueryError(new Error("Bad Request"), 400);
953 }
954 let handlerRequest = new Request(handlerUrl, {
955 method: request.method,
956 body: request.body,
957 headers: request.headers,
958 signal: request.signal,
959 ...request.body ? { duplex: "half" } : void 0
960 });
961 let result = await staticHandler.query(handlerRequest, {
962 requestContext: loadContext,
963 skipLoaderErrorBubbling: true,
964 skipRevalidation: true,
965 generateMiddlewareResponse: build.future.v8_middleware ? async (query) => {
966 try {
967 let innerResult = await query(handlerRequest);
968 return handleQueryResult(innerResult);
969 } catch (error) {
970 return handleQueryError(error);
971 }
972 } : void 0
973 });
974 return handleQueryResult(result);
975 } catch (error) {
976 return handleQueryError(error);
977 }
978 function handleQueryResult(result) {
979 return _chunk772H4TVRjs.isResponse.call(void 0, result) ? result : staticContextToResponse(result);
980 }
981 function handleQueryError(error, status = 500) {
982 handleError(error);
983 return generateSingleFetchResponse(request, build, serverMode, {
984 result: { error },
985 headers: new Headers(),
986 status
987 });
988 }
989 function staticContextToResponse(context) {
990 let headers = getDocumentHeaders(context, build);
991 if (_chunk772H4TVRjs.isRedirectStatusCode.call(void 0, context.statusCode) && headers.has("Location")) {
992 return new Response(null, { status: context.statusCode, headers });
993 }
994 if (context.errors) {
995 Object.values(context.errors).forEach((err) => {
996 if (!_chunk772H4TVRjs.isRouteErrorResponse.call(void 0, err) || err.error) {
997 handleError(err);
998 }
999 });
1000 context.errors = sanitizeErrors(context.errors, serverMode);
1001 }
1002 let singleFetchResult;
1003 if (context.errors) {
1004 singleFetchResult = { error: Object.values(context.errors)[0] };
1005 } else {
1006 singleFetchResult = {
1007 data: Object.values(context.actionData || {})[0]
1008 };
1009 }
1010 return generateSingleFetchResponse(request, build, serverMode, {
1011 result: singleFetchResult,
1012 headers,
1013 status: context.statusCode
1014 });
1015 }
1016}
1017async function singleFetchLoaders(build, serverMode, staticHandler, request, handlerUrl, loadContext, handleError) {
1018 let routesParam = new URL(request.url).searchParams.get("_routes");
1019 let loadRouteIds = routesParam ? new Set(routesParam.split(",")) : null;
1020 try {
1021 let handlerRequest = new Request(handlerUrl, {
1022 headers: request.headers,
1023 signal: request.signal
1024 });
1025 let result = await staticHandler.query(handlerRequest, {
1026 requestContext: loadContext,
1027 filterMatchesToLoad: (m) => !loadRouteIds || loadRouteIds.has(m.route.id),
1028 skipLoaderErrorBubbling: true,
1029 generateMiddlewareResponse: build.future.v8_middleware ? async (query) => {
1030 try {
1031 let innerResult = await query(handlerRequest);
1032 return handleQueryResult(innerResult);
1033 } catch (error) {
1034 return handleQueryError(error);
1035 }
1036 } : void 0
1037 });
1038 return handleQueryResult(result);
1039 } catch (error) {
1040 return handleQueryError(error);
1041 }
1042 function handleQueryResult(result) {
1043 return _chunk772H4TVRjs.isResponse.call(void 0, result) ? result : staticContextToResponse(result);
1044 }
1045 function handleQueryError(error) {
1046 handleError(error);
1047 return generateSingleFetchResponse(request, build, serverMode, {
1048 result: { error },
1049 headers: new Headers(),
1050 status: 500
1051 });
1052 }
1053 function staticContextToResponse(context) {
1054 let headers = getDocumentHeaders(context, build);
1055 if (_chunk772H4TVRjs.isRedirectStatusCode.call(void 0, context.statusCode) && headers.has("Location")) {
1056 return new Response(null, { status: context.statusCode, headers });
1057 }
1058 if (context.errors) {
1059 Object.values(context.errors).forEach((err) => {
1060 if (!_chunk772H4TVRjs.isRouteErrorResponse.call(void 0, err) || err.error) {
1061 handleError(err);
1062 }
1063 });
1064 context.errors = sanitizeErrors(context.errors, serverMode);
1065 }
1066 let results = {};
1067 let loadedMatches = new Set(
1068 context.matches.filter(
1069 (m) => loadRouteIds ? loadRouteIds.has(m.route.id) : m.route.loader != null
1070 ).map((m) => m.route.id)
1071 );
1072 if (context.errors) {
1073 for (let [id, error] of Object.entries(context.errors)) {
1074 results[id] = { error };
1075 }
1076 }
1077 for (let [id, data2] of Object.entries(context.loaderData)) {
1078 if (!(id in results) && loadedMatches.has(id)) {
1079 results[id] = { data: data2 };
1080 }
1081 }
1082 return generateSingleFetchResponse(request, build, serverMode, {
1083 result: results,
1084 headers,
1085 status: context.statusCode
1086 });
1087 }
1088}
1089function generateSingleFetchResponse(request, build, serverMode, {
1090 result,
1091 headers,
1092 status
1093}) {
1094 let resultHeaders = new Headers(headers);
1095 resultHeaders.set("X-Remix-Response", "yes");
1096 if (SERVER_NO_BODY_STATUS_CODES.has(status)) {
1097 return new Response(null, { status, headers: resultHeaders });
1098 }
1099 resultHeaders.set("Content-Type", "text/x-script");
1100 resultHeaders.delete("Content-Length");
1101 return new Response(
1102 encodeViaTurboStream(
1103 result,
1104 request.signal,
1105 build.entry.module.streamTimeout,
1106 serverMode
1107 ),
1108 {
1109 status: status || 200,
1110 headers: resultHeaders
1111 }
1112 );
1113}
1114function generateSingleFetchRedirectResponse(redirectResponse, request, build, serverMode) {
1115 let redirect2 = getSingleFetchRedirect(
1116 redirectResponse.status,
1117 redirectResponse.headers,
1118 build.basename
1119 );
1120 let headers = new Headers(redirectResponse.headers);
1121 headers.delete("Location");
1122 headers.set("Content-Type", "text/x-script");
1123 return generateSingleFetchResponse(request, build, serverMode, {
1124 result: request.method === "GET" ? { [_chunk772H4TVRjs.SingleFetchRedirectSymbol]: redirect2 } : redirect2,
1125 headers,
1126 status: _chunk772H4TVRjs.SINGLE_FETCH_REDIRECT_STATUS
1127 });
1128}
1129function getSingleFetchRedirect(status, headers, basename) {
1130 let redirect2 = headers.get("Location");
1131 if (basename) {
1132 redirect2 = _chunk772H4TVRjs.stripBasename.call(void 0, redirect2, basename) || redirect2;
1133 }
1134 return {
1135 redirect: redirect2,
1136 status,
1137 revalidate: (
1138 // Technically X-Remix-Revalidate isn't needed here - that was an implementation
1139 // detail of ?_data requests as our way to tell the front end to revalidate when
1140 // we didn't have a response body to include that information in.
1141 // With single fetch, we tell the front end via this revalidate boolean field.
1142 // However, we're respecting it for now because it may be something folks have
1143 // used in their own responses
1144 // TODO(v3): Consider removing or making this official public API
1145 headers.has("X-Remix-Revalidate") || headers.has("Set-Cookie")
1146 ),
1147 reload: headers.has("X-Remix-Reload-Document"),
1148 replace: headers.has("X-Remix-Replace")
1149 };
1150}
1151function encodeViaTurboStream(data2, requestSignal, streamTimeout, serverMode) {
1152 let controller = new AbortController();
1153 let timeoutId = setTimeout(
1154 () => controller.abort(new Error("Server Timeout")),
1155 typeof streamTimeout === "number" ? streamTimeout : 4950
1156 );
1157 let clearStreamTimeout = () => clearTimeout(timeoutId);
1158 requestSignal.addEventListener("abort", clearStreamTimeout);
1159 return _chunk772H4TVRjs.encode.call(void 0, data2, {
1160 signal: controller.signal,
1161 onComplete: clearStreamTimeout,
1162 plugins: [
1163 (value) => {
1164 if (value instanceof Error) {
1165 let { name, message, stack } = serverMode === "production" /* Production */ ? sanitizeError(value, serverMode) : value;
1166 return ["SanitizedError", name, message, stack];
1167 }
1168 if (value instanceof _chunk772H4TVRjs.ErrorResponseImpl) {
1169 let { data: data3, status, statusText } = value;
1170 return ["ErrorResponse", data3, status, statusText];
1171 }
1172 if (value && typeof value === "object" && _chunk772H4TVRjs.SingleFetchRedirectSymbol in value) {
1173 return ["SingleFetchRedirect", value[_chunk772H4TVRjs.SingleFetchRedirectSymbol]];
1174 }
1175 }
1176 ],
1177 postPlugins: [
1178 (value) => {
1179 if (!value) return;
1180 if (typeof value !== "object") return;
1181 return [
1182 "SingleFetchClassInstance",
1183 Object.fromEntries(Object.entries(value))
1184 ];
1185 },
1186 () => ["SingleFetchFallback"]
1187 ]
1188 });
1189}
1190
1191// lib/server-runtime/server.ts
1192function derive(build, mode) {
1193 let routes = createRoutes(build.routes);
1194 let dataRoutes = createStaticHandlerDataRoutes(build.routes, build.future);
1195 let serverMode = isServerMode(mode) ? mode : "production" /* Production */;
1196 let staticHandler = _chunk772H4TVRjs.createStaticHandler.call(void 0, dataRoutes, {
1197 basename: build.basename,
1198 unstable_instrumentations: build.entry.module.unstable_instrumentations
1199 });
1200 let errorHandler = build.entry.module.handleError || ((error, { request }) => {
1201 if (serverMode !== "test" /* Test */ && !request.signal.aborted) {
1202 console.error(
1203 // @ts-expect-error This is "private" from users but intended for internal use
1204 _chunk772H4TVRjs.isRouteErrorResponse.call(void 0, error) && error.error ? error.error : error
1205 );
1206 }
1207 });
1208 let requestHandler = async (request, initialContext) => {
1209 let params = {};
1210 let loadContext;
1211 let handleError = (error) => {
1212 if (mode === "development" /* Development */) {
1213 _optionalChain([getDevServerHooks, 'call', _13 => _13(), 'optionalAccess', _14 => _14.processRequestError, 'optionalCall', _15 => _15(error)]);
1214 }
1215 errorHandler(error, {
1216 context: loadContext,
1217 params,
1218 request
1219 });
1220 };
1221 if (build.future.v8_middleware) {
1222 if (initialContext && !(initialContext instanceof _chunk772H4TVRjs.RouterContextProvider)) {
1223 let error = new Error(
1224 "Invalid `context` value provided to `handleRequest`. When middleware is enabled you must return an instance of `RouterContextProvider` from your `getLoadContext` function."
1225 );
1226 handleError(error);
1227 return returnLastResortErrorResponse(error, serverMode);
1228 }
1229 loadContext = initialContext || new (0, _chunk772H4TVRjs.RouterContextProvider)();
1230 } else {
1231 loadContext = initialContext || {};
1232 }
1233 let url = new URL(request.url);
1234 let normalizedBasename = build.basename || "/";
1235 let normalizedPath = url.pathname;
1236 if (build.future.unstable_trailingSlashAwareDataRequests) {
1237 if (normalizedPath.endsWith("/_.data")) {
1238 normalizedPath = normalizedPath.replace(/_.data$/, "");
1239 } else {
1240 normalizedPath = normalizedPath.replace(/\.data$/, "");
1241 }
1242 } else {
1243 if (_chunk772H4TVRjs.stripBasename.call(void 0, normalizedPath, normalizedBasename) === "/_root.data") {
1244 normalizedPath = normalizedBasename;
1245 } else if (normalizedPath.endsWith(".data")) {
1246 normalizedPath = normalizedPath.replace(/\.data$/, "");
1247 }
1248 if (_chunk772H4TVRjs.stripBasename.call(void 0, normalizedPath, normalizedBasename) !== "/" && normalizedPath.endsWith("/")) {
1249 normalizedPath = normalizedPath.slice(0, -1);
1250 }
1251 }
1252 let isSpaMode = getBuildTimeHeader(request, "X-React-Router-SPA-Mode") === "yes";
1253 if (!build.ssr) {
1254 let decodedPath = decodeURI(normalizedPath);
1255 if (normalizedBasename !== "/") {
1256 let strippedPath = _chunk772H4TVRjs.stripBasename.call(void 0, decodedPath, normalizedBasename);
1257 if (strippedPath == null) {
1258 errorHandler(
1259 new (0, _chunk772H4TVRjs.ErrorResponseImpl)(
1260 404,
1261 "Not Found",
1262 `Refusing to prerender the \`${decodedPath}\` path because it does not start with the basename \`${normalizedBasename}\``
1263 ),
1264 {
1265 context: loadContext,
1266 params,
1267 request
1268 }
1269 );
1270 return new Response("Not Found", {
1271 status: 404,
1272 statusText: "Not Found"
1273 });
1274 }
1275 decodedPath = strippedPath;
1276 }
1277 if (build.prerender.length === 0) {
1278 isSpaMode = true;
1279 } else if (!build.prerender.includes(decodedPath) && !build.prerender.includes(decodedPath + "/")) {
1280 if (url.pathname.endsWith(".data")) {
1281 errorHandler(
1282 new (0, _chunk772H4TVRjs.ErrorResponseImpl)(
1283 404,
1284 "Not Found",
1285 `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.`
1286 ),
1287 {
1288 context: loadContext,
1289 params,
1290 request
1291 }
1292 );
1293 return new Response("Not Found", {
1294 status: 404,
1295 statusText: "Not Found"
1296 });
1297 } else {
1298 isSpaMode = true;
1299 }
1300 }
1301 }
1302 let manifestUrl = _chunk772H4TVRjs.getManifestPath.call(void 0,
1303 build.routeDiscovery.manifestPath,
1304 normalizedBasename
1305 );
1306 if (url.pathname === manifestUrl) {
1307 try {
1308 let res = await handleManifestRequest(build, routes, url);
1309 return res;
1310 } catch (e) {
1311 handleError(e);
1312 return new Response("Unknown Server Error", { status: 500 });
1313 }
1314 }
1315 let matches = matchServerRoutes(routes, normalizedPath, build.basename);
1316 if (matches && matches.length > 0) {
1317 Object.assign(params, matches[0].params);
1318 }
1319 let response;
1320 if (url.pathname.endsWith(".data")) {
1321 let handlerUrl = new URL(request.url);
1322 handlerUrl.pathname = normalizedPath;
1323 let singleFetchMatches = matchServerRoutes(
1324 routes,
1325 handlerUrl.pathname,
1326 build.basename
1327 );
1328 response = await handleSingleFetchRequest(
1329 serverMode,
1330 build,
1331 staticHandler,
1332 request,
1333 handlerUrl,
1334 loadContext,
1335 handleError
1336 );
1337 if (_chunk772H4TVRjs.isRedirectResponse.call(void 0, response)) {
1338 response = generateSingleFetchRedirectResponse(
1339 response,
1340 request,
1341 build,
1342 serverMode
1343 );
1344 }
1345 if (build.entry.module.handleDataRequest) {
1346 response = await build.entry.module.handleDataRequest(response, {
1347 context: loadContext,
1348 params: singleFetchMatches ? singleFetchMatches[0].params : {},
1349 request
1350 });
1351 if (_chunk772H4TVRjs.isRedirectResponse.call(void 0, response)) {
1352 response = generateSingleFetchRedirectResponse(
1353 response,
1354 request,
1355 build,
1356 serverMode
1357 );
1358 }
1359 }
1360 } else if (!isSpaMode && matches && matches[matches.length - 1].route.module.default == null && matches[matches.length - 1].route.module.ErrorBoundary == null) {
1361 response = await handleResourceRequest(
1362 serverMode,
1363 build,
1364 staticHandler,
1365 matches.slice(-1)[0].route.id,
1366 request,
1367 loadContext,
1368 handleError
1369 );
1370 } else {
1371 let { pathname } = url;
1372 let criticalCss = void 0;
1373 if (build.unstable_getCriticalCss) {
1374 criticalCss = await build.unstable_getCriticalCss({ pathname });
1375 } else if (mode === "development" /* Development */ && _optionalChain([getDevServerHooks, 'call', _16 => _16(), 'optionalAccess', _17 => _17.getCriticalCss])) {
1376 criticalCss = await _optionalChain([getDevServerHooks, 'call', _18 => _18(), 'optionalAccess', _19 => _19.getCriticalCss, 'optionalCall', _20 => _20(pathname)]);
1377 }
1378 response = await handleDocumentRequest(
1379 serverMode,
1380 build,
1381 staticHandler,
1382 request,
1383 loadContext,
1384 handleError,
1385 isSpaMode,
1386 criticalCss
1387 );
1388 }
1389 if (request.method === "HEAD") {
1390 return new Response(null, {
1391 headers: response.headers,
1392 status: response.status,
1393 statusText: response.statusText
1394 });
1395 }
1396 return response;
1397 };
1398 if (build.entry.module.unstable_instrumentations) {
1399 requestHandler = _chunk772H4TVRjs.instrumentHandler.call(void 0,
1400 requestHandler,
1401 build.entry.module.unstable_instrumentations.map((i) => i.handler).filter(Boolean)
1402 );
1403 }
1404 return {
1405 routes,
1406 dataRoutes,
1407 serverMode,
1408 staticHandler,
1409 errorHandler,
1410 requestHandler
1411 };
1412}
1413var createRequestHandler = (build, mode) => {
1414 let _build;
1415 let routes;
1416 let serverMode;
1417 let staticHandler;
1418 let errorHandler;
1419 let _requestHandler;
1420 return async function requestHandler(request, initialContext) {
1421 _build = typeof build === "function" ? await build() : build;
1422 if (typeof build === "function") {
1423 let derived = derive(_build, mode);
1424 routes = derived.routes;
1425 serverMode = derived.serverMode;
1426 staticHandler = derived.staticHandler;
1427 errorHandler = derived.errorHandler;
1428 _requestHandler = derived.requestHandler;
1429 } else if (!routes || !serverMode || !staticHandler || !errorHandler || !_requestHandler) {
1430 let derived = derive(_build, mode);
1431 routes = derived.routes;
1432 serverMode = derived.serverMode;
1433 staticHandler = derived.staticHandler;
1434 errorHandler = derived.errorHandler;
1435 _requestHandler = derived.requestHandler;
1436 }
1437 return _requestHandler(request, initialContext);
1438 };
1439};
1440async function handleManifestRequest(build, routes, url) {
1441 if (build.assets.version !== url.searchParams.get("version")) {
1442 return new Response(null, {
1443 status: 204,
1444 headers: {
1445 "X-Remix-Reload-Document": "true"
1446 }
1447 });
1448 }
1449 let patches = {};
1450 if (url.searchParams.has("paths")) {
1451 let paths = /* @__PURE__ */ new Set();
1452 let pathParam = url.searchParams.get("paths") || "";
1453 let requestedPaths = pathParam.split(",").filter(Boolean);
1454 requestedPaths.forEach((path) => {
1455 if (!path.startsWith("/")) {
1456 path = `/${path}`;
1457 }
1458 let segments = path.split("/").slice(1);
1459 segments.forEach((_, i) => {
1460 let partialPath = segments.slice(0, i + 1).join("/");
1461 paths.add(`/${partialPath}`);
1462 });
1463 });
1464 for (let path of paths) {
1465 let matches = matchServerRoutes(routes, path, build.basename);
1466 if (matches) {
1467 for (let match of matches) {
1468 let routeId = match.route.id;
1469 let route = build.assets.routes[routeId];
1470 if (route) {
1471 patches[routeId] = route;
1472 }
1473 }
1474 }
1475 }
1476 return Response.json(patches, {
1477 headers: {
1478 "Cache-Control": "public, max-age=31536000, immutable"
1479 }
1480 });
1481 }
1482 return new Response("Invalid Request", { status: 400 });
1483}
1484async function handleSingleFetchRequest(serverMode, build, staticHandler, request, handlerUrl, loadContext, handleError) {
1485 let response = request.method !== "GET" ? await singleFetchAction(
1486 build,
1487 serverMode,
1488 staticHandler,
1489 request,
1490 handlerUrl,
1491 loadContext,
1492 handleError
1493 ) : await singleFetchLoaders(
1494 build,
1495 serverMode,
1496 staticHandler,
1497 request,
1498 handlerUrl,
1499 loadContext,
1500 handleError
1501 );
1502 return response;
1503}
1504async function handleDocumentRequest(serverMode, build, staticHandler, request, loadContext, handleError, isSpaMode, criticalCss) {
1505 try {
1506 if (request.method === "POST") {
1507 try {
1508 throwIfPotentialCSRFAttack(
1509 request.headers,
1510 Array.isArray(build.allowedActionOrigins) ? build.allowedActionOrigins : []
1511 );
1512 } catch (e) {
1513 handleError(e);
1514 return new Response("Bad Request", { status: 400 });
1515 }
1516 }
1517 let result = await staticHandler.query(request, {
1518 requestContext: loadContext,
1519 generateMiddlewareResponse: build.future.v8_middleware ? async (query) => {
1520 try {
1521 let innerResult = await query(request);
1522 if (!_chunk772H4TVRjs.isResponse.call(void 0, innerResult)) {
1523 innerResult = await renderHtml(innerResult, isSpaMode);
1524 }
1525 return innerResult;
1526 } catch (error) {
1527 handleError(error);
1528 return new Response(null, { status: 500 });
1529 }
1530 } : void 0
1531 });
1532 if (!_chunk772H4TVRjs.isResponse.call(void 0, result)) {
1533 result = await renderHtml(result, isSpaMode);
1534 }
1535 return result;
1536 } catch (error) {
1537 handleError(error);
1538 return new Response(null, { status: 500 });
1539 }
1540 async function renderHtml(context, isSpaMode2) {
1541 let headers = getDocumentHeaders(context, build);
1542 if (SERVER_NO_BODY_STATUS_CODES.has(context.statusCode)) {
1543 return new Response(null, { status: context.statusCode, headers });
1544 }
1545 if (context.errors) {
1546 Object.values(context.errors).forEach((err) => {
1547 if (!_chunk772H4TVRjs.isRouteErrorResponse.call(void 0, err) || err.error) {
1548 handleError(err);
1549 }
1550 });
1551 context.errors = sanitizeErrors(context.errors, serverMode);
1552 }
1553 let state = {
1554 loaderData: context.loaderData,
1555 actionData: context.actionData,
1556 errors: serializeErrors(context.errors, serverMode)
1557 };
1558 let baseServerHandoff = {
1559 basename: build.basename,
1560 future: build.future,
1561 routeDiscovery: build.routeDiscovery,
1562 ssr: build.ssr,
1563 isSpaMode: isSpaMode2
1564 };
1565 let entryContext = {
1566 manifest: build.assets,
1567 routeModules: createEntryRouteModules(build.routes),
1568 staticHandlerContext: context,
1569 criticalCss,
1570 serverHandoffString: createServerHandoffString({
1571 ...baseServerHandoff,
1572 criticalCss
1573 }),
1574 serverHandoffStream: encodeViaTurboStream(
1575 state,
1576 request.signal,
1577 build.entry.module.streamTimeout,
1578 serverMode
1579 ),
1580 renderMeta: {},
1581 future: build.future,
1582 ssr: build.ssr,
1583 routeDiscovery: build.routeDiscovery,
1584 isSpaMode: isSpaMode2,
1585 serializeError: (err) => serializeError(err, serverMode)
1586 };
1587 let handleDocumentRequestFunction = build.entry.module.default;
1588 try {
1589 return await handleDocumentRequestFunction(
1590 request,
1591 context.statusCode,
1592 headers,
1593 entryContext,
1594 loadContext
1595 );
1596 } catch (error) {
1597 handleError(error);
1598 let errorForSecondRender = error;
1599 if (_chunk772H4TVRjs.isResponse.call(void 0, error)) {
1600 try {
1601 let data2 = await unwrapResponse(error);
1602 errorForSecondRender = new (0, _chunk772H4TVRjs.ErrorResponseImpl)(
1603 error.status,
1604 error.statusText,
1605 data2
1606 );
1607 } catch (e) {
1608 }
1609 }
1610 context = _chunk772H4TVRjs.getStaticContextFromError.call(void 0,
1611 staticHandler.dataRoutes,
1612 context,
1613 errorForSecondRender
1614 );
1615 if (context.errors) {
1616 context.errors = sanitizeErrors(context.errors, serverMode);
1617 }
1618 let state2 = {
1619 loaderData: context.loaderData,
1620 actionData: context.actionData,
1621 errors: serializeErrors(context.errors, serverMode)
1622 };
1623 entryContext = {
1624 ...entryContext,
1625 staticHandlerContext: context,
1626 serverHandoffString: createServerHandoffString(baseServerHandoff),
1627 serverHandoffStream: encodeViaTurboStream(
1628 state2,
1629 request.signal,
1630 build.entry.module.streamTimeout,
1631 serverMode
1632 ),
1633 renderMeta: {}
1634 };
1635 try {
1636 return await handleDocumentRequestFunction(
1637 request,
1638 context.statusCode,
1639 headers,
1640 entryContext,
1641 loadContext
1642 );
1643 } catch (error2) {
1644 handleError(error2);
1645 return returnLastResortErrorResponse(error2, serverMode);
1646 }
1647 }
1648 }
1649}
1650async function handleResourceRequest(serverMode, build, staticHandler, routeId, request, loadContext, handleError) {
1651 try {
1652 let result = await staticHandler.queryRoute(request, {
1653 routeId,
1654 requestContext: loadContext,
1655 generateMiddlewareResponse: build.future.v8_middleware ? async (queryRoute) => {
1656 try {
1657 let innerResult = await queryRoute(request);
1658 return handleQueryRouteResult(innerResult);
1659 } catch (error) {
1660 return handleQueryRouteError(error);
1661 }
1662 } : void 0
1663 });
1664 return handleQueryRouteResult(result);
1665 } catch (error) {
1666 return handleQueryRouteError(error);
1667 }
1668 function handleQueryRouteResult(result) {
1669 if (_chunk772H4TVRjs.isResponse.call(void 0, result)) {
1670 return result;
1671 }
1672 if (typeof result === "string") {
1673 return new Response(result);
1674 }
1675 return Response.json(result);
1676 }
1677 function handleQueryRouteError(error) {
1678 if (_chunk772H4TVRjs.isResponse.call(void 0, error)) {
1679 return error;
1680 }
1681 if (_chunk772H4TVRjs.isRouteErrorResponse.call(void 0, error)) {
1682 handleError(error);
1683 return errorResponseToJson(error, serverMode);
1684 }
1685 if (error instanceof Error && error.message === "Expected a response from queryRoute") {
1686 let newError = new Error(
1687 "Expected a Response to be returned from resource route handler"
1688 );
1689 handleError(newError);
1690 return returnLastResortErrorResponse(newError, serverMode);
1691 }
1692 handleError(error);
1693 return returnLastResortErrorResponse(error, serverMode);
1694 }
1695}
1696function errorResponseToJson(errorResponse, serverMode) {
1697 return Response.json(
1698 serializeError(
1699 // @ts-expect-error This is "private" from users but intended for internal use
1700 errorResponse.error || new Error("Unexpected Server Error"),
1701 serverMode
1702 ),
1703 {
1704 status: errorResponse.status,
1705 statusText: errorResponse.statusText
1706 }
1707 );
1708}
1709function returnLastResortErrorResponse(error, serverMode) {
1710 let message = "Unexpected Server Error";
1711 if (serverMode !== "production" /* Production */) {
1712 message += `
1713
1714${String(error)}`;
1715 }
1716 return new Response(message, {
1717 status: 500,
1718 headers: {
1719 "Content-Type": "text/plain"
1720 }
1721 });
1722}
1723function unwrapResponse(response) {
1724 let contentType = response.headers.get("Content-Type");
1725 return contentType && /\bapplication\/json\b/.test(contentType) ? response.body == null ? null : response.json() : response.text();
1726}
1727
1728// lib/server-runtime/sessions.ts
1729function flash(name) {
1730 return `__flash_${name}__`;
1731}
1732var createSession = (initialData = {}, id = "") => {
1733 let map = new Map(Object.entries(initialData));
1734 return {
1735 get id() {
1736 return id;
1737 },
1738 get data() {
1739 return Object.fromEntries(map);
1740 },
1741 has(name) {
1742 return map.has(name) || map.has(flash(name));
1743 },
1744 get(name) {
1745 if (map.has(name)) return map.get(name);
1746 let flashName = flash(name);
1747 if (map.has(flashName)) {
1748 let value = map.get(flashName);
1749 map.delete(flashName);
1750 return value;
1751 }
1752 return void 0;
1753 },
1754 set(name, value) {
1755 map.set(name, value);
1756 },
1757 flash(name, value) {
1758 map.set(flash(name), value);
1759 },
1760 unset(name) {
1761 map.delete(name);
1762 }
1763 };
1764};
1765var isSession = (object) => {
1766 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";
1767};
1768function createSessionStorage({
1769 cookie: cookieArg,
1770 createData,
1771 readData,
1772 updateData,
1773 deleteData
1774}) {
1775 let cookie = isCookie(cookieArg) ? cookieArg : createCookie(_optionalChain([cookieArg, 'optionalAccess', _21 => _21.name]) || "__session", cookieArg);
1776 warnOnceAboutSigningSessionCookie(cookie);
1777 return {
1778 async getSession(cookieHeader, options) {
1779 let id = cookieHeader && await cookie.parse(cookieHeader, options);
1780 let data2 = id && await readData(id);
1781 return createSession(data2 || {}, id || "");
1782 },
1783 async commitSession(session, options) {
1784 let { id, data: data2 } = session;
1785 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;
1786 if (id) {
1787 await updateData(id, data2, expires);
1788 } else {
1789 id = await createData(data2, expires);
1790 }
1791 return cookie.serialize(id, options);
1792 },
1793 async destroySession(session, options) {
1794 await deleteData(session.id);
1795 return cookie.serialize("", {
1796 ...options,
1797 maxAge: void 0,
1798 expires: /* @__PURE__ */ new Date(0)
1799 });
1800 }
1801 };
1802}
1803function warnOnceAboutSigningSessionCookie(cookie) {
1804 _chunk772H4TVRjs.warnOnce.call(void 0,
1805 cookie.isSigned,
1806 `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.`
1807 );
1808}
1809
1810// lib/server-runtime/sessions/cookieStorage.ts
1811function createCookieSessionStorage({ cookie: cookieArg } = {}) {
1812 let cookie = isCookie(cookieArg) ? cookieArg : createCookie(_optionalChain([cookieArg, 'optionalAccess', _24 => _24.name]) || "__session", cookieArg);
1813 warnOnceAboutSigningSessionCookie(cookie);
1814 return {
1815 async getSession(cookieHeader, options) {
1816 return createSession(
1817 cookieHeader && await cookie.parse(cookieHeader, options) || {}
1818 );
1819 },
1820 async commitSession(session, options) {
1821 let serializedCookie = await cookie.serialize(session.data, options);
1822 if (serializedCookie.length > 4096) {
1823 throw new Error(
1824 "Cookie length will exceed browser maximum. Length: " + serializedCookie.length
1825 );
1826 }
1827 return serializedCookie;
1828 },
1829 async destroySession(_session, options) {
1830 return cookie.serialize("", {
1831 ...options,
1832 maxAge: void 0,
1833 expires: /* @__PURE__ */ new Date(0)
1834 });
1835 }
1836 };
1837}
1838
1839// lib/server-runtime/sessions/memoryStorage.ts
1840function createMemorySessionStorage({ cookie } = {}) {
1841 let map = /* @__PURE__ */ new Map();
1842 return createSessionStorage({
1843 cookie,
1844 async createData(data2, expires) {
1845 let id = Math.random().toString(36).substring(2, 10);
1846 map.set(id, { data: data2, expires });
1847 return id;
1848 },
1849 async readData(id) {
1850 if (map.has(id)) {
1851 let { data: data2, expires } = map.get(id);
1852 if (!expires || expires > /* @__PURE__ */ new Date()) {
1853 return data2;
1854 }
1855 if (expires) map.delete(id);
1856 }
1857 return null;
1858 },
1859 async updateData(id, data2, expires) {
1860 map.set(id, { data: data2, expires });
1861 },
1862 async deleteData(id) {
1863 map.delete(id);
1864 }
1865 });
1866}
1867
1868// lib/href.ts
1869function href(path, ...args) {
1870 let params = args[0];
1871 let result = trimTrailingSplat(path).replace(
1872 /\/:([\w-]+)(\?)?/g,
1873 // same regex as in .\router\utils.ts: compilePath().
1874 (_, param, questionMark) => {
1875 const isRequired = questionMark === void 0;
1876 const value = _optionalChain([params, 'optionalAccess', _25 => _25[param]]);
1877 if (isRequired && value === void 0) {
1878 throw new Error(
1879 `Path '${path}' requires param '${param}' but it was not provided`
1880 );
1881 }
1882 return value === void 0 ? "" : "/" + value;
1883 }
1884 );
1885 if (path.endsWith("*")) {
1886 const value = _optionalChain([params, 'optionalAccess', _26 => _26["*"]]);
1887 if (value !== void 0) {
1888 result += "/" + value;
1889 }
1890 }
1891 return result || "/";
1892}
1893function trimTrailingSplat(path) {
1894 let i = path.length - 1;
1895 let char = path[i];
1896 if (char !== "*" && char !== "/") return path;
1897 i--;
1898 for (; i >= 0; i--) {
1899 if (path[i] !== "/") break;
1900 }
1901 return path.slice(0, i + 1);
1902}
1903
1904// lib/rsc/server.ssr.tsx
1905
1906
1907// lib/rsc/html-stream/server.ts
1908var encoder2 = new TextEncoder();
1909var trailer = "</body></html>";
1910function injectRSCPayload(rscStream) {
1911 let decoder = new TextDecoder();
1912 let resolveFlightDataPromise;
1913 let flightDataPromise = new Promise(
1914 (resolve) => resolveFlightDataPromise = resolve
1915 );
1916 let startedRSC = false;
1917 let buffered = [];
1918 let timeout = null;
1919 function flushBufferedChunks(controller) {
1920 for (let chunk of buffered) {
1921 let buf = decoder.decode(chunk, { stream: true });
1922 if (buf.endsWith(trailer)) {
1923 buf = buf.slice(0, -trailer.length);
1924 }
1925 controller.enqueue(encoder2.encode(buf));
1926 }
1927 buffered.length = 0;
1928 timeout = null;
1929 }
1930 return new TransformStream({
1931 transform(chunk, controller) {
1932 buffered.push(chunk);
1933 if (timeout) {
1934 return;
1935 }
1936 timeout = setTimeout(async () => {
1937 flushBufferedChunks(controller);
1938 if (!startedRSC) {
1939 startedRSC = true;
1940 writeRSCStream(rscStream, controller).catch((err) => controller.error(err)).then(resolveFlightDataPromise);
1941 }
1942 }, 0);
1943 },
1944 async flush(controller) {
1945 await flightDataPromise;
1946 if (timeout) {
1947 clearTimeout(timeout);
1948 flushBufferedChunks(controller);
1949 }
1950 controller.enqueue(encoder2.encode("</body></html>"));
1951 }
1952 });
1953}
1954async function writeRSCStream(rscStream, controller) {
1955 let decoder = new TextDecoder("utf-8", { fatal: true });
1956 const reader = rscStream.getReader();
1957 try {
1958 let read;
1959 while ((read = await reader.read()) && !read.done) {
1960 const chunk = read.value;
1961 try {
1962 writeChunk(
1963 JSON.stringify(decoder.decode(chunk, { stream: true })),
1964 controller
1965 );
1966 } catch (err) {
1967 let base64 = JSON.stringify(btoa(String.fromCodePoint(...chunk)));
1968 writeChunk(
1969 `Uint8Array.from(atob(${base64}), m => m.codePointAt(0))`,
1970 controller
1971 );
1972 }
1973 }
1974 } finally {
1975 reader.releaseLock();
1976 }
1977 let remaining = decoder.decode();
1978 if (remaining.length) {
1979 writeChunk(JSON.stringify(remaining), controller);
1980 }
1981}
1982function writeChunk(chunk, controller) {
1983 controller.enqueue(
1984 encoder2.encode(
1985 `<script>${escapeScript(
1986 `(self.__FLIGHT_DATA||=[]).push(${chunk})`
1987 )}</script>`
1988 )
1989 );
1990}
1991function escapeScript(script) {
1992 return script.replace(/<!--/g, "<\\!--").replace(/<\/(script)/gi, "</\\$1");
1993}
1994
1995// lib/rsc/server.ssr.tsx
1996var REACT_USE = "use";
1997var useImpl = React3[REACT_USE];
1998function useSafe(promise) {
1999 if (useImpl) {
2000 return useImpl(promise);
2001 }
2002 throw new Error("React Router v7 requires React 19+ for RSC features.");
2003}
2004async function routeRSCServerRequest({
2005 request,
2006 serverResponse,
2007 createFromReadableStream,
2008 renderHTML,
2009 hydrate = true
2010}) {
2011 const url = new URL(request.url);
2012 const isDataRequest = isReactServerRequest(url);
2013 const respondWithRSCPayload = isDataRequest || isManifestRequest(url) || request.headers.has("rsc-action-id");
2014 if (respondWithRSCPayload || serverResponse.headers.get("React-Router-Resource") === "true") {
2015 return serverResponse;
2016 }
2017 if (!serverResponse.body) {
2018 throw new Error("Missing body in server response");
2019 }
2020 const detectRedirectResponse = serverResponse.clone();
2021 let serverResponseB = null;
2022 if (hydrate) {
2023 serverResponseB = serverResponse.clone();
2024 }
2025 const body = serverResponse.body;
2026 let buffer;
2027 let streamControllers = [];
2028 const createStream = () => {
2029 if (!buffer) {
2030 buffer = [];
2031 return body.pipeThrough(
2032 new TransformStream({
2033 transform(chunk, controller) {
2034 buffer.push(chunk);
2035 controller.enqueue(chunk);
2036 streamControllers.forEach((c) => c.enqueue(chunk));
2037 },
2038 flush() {
2039 streamControllers.forEach((c) => c.close());
2040 streamControllers = [];
2041 }
2042 })
2043 );
2044 }
2045 return new ReadableStream({
2046 start(controller) {
2047 buffer.forEach((chunk) => controller.enqueue(chunk));
2048 streamControllers.push(controller);
2049 }
2050 });
2051 };
2052 let deepestRenderedBoundaryId = null;
2053 const getPayload = () => {
2054 const payloadPromise = Promise.resolve(
2055 createFromReadableStream(createStream())
2056 );
2057 return Object.defineProperties(payloadPromise, {
2058 _deepestRenderedBoundaryId: {
2059 get() {
2060 return deepestRenderedBoundaryId;
2061 },
2062 set(boundaryId) {
2063 deepestRenderedBoundaryId = boundaryId;
2064 }
2065 },
2066 formState: {
2067 get() {
2068 return payloadPromise.then(
2069 (payload) => payload.type === "render" ? payload.formState : void 0
2070 );
2071 }
2072 }
2073 });
2074 };
2075 let renderRedirect;
2076 let renderError;
2077 try {
2078 if (!detectRedirectResponse.body) {
2079 throw new Error("Failed to clone server response");
2080 }
2081 const payload = await createFromReadableStream(
2082 detectRedirectResponse.body
2083 );
2084 if (serverResponse.status === _chunk772H4TVRjs.SINGLE_FETCH_REDIRECT_STATUS && payload.type === "redirect") {
2085 const headers2 = new Headers(serverResponse.headers);
2086 headers2.delete("Content-Encoding");
2087 headers2.delete("Content-Length");
2088 headers2.delete("Content-Type");
2089 headers2.delete("X-Remix-Response");
2090 headers2.set("Location", payload.location);
2091 return new Response(_optionalChain([serverResponseB, 'optionalAccess', _27 => _27.body]) || "", {
2092 headers: headers2,
2093 status: payload.status,
2094 statusText: serverResponse.statusText
2095 });
2096 }
2097 let reactHeaders = new Headers();
2098 let status = serverResponse.status;
2099 let statusText = serverResponse.statusText;
2100 let html = await renderHTML(getPayload, {
2101 onError(error) {
2102 if (typeof error === "object" && error && "digest" in error && typeof error.digest === "string") {
2103 renderRedirect = _chunk772H4TVRjs.decodeRedirectErrorDigest.call(void 0, error.digest);
2104 if (renderRedirect) {
2105 return error.digest;
2106 }
2107 let routeErrorResponse = _chunk772H4TVRjs.decodeRouteErrorResponseDigest.call(void 0, error.digest);
2108 if (routeErrorResponse) {
2109 renderError = routeErrorResponse;
2110 status = routeErrorResponse.status;
2111 statusText = routeErrorResponse.statusText;
2112 return error.digest;
2113 }
2114 }
2115 },
2116 onHeaders(headers2) {
2117 for (const [key, value] of headers2) {
2118 reactHeaders.append(key, value);
2119 }
2120 }
2121 });
2122 const headers = new Headers(reactHeaders);
2123 for (const [key, value] of serverResponse.headers) {
2124 headers.append(key, value);
2125 }
2126 headers.set("Content-Type", "text/html; charset=utf-8");
2127 if (renderRedirect) {
2128 headers.set("Location", renderRedirect.location);
2129 return new Response(html, {
2130 status: renderRedirect.status,
2131 headers
2132 });
2133 }
2134 const redirectTransform = new TransformStream({
2135 flush(controller) {
2136 if (renderRedirect) {
2137 controller.enqueue(
2138 new TextEncoder().encode(
2139 `<meta http-equiv="refresh" content="0;url=${_chunk772H4TVRjs.escapeHtml.call(void 0, renderRedirect.location)}"/>`
2140 )
2141 );
2142 }
2143 }
2144 });
2145 if (!hydrate) {
2146 return new Response(html.pipeThrough(redirectTransform), {
2147 status,
2148 statusText,
2149 headers
2150 });
2151 }
2152 if (!_optionalChain([serverResponseB, 'optionalAccess', _28 => _28.body])) {
2153 throw new Error("Failed to clone server response");
2154 }
2155 const body2 = html.pipeThrough(injectRSCPayload(serverResponseB.body)).pipeThrough(redirectTransform);
2156 return new Response(body2, {
2157 status,
2158 statusText,
2159 headers
2160 });
2161 } catch (reason) {
2162 if (reason instanceof Response) {
2163 return reason;
2164 }
2165 if (renderRedirect) {
2166 return new Response(`Redirect: ${renderRedirect.location}`, {
2167 status: renderRedirect.status,
2168 headers: {
2169 Location: renderRedirect.location
2170 }
2171 });
2172 }
2173 try {
2174 reason = _nullishCoalesce(renderError, () => ( reason));
2175 let [status, statusText] = _chunk772H4TVRjs.isRouteErrorResponse.call(void 0, reason) ? [reason.status, reason.statusText] : [500, ""];
2176 let retryRedirect;
2177 let reactHeaders = new Headers();
2178 const html = await renderHTML(
2179 () => {
2180 const decoded = Promise.resolve(
2181 createFromReadableStream(createStream())
2182 );
2183 const payloadPromise = decoded.then(
2184 (payload) => Object.assign(payload, {
2185 status,
2186 errors: deepestRenderedBoundaryId ? {
2187 [deepestRenderedBoundaryId]: reason
2188 } : {}
2189 })
2190 );
2191 return Object.defineProperties(payloadPromise, {
2192 _deepestRenderedBoundaryId: {
2193 get() {
2194 return deepestRenderedBoundaryId;
2195 },
2196 set(boundaryId) {
2197 deepestRenderedBoundaryId = boundaryId;
2198 }
2199 },
2200 formState: {
2201 get() {
2202 return payloadPromise.then(
2203 (payload) => payload.type === "render" ? payload.formState : void 0
2204 );
2205 }
2206 }
2207 });
2208 },
2209 {
2210 onError(error) {
2211 if (typeof error === "object" && error && "digest" in error && typeof error.digest === "string") {
2212 retryRedirect = _chunk772H4TVRjs.decodeRedirectErrorDigest.call(void 0, error.digest);
2213 if (retryRedirect) {
2214 return error.digest;
2215 }
2216 let routeErrorResponse = _chunk772H4TVRjs.decodeRouteErrorResponseDigest.call(void 0,
2217 error.digest
2218 );
2219 if (routeErrorResponse) {
2220 status = routeErrorResponse.status;
2221 statusText = routeErrorResponse.statusText;
2222 return error.digest;
2223 }
2224 }
2225 },
2226 onHeaders(headers2) {
2227 for (const [key, value] of headers2) {
2228 reactHeaders.append(key, value);
2229 }
2230 }
2231 }
2232 );
2233 const headers = new Headers(reactHeaders);
2234 for (const [key, value] of serverResponse.headers) {
2235 headers.append(key, value);
2236 }
2237 headers.set("Content-Type", "text/html; charset=utf-8");
2238 if (retryRedirect) {
2239 headers.set("Location", retryRedirect.location);
2240 return new Response(html, {
2241 status: retryRedirect.status,
2242 headers
2243 });
2244 }
2245 const retryRedirectTransform = new TransformStream({
2246 flush(controller) {
2247 if (retryRedirect) {
2248 controller.enqueue(
2249 new TextEncoder().encode(
2250 `<meta http-equiv="refresh" content="0;url=${_chunk772H4TVRjs.escapeHtml.call(void 0, retryRedirect.location)}"/>`
2251 )
2252 );
2253 }
2254 }
2255 });
2256 if (!hydrate) {
2257 return new Response(html.pipeThrough(retryRedirectTransform), {
2258 status,
2259 statusText,
2260 headers
2261 });
2262 }
2263 if (!_optionalChain([serverResponseB, 'optionalAccess', _29 => _29.body])) {
2264 throw new Error("Failed to clone server response");
2265 }
2266 const body2 = html.pipeThrough(injectRSCPayload(serverResponseB.body)).pipeThrough(retryRedirectTransform);
2267 return new Response(body2, {
2268 status,
2269 statusText,
2270 headers
2271 });
2272 } catch (e3) {
2273 }
2274 throw reason;
2275 }
2276}
2277function RSCStaticRouter({ getPayload }) {
2278 const decoded = getPayload();
2279 const payload = useSafe(decoded);
2280 if (payload.type === "redirect") {
2281 throw new Response(null, {
2282 status: payload.status,
2283 headers: {
2284 Location: payload.location
2285 }
2286 });
2287 }
2288 if (payload.type !== "render") return null;
2289 let patchedLoaderData = { ...payload.loaderData };
2290 for (const match of payload.matches) {
2291 if (_chunk772H4TVRjs.shouldHydrateRouteLoader.call(void 0,
2292 match.id,
2293 match.clientLoader,
2294 match.hasLoader,
2295 false
2296 ) && (match.hydrateFallbackElement || !match.hasLoader)) {
2297 delete patchedLoaderData[match.id];
2298 }
2299 }
2300 const context = {
2301 get _deepestRenderedBoundaryId() {
2302 return _nullishCoalesce(decoded._deepestRenderedBoundaryId, () => ( null));
2303 },
2304 set _deepestRenderedBoundaryId(boundaryId) {
2305 decoded._deepestRenderedBoundaryId = boundaryId;
2306 },
2307 actionData: payload.actionData,
2308 actionHeaders: {},
2309 basename: payload.basename,
2310 errors: payload.errors,
2311 loaderData: patchedLoaderData,
2312 loaderHeaders: {},
2313 location: payload.location,
2314 statusCode: 200,
2315 matches: payload.matches.map((match) => ({
2316 params: match.params,
2317 pathname: match.pathname,
2318 pathnameBase: match.pathnameBase,
2319 route: {
2320 id: match.id,
2321 action: match.hasAction || !!match.clientAction,
2322 handle: match.handle,
2323 hasErrorBoundary: match.hasErrorBoundary,
2324 loader: match.hasLoader || !!match.clientLoader,
2325 index: match.index,
2326 path: match.path,
2327 shouldRevalidate: match.shouldRevalidate
2328 }
2329 }))
2330 };
2331 const router = _chunkB5UMK6O7js.createStaticRouter.call(void 0,
2332 payload.matches.reduceRight((previous, match) => {
2333 const route = {
2334 id: match.id,
2335 action: match.hasAction || !!match.clientAction,
2336 element: match.element,
2337 errorElement: match.errorElement,
2338 handle: match.handle,
2339 hasErrorBoundary: !!match.errorElement,
2340 hydrateFallbackElement: match.hydrateFallbackElement,
2341 index: match.index,
2342 loader: match.hasLoader || !!match.clientLoader,
2343 path: match.path,
2344 shouldRevalidate: match.shouldRevalidate
2345 };
2346 if (previous.length > 0) {
2347 route.children = previous;
2348 }
2349 return [route];
2350 }, []),
2351 context
2352 );
2353 const frameworkContext = {
2354 future: {
2355 // These flags have no runtime impact so can always be false. If we add
2356 // flags that drive runtime behavior they'll need to be proxied through.
2357 v8_middleware: false,
2358 unstable_subResourceIntegrity: false,
2359 unstable_trailingSlashAwareDataRequests: true
2360 // always on for RSC
2361 },
2362 isSpaMode: false,
2363 ssr: true,
2364 criticalCss: "",
2365 manifest: {
2366 routes: {},
2367 version: "1",
2368 url: "",
2369 entry: {
2370 module: "",
2371 imports: []
2372 }
2373 },
2374 routeDiscovery: { mode: "lazy", manifestPath: "/__manifest" },
2375 routeModules: _chunkZJMCM6KTjs.createRSCRouteModules.call(void 0, payload)
2376 };
2377 return /* @__PURE__ */ React3.createElement(_chunk772H4TVRjs.RSCRouterContext.Provider, { value: true }, /* @__PURE__ */ React3.createElement(_chunkZJMCM6KTjs.RSCRouterGlobalErrorBoundary, { location: payload.location }, /* @__PURE__ */ React3.createElement(_chunk772H4TVRjs.FrameworkContext.Provider, { value: frameworkContext }, /* @__PURE__ */ React3.createElement(
2378 _chunkB5UMK6O7js.StaticRouterProvider,
2379 {
2380 context,
2381 router,
2382 hydrate: false,
2383 nonce: payload.nonce
2384 }
2385 ))));
2386}
2387function isReactServerRequest(url) {
2388 return url.pathname.endsWith(".rsc");
2389}
2390function isManifestRequest(url) {
2391 return url.pathname.endsWith(".manifest");
2392}
2393
2394// lib/dom/ssr/errors.ts
2395function deserializeErrors(errors) {
2396 if (!errors) return null;
2397 let entries = Object.entries(errors);
2398 let serialized = {};
2399 for (let [key, val] of entries) {
2400 if (val && val.__type === "RouteErrorResponse") {
2401 serialized[key] = new (0, _chunk772H4TVRjs.ErrorResponseImpl)(
2402 val.status,
2403 val.statusText,
2404 val.data,
2405 val.internal === true
2406 );
2407 } else if (val && val.__type === "Error") {
2408 if (val.__subType) {
2409 let ErrorConstructor = window[val.__subType];
2410 if (typeof ErrorConstructor === "function") {
2411 try {
2412 let error = new ErrorConstructor(val.message);
2413 error.stack = val.stack;
2414 serialized[key] = error;
2415 } catch (e) {
2416 }
2417 }
2418 }
2419 if (serialized[key] == null) {
2420 let error = new Error(val.message);
2421 error.stack = val.stack;
2422 serialized[key] = error;
2423 }
2424 } else {
2425 serialized[key] = val;
2426 }
2427 }
2428 return serialized;
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
2545
2546
2547
2548
2549
2550
2551
2552
2553
2554
2555
2556
2557
2558
2559
2560exports.Await = _chunk772H4TVRjs.Await; exports.BrowserRouter = _chunkB5UMK6O7js.BrowserRouter; exports.Form = _chunkB5UMK6O7js.Form; exports.HashRouter = _chunkB5UMK6O7js.HashRouter; exports.IDLE_BLOCKER = _chunk772H4TVRjs.IDLE_BLOCKER; exports.IDLE_FETCHER = _chunk772H4TVRjs.IDLE_FETCHER; exports.IDLE_NAVIGATION = _chunk772H4TVRjs.IDLE_NAVIGATION; exports.Link = _chunkB5UMK6O7js.Link; exports.Links = _chunk772H4TVRjs.Links; exports.MemoryRouter = _chunk772H4TVRjs.MemoryRouter; exports.Meta = _chunk772H4TVRjs.Meta; exports.NavLink = _chunkB5UMK6O7js.NavLink; exports.Navigate = _chunk772H4TVRjs.Navigate; exports.NavigationType = _chunk772H4TVRjs.Action; exports.Outlet = _chunk772H4TVRjs.Outlet; exports.PrefetchPageLinks = _chunk772H4TVRjs.PrefetchPageLinks; exports.Route = _chunk772H4TVRjs.Route; exports.Router = _chunk772H4TVRjs.Router; exports.RouterContextProvider = _chunk772H4TVRjs.RouterContextProvider; exports.RouterProvider = _chunk772H4TVRjs.RouterProvider; exports.Routes = _chunk772H4TVRjs.Routes; exports.Scripts = _chunk772H4TVRjs.Scripts; exports.ScrollRestoration = _chunkB5UMK6O7js.ScrollRestoration; exports.ServerRouter = ServerRouter; exports.StaticRouter = _chunkB5UMK6O7js.StaticRouter; exports.StaticRouterProvider = _chunkB5UMK6O7js.StaticRouterProvider; exports.UNSAFE_AwaitContextProvider = _chunk772H4TVRjs.AwaitContextProvider; exports.UNSAFE_DataRouterContext = _chunk772H4TVRjs.DataRouterContext; exports.UNSAFE_DataRouterStateContext = _chunk772H4TVRjs.DataRouterStateContext; exports.UNSAFE_ErrorResponseImpl = _chunk772H4TVRjs.ErrorResponseImpl; exports.UNSAFE_FetchersContext = _chunk772H4TVRjs.FetchersContext; exports.UNSAFE_FrameworkContext = _chunk772H4TVRjs.FrameworkContext; exports.UNSAFE_LocationContext = _chunk772H4TVRjs.LocationContext; exports.UNSAFE_NavigationContext = _chunk772H4TVRjs.NavigationContext; exports.UNSAFE_RSCDefaultRootErrorBoundary = _chunkZJMCM6KTjs.RSCDefaultRootErrorBoundary; exports.UNSAFE_RemixErrorBoundary = _chunk772H4TVRjs.RemixErrorBoundary; exports.UNSAFE_RouteContext = _chunk772H4TVRjs.RouteContext; exports.UNSAFE_ServerMode = ServerMode; exports.UNSAFE_SingleFetchRedirectSymbol = _chunk772H4TVRjs.SingleFetchRedirectSymbol; exports.UNSAFE_ViewTransitionContext = _chunk772H4TVRjs.ViewTransitionContext; exports.UNSAFE_WithComponentProps = _chunk772H4TVRjs.WithComponentProps; exports.UNSAFE_WithErrorBoundaryProps = _chunk772H4TVRjs.WithErrorBoundaryProps; exports.UNSAFE_WithHydrateFallbackProps = _chunk772H4TVRjs.WithHydrateFallbackProps; exports.UNSAFE_createBrowserHistory = _chunk772H4TVRjs.createBrowserHistory; exports.UNSAFE_createClientRoutes = _chunk772H4TVRjs.createClientRoutes; exports.UNSAFE_createClientRoutesWithHMRRevalidationOptOut = _chunk772H4TVRjs.createClientRoutesWithHMRRevalidationOptOut; exports.UNSAFE_createHashHistory = _chunk772H4TVRjs.createHashHistory; exports.UNSAFE_createMemoryHistory = _chunk772H4TVRjs.createMemoryHistory; exports.UNSAFE_createRouter = _chunk772H4TVRjs.createRouter; exports.UNSAFE_decodeViaTurboStream = _chunk772H4TVRjs.decodeViaTurboStream; exports.UNSAFE_deserializeErrors = deserializeErrors; exports.UNSAFE_getHydrationData = _chunkZJMCM6KTjs.getHydrationData; exports.UNSAFE_getPatchRoutesOnNavigationFunction = _chunk772H4TVRjs.getPatchRoutesOnNavigationFunction; exports.UNSAFE_getTurboStreamSingleFetchDataStrategy = _chunk772H4TVRjs.getTurboStreamSingleFetchDataStrategy; exports.UNSAFE_hydrationRouteProperties = _chunk772H4TVRjs.hydrationRouteProperties; exports.UNSAFE_invariant = _chunk772H4TVRjs.invariant; exports.UNSAFE_mapRouteProperties = _chunk772H4TVRjs.mapRouteProperties; exports.UNSAFE_shouldHydrateRouteLoader = _chunk772H4TVRjs.shouldHydrateRouteLoader; exports.UNSAFE_useFogOFWarDiscovery = _chunk772H4TVRjs.useFogOFWarDiscovery; exports.UNSAFE_useScrollRestoration = _chunkB5UMK6O7js.useScrollRestoration; exports.UNSAFE_withComponentProps = _chunk772H4TVRjs.withComponentProps; exports.UNSAFE_withErrorBoundaryProps = _chunk772H4TVRjs.withErrorBoundaryProps; exports.UNSAFE_withHydrateFallbackProps = _chunk772H4TVRjs.withHydrateFallbackProps; exports.createBrowserRouter = _chunkB5UMK6O7js.createBrowserRouter; exports.createContext = _chunk772H4TVRjs.createContext; exports.createCookie = createCookie; exports.createCookieSessionStorage = createCookieSessionStorage; exports.createHashRouter = _chunkB5UMK6O7js.createHashRouter; exports.createMemoryRouter = _chunk772H4TVRjs.createMemoryRouter; exports.createMemorySessionStorage = createMemorySessionStorage; exports.createPath = _chunk772H4TVRjs.createPath; exports.createRequestHandler = createRequestHandler; exports.createRoutesFromChildren = _chunk772H4TVRjs.createRoutesFromChildren; exports.createRoutesFromElements = _chunk772H4TVRjs.createRoutesFromElements; exports.createRoutesStub = createRoutesStub; exports.createSearchParams = _chunkB5UMK6O7js.createSearchParams; exports.createSession = createSession; exports.createSessionStorage = createSessionStorage; exports.createStaticHandler = _chunkB5UMK6O7js.createStaticHandler; exports.createStaticRouter = _chunkB5UMK6O7js.createStaticRouter; exports.data = _chunk772H4TVRjs.data; exports.generatePath = _chunk772H4TVRjs.generatePath; exports.href = href; exports.isCookie = isCookie; exports.isRouteErrorResponse = _chunk772H4TVRjs.isRouteErrorResponse; exports.isSession = isSession; exports.matchPath = _chunk772H4TVRjs.matchPath; exports.matchRoutes = _chunk772H4TVRjs.matchRoutes; exports.parsePath = _chunk772H4TVRjs.parsePath; exports.redirect = _chunk772H4TVRjs.redirect; exports.redirectDocument = _chunk772H4TVRjs.redirectDocument; exports.renderMatches = _chunk772H4TVRjs.renderMatches; exports.replace = _chunk772H4TVRjs.replace; exports.resolvePath = _chunk772H4TVRjs.resolvePath; exports.unstable_HistoryRouter = _chunkB5UMK6O7js.HistoryRouter; exports.unstable_RSCStaticRouter = RSCStaticRouter; exports.unstable_routeRSCServerRequest = routeRSCServerRequest; exports.unstable_setDevServerHooks = setDevServerHooks; exports.unstable_usePrompt = _chunkB5UMK6O7js.usePrompt; exports.unstable_useRoute = _chunk772H4TVRjs.useRoute; exports.useActionData = _chunk772H4TVRjs.useActionData; exports.useAsyncError = _chunk772H4TVRjs.useAsyncError; exports.useAsyncValue = _chunk772H4TVRjs.useAsyncValue; exports.useBeforeUnload = _chunkB5UMK6O7js.useBeforeUnload; exports.useBlocker = _chunk772H4TVRjs.useBlocker; exports.useFetcher = _chunkB5UMK6O7js.useFetcher; exports.useFetchers = _chunkB5UMK6O7js.useFetchers; exports.useFormAction = _chunkB5UMK6O7js.useFormAction; exports.useHref = _chunk772H4TVRjs.useHref; exports.useInRouterContext = _chunk772H4TVRjs.useInRouterContext; exports.useLinkClickHandler = _chunkB5UMK6O7js.useLinkClickHandler; exports.useLoaderData = _chunk772H4TVRjs.useLoaderData; exports.useLocation = _chunk772H4TVRjs.useLocation; exports.useMatch = _chunk772H4TVRjs.useMatch; exports.useMatches = _chunk772H4TVRjs.useMatches; exports.useNavigate = _chunk772H4TVRjs.useNavigate; exports.useNavigation = _chunk772H4TVRjs.useNavigation; exports.useNavigationType = _chunk772H4TVRjs.useNavigationType; exports.useOutlet = _chunk772H4TVRjs.useOutlet; exports.useOutletContext = _chunk772H4TVRjs.useOutletContext; exports.useParams = _chunk772H4TVRjs.useParams; exports.useResolvedPath = _chunk772H4TVRjs.useResolvedPath; exports.useRevalidator = _chunk772H4TVRjs.useRevalidator; exports.useRouteError = _chunk772H4TVRjs.useRouteError; exports.useRouteLoaderData = _chunk772H4TVRjs.useRouteLoaderData; exports.useRoutes = _chunk772H4TVRjs.useRoutes; exports.useSearchParams = _chunkB5UMK6O7js.useSearchParams; exports.useSubmit = _chunkB5UMK6O7js.useSubmit; exports.useViewTransitionState = _chunkB5UMK6O7js.useViewTransitionState;