INDIE UNPKG

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