556 lines
15 KiB
JavaScript
556 lines
15 KiB
JavaScript
/*
|
|
* Extracted from browser-delivered Turbopack chunk: ffa5de913d3f001d.98ff1c0dc5.js
|
|
* Module id: 414964
|
|
* For reading/searching only; this factory depends on the original Turbopack runtime.
|
|
*/
|
|
|
|
const moduleFactory = (e, t, r) => {
|
|
"use strict";
|
|
Object.defineProperty(r, "__esModule", { value: !0 });
|
|
var n,
|
|
a = {
|
|
FreshnessPolicy: function () {
|
|
return g;
|
|
},
|
|
createInitialCacheNodeForHydration: function () {
|
|
return _;
|
|
},
|
|
isDeferredRsc: function () {
|
|
return N;
|
|
},
|
|
spawnDynamicRequests: function () {
|
|
return w;
|
|
},
|
|
startPPRNavigation: function () {
|
|
return b;
|
|
},
|
|
};
|
|
for (var l in a) Object.defineProperty(r, l, { enumerable: !0, get: a[l] });
|
|
let u = e.r(745347),
|
|
o = e.r(414531),
|
|
i = e.r(523712),
|
|
s = e.r(258740),
|
|
c = e.r(687946),
|
|
f = e.r(247556),
|
|
d = e.r(789467),
|
|
h = e.r(98e4),
|
|
p = e.r(871798),
|
|
y = e.r(55197);
|
|
var g =
|
|
(((n = {})[(n.Default = 0)] = "Default"),
|
|
(n[(n.Hydration = 1)] = "Hydration"),
|
|
(n[(n.HistoryTraversal = 2)] = "HistoryTraversal"),
|
|
(n[(n.RefreshAll = 3)] = "RefreshAll"),
|
|
(n[(n.HMRRefresh = 4)] = "HMRRefresh"),
|
|
n);
|
|
let v = () => {};
|
|
function _(e, t, r, n) {
|
|
return R(e, t, void 0, 1, r, n, null, null, !1, null, null, !1, {
|
|
scrollableSegments: null,
|
|
separateRefreshUrls: null,
|
|
}).node;
|
|
}
|
|
function b(e, t, r, n, a, l, c, f, d, p, y, g, v) {
|
|
return (function e(t, r, n, a, l, c, f, d, p, y, g, v, _, b, T, w, j, M) {
|
|
var A, C;
|
|
let N,
|
|
F,
|
|
U,
|
|
k = a[0],
|
|
I = l[0];
|
|
if (!(0, o.matchSegment)(I, k))
|
|
return (!f && (0, h.isNavigatingToNewRootLayout)(a, l)) ||
|
|
I === u.NOT_FOUND_SEGMENT_KEY ||
|
|
null === b ||
|
|
null === T
|
|
? null
|
|
: R(t, l, n, c, d, p, y, g, v, b, T, w, M);
|
|
let L = null !== T && null !== b ? b.concat([T, I]) : [],
|
|
D = l[1],
|
|
x = a[1],
|
|
H = null !== d ? d[1] : null,
|
|
B = null !== y ? y[1] : null,
|
|
$ = !0 === l[4],
|
|
K = f || $,
|
|
V = void 0 !== n ? n.parallelRoutes : void 0,
|
|
q = !1,
|
|
G = !1;
|
|
switch (c) {
|
|
case 0:
|
|
case 2:
|
|
case 1:
|
|
(q = !1), (G = !1);
|
|
break;
|
|
case 3:
|
|
case 4:
|
|
(q = !0), (G = !0);
|
|
}
|
|
let W = new Map(q ? void 0 : V),
|
|
X = 0 === Object.keys(D).length;
|
|
if (void 0 === n || G || (X && _))
|
|
if (null !== d && null !== d[0]) {
|
|
let e = d[0],
|
|
r = d[2],
|
|
n = null === p;
|
|
(F = S(e, r, !1, p, n, X, W, t)), (U = X && n);
|
|
} else if (null !== y) {
|
|
let e = y[0],
|
|
r = y[2],
|
|
n = y[3];
|
|
(F = S(e, r, n, g, v, X, W, t)), (U = n || (X && v));
|
|
} else (F = O(W, X, t, c)), (U = !0);
|
|
else (F = E(!1, n, W)), (U = !1);
|
|
let z = l[2],
|
|
Y = "string" == typeof z && "refresh" === l[3] ? z : j;
|
|
U &&
|
|
null !== Y &&
|
|
((A = M),
|
|
(C = Y),
|
|
null === (N = A.separateRefreshUrls)
|
|
? (A.separateRefreshUrls = new Set([C]))
|
|
: N.add(C));
|
|
let Q = {},
|
|
J = null,
|
|
Z = !1,
|
|
ee = {};
|
|
for (let n in D) {
|
|
let a = D[n],
|
|
l = x[n];
|
|
if (void 0 === l) return null;
|
|
let o = void 0 !== V ? V.get(n) : void 0,
|
|
f = null !== H ? H[n] : null,
|
|
d = null !== B ? B[n] : null,
|
|
h = a[0],
|
|
y = p,
|
|
b = g,
|
|
R = v;
|
|
2 !== c &&
|
|
h === u.DEFAULT_SEGMENT_KEY &&
|
|
((h = (a = (function (e, t) {
|
|
let r;
|
|
return (
|
|
"refresh" === t[3]
|
|
? (r = t)
|
|
: (((r = m(t, t[1]))[2] = (0, i.createHrefFromUrl)(e)),
|
|
(r[3] = "refresh")),
|
|
r
|
|
);
|
|
})(r, l))[0]),
|
|
(f = null),
|
|
(y = null),
|
|
(d = null),
|
|
(b = null),
|
|
(R = !1));
|
|
let P = (0, s.createRouterCacheKey)(h),
|
|
E = e(
|
|
t,
|
|
r,
|
|
void 0 !== o ? o.get(P) : void 0,
|
|
l,
|
|
a,
|
|
c,
|
|
K,
|
|
f ?? null,
|
|
y,
|
|
d ?? null,
|
|
b,
|
|
R,
|
|
_,
|
|
L,
|
|
n,
|
|
w || U,
|
|
Y,
|
|
M,
|
|
);
|
|
if (null === E) return null;
|
|
null === J && (J = new Map()), J.set(n, E);
|
|
let S = E.node;
|
|
if (null !== S) {
|
|
let e = new Map(q ? void 0 : o);
|
|
e.set(P, S), W.set(n, e);
|
|
}
|
|
let O = E.route;
|
|
Q[n] = O;
|
|
let T = E.dynamicRequestTree;
|
|
null !== T ? ((Z = !0), (ee[n] = T)) : (ee[n] = O);
|
|
}
|
|
return {
|
|
status: +!U,
|
|
route: m(l, Q),
|
|
node: F,
|
|
dynamicRequestTree: P(l, ee, U, Z, w),
|
|
refreshUrl: Y,
|
|
children: J,
|
|
};
|
|
})(
|
|
e,
|
|
t,
|
|
null !== r ? r : void 0,
|
|
n,
|
|
a,
|
|
l,
|
|
!1,
|
|
c,
|
|
f,
|
|
d,
|
|
p,
|
|
y,
|
|
g,
|
|
null,
|
|
null,
|
|
!1,
|
|
null,
|
|
v,
|
|
);
|
|
}
|
|
function R(e, t, r, n, a, l, u, o, i, c, f, d, h) {
|
|
let y,
|
|
g,
|
|
v = t[0],
|
|
_ = null !== f && null !== c ? c.concat([f, v]) : [],
|
|
b = t[1],
|
|
T = null !== u ? u[1] : null,
|
|
w = null !== a ? a[1] : null,
|
|
j = void 0 !== r ? r.parallelRoutes : void 0,
|
|
M = !1,
|
|
A = !1,
|
|
C = !1;
|
|
switch (n) {
|
|
case 0:
|
|
(M = !1),
|
|
(A = void 0 === r || e - r.navigatedAt >= p.DYNAMIC_STALETIME_MS),
|
|
(C = !1);
|
|
break;
|
|
case 1:
|
|
(A = !1), (M = !1), (C = !1);
|
|
break;
|
|
case 2:
|
|
if (((A = !1), (A = !1), void 0 !== r)) {
|
|
let e = r.rsc;
|
|
C = !N(e) || "pending" !== e.status;
|
|
} else C = !1;
|
|
break;
|
|
case 3:
|
|
case 4:
|
|
(A = !0), (M = !0), (C = !1);
|
|
}
|
|
let F = new Map(M ? void 0 : j),
|
|
U = 0 === Object.keys(b).length;
|
|
if (
|
|
(U &&
|
|
(null === h.scrollableSegments && (h.scrollableSegments = []),
|
|
h.scrollableSegments.push(_)),
|
|
A || void 0 === r)
|
|
)
|
|
if (null !== a && null !== a[0]) {
|
|
let t = a[0],
|
|
r = a[2],
|
|
u = null === l && 1 !== n;
|
|
(y = S(t, r, !1, l, u, U, F, e)), (g = U && u);
|
|
} else if (1 === n && U && null !== l)
|
|
(y = S(null, null, !1, l, !1, U, F, e)), (g = !1);
|
|
else if (1 !== n && null !== u) {
|
|
let t = u[0],
|
|
r = u[2],
|
|
n = u[3];
|
|
(y = S(t, r, n, o, i, U, F, e)), (g = n || (U && i));
|
|
} else (y = O(F, U, e, n)), (g = !0);
|
|
else (y = E(C, r, F)), (g = !1);
|
|
let k = {},
|
|
I = null,
|
|
L = !1,
|
|
D = {};
|
|
for (let t in b) {
|
|
let r = b[t],
|
|
a = void 0 !== j ? j.get(t) : void 0,
|
|
u = null !== w ? w[t] : null,
|
|
c = null !== T ? T[t] : null,
|
|
f = r[0],
|
|
p = (0, s.createRouterCacheKey)(f),
|
|
y = R(
|
|
e,
|
|
r,
|
|
void 0 !== a ? a.get(p) : void 0,
|
|
n,
|
|
u ?? null,
|
|
l,
|
|
c ?? null,
|
|
o,
|
|
i,
|
|
_,
|
|
t,
|
|
d || g,
|
|
h,
|
|
);
|
|
null === I && (I = new Map()), I.set(t, y);
|
|
let v = y.node;
|
|
if (null !== v) {
|
|
let e = new Map(M ? void 0 : a);
|
|
e.set(p, v), F.set(t, e);
|
|
}
|
|
let m = y.route;
|
|
k[t] = m;
|
|
let P = y.dynamicRequestTree;
|
|
null !== P ? ((L = !0), (D[t] = P)) : (D[t] = m);
|
|
}
|
|
return {
|
|
status: +!g,
|
|
route: m(t, k),
|
|
node: y,
|
|
dynamicRequestTree: P(t, D, g, L, d),
|
|
refreshUrl: null,
|
|
children: I,
|
|
};
|
|
}
|
|
function m(e, t) {
|
|
let r = [e[0], t];
|
|
return (
|
|
2 in e && (r[2] = e[2]),
|
|
3 in e && (r[3] = e[3]),
|
|
4 in e && (r[4] = e[4]),
|
|
r
|
|
);
|
|
}
|
|
function P(e, t, r, n, a) {
|
|
let l = null;
|
|
return (
|
|
r ? ((l = m(e, t)), a || (l[3] = "refetch")) : (l = n ? m(e, t) : null),
|
|
l
|
|
);
|
|
}
|
|
function E(e, t, r) {
|
|
return {
|
|
rsc: t.rsc,
|
|
prefetchRsc: e ? null : t.prefetchRsc,
|
|
head: t.head,
|
|
prefetchHead: e ? null : t.prefetchHead,
|
|
loading: t.loading,
|
|
parallelRoutes: r,
|
|
navigatedAt: t.navigatedAt,
|
|
};
|
|
}
|
|
function S(e, t, r, n, a, l, u, o) {
|
|
let i, s, c, f;
|
|
return (
|
|
r ? ((s = e), (i = F())) : ((s = null), (i = e)),
|
|
l
|
|
? a
|
|
? ((c = n), (f = F()))
|
|
: ((c = null), (f = n))
|
|
: ((c = null), (f = null)),
|
|
{
|
|
rsc: i,
|
|
prefetchRsc: s,
|
|
head: f,
|
|
prefetchHead: c,
|
|
loading: t,
|
|
parallelRoutes: u,
|
|
navigatedAt: o,
|
|
}
|
|
);
|
|
}
|
|
function O(e, t, r, n) {
|
|
let a = 1 === n;
|
|
return {
|
|
rsc: a ? null : F(),
|
|
prefetchRsc: null,
|
|
head: !a && t ? F() : null,
|
|
prefetchHead: null,
|
|
loading: a ? null : F(),
|
|
parallelRoutes: e,
|
|
navigatedAt: r,
|
|
};
|
|
}
|
|
let T = !1;
|
|
function w(e, t, r, n, a) {
|
|
let l = e.dynamicRequestTree;
|
|
if (null === l) {
|
|
T = !1;
|
|
return;
|
|
}
|
|
let u = A(e, l, t, r, n),
|
|
o = a.separateRefreshUrls,
|
|
s = null;
|
|
if (null !== o) {
|
|
s = [];
|
|
let a = (0, i.createHrefFromUrl)(t);
|
|
for (let t of o)
|
|
t !== a &&
|
|
null !== l &&
|
|
s.push(A(e, l, new URL(t, location.origin), r, n));
|
|
}
|
|
j(e, r, u, s).then(v, v);
|
|
}
|
|
async function j(e, t, r, n) {
|
|
var a, l;
|
|
let u = await ((a = r),
|
|
(l = n),
|
|
new Promise((e) => {
|
|
let t = (t) => {
|
|
0 === t.exitStatus ? 0 == --n && e(0) : e(t.exitStatus);
|
|
},
|
|
r = () => e(2),
|
|
n = 1;
|
|
a.then(t, r),
|
|
null !== l && ((n += l.length), l.forEach((e) => e.then(t, r)));
|
|
}));
|
|
switch (
|
|
(0 === u &&
|
|
(u = (function e(t, r, n) {
|
|
var a, l, u;
|
|
let o, i, s, c;
|
|
0 === t.status
|
|
? ((t.status = 2),
|
|
(a = t.node),
|
|
(l = r),
|
|
(u = n),
|
|
N((i = a.rsc)) &&
|
|
(null === l ? i.resolve(null, u) : i.reject(l, u)),
|
|
N((s = a.loading)) && s.resolve(null, u),
|
|
N((c = a.head)) && c.resolve(null, u),
|
|
(o = null === t.refreshUrl ? 1 : 2))
|
|
: (o = 0);
|
|
let f = t.children;
|
|
if (null !== f)
|
|
for (let [, t] of f) {
|
|
let a = e(t, r, n);
|
|
a > o && (o = a);
|
|
}
|
|
return o;
|
|
})(e, null, null)),
|
|
u)
|
|
) {
|
|
case 0:
|
|
T = !1;
|
|
return;
|
|
case 1: {
|
|
let n = await r;
|
|
M(!1, n.url, t, n.seed, e.route);
|
|
return;
|
|
}
|
|
case 2: {
|
|
let n = await r;
|
|
M(!0, n.url, t, n.seed, e.route);
|
|
return;
|
|
}
|
|
default:
|
|
return u;
|
|
}
|
|
}
|
|
function M(e, t, r, n, a) {
|
|
(e = e || T), (T = !0);
|
|
let l = {
|
|
type: d.ACTION_SERVER_PATCH,
|
|
previousTree: a,
|
|
url: t,
|
|
nextUrl: r,
|
|
seed: n,
|
|
mpa: e,
|
|
};
|
|
(0, f.dispatchAppRouterAction)(l);
|
|
}
|
|
async function A(e, t, r, n, a) {
|
|
try {
|
|
let l = await (0, c.fetchServerResponse)(r, {
|
|
flightRouterState: t,
|
|
nextUrl: n,
|
|
isHmrRefresh: 4 === a,
|
|
});
|
|
if ("string" == typeof l)
|
|
return {
|
|
exitStatus: 2,
|
|
url: new URL(l, location.origin),
|
|
seed: null,
|
|
};
|
|
let u = (0, y.convertServerPatchToFullTree)(
|
|
e.route,
|
|
l.flightData,
|
|
l.renderedSearch,
|
|
);
|
|
return {
|
|
exitStatus: +!!(function e(t, r, n, a, l) {
|
|
0 === t.status &&
|
|
null !== n &&
|
|
((t.status = 1),
|
|
(function (e, t, r, n) {
|
|
let a = e.rsc,
|
|
l = t[0];
|
|
if (null === l) return;
|
|
null === a ? (e.rsc = l) : N(a) && a.resolve(l, n);
|
|
let u = e.loading;
|
|
if (N(u)) {
|
|
let e = t[2];
|
|
u.resolve(e, n);
|
|
}
|
|
let o = e.head;
|
|
N(o) && o.resolve(r, n);
|
|
})(t.node, n, a, l));
|
|
let u = t.children,
|
|
i = r[1],
|
|
s = null !== n ? n[1] : null,
|
|
c = !1;
|
|
if (null !== u)
|
|
for (let t in i) {
|
|
let r = i[t],
|
|
n = null !== s ? s[t] : null,
|
|
f = u.get(t);
|
|
if (void 0 === f) c = !0;
|
|
else {
|
|
let t = f.route[0];
|
|
(0, o.matchSegment)(r[0], t) &&
|
|
null != n &&
|
|
e(f, r, n, a, l) &&
|
|
(c = !0);
|
|
}
|
|
}
|
|
return c;
|
|
})(e, u.tree, u.data, u.head, l.debugInfo),
|
|
url: new URL(l.canonicalUrl, location.origin),
|
|
seed: u,
|
|
};
|
|
} catch {
|
|
return { exitStatus: 2, url: r, seed: null };
|
|
}
|
|
}
|
|
let C = Symbol();
|
|
function N(e) {
|
|
return e && "object" == typeof e && e.tag === C;
|
|
}
|
|
function F() {
|
|
let e,
|
|
t,
|
|
r = [],
|
|
n = new Promise((r, n) => {
|
|
(e = r), (t = n);
|
|
});
|
|
return (
|
|
(n.status = "pending"),
|
|
(n.resolve = (t, a) => {
|
|
"pending" === n.status &&
|
|
((n.status = "fulfilled"),
|
|
(n.value = t),
|
|
null !== a && r.push.apply(r, a),
|
|
e(t));
|
|
}),
|
|
(n.reject = (e, a) => {
|
|
"pending" === n.status &&
|
|
((n.status = "rejected"),
|
|
(n.reason = e),
|
|
null !== a && r.push.apply(r, a),
|
|
t(e));
|
|
}),
|
|
(n.tag = C),
|
|
(n._debugInfo = r),
|
|
n
|
|
);
|
|
}
|
|
("function" == typeof r.default ||
|
|
("object" == typeof r.default && null !== r.default)) &&
|
|
void 0 === r.default.__esModule &&
|
|
(Object.defineProperty(r.default, "__esModule", { value: !0 }),
|
|
Object.assign(r.default, r),
|
|
(t.exports = r.default));
|
|
};
|
|
|
|
export default moduleFactory;
|