https://doloffer.com/assets/entries/entry-client-routing.CePMRoR_.js

1const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=["assets/entries/pages_GuideDiscord.CE_nGb4t.js","assets/chunks/chunk-DWeE5Y0G.js","assets/chunks/chunk-DC5fQwvS.js","assets/chunks/chunk-Dxqvi9v3.js","assets/static/vike-react-b64a028b.BcWtY8Ol.css","assets/static/src_v2_styles_index-c047eaab.D9yH6Gw8.css","assets/chunks/chunk-BArghIwn.js","assets/chunks/chunk-C0TFbFtH.js","assets/entries/pages_aboutUs.CInV3kcb.js","assets/entries/pages_affiliate.Bl9f-M7d.js","assets/entries/pages_aml-policy.Cgnj4hW-.js","assets/entries/pages_blog.44YGRW5O.js","assets/chunks/chunk-vuFFcsqA.js","assets/chunks/chunk-BBbQcHMe.js","assets/chunks/chunk-BKApCE6t.js","assets/entries/pages_blog_-slug.Coq1b29_.js","assets/chunks/chunk-I930ZYhp.js","assets/chunks/chunk-C5iOjZdu.js","assets/entries/pages_contactUs.8yb-8lhV.js","assets/entries/pages_cooperate.CQgNVjBZ.js","assets/entries/pages_copyright.BpVaFymp.js","assets/entries/pages_help-recharge.CmK43nRV.js","assets/entries/pages_help-useGpt.B9pQtMVf.js","assets/entries/pages_help-useNetflix.CXyCqiRX.js","assets/entries/pages_help-ytbRegion.D-jcWGei.js","assets/entries/pages_index.DCZt-MI_.js","assets/entries/pages_privacy-policy.DZKHnXsh.js","assets/entries/pages_product_-slug.CLknIk3l.js","assets/chunks/chunk-0x1gBMBx.js","assets/entries/pages_refund-policy.DI4H0vQ3.js","assets/entries/pages_terms.Duvwdv5J.js","assets/entries/pages_-lang_GuideDiscord.BCQjQpcH.js","assets/entries/pages_-lang_aboutUs.DF_uytW5.js","assets/entries/pages_-lang_affiliate.RazzqSfl.js","assets/entries/pages_-lang_aml-policy.CRdGmQtX.js","assets/entries/pages_-lang_blog.Cqyj7Cj7.js","assets/entries/pages_-lang_blog_-slug.t3H6-sQ8.js","assets/entries/pages_-lang_contactUs.C-Z7jOKc.js","assets/entries/pages_-lang_cooperate.DnR1-maX.js","assets/entries/pages_-lang_copyright._Z_R-XKv.js","assets/entries/pages_-lang_help-recharge.Cs1Lh99W.js","assets/entries/pages_-lang_help-useGpt.CrWHC1oD.js","assets/entries/pages_-lang_help-useNetflix.BBRyJO-k.js","assets/entries/pages_-lang_help-ytbRegion.DIA1zTqN.js","assets/entries/pages_-lang_index.pc7R_DM_.js","assets/entries/pages_-lang_privacy-policy.3cVNMbxL.js","assets/entries/pages_-lang_product_-slug.Crm6tnuF.js","assets/entries/pages_-lang_refund-policy.CMG0XXkF.js","assets/entries/pages_-lang_terms.dYP7X8Jy.js","assets/entries/pages_spa.C5xTuQKw.js","assets/chunks/chunk-DwPmycG5.js"])))=>i.map(i=>d[i]);
2import { af as L, ag as h, ah as p, ai as C, aj as a, ak as w, al as Ct, am as U, an as Vn, _ as E, ao as Un, ap as Bn } from "../chunks/chunk-DC5fQwvS.js";
3import { W as Hn, __tla as __tla_0 } from "../chunks/chunk-BArghIwn.js";
4import "../chunks/chunk-C0TFbFtH.js";
5Promise.all([
6  (() => {
7    try {
8      return __tla_0;
9    } catch {
10    }
11  })()
12]).then(async () => {
13  function Y() {
14    return typeof window < "u" && typeof window.scrollY == "number";
15  }
16  const wt = L("utils/assertRouterType.ts", {});
17  function ne() {
18    Nn(Wn()), wt.isClientRouting = true;
19  }
20  function Wn() {
21    return wt.isClientRouting !== false;
22  }
23  function Nn(e) {
24    h(Y(), `${p.cyan("import { something } from 'vike/client/router'")} is forbidden on the server-side`, {
25      showStackTrace: true
26    }), C(e, "You shouldn't `import { something } from 'vike/client/router'` when using Server Routing. The 'vike/client/router' utilities work only with Client Routing. In particular, don't `import { navigate }` nor `import { prefetch }` as they unnecessarily bloat your client-side bundle sizes.", {
27      showStackTrace: true,
28      onlyOnce: true
29    });
30  }
31  function zt() {
32    a(Y());
33  }
34  function Gn() {
35    zt(), ne();
36  }
37  function N(e) {
38    return e instanceof Function || typeof e == "function";
39  }
40  function W(e) {
41    return Array.isArray(e);
42  }
43  function Mn(e) {
44    return W(e) && e.every((t) => typeof t == "string");
45  }
46  function Kn(e) {
47    return w(e) && Object.values(e).every((t) => typeof t == "string");
48  }
49  function m(e, t, n) {
50    if (!w(e)) return false;
51    if (!(t in e)) return n === "undefined";
52    if (n === void 0) return true;
53    const i = e[t];
54    return n === "undefined" ? i === void 0 : n === "array" ? W(i) : n === "object" ? w(i) : n === "string[]" ? Mn(i) : n === "string{}" ? Kn(i) : n === "function" ? N(i) : W(n) ? typeof i == "string" && n.includes(i) : n === "null" ? i === null : n === "true" ? i === true : n === "fal

54se" ? i === false : typeof i === n;
55  }
56  function J(e) {
57    return typeof e != "object" || e === null ? false : Object.getPrototypeOf(e) === null ? true : e.constructor.name === "Object";
58  }
59  function Yn() {
60    var _a2, _b, _c, _d;
61    const e = !!((_b = (_a2 = window.__REACT_DEVTOOLS_GLOBAL_HOOK__) == null ? void 0 : _a2.renderers) == null ? void 0 : _b.size), t = !!((_d = (_c = window.__REACT_DEVTOOLS_GLOBAL_HOOK__) == null ? void 0 : _c.rendererInterfaces) == null ? void 0 : _d.size), n = !!window.__vite_plugin_react_preamble_installed__;
62    return e || t || n;
63  }
64  function Qe(e, t) {
65    return !w(e) || !w(t) ? false : e.message === t.message;
66  }
67  function y(e, t, n) {
68    t && (n || a(!("isPageContext" in t)), Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)));
69  }
70  function B(e, t, n) {
71    return typeof e == "string" ? et(e.split(""), t, n).join("") : et(e, t, n);
72  }
73  function et(e, t, n) {
74    const i = [];
75    let r = t >= 0 ? t : e.length + t;
76    a(r >= 0 && r <= e.length);
77    let o = n >= 0 ? n : e.length + n;
78    for (a(o >= 0 && o <= e.length); !(r === o || (r === e.length && (r = 0), r === o)); ) {
79      const s = e[r];
80      a(s !== void 0), i.push(s), r++;
81    }
82    return i;
83  }
84  function ce(e, t) {
85    a(Ot(e), e), a(t.startsWith("/"));
86    const { hashString: n, withoutHash: i } = Jn(e);
87    a(n === null || n.startsWith("#"));
88    const r = n === null ? "" : xt(n.slice(1)), { searchString: o, withoutSearch: s } = tt(i);
89    a(o === null || o.startsWith("?"));
90    let l = "";
91    if (o !== null) l = o;
92    else if (e.startsWith("#")) {
93      const g = jt();
94      l = g && tt(g).searchString || "";
95    }
96    const u = {}, d = {};
97    Array.from(new URLSearchParams(l)).forEach(([g, z]) => {
98      u[g] = z, d[g] = [
99        ...d.hasOwnProperty(g) ? d[g] : [],
100        z
101      ];
102    });
103    let { protocol: c, origin: f, pathnameAbsoluteWithBase: S } = Xn(s, t);
104    const R = s.slice((f || "").length);
105    ti(e, f, R, o, n);
106    let { pathname: P, isBaseMissing: I } = ei(S, t);
107    const x = Dt(f, P, o, n), $ = f ? f.slice(c.length) : null, { hostname: _, port: v } = Zn($, e);
108    return P = qn(P), a(P.startsWith("/")), {
109      href: x,
110      protocol: c,
111      hostname: _,
112      port: v,
113      origin: f,
114      pathname: P,
115      pathnameOriginal: R,
116      isBaseMissing: I,
117      search: u,
118      searchAll: d,
119      searchOriginal: o,
120      hash: r,
121      hashOriginal: n
122    };
123  }
124  function Jn(e) {
125    const [t, ...n] = e.split("#");
126    return {
127      hashString: [
128        "",
129        ...n
130      ].join("#") || null,
131      withoutHash: t
132    };
133  }
134  function tt(e) {
135    const [t, ...n] = e.split("?");
136    return {
137      searchString: [
138        "",
139        ...n
140      ].join("?") || null,
141      withoutSearch: t
142    };
143  }
144  function xt(e) {
145    try {
146      return decodeURIComponent(e);
147    } catch {
148    }
149    try {
150      return decodeURI(e);
151    } catch {
152    }
153    return e;
154  }
155  function qn(e) {
156    return e = e.replace(/\s+$/, ""), e = e.split("/").map((t) => xt(t).split("/").join("%2F")).join("/"), e;
157  }
158  function Xn(e, t) {
159    a(!e.includes("?") && !e.includes("#"));
160    {
161      const { protocol: n, origin: i, pathname: r }

161 = nt(e);
162      if (i) return {
163        protocol: n,
164        origin: i,
165        pathnameAbsoluteWithBase: r
166      };
167      a(r === e);
168    }
169    if (e.startsWith("/")) return {
170      protocol: null,
171      origin: null,
172      pathnameAbsoluteWithBase: e
173    };
174    {
175      const n = jt();
176      let i;
177      return n ? i = nt(n.split("?")[0].split("#")[0]).pathname : i = t, {
178        protocol: null,
179        origin: null,
180        pathnameAbsoluteWithBase: Qn(e, i)
181      };
182    }
183  }
184  function jt() {
185    var _a2;
186    return typeof window < "u" ? (_a2 = window == null ? void 0 : window.document) == null ? void 0 : _a2.baseURI : void 0;
187  }
188  function nt(e) {
189    if (De(e)) {
190      const { protocol: t, uriWithoutProtocol: n } = je(e);
191      a(t);
192      const [i, ...r] = n.split("/"), o = t + i;
193      return {
194        pathname: "/" + r.join("/"),
195        origin: o,
196        protocol: t
197      };
198    } else return {
199      pathname: e,
200      origin: null,
201      protocol: null
202    };
203  }
204  function Zn(e, t) {
205    const n = {
206      hostname: null,
207      port: null
208    };
209    if (!e) return n;
210    const i = e.split(":");
211    if (i.length > 1) {
212      const r = parseInt(i.pop(), 10);
213      a(r || r === 0, t), n.port = r;
214    }
215    return n.hostname = i.join(":"), n;
216  }
217  function je(e) {
218    const t = ":", [n, ...i] = e.split(t);
219    if (i.length === 0 || !/^[a-z][a-z0-9\+\-]*$/i.test(n)) return {
220      protocol: null,
221      uriWithoutProtocol: e
222    };
223    let r = n + t, o = i.join(t);
224    const s = "//";
225    return o.startsWith(s) && (r = r + s, o = o.slice(s.length)), {
226      protocol: r,
227      uriWithoutProtocol: o
228    };
229  }
230  function It(e) {
231    return [
232      "ipfs://",
233      "ipns://"
234    ].includes(e) ? false : e.endsWith("://");
235  }
236  function Qn(e, t) {
237    const n = t.split("/"), i = e.split("/");
238    let r = t.endsWith("/");
239    e.startsWith(".") && n.pop();
240    for (const s in i) {
241      const l = i[s];
242      l == "" && s === "0" || l != "." && (l == ".." ? n.pop() : (r = false, n.push(l)));
243    }
244    let o = n.join("/");
245    return r && !o.endsWith("/") && (o += "/"), o.startsWith("/") || (o = "/" + o), o;
246  }
247  function ei(e, t) {
248    a(e.startsWith("/")), a(Ie(t));
249    let n = e;
250    if (a(n.startsWith("/")), a(t.startsWith("/")), t === "/") return {
251      pathname: e,
252      isBaseMissing: false
253    };
254    let i = t;
255    return t.endsWith("/") && n === B(t, 0, -1) && (i = B(t, 0, -1), a(n === i)), n.startsWith(i) ? (a(n.startsWith("/") || n.startsWith("http")), a(n.startsWith(i)), n = n.slice(i.length), n.startsWith("/") || (n = "/" + n), a(n.startsWith("/")), {
256      pathname: n,
257      isBaseMissing: false
258    }) : {
259      pathname: e,
260      isBaseMissing: true
261    };
262  }
263  function Ie(e) {
264    return e.startsWith("/");
265  }
266  function ti(e, t, n, i, r) {
267    const o = Dt(t, n, i, r);
268    a(e === o);
269  }
270  function Dt(e, t, n, i) {
271    return `${e || ""}${t}${n || ""}${i || ""}`;
272  }
273  function Ot(e) {
274    return De(e) || e.startsWith("/") || kt(e);
275  }
276  function ni(e) {
277    return e.startsWith("/") || ri(e) || De(e);
278  }
279  function kt(e) {
280    return [
281      ".",
282      "?",
283      "#"
284    ].some((t) => e.startsWith(t)) || e === "";
285  }
286  function ii(e) {
287    return !e.startsWith("/") && !kt(e);
288  }
289  function De(e) {
290    const { protocol: t } = je(e);
291    return !!t && It(t);
292  }
293  function ri(e) {
294    const { protocol: t } = je(e);
295    return !!t && !It(e);
296  }
297  function oi(e, t) {
298    ai(e, t);
299  }
300  function ai(e, t, { isRedirectTarget: n } = {}) {
301    if (e.startsWith("/")) return;
302    let i = `${t} is ${p.string(e)} but it should start with ${p.string("/")}`;
303    if (n) {
304      if (ni(e)) return;
305      if (i += ` or a protocol (${p.string("http://")}, ${p.string("mailto:")}, ...)`, n === "unresolved") {
306        if (e === "*") return;
307        i += `, or be ${p.string("*")}`;
308      }
309    }
310    h(false, i);
311  }
312  function M(e) {
313    window.location.href = e;
314  }
315  function si(e) {
316    return new Promise((t) => setTimeout(t, e));
317  }
318  function li(e, t) {
319    let n = false;
320    return () => {
321      n || (n = true, setTimeout(() => {

322        n = false, e();
323      }, t));
324    };
325  }
326  function Ft(e) {
327    window.addEventListener("visibilitychange", () => {
328      document.visibilityState === "hidden" && e();
329    });
330  }
331  function ui(e) {
332    window.addEventListener("visibilitychange", () => {
333      document.visibilityState === "visible" && e();
334    });
335  }
336  function le(e, t) {
337    a(e === t);
338  }
339  function Lt() {
340    let e;
341    return {
342      promise: new Promise((n) => e = n),
343      resolve: e
344    };
345  }
346  const he = {};
347  function $t(e, t = 100, n = 5) {
348    const i = /* @__PURE__ */ new Date();
349    let r = he[e] ?? (he[e] = it(i));
350    i.getTime() - r.start.getTime() > n * 1e3 && (r = he[e] = it(i)), r.count++;
351    const s = `[Infinite Loop] Rendering ${r.count} times within ${n} seconds [${e}]`;
352    r.count > t && h(false, s), !r.warned && r.count > t * 0.5 && (C(false, s, {
353      onlyOnce: false,
354      showStackTrace: true
355    }), r.warned = true);
356  }
357  function it(e) {
358    return {
359      count: 0,
360      start: e
361    };
362  }
363  Gn();
364  const di = [
365    {
366      is: (e) => e === void 0,
367      match: (e) => e === "!undefined",
368      serialize: () => "!undefined",
369      deserialize: () => {
370      }
371    },
372    {
373      is: (e) => e === 1 / 0,
374      match: (e) => e === "!Infinity",
375      serialize: () => "!Infinity",
376      deserialize: () => 1 / 0
377    },
378    {
379      is: (e) => e === -1 / 0,
380      match: (e) => e === "!-Infinity",
381      serialize: () => "!-Infinity",
382      deserialize: () => -1 / 0
383    },
384    {
385      is: (e) => typeof e == "number" && isNaN(e),
386      match: (e) => e === "!NaN",
387      serialize: () => "!NaN",
388      deserialize: () => NaN
389    },
390    {
391      is: (e) => e instanceof Date,
392      match: (e) => e.startsWith("!Date:"),
393      serialize: (e) => "!Date:" + e.toISOString(),
394      deserialize: (e) => new Date(e.slice(6))
395    },
396    {
397      is: (e) => typeof e == "bigint",
398      match: (e) => e.startsWith("!BigInt:"),
399      serialize: (e) => "!BigInt:" + e.toString(),
400      deserialize: (e) => {
401        if (typeof BigInt > "u") throw new Error("Your JavaScript environement does not support BigInt. Consider adding a polyfill.");
402        return BigInt(e.slice(8));
403      }
404    },
405    {
406      is: (e) => e instanceof RegExp,
407      match: (e) => e.startsWith("!RegExp:"),

408      serialize: (e) => "!RegExp:" + e.toString(),
409      deserialize: (e) => {
410        e = e.slice(8);
411        const t = e.match(/\/(.*)\/(.*)?/), n = t[1], i = t[2];
412        return new RegExp(n, i);
413      }
414    },
415    {
416      is: (e) => e instanceof Map,
417      match: (e) => e.startsWith("!Map:"),
418      serialize: (e, t) => "!Map:" + t(Array.from(e.entries())),
419      deserialize: (e, t) => new Map(t(e.slice(5)))
420    },
421    {
422      is: (e) => e instanceof Set,
423      match: (e) => e.startsWith("!Set:"),
424      serialize: (e, t) => "!Set:" + t(Array.from(e.values())),
425      deserialize: (e, t) => new Set(t(e.slice(5)))
426    },
427    {
428      is: (e) => typeof e == "string" && e.startsWith("!"),
429      match: (e) => e.startsWith("!"),
430      serialize: (e) => "!" + e,
431      deserialize: (e) => e.slice(1)
432    }
433  ];
434  function Oe(e, t = {}) {
435    const n = JSON.parse(e);
436    return ke(n, t);
437  }
438  function ke(e, t = {}, n = []) {
439    return typeof e == "string" ? ci(e, t, n) : (typeof e == "object" && e !== null && Object.entries(e).forEach(([i, r]) => {
440      e[i] = ke(r, t, [
441        ...n,
442        i
443      ]);
444    }), e);
445  }
446  function ci(e, t, n) {
447    var _a2;
448    const i = (r) => Oe(r, t);
449    {
450      const r = (_a2 = t.reviver) == null ? void 0 : _a2.call(t, n, e, i);
451      if (r) {
452        if (typeof r.replacement != "string") return r.replacement;
453        if (e = r.replacement, r.resolved) return e;
454      }
455    }
456    for (const { match: r, deserialize: o } of di) if (r(e)) return o(e, i);
457    return e;
458  }
459  const fi = "vike_pageContext", gi = "vike_globalContext";
460  function pi() {
461    const e = Vt(fi);
462    return a(m(e, "pageId", "string")), a(m(e, "routeParams", "string{}")), e;
463  }
464  function hi() {
465    return Vt(gi);
466  }
467  function Vt(e) {
468    const t = document.getElementById(e);
469    h(t, `Couldn't find #${e} (which Vike automatically injects in the HTML): make sure it exists (i.e. don't remove it and make sure your HTML isn't malformed)`);
470    const n = t.textContent;
471    return a(n), Oe(n);
472  }
473  function ue(e) {
474    return (t, n) => {
475      const i = e(t), r = e(n);
476      return i === r ? 0 : i > r ? -1 : 1;
477    };
478  }
479  function yi(e) {
480    return (t, n) => {
481      const i = e(t), r = e(n);
482      return i === r ? 0 : i < r ? -1 : 1;
483    };
484  }
485  function G(e) {
486    return (t, n) => {
487      const i = e(t), r = e(n);
488      if (a([
489        true,
490        false,
491        null
492      ].includes(i)), a([
493        true,
494        false,
495        null
496      ].includes(r)), i === r) return 0;
497      if (i === true || r === false) return -1;
498      if (r === true || i === false) return 1;
499      a(false);
500    };
501  }
502  function mi(e) {
503    return G((t) => {
504      const n = e(t);
505      return n === null ? null : !n;
506    });
507  }
508  function vi(e, t) {
509    return e.toLowerCase() < t.toLowerCase() ? -1 : e.toLowerCase() > t.toLowerCase() ? 1 : 0;
510  }
511  function Si(e) {
512    return e == null;
513  }
514  function Pi(e) {
515    return !Si(e);
516  }
517  function rt(e) {
518    return "[" + e.map((t) => "'" + t + "'").join(", ") + "]";
519  }
520  function ye(e, t) {
521    const n = Object.getOwnPropertyDescriptor(e, t);
522    return !!n && !("value" in n) && !!n.get;
523  }
524  function Ei(e) {
525    return typeof e == "object" && e !== null && "then" in e && N(e.then);
526  }
527  function Ri(e) {
528    return [
529      null,
530      void 0
531    ].includes(e) ? String(e) : [
532      "boolean",
533      "number",
534      "string"
535    ].includes(typeof e) ? JSON.stringify(e) : null;
536  }
537  function _i(e) {
538    return e.replace(/[/\-\\^$*+?.()|[\]{}]/g, "\\$&");
539  }
540  function re(e, t, n) {
541    const i = Object.getOwnPropertyDescriptor(e, t);
542    Object.defineProperty(e, t, {
543      ...i,
544      enumerable: n
545    });
546  }
547  function me(e, t, { get: n, ...i }) {
548    Object.defineProperty(e, t, {
549      ...i,
550      get: n
551    });
552  }
553  const Ut = [
554    "js",
555    "ts",
556    "cjs",
557    "cts",
558    "mjs",
559    "mts"
560  ], Ai = [
561    "jsx",
562    "tsx",
563    "cjsx",
564    "ctsx",
565    "mjsx",
566    "mtsx"
567  ], Bt = [
568    "vue",
569    "svelte",
570    "marko",
571    "md",
572    "mdx"
573  ], Ti = [
574    ...Ut,
575    ...Ai,
576    ...Bt
577  ];
578  function Ht(e) {
579    const t = Ti.some((n) => e.endsWith("." + n));
580    return bi(e) && a(t), t;
581  }
582  function bi(e) {
583    const t = /\.(c|m)?(j|t)s$/.test(e), n = Ut.some((i) => e.endsWith("." + i));
584    return a(t === n), t;
585  }
586  function Ci(e) {
587    return Bt.some((t) => e.endsWith("." + t));
588  }
589  function Fe(e, t) {
590    return Nt(e, t, true);
591  }
592  function Wt(e, t) {
593    return Nt(e, t, false);
594  }
595  function Nt(e, t, n) {
596    const i = n ? "CLIENT_ONLY" : "SERVER_ONLY", r = e.filter((R) => R.isRelevant(t) && R.fileType !== ".page.route").sort(wi(n, t)), o = (R) => {
597      const P = r.filter((x) => x.pageId === t && x.isEnv(R ? "CLIENT_AND_SERVER" : i));
598      h(P.length <= 1, `Merge the following files into a single file: ${P.map((x) => x.filePath).join(" ")}`);
599      const I = P[0];
600      return a(I === void 0 || !I.isDefaultPageFile), I;
601    }, s = o(false), l = o(true), u = (R) => r.filter((P) => P.isRendererPageFile && P.isEnv(R ? "CLIENT_AND_SERVER" : i))[0], d = u(false), c = u(true), f = r.filter((R) => R.isDefaultPageFile && !R.isRendererPageFile && (R.isEnv(i) || R.isEnv("CLIENT_AND_SERVER")));
602    return [
603      s,
604      l,
605      ...f,
606      d,
607      c
608    ].filter(Pi);
609  }
610  function wi(e, t) {
611    const n = e ? "CLIENT_ONLY" : "SERVER_ONLY", i = -1, r = 1, o = 0;
612    return (s, l) => {
613      if (!s.isDefaultPageFile && l.isDefaultPageFile) return i;
614      if (!l.isDefaultPageFile && s.isDefaultPageFile) return r;
615      {
616        const u = s.isRendererPageFile, d = l.isRendererPageFile;
617        if (!u && d) return i;
618        if (!d && u) return r;
619        a(u === d);
620      }
621      {
622        const u = ot(t, s.filePath), d = ot(t, l.filePath);
623        if (u < d) return i;
624        if (d < u) return r;
625        a(u === d);
626      }
627      {
628        if (s.isEnv(n) && l.isEnv("CLIENT_AND_SERVER")) return i;
629        if (l.isEnv(n) && s.isEnv("CLIENT_AND_SERVER")) return r;
630      }
631      return o;
632    };
633  }
634  function ot(e, t) {
635    let n = 0;
636    for (; n < e.length && n < t.length && e[n] === t[n]; n++) ;
637    const i = e.slice(n), r = t.slice(n), o = i.split("/").length, s = r.split("/").length;
638    return o + s;
639  }
640  async function zi(e, t) {
641    const i = Wt(e, t).filter((o) => o.fileType === ".page.server");
642    return await Promise.all(i.map(async (o) => {
643      o.exportNames || (a(o.loadExportNames, t), await o.loadExportNames());
644    })), {
645      hasOnBeforeRenderServerSideOnlyHook: i.some(({ exportNames: o }) => (a(o), o.includes("onBeforeRender")))
646    };
647  }
648  function Gt(e, t) {
649    const n = t.find((i) => i.pageId === e);
650    return a(t.length > 0), a(n), n;
651  }
652  function Mt(e) {
653    if (!e || W(e) || e.definedBy) return null;
654    const { filePathToShowToUser: t } = e;
655    return a(t), t;
656  }
657  function Kt(e) {
658    const t = Mt(e);
659    return a(t), t;
660  }
661  function xi(e, t) {
662    if (!e) return null;
663    let [n, ...i] = e;
664    if (!n || i.length === 0 && [
665      "*",
666      "default",
667      t
668    ].includes(n)) return null;
669    a(n !== "*");
670    let r = "", o = "";
671    return n === "default" ? r = "export default" : (r = "export", i = [
672      n,
673      ...i

674    ]), i.forEach((l) => {
675      r = `${r} { ${l}`, o = ` }${o}`;
676    }), r + o;
677  }
678  function ji(e, t, n) {
679    return `${Pe(e, t)} at ${Q(n, t)}`;
680  }
681  function Yt(e, t, n) {
682    return n ? `${Pe(e, t)} at ${Q(n, t)}` : `${Pe(e, t)} internally`;
683  }
684  function Pe(e, t) {
685    return `${e} ${p.cyan(t)} defined`;
686  }
687  function Q(e, t) {
688    let n;
689    return W(e) ? n = e : n = [
690      e
691    ], a(n.length >= 1), n.map((r) => {
692      if (r.definedBy) return Ii(r, t);
693      const { filePathToShowToUser: o, fileExportPathToShowToUser: s } = r;
694      let l = o;
695      const u = xi(s, t);
696      return u && (l = `${l} > ${p.cyan(u)}`), l;
697    }).join(" / ");
698  }
699  function Ii(e, t) {
700    if (e.definedBy === "api") return `API call ${p.cyan(`${e.operation}({ vikeConfig: { ${t} } })`)}`;
701    const { definedBy: n } = e;
702    if (n === "cli") return `CLI option ${p.cyan(`--${t}`)}`;
703    if (n === "env") return `environment variable ${p.cyan(`VIKE_CONFIG="{${t}}"`)}`;
704    a(false);
705  }
706  function Di(e, t, n) {
707    const { value: i, definedAtData: r } = e;
708    return n && Oi(i, n, t, r), e;
709  }
710  function Oi(e, t, n, i) {
711    a(e !== null);
712    const r = typeof e;
713    if (r === t) return;
714    const o = Ri(e), s = o !== null ? `value ${p.cyan(o)}` : `type ${p.cyan(r)}`, u = `${Yt("Config", n, i)} has an invalid ${s}: it should be a ${p.cyan(t)} instead`;
715    h(false, u);
716  }
717  function q(e, t, n) {
718    const i = e.configValues[t];
719    return i ? Di(i, t, n) : null;
720  }
721  const ki = L("hooks/getHook.ts", {});
722  function H(e, t) {
723    if (!(t in e.exports)) return null;
724    const { hooksTimeout: n } = e.config, i = Ui(n, t), r = e.exports[t];
725    if (r === null) return null;
726    const o = e.exportsAll[t][0];
727    a(o.exportValue === r);
728    const s = o.filePath;
729    return a(s), Le(r, t, s, i);
730  }
731  function Fi(e, t) {
732    const n = e.configValues[t];
733    if (!(n == null ? void 0 : n.value)) return null;
734    const { hookFn: i, hookFilePath: r } = $i(n), o = Jt(t);
735    return Le(i, t, r, o);
736  }
737  function Li(e, t) {
738    const n = e.configValues[t];
739    if (!(n == null ? void 0 : n.value)) return [];
740    const i = n.value;
741    return a(W(i)), i.map((r, o) => {
742      const s = r, l = Jt(t);
743      a(W(n.definedAtData));
744      const u = Kt(n.definedAtData[o]);
745      return Le(s, t, u, l);
746    });
747  }
748  function Jt(e) {
749    return fe(e);
750  }
751  function Le(e, t, n, i) {
752    return a(n), Vi(e, {
753      hookName: t,
754      hookFilePath: n
755    }), {
756      hookFn: e,
757      hookName: t,
758      hookFilePath: n,
759      hookTimeout: i
760    };
761  }
762  function $i(e) {
763    const t = e.value;
764    a(t);
765    const n = Kt(e.definedAtData);
766    return {
767      hookFn: t,
768      hookFilePath: n
769    };
770  }
771  function ve(e, t) {
772    H(e, t);
773  }
774  function Vi(e, { hookName: t, hookFilePath: n }) {
775    a(t && n), a(!t.endsWith(")")), a(!n.endsWith(" ")), h(N(e), `Hook ${t}() defined by ${n} should be a function`);
776  }
777  function Ui(e, t) {
778    const n = Bi(e);
779    if (n === false) return {
780      error: false,
781      warning: false
782    };
783    const i = n[t], r = fe(t);
784    return (i == null ? void 0 : i.error) !== void 0 && (r.error = i.error), (i == null ? void 0 : i.warning) !== void 0 && (r.warning = i.warning), r;
785  }
786  function Bi(e) {
787    if (e === void 0) return {};
788    if (e === false) return false;
789    h(w(e), `Setting ${p.cyan("hooksTimeout")} should be ${p.cyan("false")} or an object`);
790    const t = {};
791    return Object.entries(e).forEach(([n, i]) => {
792      if (i === false) {
793        t[n] = {
794          error: false,
795          warning: false
796        };
797        return;
798      }
799      h(w(i), `Setting ${p.cyan(`hooksTimeout.${n}`)} should be ${p.cyan("false")} or an object`);
800      const [r, o] = [
801        "error",
802        "warning"
803      ].map((s) => {
804        const l = i[s];
805        if (l === void 0 || l === false) return l;
806        const u = `Setting ${p.cyan(`hooksTimeout.${n}.${s}`)} should be`;
807        return h(typeof l == "number", `${u} ${p.cyan("false")} or a number`), h(l > 0, `${u} a positive number`), l;
808      });
809      t[n] = {
810        error: r,
811        warning: o
812      };
813    }), t;
814  }
815  function fe(e) {
816    return e === "onBeforeRoute" ? {
817      error: 5 * 1e3,
818      warning: 1 * 1e3
819    } : ki.isPrerendering ? {
820      error: 2 * 60 * 1e3,
821      warning: 30 * 1e3
822    } : (a(!e.toLowerCase().includes("prerender")), {
823      error: 30 * 1e3,
824      warning: 4 * 1e3
825    });
826  }
827  function Hi() {
828    zt();
829  }
830  function Wi(e) {
831    return typeof e == "string" && Ni(e) ? `.${e}` : `[${JSON.stringify(e)}]`;
832  }
833  function Ni(e) {
834    return /^[a-z0-9\$_]+$/i.test(e);
835  }
836  Hi();
837  const Gi = "__VIKE__NOT_SERIALIZABLE__";
838  function Mi(e) {
839    return new Proxy(e, {
840      get(t, n) {
841        const i = e[n], r = Wi(n);
842        return h(i !== Gi, `Can't access pageContext${r} on the client side. Because it can't be serialized, see server logs.`), i;
843      }
844    });
845  }
846  function Ki(e, t) {
847    if (t.length > 0) {
848      const i = t.filter((r) => r.isErrorPage);
849      return i.length === 0 ? null : (h(i.length === 1, "Only one error page can be defined"), i[0].pageId);
850    }

851    const n = Ct(e.map(({ pageId: i }) => i).filter((i) => ie(i)));
852    if (h(n.length <= 1, `Only one _error.page.js is allowed, but found several: ${n.join(" ")}`), n.length > 0) {
853      const i = n[0];
854      return a(i), i;
855    }
856    return null;
857  }
858  function ie(e, t) {
859    return a(!e.includes("\\")), e.includes("/_error");
860  }
861  function Yi(e, t) {
862    if (t.length > 0) {
863      const n = t.find((i) => i.pageId === e);
864      return a(n), !!n.isErrorPage;
865    } else return ie(e);
866  }
867  function Ji(e) {
868    qi(e), Xi(e);
869  }
870  function qi(e) {
871    Yi(e.pageId, e._pageConfigs) && a(m(e, "is404", "boolean"));
872  }
873  function Xi(e) {
874    if (e.is404 === void 0 || e.is404 === null) return;
875    const t = e.pageProps || {};
876    if (!w(t)) {
877      C(false, "pageContext.pageProps should be an object", {
878        showStackTrace: true,
879        onlyOnce: true
880      });
881      return;
882    }
883    t.is404 = t.is404 || e.is404, e.pageProps = t;
884  }
885  function Zi(e) {
886    a(e.pageId), a("config" in e), a("configEntries" in e), Ji(e), "_pageId" in e || Object.defineProperty(e, "_pageId", {
887      get() {
888        return C(false, "pageContext._pageId has been renamed to pageContext.pageId", {
889          showStackTrace: true,
890          onlyOnce: true
891        }), e.pageId;
892      },
893      enumerable: false
894    }), Qi(e);
895  }
896  function Qi(e) {
897    let t = Object.getOwnPropertyDescriptors(e);
898    for (const n of Object.keys(e)) delete e[n];
899    t = Object.fromEntries(Object.entries(t).sort(([n], [i]) => vi(n, i))), Object.defineProperties(e, t);
900  }
901  function $e(e, t) {
902    {
903      const r = e;
904      a([
905        true,
906        false
907      ].includes(r.isHydration)), a([
908        true,
909        false,
910        null
911      ].includes(r.isBackwardNavigation));
912    }
913    const n = e.config.Page || e.exports.Page;
914    return y(e, {
915      Page: n
916    }), er(e), Zi(e), Mi(e);
917  }
918  function er(e) {
919    tr(e);
920  }
921  function tr(e) {
922    Object.entries(e).forEach(([t, n]) => {
923      delete e[t], e[t] = n;
924    });
925  }
926  const at = [
927    "urlPathname",
928    "urlParsed"
929  ], nr = [
930    "Page",
931    "pageExports",
932    "exports"
933  ];
934  function ir(e) {
935    [
936      ...nr,
937      ...at
938    ].forEach((n) => {
939      n in e && (at.includes(n) ? (a(n.startsWith("url")), C(false, `pageContext.${n} is already available in the browser when using Client Routing; adding '${n}' to passToClient has no effect`, {
940        onlyOnce: true
941      })) : C(false, `pageContext.${n} is a built-in that cannot be overriden; adding '${n}' to passToClient has no effect`, {
942        onlyOnce: true
943      }), delete e[n]);
944    });
945  }
946  const rr = "/";
947  function or(e, t, n) {
948    const { pathnameOriginal: i, searchOriginal: r, hashOriginal: o } = ce(e, rr);
949    e.startsWith("/") && a(e === `${i}${r || ""}${o || ""}`, {
950      url: e
951    });
952    const s = i.endsWith("/");
953    let l;
954    return l = i + (s ? "" : "/") + "index", a(l), l = l + t, `${l}${r || ""}${o || ""}`;
955  }
956  const ar = ".pageContext.json";
957  function sr(e) {
958    return or(e, ar);
959  }
960  function qt(e, { hookName: t, hookFilePath: n }) {
961    if (e == null) return;
962    a(!t.endsWith(")"));
963    const i = `The ${p.cyan("pageContext")} object provided by the ${t}() hook defined by ${n}`;
964    h(w(e), `${i} should be an object (but it's ${p.cyan(`typeof pageContext === ${JSON.stringify(typeof e)}`)} instead)`), h(!("isPageContext" in e), `${i} shouldn't be the whole ${p.cyan("pageContext")} object, see https://vike.dev/pageContext-manipulation#do-not-return-entire-pagecontext`), C(!("pageId" in e), `${i} sets ${p.cyan("pageContext.pageId")} which means that Vike's routing is overriden. This is an experimental feature: make sure to contact a vike maintainer before using this.`, {
965      onlyOnce: true
966    }), h(!("is404" in e), `${i} sets ${p.cyan("pageContext.is404")} which is forbidden, use ${p.cyan("throw render()")} instead, see https://vike.dev/render`);
967  }
968  function lr(e, t, n) {
969    a(!n.endsWith(" "));
970    const i = [], r = Object.keys(e);
971    for (const o of r) t.includes(o) || i.push(o);
972    h(i.length === 0, [
973      n,
974      "returned an object with following unknown keys:",
975      rt(i) + ".",
976      "Only following keys are allowed:",
977      rt(t) + "."
978    ].join(" "));
979  }
980  function ur(e, t) {
981    if (e == null) return;
982    const n = `The onBeforeRender() hook defined by ${t}`;
983    h(J(e), `${n} should return a plain JavaScript object, ${p.cyan("undefined")}, or ${p.cyan("null")}`), lr(e, [
984      "pageContext"

985    ], n), e.pageContext && qt(e.pageContext, {
986      hookName: "onBeforeRender",
987      hookFilePath: t
988    });
989  }
990  function dr(e, t) {
991    if (!J(e)) return false;
992    for (const n of Object.keys(e)) if (!t.includes(n)) return false;
993    return true;
994  }
995  function cr(e, t, n = (i) => i) {
996    if (a(e.length > 0), e.length === 1) return n(e[0]);
997    const i = e.slice(0, e.length - 1), r = e[e.length - 1];
998    return i.map(n).join(", ") + `, ${t} ` + n(r);
999  }
1000  Y() && ne();
1001  const Xt = "The guard() hook defined by";
1002  async function fr(e, t) {
1003    let n;
1004    if (e._pageFilesAll.length > 0 ? (a(e._pageConfigs.length === 0), n = gr(e.pageId, e._pageFilesAll)) : n = H(e, "guard"), !n) return;
1005    const i = n.hookFn;
1006    let r = e;
1007    const o = t(e);
1008    o && (r = o);
1009    const s = await U(() => i(r), n, e);
1010    h(s === void 0, `${Xt} ${n.hookFilePath} returns a value, but guard() shouldn't return any value`);
1011  }
1012  function gr(e, t) {
1013    const n = t.find((u) => u.pageId === e && u.fileType === ".page.route");
1014    if (!n) return null;
1015    const { filePath: i, fileExports: r } = n;
1016    a(r);
1017    const o = r.guard;
1018    if (!o) return null;
1019    const s = i, l = fe("guard");
1020    return h(N(o), `${Xt} ${s} should be a function`), {
1021      hookFn: o,
1022      hookName: "guard",
1023      hookFilePath: s,
1024      hookTimeout: l
1025    };
1026  }
1027  function pr(e) {
1028    const t = new Error("AbortRender");
1029    return y(t, {
1030      _pageContextAbort: e,
1031      [Zt]: true
1032    }), t;
1033  }
1034  const Zt = "_isAbortError";
1035  function st(e) {
1036    return typeof e == "object" && e !== null && Zt in e;
1037  }
1038  function hr(e) {
1039    return e._urlRewrite || e._urlRedirect || e.abortStatusCode ? (a(m(e, "_abortCall", "string")), true) : false;
1040  }
1041  function yr(e) {
1042    mr(e);
1043    const t = {
1044      _urlRewrite: null
1045    };
1046    return e.forEach((n) => {
1047      Object.assign(t, n);
1048    }), t;
1049  }
1050  function mr(e) {
1051    const t = [];
1052    e.forEach((n) => {
1053      const i = n._urlRewrite;
1054      {
1055        const r = t.indexOf(i);
1056        if (r !== -1) {
1057          const o = [
1058            ...t.slice(r),
1059            i
1060          ].map((s) => `render('${s}')`).join(" => ");
1061          h(false, `Infinite loop of render() calls: ${o}`);
1062        }
1063      }
1064      t.push(i);
1065    });
1066  }
1067  function vr(e, t) {
1068    const n = [
1069      e > 0 && p.cyan("throw render('/some-url')"),
1070      t > 0 && p.cyan("throw redirect('/some-url')")
1071    ].filter(Boolean).join(" and ");
1072    h(e + t <= 7, `Maximum chain length of 7 ${n} exceeded. Did you define an infinite loop of ${n}?`);
1073  }
1074  const Sr = "_pageContextInitIsPassedToClient", Qt = "_isServerSideError", en = L("client-routing-runtime/getPageContextFromHooks.ts", {});
1075  function Pr() {
1076    const e = pi();
1077    return h(!("urlOriginal" in e), "Adding 'urlOriginal' to passToClient is forbidden"), rn(e), y(e, {
1078      _hasPageContextFromServer: true
1079    }), e;
1080  }
1081  async function Er(e) {
1082    y(e, {
1083      _hasPageContextFromClient: false
1084    });
1085    for (const t of [
1086      "data",
1087      "onBeforeRender"
1088    ]) if (nn(t, e)) {
1089      const n = await tn(t, e);
1090      a(!("urlOriginal" in n)), Object.assign(e, n);
1091    }
1092    return e;
1093  }
1094  async function Ee(e, t) {
1095    const n = {
1096      _hasPageContextFromServer: false
1097    };
1098    if (!t && await _r(e)) {
1099      const i = await Ar(e);
1100      if ("is404ServerSideRouted" in i) return {
1101        is404ServerSideRouted: true
1102      };
1103      const { pageContextFromServer: r } = i;
1104      n._hasPageContextFromServer = true, a(!(Qt in r)), a(!("serverSideError" in r)), y(n, r);
1105    }
1106    return {
1107      pageContextFromServerHooks: n
1108    };
1109  }
1110  async function lt(e, t) {
1111    y(e, {
1112      _hasPageContextFromClient: false
1113    });
1114    for (const i of [
1115      "guard",
1116      "data",
1117      "onBeforeRender"
1118    ]) if (i === "guard") !t && !e._hasPageContextFromServer && await fr(e, (r) => $e(r));
1119    else if (a(i === "data" || i === "onBeforeRender"), nn(i, e) || !e._hasPageContextFromServer) {
1120      const r = await tn(i, e);
1121      a(!("urlOriginal" in r)), Object.assign(e, r);
1122    }
1123    return e;
1124  }
1125  async function tn(e, t) {
1126    const n = H(t, e);
1127    if (!n) return {};
1128    const i = $e(t), r = await U(() => n.hookFn(i), n, t), o = {};
1129    if (e === "onBeforeRender") {
1130      ur(r, n.hookFilePath);

1131      const s = r == null ? void 0 : r.pageContext;
1132      s && (y(o, {
1133        _hasPageContextFromClient: true
1134      }), y(o, s));
1135    } else {
1136      a(e === "data");
1137      const s = {
1138        data: r
1139      };
1140      r && y(o, {
1141        _hasPageContextFromClient: true
1142      }), y(o, s);
1143    }
1144    return o;
1145  }
1146  function Rr(e) {
1147    e[Sr] && (en.pageContextInitIsPassedToClient = true);
1148  }
1149  async function _r(e) {
1150    return !!en.pageContextInitIsPassedToClient || await ut("data", e) || await ut("onBeforeRender", e);
1151  }
1152  async function ut(e, t) {
1153    var _a2;
1154    if (t._pageConfigs.length > 0) {
1155      const n = Gt(t.pageId, t._pageConfigs), i = (_a2 = q(n, `${e}Env`)) == null ? void 0 : _a2.value;
1156      if (i === null) return false;
1157      a(w(i));
1158      const { client: r, server: o } = i;
1159      return a(r === true || r === void 0), a(o === true || o === void 0), a(r || o), !!o && !r;
1160    } else {
1161      if (e === "data") return false;
1162      a(e === "onBeforeRender");
1163      const { hasOnBeforeRenderServerSideOnlyHook: n } = await zi(t._pageFilesAll, t.pageId);
1164      return n;
1165    }
1166  }
1167  function nn(e, t) {
1168    var _a2;
1169    if (t._pageConfigs.length > 0) {
1170      const n = Gt(t.pageId, t._pageConfigs), i = ((_a2 = q(n, `${e}Env`)) == null ? void 0 : _a2.value) ?? {};
1171      return a(w(i)), !!i.client && !i.server;
1172    } else return false;
1173  }
1174  async function Ar(e) {
1175    const t = sr(e._urlRewrite ?? e.urlOriginal), n = await fetch(t);
1176    {
1177      const o = n.headers.get("content-type"), s = "application/json", l = o && o.includes(s);
1178      if (!l && n.status === 404) return M(e.urlOriginal), {
1179        is404ServerSideRouted: true
1180      };
1181      h(l, `Wrong Content-Type for ${t}: it should be ${s} but it's ${o} instead. Make sure to properly use pageContext.httpResponse.headers, see https://vike.dev/renderPage`);
1182    }
1183    const i = await n.text(), r = Oe(i);
1184    if (a(w(r)), hr(r)) throw pr(r);
1185    if ("serverSideError" in r || Qt in r) throw Vn("pageContext couldn't be fetched because an error occurred on the server-side");
1186    return a(m(r, "pageId", "string")), rn(r), {
1187      pageContextFromServer: r
1188    };
1189  }
1190  function rn(e) {
1191    ir(e);
1192  }
1193  async function on(e, t, n, i) {
1194    const r = Li(t, e);
1195    await Promise.all(r.map(async (o) => {
1196      await U(() => o.hookFn(i), o, n);
1197    }));
1198  }
1199  const Tr = [
1200    "clientRouting"
1201  ];
1202  function br(e) {
1203    Tr.forEach((t) => {
1204      if (a(e.fileExports), !(t in e.fileExports)) return;
1205      const n = `The value of \`${t}\` is only allowed to be \`true\`.`;
1206      h(e.fileExports[t] !== false, `${e.filePath} has \`export { ${t} }\` with the value \`false\` which is prohibited: remove \`export { ${t} }\` instead. (${n})`), h(e.fileExports[t] === true, `${e.filePath} has \`export { ${t} }\` with a forbidden value. ${n}`);
1207    });
1208  }
1209  const an = [
1210    "render",
1211    "clientRouting",
1212    "prerender",
1213    "doNotPrerender"
1214  ];
1215  function Cr(e, t) {
1216    h(!an.includes(e), `${t} has \`export default { ${e} }\` which is prohibited, use \`export { ${e} }\` instead.`);
1217  }
1218  function wr(e, t, n) {
1219    const i = zr({
1220      pageConfigGlobalValues: e,
1221      pageConfigValues: n
1222    });
1223    let r;
1224    if (t.isErrorPage) r = {
1225      ...i,
1226      isErrorPage: true
1227    };
1228    else {
1229      const o = i.config.route ?? t.routeFilesystem.routeString;
1230      r = {
1231        ...i,
1232        route: o
1233      };
1234    }
1235    return [
1236      t.pageId,
1237      r
1238    ];
1239  }
1240  function zr({ pageConfigGlobalValues: e, pageConfigValues: t }) {
1241    const n = ln({
1242      pageConfigGlobalValues: e,
1243      pageConfigValues: t
1244    });
1245    return sn(n);
1246  }
1247  function sn(e) {
1248    const t = e;
1249    return {
1250      config: t.config,
1251      _source: t.source,
1252      _sources: t.sources,
1253      _from: t.from
1254    };
1255  }
1256  function ln({ pageConfigGlobalValues: e, pageConfigValues: t }) {
1257    const n = {
1258      ...e,
1259      ...t
1260    };
1261    return dn({
1262      configValues: n
1263    });
1264  }
1265  function un({ pageConfigGlobalValues: e }) {
1266    const t = dn({
1267      configValues: e
1268    });
1269    return sn(t);
1270  }
1271  function xr(e, t, n) {
1272    const i = {}, r = {}, o = {};
1273    e.forEach((S) => {

1274      jr(S).forEach(({ exportName: P, exportValue: I, isFromDefaultExport: x }) => {
1275        a(P !== "default"), o[P] = o[P] ?? [], o[P].push({
1276          exportValue: I,
1277          exportSource: `${S.filePath} > ${x ? `\`export default { ${P} }\`` : `\`export { ${P} }\``}`,
1278          filePath: S.filePath,
1279          _filePath: S.filePath,
1280          _fileType: S.fileType,
1281          _isFromDefaultExport: x
1282        });
1283      });
1284    });
1285    let s, l, u;
1286    if (t) {
1287      const S = ln({
1288        pageConfigGlobalValues: n.configValues,
1289        pageConfigValues: t.configValues
1290      });
1291      s = S.source, l = S.sources, u = S.from, Object.assign(i, S.config), Object.assign(r, S.configEntries), Object.assign(o, S.exportsAll);
1292    } else s = {}, l = {}, u = {
1293      configsStandard: {},
1294      configsCumulative: {},
1295      configsComputed: {}
1296    };
1297    const d = Ir(), c = {};
1298    return Object.entries(o).forEach(([S, R]) => {
1299      R.forEach(({ exportValue: P, _fileType: I, _isFromDefaultExport: x }) => {
1300        c[S] = c[S] ?? P, I === ".page" && !x && (S in d || (d[S] = P));
1301      });
1302    }), a(!("default" in c)), a(!("default" in o)), {
1303      config: i,
1304      from: u,
1305      source: s,
1306      sources: l,
1307      configEntries: r,
1308      exports: c,
1309      exportsAll: o,
1310      pageExports: d
1311    };
1312  }
1313  function dn(e) {
1314    const t = {}, n = {}, i = {}, r = {}, o = {}, s = {
1315      configsStandard: {},
1316      configsCumulative: {},
1317      configsComputed: {}
1318    }, l = (u, d) => {
1319      r[d] = u, o[d] ?? (o[d] = []), o[d].push(u);
1320    };
1321    return Object.entries(e.configValues).forEach(([u, d]) => {
1322      const { value: c } = d, f = Mt(d.definedAtData), S = Yt("Config", u, d.definedAtData);
1323      if (t[u] = t[u] ?? c, n[u] = n[u] ?? [], a(n[u].length === 0), n[u].push({
1324        configValue: c,
1325        configDefinedAt: S,
1326        configDefinedByFile: f
1327      }), d.type === "standard") {
1328        const P = {
1329          type: "configsStandard",
1330          value: d.value,
1331          definedAt: Q(d.definedAtData, u)
1332        };
1333        l(P, u), s.configsStandard[u] = P;
1334      }
1335      if (d.type === "cumulative") {
1336        const P = {
1337          type: "configsCumulative",
1338          values: d.value.map((I, x) => {
1339            const $ = d.definedAtData[x];
1340            a($);
1341            const _ = Q($, u);
1342            return {
1343              value: I,
1344              definedAt: _
1345            };
1346          })
1347        };
1348        l(P, u), s.configsCumulative[u] = P;
1349      }
1350      if (d.type === "computed") {
1351        const P = {
1352          type: "configsComputed",
1353          value: d.value
1354        };
1355        l(P, u), s.configsComputed[u] = P;
1356      }
1357      const R = u;
1358      i[R] = i[R] ?? [], i[R].push({
1359        exportValue: c,
1360        exportSource: S,
1361        filePath: f,
1362        _filePath: f,
1363        _fileType: null,
1364        _isFromDefaultExport: null
1365      });
1366    }), {
1367      config: t,
1368      configEntries: n,
1369      exportsAll: i,
1370      source: r,
1371      sources: o,
1372      from: s
1373    };
1374  }
1375  function jr(e) {
1376    const { filePath: t, fileExports: n } = e;
1377    a(n), a(Ht(t));
1378    const i = [];
1379    return Object.entries(n).sort(mi(([r]) => r === "default")).forEach(([r, o]) => {
1380      let s = r === "default";
1381      if (s) if (Ci(t)) r = "Page";
1382      else {
1383        h(w(o), `The ${p.cyan("export default")} of ${t} should be an object.`), Object.entries(o).forEach(([l, u]) => {
1384          Cr(l, t), i.push({
1385            exportName: l,
1386            exportValue: u,
1387            isFromDefaultExport: s
1388          });
1389        });
1390        return;
1391      }
1392      i.push({
1393        exportName: r,
1394        exportValue: o,
1395        isFromDefaultExport: s
1396      });
1397    }), i.forEach(({ exportName: r, isFromDefaultExport: o }) => {
1398      a(!(o && an.includes(r)));
1399    }), i;
1400  }
1401  function Ir() {
1402    return new Proxy({}, {
1403      get(...e) {
1404        return Y() || C(false, "`pageContext.pageExports` is outdated. Use `pageContext.exports` instead, see https://vike.dev/exports", {
1405          onlyOnce: true,
1406          showStackTrace: true
1407        }), Reflect.get(...e);
1408      }
1409    });
1410  }
1411  async function Dr(e, t) {
1412    const n = un({
1413      pageConfigGlobalValues: t.configValues
1414    });
1415    return y(e, {
1416      isPageContext: true,
1417      ...n
1418    }, true), await on("onCreatePageContext", t, e, e), e;
1419  }
1420  function Or(e) {
1421    a(typeof e.urlOriginal == "string"), pn(e);
1422    const t = {};
1423    return me(t, "urlPathname", {
1424      get: fn,
1425      enumerable: true,
1426      configurable: true
1427    }), me(t, "url", {
1428      get: kr,
1429      enumerable: false,
1430      configurable: true
1431    }), me(t, "urlParsed", {
1432      get: Fr,
1433      enumerable: true,
1434      configurable: true
1435    }), t;
1436  }
1437  function cn(e) {
1438    const t = (s) => a(typeof n == "string", {
1439      src: s,
1440      urlResolved: n
1441    });
1442    let n, i;
1443    e.urlLogical ? (n = e.urlLogical, i = false, t(1)) : e._urlRewrite ? (n = e._urlRewrite, i = false, t(2)) : (n = e.urlOriginal, i = true, t(3)), t(4);
1444    let r = e._urlHandler;
1445    r || (r = (s) => s), n = r(n);
1446    const o = i ? e._baseServer : "/";
1447    return ce(n, o);
1448  }
1449  function fn() {
1450    const { pathname: e } = cn(this), t = e;
1451    return a(t.startsWith("/")), t;
1452  }
1453  function kr() {
1454    return C(false, "`pageContext.url` is outdated. Use `pageContext.urlPathname`, `pageContext.urlParsed`, or `pageContext.urlOriginal` instead. (See https://vike.dev/migration/0.4.23 for more information.)", {
1455      onlyOnce: true,
1456      showStackTrace: true
1457    }), fn.call(this);
1458  }
1459  function Fr() {
1460    const { isBaseMissing: e, ...t } = cn(this), n = Y(), i = (o) => {
1461      C(n, `pageContext.urlParsed.${o} isn't available on the server-side (HTTP requests don't include the URL hash)`, {
1462        onlyOnce: true,
1463        showStackTrace: true
1464      });
1465    }, r = {
1466      ...t,
1467      get hash() {
1468        return i("hash"), t.hash;
1469      },
1470      get hashOriginal() {
1471        return i("hashOriginal"), t.hashOriginal;
1472      },
1473      get hashString() {

1474        return C(false, "pageContext.urlParsed.hashString has been renamed to pageContext.urlParsed.hashOriginal", {
1475          onlyOnce: true,
1476          showStackTrace: true
1477        }), i("hashString"), t.hashOriginal;
1478      },
1479      get searchString() {
1480        return C(false, "pageContext.urlParsed.searchString has been renamed to pageContext.urlParsed.searchOriginal", {
1481          onlyOnce: true,
1482          showStackTrace: true
1483        }), t.searchOriginal;
1484      }
1485    };
1486    return re(r, "hashString", false), re(r, "searchString", false), n || (re(r, "hash", false), re(r, "hashOriginal", false)), r;
1487  }
1488  function gn(e) {
1489    a(typeof e.urlOriginal == "string"), a(typeof e.urlPathname == "string"), a(J(e.urlParsed)), a(e.urlPathname === e.urlParsed.pathname), pn(e);
1490  }
1491  function pn(e) {
1492    "urlPathname" in e ? (a(typeof e.urlPathname == "string"), a(ye(e, "urlPathname")), a(ye(e, "urlParsed")), a(ye(e, "url"))) : (a(!("urlParsed" in e)), a(!("url" in e)));
1493  }
1494  function hn() {
1495    const e = "/";
1496    return a(Lr(e)), e;
1497  }
1498  function Lr(e) {
1499    return e.startsWith("/");
1500  }
1501  function $r(e) {
1502    const t = ".page.", n = B(e.split(t), 0, -1).join(t);
1503    return a(!n.includes("\\")), n;
1504  }
1505  const Vr = [
1506    ".page",
1507    ".page.server",
1508    ".page.route",
1509    ".page.client",
1510    ".css"
1511  ];
1512  function Ur(e) {
1513    if (e.endsWith(".css")) return ".css";
1514    a(Ht(e), e);
1515    const n = e.split("/").slice(-1)[0].split("."), i = n.slice(-3)[0], r = n.slice(-2)[0];
1516    if (r === "page") return ".page";
1517    if (a(i === "page", e), r === "server") return ".page.server";
1518    if (r === "client") return ".page.client";
1519    if (r === "route") return ".page.route";
1520    a(false, e);
1521  }
1522  function yn(e) {
1523    const t = (o) => r.pageId === o || r.isDefaultPageFile && (dt(r.filePath) || Br(o, r.filePath)), n = Ur(e), r = {
1524      filePath: e,
1525      fileType: n,
1526      isEnv: (o) => {
1527        if (a(n !== ".page.route"), o === "CLIENT_ONLY") return n === ".page.client" || n === ".css";
1528        if (o === "SERVER_ONLY") return n === ".page.server";
1529        if (o === "CLIENT_AND_SERVER") return n === ".page";
1530        a(false);
1531      },
1532      isRelevant: t,
1533      isDefaultPageFile: Re(e),
1534      isRendererPageFile: n !== ".css" && Re(e) && dt(e),
1535      isErrorPageFile: ie(e),
1536      pageId: $r(e)
1537    };
1538    return r;
1539  }
1540  function Re(e) {
1541    return ie(e) ? false : e.includes("/_default");
1542  }
1543  function dt(e) {
1544    return e.includes("/renderer/");
1545  }
1546  function Br(e, t) {
1547    a(!e.endsWith("/")), a(!t.endsWith("/")), a(Re(t));
1548    const n = B(t.split("/"), 0, -1).filter((i) => i !== "_default").join("/");
1549    return e.startsWith(n);
1550  }
1551  const Hr = [
1552    "$$registrations",
1553    "_rerender_only"
1554  ], Wr = [
1555    ".md",
1556    ".mdx"
1557  ];
1558  function Nr(e, t, n) {
1559    const i = Object.keys(e), r = (d) => d === "default" || d === n, o = i.filter(r), s = p.code("export default"), l = p.code(`export { ${n} }`);
1560    o.length === 0 && h(false, `${t} should have ${l} or ${s}`), o.length === 2 && h(false, `${t} is ambiguous: remove ${s} or ${l}`), a(o.length === 1);
1561    const u = i.filter((d) => !r(d)).filter((d) => !Hr.includes(d));
1562    Wr.some((d) => t.endsWith(d)) || u.forEach((d) => {
1563      C(false, `${t} unexpected ${p.cyan(`export { ${d} }`)}, see https://vike.dev/no-side-exports`, {
1564        onlyOnce: true
1565      });
1566    });
1567  }
1568  function Gr(e, t) {
1569    const n = e.map((r) => {
1570      const o = _e(r.configValuesSerialized);
1571      return Mr(o), {
1572        ...r,
1573        configValues: o
1574      };
1575    }), i = {
1576      configValues: {}
1577    };
1578    {
1579      const r = _e(t.configValuesSerialized);
1580      Object.assign(i.configValues, r);
1581    }
1582    return {
1583      pageConfigs: n,
1584      pageConfigGlobal: i
1585    };
1586  }
1587  function Mr(e) {
1588    const t = "route", n = e[t];
1589    if (!n) return;
1590    const { value: i, definedAtData: r } = n, o = typeof i;
1591    a(r);
1592    const s = ji("Config", t, r);
1593    h(o === "string" || N(i), `${s} has an invalid type '${o}': it should be a string or a function instead, see https://vike.dev/route`);
1594  }
1595  function _e(e) {
1596    const t = {};
1597    return Object.entries(e).forEach(([i, r]) => {
1598      let o;
1599      if (r.type === "cumulative") {
1600        const { valueSerialized: s, ...l } = r;
1601        o = {
1602          value: s.map((d, c) => {
1603            const { value: f, sideExports: S } = ct(d, i, () => {
1604              const R = r.definedAtData[c];
1605              return a(R), R;
1606            });
1607            return n(S), f;
1608          }),
1609          ...l
1610        };
1611      } else {
1612        const { valueSerialized: s, ...l } = r, { value: u, sideExports: d } = ct(s, i, () => {
1613          a(r.type !== "computed");
1614          const { definedAtData: c } = r;
1615          return Array.isArray(c) ? c[0] : c;
1616        });
1617        n(d), o = {
1618          value: u,
1619          ...l
1620        };
1621      }
1622      t[i] = o;
1623    }), t;
1624    function n(i) {

1625      i.forEach((r) => {
1626        const { configName: o, configValue: s } = r;
1627        t[o] || (t[o] = s);
1628      });
1629    }
1630  }
1631  function ct(e, t, n) {
1632    if (e.type === "js-serialized") {
1633      let { value: i } = e;
1634      return i = ke(i), {
1635        value: i,
1636        sideExports: []
1637      };
1638    }
1639    if (e.type === "pointer-import") {
1640      const { value: i } = e;
1641      return {
1642        value: i,
1643        sideExports: []
1644      };
1645    }
1646    if (e.type === "plus-file") {
1647      const i = n(), { exportValues: r } = e;
1648      a(!i.definedBy), Nr(r, i.filePathToShowToUser, t);
1649      let o, s = false;
1650      const l = [];
1651      return Object.entries(r).forEach(([u, d]) => {
1652        u !== "default" && u !== t ? l.push({
1653          configName: u,
1654          configValue: {
1655            type: "standard",
1656            value: d,
1657            definedAtData: {
1658              filePathToShowToUser: i.filePathToShowToUser,
1659              fileExportPathToShowToUser: [
1660                u
1661              ]
1662            }
1663          }
1664        }) : (o = d, a(!s), s = true);
1665      }), a(s), {
1666        value: o,
1667        sideExports: l
1668      };
1669    }
1670    a(false);
1671  }
1672  function Kr(e) {
1673    a(m(e, "pageFilesLazy", "object")), a(m(e, "pageFilesEager", "object")), a(m(e, "pageFilesExportNamesLazy", "object")), a(m(e, "pageFilesExportNamesEager", "object")), a(m(e.pageFilesLazy, ".page")), a(m(e.pageFilesLazy, ".page.client") || m(e.pageFilesLazy, ".page.server")), a(m(e, "pageFilesList", "string[]")), a(m(e, "pageConfigsSerialized")), a(m(e, "pageConfigGlobalSerialized"));
1674    const { pageConfigsSerialized: t, pageConfigGlobalSerialized: n } = e;
1675    Yr(t), Jr(n);
1676    const { pageConfigs: i, pageConfigGlobal: r } = Gr(t, n), o = {};
1677    oe(e.pageFilesLazy).forEach(({ filePath: l, pageFile: u, globValue: d }) => {
1678      u = o[l] = o[l] ?? u;
1679      const c = d;
1680      ft(c), u.loadFile = async () => {
1681        "fileExports" in u || (u.fileExports = await c(), br(u));
1682      };
1683    }), oe(e.pageFilesExportNamesLazy).forEach(({ filePath: l, pageFile: u, globValue: d }) => {
1684      u = o[l] = o[l] ?? u;
1685      const c = d;
1686      ft(c), u.loadExportNames = async () => {
1687        if (!("exportNames" in u)) {
1688          const f = await c();
1689          a(m(f, "exportNames", "string[]"), u.filePath), u.exportNames = f.exportNames;
1690        }
1691      };
1692    }), oe(e.pageFilesEager).forEach(({ filePath: l, pageFile: u, globValue: d }) => {
1693      u = o[l] = o[l] ?? u;
1694      const c = d;
1695      a(w(c)), u.fileExports = c;
1696    }), oe(e.pageFilesExportNamesEager).forEach(({ filePath: l, pageFile: u, globValue: d }) => {
1697      u = o[l] = o[l] ?? u;
1698      const c = d;
1699      a(w(c)), a(m(c, "exportNames", "string[]"), u.filePath), u.exportNames = c.exportNames;
1700    }), e.pageFilesList.forEach((l) => {
1701      o[l] = o[l] ?? yn(l);
1702    });
1703    const s = Object.values(o);
1704    return s.forEach(({ filePath: l }) => {
1705      a(!l.includes("\\"));
1706    }), {
1707      pageFilesAll: s,
1708      pageConfigs: i,
1709      pageConfigGlobal: r
1710    };
1711  }
1712  function oe(e) {
1713    const t = [];
1714    return Object.entries(e).forEach(([n, i]) => {
1715      a(Vr.includes(n)), a(w(i)), Object.entries(i).forEach(([r, o]) => {
1716        const s = yn(r);
1717        a(s.fileType === n), t.push({
1718          filePath: r,
1719          pageFile: s,
1720          globValue: o
1721        });
1722      });
1723    }), t;
1724  }
1725  function ft(e) {
1726    a(N(e));
1727  }
1728  function Yr(e) {
1729    a(W(e)), e.forEach((t) => {
1730      a(w(t)), a(m(t, "pageId", "string")), a(m(t, "routeFilesystem")), a(m(t, "configValuesSerialized"));
1731    });
1732  }
1733  function Jr(e) {
1734    a(m(e, "configValuesSerialized"));
1735  }
1736  function qr(e) {
1737    const { pageFilesAll: t, pageConfigs: n, pageConfigGlobal: i } = Kr(e), r = Xr(t, n), o = un({
1738      pageConfigGlobalValues: i.configValues
1739    }), s = Object.fromEntries(n.map((l) => wr(i.configValues, l, l.configValues)));
1740    return {
1741      pageFilesAll: t,
1742      allPageIds: r,
1743      pageConfigs: n,
1744      pageConfigGlobal: i,
1745      globalConfig: o,
1746      pageConfigsUserFriendly: s
1747    };
1748  }
1749  function Xr(e, t) {
1750    const n = e.filter(({ isDefaultPageFile: o }) => !o).map(({ pageId: o }) => o), i = Ct(n), r = t.map((o) => o.pageId);
1751    return [
1752      ...i,
1753      ...r
1754    ];
1755  }
1756  async function Zr(e, t, n) {
1757    const i = Qr(e), r = await (n == null ? void 0 : n(i));
1758    return y(i, r), t.globalContext ? y(t.globalContext, i) : (t.globalContext = i, await on("onCreateGlobalContext", i._pageConfigGlobal, null, i)), t.globalContext;
1759  }
1760  function Qr(e) {
1761    const { pageFilesAll: t, allPageIds: n, pageConfigs: i, pageConfigGlobal: r, globalConfig: o, pageConfigsUserFriendly: s } = qr(e);
1762    return {
1763      isGlobalContext: true,
1764      _virtualFileExports: e,
1765      _pageFilesAll: t,
1766      _pageConfigs: i,
1767      _pageConfigGlobal: r,
1768      _allPageIds: n,
1769      config: o.config,
1770      pages: s
1771    };
1772  }
1773  const F = L("createGetGlobalContextClient.ts", (() => {
1774    const { promise: e, resolve: t } = Lt();
1775    return {
1776      globalContextPromise: e,
1777      globalContextPromiseResolve: t
1778    };
1779  })());
1780  function eo(e, t, n) {
1781    return a(F.isClientRouting === void 0 || F.isClientRouting === t), F.isClientRouting = t, i(), i;
1782    async function i() {
1783      if (F.globalContext && F.globalContext._virtualFileExports !== e) return F.globalContext;
1784      const r = await Zr(e, F, async (o) => {
1785        const s = {
1786          isClientSide: true
1787        };
1788        return y(s, hi()), y(s, await (n == null ? void 0 : n(o))), s;
1789      });
1790      return a(F.globalContext), F.globalContextPromiseResolve(F.globalContext), r;
1791    }
1792  }
1793  function to(e, t) {
1794    const i = t.filter(({ filesystemRoot: o }) => e.startsWith(o)).sort(ue(({ filesystemRoot: o }) => o.length))[0];
1795    let r;
1796    if (i) {
1797      const { filesystemRoot: o, urlRoot: s } = i, l = {
1798        pageId: e,
1799        filesystemRoot: o,
1800        urlRoot: s
1801      };
1802      a(s.startsWith("/") && e.startsWith("/") && o.startsWith("/"), l), a(e.startsWith(o), l), o !== "/" ? (a(!o.endsWith("/"), l), r = B(e, o.length, 0)) : r = e, a(r.startsWith("/"), l), r = s + (s.endsWith("/") ? "" : "/") + B(r, 1, 0

1802);
1803    } else r = e;
1804    return a(r.startsWith("/")), r = r.split("/").filter((o) => o !== "pages" && o !== "src" && o !== "index").join("/"), a(!r.includes(".page.")), a(!r.endsWith(".")), r.endsWith("/index") && (r = B(r, 0, -6)), r === "" && (r = "/"), a(r.startsWith("/")), a(!r.endsWith("/") || r === "/"), r;
1805  }
1806  async function no(e, t, n) {
1807    gn(t);
1808    let i = e(t);
1809    if (mn(i, `The Route Function ${n}`), i = await i, i === false) return null;
1810    if (i === true && (i = {}), h(J(i), `The Route Function ${n} should return a boolean or a plain JavaScript object (but it's ${p.cyan(`typeof result === ${JSON.stringify(typeof i)}`)} instead)`), "match" in i) {
1811      const { match: s } = i;
1812      if (h(typeof s == "boolean", `The ${p.cyan("match")} value returned by the Route Function ${n} should be a boolean.`), !s) return null;
1813    }
1814    let r = null;
1815    "precedence" in i && (r = i.precedence, h(typeof r == "number", `The ${p.cyan("precedence")} value returned by the Route Function ${n} should be a number.`)), vn(i, `The ${p.cyan("routeParams")} object returned by the Route Function ${n} should`);
1816    const o = i.routeParams || {};
1817    return h(!("pageContext" in i), `Providing ${p.cyan("pageContext")} in Route Functions is prohibited, see https://vike.dev/route-function#cannot-provide-pagecontext`), a(J(o)), Object.keys(i).forEac

1817h((s) => {
1818      h(s === "match" || s === "routeParams" || s === "precedence", `The Route Function ${n} returned an object with an unknown property ${p.cyan(s)} (the known properties are ${p.cyan("match")}, ${p.cyan("routeParams")}, and ${p.cyan("precedence")})`);
1819    }), {
1820      precedence: r,
1821      routeParams: o
1822    };
1823  }
1824  function mn(e, t) {
1825    C(!Ei(e), `${t} returned a promise, but asynchronous routing is deprecated and will be removed in the next major release, see https://vike.dev/route-function#async`, {
1826      onlyOnce: true
1827    });
1828  }
1829  function gt() {
1830    const e = p.cyan("iKnowThePerformanceRisksOfAsyncRouteFunctions");
1831    C(false, `${e} is deprecated and will be removed in the next major release`, {
1832      onlyOnce: true
1833    });
1834  }
1835  function vn(e, t) {
1836    a(t.endsWith(" should")), m(e, "routeParams") && (a(t.endsWith(" should")), h(m(e, "routeParams", "string{}"), `${t} be an object holding string values.`));
1837  }
1838  async function io(e, t, n, i) {
1839    await Promise.all(e.filter((l) => l.fileType === ".page.route").map((l) => {
1840      var _a2;
1841      return (_a2 = l.loadFile) == null ? void 0 : _a2.call(l);
1842    }));
1843    const { onBeforeRouteHook: r, filesystemRoots: o } = oo(e, t, n);
1844    return {
1845      pageRoutes: ro(o, e, t, i),
1846      onBeforeRouteHook: r
1847    };
1848  }
1849  function ro(e, t, n, i) {
1850    const r = [];
1851    if (n.length > 0) {
1852      a(e === null);
1853      const o = true;
1854      n.filter((s) => !s.isErrorPage).forEach((s) => {
1855        const l = s.pageId;
1856        let u = null;
1857        {
1858          const d = "route", c = q(s, d);
1859          if (c) {
1860            const f = c.value;
1861            a(c.definedAtData);
1862            const S = Q(c.definedAtData, d);
1863            typeof f == "string" ? u = {
1864              pageId: l,
1865              comesFromV1PageConfig: o,
1866              routeString: f,
1867              routeDefinedAtString: S,
1868              routeType: "STRING"
1869            } : (a(N(f)), q(s, "iKnowThePerformanceRisksOfAsyncRouteFunctions", "boolean") && gt(), u = {
1870              pageId: l,
1871              comesFromV1PageConfig: o,
1872              routeFunction: f,
1873              routeDefinedAtString: S,
1874              routeType: "FUNCTION"
1875            });
1876          }
1877        }
1878        if (!u) {
1879          const { routeFilesystem: d } = s;
1880          a(d);
1881          const { routeString: c, definedAtLocation: f } = d;
1882          a(d.routeString.startsWith("/")), u = {
1883            pageId: l,
1884            routeFilesystemDefinedBy: f,
1885            comesFromV1PageConfig: o,
1886            routeString: c,
1887            routeDefinedAtString: null,
1888            routeType: "FILESYSTEM"
1889          };
1890        }
1891        a(u), r.push(u);
1892      });
1893    }
1894    if (n.length === 0) {
1895      a(e);
1896      const o = false;
1897      i.filter((s) => !ie(s)).forEach((s) => {
1898        const l = t.find((u) => u.pageId === s && u.fileType === ".page.route");
1899        if (!l || !("default" in l.fileExports)) {
1900          const u = to(s, e);
1901          a(u.startsWith("/")), a(!u.endsWith("/") || u === "/"), r.push({
1902            pageId: s,
1903            comesFromV1PageConfig: o,
1904            routeString: u,
1905            routeDefinedAtString: null,
1906            routeFilesystemDefinedBy: `${s}.page.*`,
1907            routeType: "FILESYSTEM"
1908          });
1909        } else {
1910          const { filePath: u, fileExports: d } = l;
1911          if (a(d.default), m(d, "default", "string")) {
1912            const c = d.default;
1913            h(c.startsWith("/"), `A Route String should start with a leading slash '/' but ${u} has \`export default '${c}'\`. Make sure to \`export default '/${c}'\` instead.`), r.push({
1914              pageId: s,
1915              comesFromV1PageConfig: o,
1916              routeString: c,
1917              routeDefinedAtString: u,
1918              routeType: "STRING"
1919            });
1920            return;
1921          }
1922          if (m(d, "default", "function")) {
1923            const c = d.default;
1924            "iKnowThePerformanceRisksOfAsyncRouteFunctions" in d && gt(), r.push({
1925              pageId: s,
1926              comesFromV1PageConfig: o,
1927              routeFunction: c,
1928              routeDefinedAtString: u,
1929              routeType: "FUNCTION"
1930            });
1931            return;
1932          }
1933          h(false, `The default export of ${u} should be a string or a function.`);
1934        }
1935      });
1936    }
1937    return r;
1938  }
1939  function oo(e, t, n) {
1940    if (t.length > 0) return {
1941      onBeforeRouteHook: Fi(n, "onBeforeRoute"),
1942      filesystemRoots: null
1943    };
1944    let i = null;
1945    const r = [];
1946    return e.filter((o) => o.fileType === ".page.route" && o.isDefaultPageFile).forEach(({ filePath: o, fileExports: s }) => {
1947      if (a(s), "onBeforeRoute" in s) {
1948        h(m(s, "onBeforeRoute", "function"), `\`export { onBeforeRoute }\` of ${o} should be a function.`);
1949        const { onBeforeRoute: l } = s, u = "onBeforeRoute";
1950        i = {
1951          hookFilePath: o,
1952          hookFn: l,
1953          hookName: u,
1954          hookTimeout: fe(u)
1955        };
1956      }

1957      "filesystemRoutingRoot" in s && (h(m(s, "filesystemRoutingRoot", "string"), `\`export { filesystemRoutingRoot }\` of ${o} should be a string.`), h(m(s, "filesystemRoutingRoot", "string"), `\`export { filesystemRoutingRoot }\` of ${o} is \`'${s.filesystemRoutingRoot}'\` but it should start with a leading slash \`/\`.`), r.push({
1958        filesystemRoot: ao(o),
1959        urlRoot: s.filesystemRoutingRoot
1960      }));
1961    }), {
1962      onBeforeRouteHook: i,
1963      filesystemRoots: r
1964    };
1965  }
1966  function ao(e) {
1967    a(e.startsWith("/")), a(!e.endsWith("/"));
1968    const t = e.split("/"), n = B(t, 0, -1).join("/") || "/";
1969    return a(n.startsWith("/")), a(!n.endsWith("/") || n === "/"), n;
1970  }
1971  const so = "ko|hk";
1972  function j(e) {
1973    const t = e.replace(/^\//, "").replace(/\/$/, ""), n = t ? `/${t}` : "", i = new RegExp(`^/(${so})${n}/?$`);
1974    return function(o) {
1975      const s = o.urlPathname.match(i);
1976      return s ? {
1977        routeParams: {
1978          lang: s[1]
1979        }
1980      } : false;
1981    };
1982  }
1983  const lo = j("GuideDiscord"), uo = Object.freeze(Object.defineProperty({
1984    __proto__: null,
1985    route: lo
1986  }, Symbol.toStringTag, {
1987    value: "Module"
1988  })), co = j("aboutUs"), fo = Object.freeze(Object.defineProperty({
1989    __proto__: null,
1990    route: co
1991  }, Symbol.toStringTag, {
1992    value: "Module"
1993  })), go = j("affiliate"), po = Object.freeze(Object.defineProperty({
1994    __proto__: null,
1995    route: go
1996  }, Symbol.toStringTag, {
1997    value: "Module"
1998  })), ho = j("aml-policy"), yo = Object.freeze(Object.defineProperty({
1999    __proto__: null,
2000    route: ho
2001  }, Symbol.toStringTag, {
2002    value: "Module"
2003  })), Sn = "ko|hk";
2004  function mo() {
2005    const e = new RegExp(`^/(${Sn})/blog/?$`);
2006    return function(n) {
2007      const i = n.urlPathname.match(e);
2008      return i ? {
2009        routeParams: {
2010          lang: i[1]
2011        }
2012      } : false;
2013    };
2014  }
2015  function vo() {
2016    const e = new RegExp(`^/(${Sn})/blog/([^/]+)/?$`);
2017    return function(n) {
2018      const i = n.urlPathname.match(e);
2019      return i ? {
2020        routeParams: {
2021          lang: i[1],
2022          slug: i[2]
2023        }
2024      } : false;
2025    };
2026  }
2027  const So = mo(), Po = Object.freeze(Object.defineProperty({
2028    __proto__: null,
2029    route: So
2030  }, Symbol.toStringTag, {
2031    value: "Module"
2032  })), Eo = vo(), Ro = Object.freeze(Object.defineProperty({
2033    __proto__: null,
2034    route: Eo
2035  }, Symbol.toStringTag, {
2036    value: "Module"
2037  })), _o = j("contactUs"), Ao = Object.freeze(Object.defineProperty({
2038    __proto__: null,
2039    route: _o
2040  }, Symbol.toStringTag, {
2041    value: "Module"
2042  })), To = j("cooperate"), bo = Object.freeze(Object.defineProperty({
2043    __proto__: null,
2044    route: To
2045  }, Symbol.toStringTag, {
2046    value: "Module"
2047  })), Co = j("copyright"), wo = Object.freeze(Object.defineProperty({
2048    __proto__: null,
2049    route: Co
2050  }, Symbol.toStringTag, {
2051    value: "Module"
2052  })), zo = j("help-recharge"), xo = Object.freeze(Object.defineProperty({
2053    __proto__: null,
2054    route: zo
2055  }, Symbol.toStringTag, {
2056    value: "Module"
2057  })), jo = j("help-useGpt"), Io = Object.freeze(Object.defineProperty({
2058    __proto__: null,
2059    route: jo
2060  }, Symbol.toStringTag, {
2061    value: "Module"
2062  })), Do = j("help-useNetflix"), Oo = Object.freeze(Object.defineProperty({
2063    __proto__: null,
2064    route: Do
2065  }, Symbol.toStringTag, {
2066    value: "Module"
2067  })), ko = j("help-ytbRegion"), Fo = Object.freeze(Object.defineProperty({
2068    __proto__: null,
2069    route: ko
2070  }, Symbol.toStringTag, {
2071    value: "Module"
2072  })), Lo = j(""), $o = Object.freeze(Object.defineProperty({
2073    __proto__: null,
2074    route: Lo
2075  }, Symbol.toStringTag, {
2076    value: "Module"
2077  })), Vo = j("privacy-policy"), Uo = Object.freeze(Object.defineProperty({
2078    __proto__: null,
2079    route: Vo
2080  }, Symbol.toStringTag, {
2081    value: "Module"
2082  })), Bo = "ko|hk";
2083  function Ho() {
2084    const e = new RegExp(`^/(${Bo})/product/([^/]+)/?$`);
2085    return function(n) {
2086      const i = n.urlPathname.match(e);
2087      return i ? {
2088        routeParams: {
2089          lang: i[1],
2090          slug: i[2]
2091        }
2092      } : false;
2093    };
2094  }
2095  const Wo = Ho(), No = Object.freeze(Object.defineProperty({
2096    __proto__: null,
2097    route: Wo
2098  }, Symbol.toStringTag, {
2099    value: "Module"
2100  })), Go = j("refund-policy"), Mo = Object.freeze(Object.defineProperty({
2101    __proto__: null,
2102    route: Go
2103  }, Symbol.toStringTag, {
2104    value: "Module"
2105  })), Ko = j("terms"), Yo = Object.freeze(Object.defineProperty({
2106    __proto__: null,
2107    route: Ko
2108  }, Symbol.toStringTag, {
2109    value: "Module"
2110  })), Jo = [
2111    "/product",
2112    "/blog"
2113  ];
2114  function qo(e) {

2115    const t = e.split("/").filter(Boolean);
2116    return t.length > 0 && [
2117      "ko",
2118      "hk",
2119      "en"
2120    ].includes(t[0]) && t.shift(), t.length ? `/${t.join("/")}` : "/";
2121  }
2122  function Xo(e) {
2123    const { urlPathname: t } = e;
2124    if (Hn(t)) return false;
2125    const n = qo(t);
2126    return !Jo.some((i) => n === i || n.startsWith(`${i}/`));
2127  }
2128  const Zo = Object.freeze(Object.defineProperty({
2129    __proto__: null,
2130    default: Xo
2131  }, Symbol.toStringTag, {
2132    value: "Module"
2133  })), Ve = {}, Pn = {}, Qo = {}, ge = {}, ea = [], En = {}, ta = [
2134    {
2135      pageId: "/pages/GuideDiscord",
2136      isErrorPage: void 0,
2137      routeFilesystem: {
2138        routeString: "/GuideDiscord",
2139        definedAtLocation: "/pages/GuideDiscord/"
2140      },
2141      loadConfigValuesAll: () => ({
2142        moduleId: "virtual:vike:pageConfigValuesAll:client:/pages/GuideDiscord",
2143        moduleExports: E(() => import("./pages_GuideDiscord.CE_nGb4t.js"), __vite__mapDeps([0,1,2,3,4,5,6,7]))
2144      }),
2145      configValuesSerialized: {
2146        isClientRuntimeLoaded: {
2147          type: "computed",
2148          definedAtData: null,
2149          valueSerialized: {
2150            type: "js-serialized",
2151            value: true
2152          }
2153        },
2154        onBeforeRenderEnv: {
2155          type: "computed",
2156          definedAtData: null,
2157          valueSerialized: {
2158            type: "js-serialized",
2159            value: {
2160              server: true
2161            }
2162          }
2163        },
2164        dataEnv: {
2165          type: "computed",
2166          definedAtData: null,
2167          valueSerialized: {
2168            type: "js-serialized",
2169            value: null
2170          }
2171        },
2172        clientRouting: {
2173          type: "standard",
2174          definedAtData: {
2175            filePathToShowToUser: "vike-react/config",
2176            fileExportPathToShowToUser: [
2177              "default",
2178              "clientRouting"
2179            ]
2180          },
2181          valueSerialized: {
2182            type: "js-serialized",
2183            value: true
2184          }
2185        }
2186      }
2187    },
2188    {
2189      pageId: "/pages/aboutUs",
2190      isErrorPage: void 0,
2191      routeFilesystem: {
2192        routeString: "/aboutUs",
2193        definedAtLocation: "/pages/aboutUs/"
2194      },
2195      loadConfigValuesAll: () => ({
2196        moduleId: "virtual:vike:pageConfigValuesAll:client:/pages/aboutUs",
2197        moduleExports: E(() => import("./pages_aboutUs.CInV3kcb.js"), __vite__mapDeps([8,1,2,3,4,5,6,7]))
2198      }),
2199      configValuesSerialized: {
2200        isClientRuntimeLoaded: {
2201          type: "computed",
2202          definedAtData: null,
2203          valueSerialized: {
2204            type: "js-serialized",
2205            value: true
2206          }
2207        },
2208        onBeforeRenderEnv: {
2209          type: "computed",
2210          definedAtData: null,
2211          valueSerialized: {
2212            type: "js-serialized",
2213            value: {
2214              server: true
2215            }
2216          }
2217        },
2218        dataEnv: {
2219          type: "computed",
2220          definedAtData: null,
2221          valueSerialized: {
2222            type: "js-serialized",
2223            value: null
2224          }
2225        },
2226        clientRouting: {
2227          type: "standard",
2228          definedAtData: {
2229            filePathToShowToUser: "vike-react/config",
2230            fileExportPathToShowToUser: [
2231              "default",
2232              "clientRouting"
2233            ]
2234          },
2235          valueSerialized: {
2236            type: "js-serialized",
2237            value: true
2238          }
2239        }
2240      }
2241    },
2242    {
2243      pageId: "/pages/affiliate",
2244      isErrorPage: void 0,
2245      routeFilesystem: {
2246        routeString: "/affiliate",
2247        definedAtLocation: "/pages/affiliate/"
2248      },
2249      loadConfigValuesAll: () => ({
2250        moduleId: "virtual:vike:pageConfigValuesAll:client:/pages/affiliate",
2251        moduleExports: E(() => import("./pages_affiliate.Bl9f-M7d.js"), __vite__mapDeps([9,1,2,3,4,5,6,7]))
2252      }),
2253      configValuesSerialized: {
2254        isClientRuntimeLoaded: {
2255          type: "computed",
2256          definedAtData: null,
2257          valueSerialized: {
2258            type: "js-serialized",
2259            value: true
2260          }
2261        },
2262        onBeforeRenderEnv: {
2263          type: "computed",
2264          definedAtData: null,
2265          valueSerialized: {
2266            type: "js-serialized",
2267            value: {
2268              server: true
2269            }
2270          }
2271        },
2272        dataEnv: {
2273          type: "computed",
2274          definedAtData: null,
2275          valueSerialized: {
2276            type: "js-serialized",
2277            value: null
2278          }
2279        },
2280        clientRouting: {
2281          type: "standard",
2282          definedAtData: {
2283            filePathToShowToUser: "vike-react/config",
2284            fileExportPathToShowToUser: [
2285              "default",
2286              "clientRouting"
2287            ]
2288          },
2289          valueSerialized: {
2290            type: "js-serialized",
2291            value: true
2292          }
2293        }
2294      }
2295    },
2296    {
2297      pageId: "/pages/aml-policy",
2298      isErrorPage: void 0,
2299      routeFilesystem: {
2300        routeString: "/aml-policy",
2301        definedAtLocation: "/pages/aml-policy/"
2302      },
2303      loadConfigValuesAll: () => ({
2304        moduleId: "virtual:vike:pageConfigValuesAll:client:/pages/aml-policy",
2305        moduleExports: E(() => import("./pages_aml-policy.Cgnj4hW-.js"), __vite__mapDeps([10,1,2,3,4,5,6,7]))
2306      }),
2307      configValuesSerialized: {
2308        isClientRuntimeLoaded: {
2309          type: "computed",
2310          definedAtData: null,
2311          valueSerialized: {
2312            type: "js-serialized",
2313            value: true
2314          }
2315        },
2316        onBeforeRenderEnv: {
2317          type: "computed",
2318          definedAtData: null,
2319          valueSerialized: {
2320            type: "js-serialized",
2321            value: {
2322              server: true
2323            }
2324          }
2325        },
2326        dataEnv: {
2327          type: "computed",
2328          definedAtData: null,
2329          valueSerialized: {
2330            type: "js-serialized",
2331            value: null
2332          }
2333        },
2334        clientRouting: {
2335          type: "standard",
2336          definedAtData: {
2337            filePathToShowToUser: "vike-react/config",
2338            fileExportPathToShowToUser: [
2339              "default",
2340              "clientRouting"
2341            ]
2342          },
2343          valueSerialized: {
2344            type: "js-serialized",
2345            value: true
2346          }
2347        }
2348      }
2349    },
2350    {
2351      pageId: "/pages/blog",
2352      isErrorPage: void 0,
2353      routeFilesystem: {
2354        routeString: "/blog",
2355        definedAtLocation: "/pages/blog/"
2356      },
2357      loadConfigValuesAll: () => ({
2358        moduleId: "virtual:vike:pageConfigValuesAll:client:/pages/blog",
2359        moduleExports: E(() => import("./pages_blog.44YGRW5O.js"), __vite__mapDeps([11,1,2,3,4,5,12,13,14]))
2360      }),
2361      configValuesSerialized: {
2362        isClientRuntimeLoaded: {
2363          type: "computed",
2364          definedAtData: null,
2365          valueSerialized: {
2366            type: "js-serialized",
2367            value: true
2368          }
2369        },
2370        onBeforeRenderEnv: {
2371          type: "computed",
2372          definedAtData: null,
2373          valueSerialized: {
2374            type: "js-serialized",
2375            value: {
2376              server: true
2377            }
2378          }
2379        },
2380        dataEnv: {
2381          type: "computed",
2382          definedAtData: null,
2383          valueSerialized: {
2384            type: "js-serialized",
2385            value: null
2386          }
2387        },
2388        clientRouting: {
2389          type: "standard",
2390          definedAtData: {
2391            filePathToShowToUser: "vike-react/config",
2392            fileExportPathToShowToUser: [
2393              "default",
2394              "clientRouting"
2395            ]
2396          },
2397          valueSerialized: {
2398            type: "js-serialized",
2399            value: true
2400          }
2401        }
2402      }
2403    },
2404    {
2405      pageId: "/pages/blog/@slug",
2406      isErrorPage: void 0,
2407      routeFilesystem: {
2408        routeString: "/blog/@slug",
2409        definedAtLocation: "/pages/blog/@slug/"
2410      },
2411      loadConfigValuesAll: () => ({
2412        moduleId: "virtual:vike:pageConfigValuesAll:client:/pages/blog/@slug",
2413        moduleExports: E(() => import("./pages_blog_-slug.Coq1b29_.js"), __vite__mapDeps([15,1,2,3,4,5,16,17,13,7,14]))
2414      }),
2415      configValuesSerialized: {
2416        isClientRuntimeLoaded: {
2417          type: "computed",
2418          definedAtData: null,
2419          valueSerialized: {
2420            type: "js-serialized",
2421            value: true
2422          }
2423        },
2424        onBeforeRenderEnv: {
2425          type: "computed",
2426          definedAtData: null,
2427          valueSerialized: {
2428            type: "js-serialized",
2429            value: {
2430              server: true
2431            }
2432          }
2433        },
2434        dataEnv: {
2435          type: "computed",
2436          definedAtData: null,
2437          valueSerialized: {
2438            type: "js-serialized",
2439            value: null
2440          }
2441        },
2442        clientRouting: {
2443          type: "standard",
2444          definedAtData: {
2445            filePathToShowToUser: "vike-react/config",
2446            fileExportPathToShowToUser: [
2447              "default",
2448              "clientRouting"
2449            ]
2450          },
2451          valueSerialized: {
2452            type: "js-serialized",
2453            value: true
2454          }
2455        }
2456      }
2457    },
2458    {
2459      pageId: "/pages/contactUs",
2460      isErrorPage: void 0,
2461      routeFilesystem: {
2462        routeString: "/contactUs",
2463        definedAtLocation: "/pages/contactUs/"
2464      },
2465      loadConfigValuesAll: () => ({
2466        moduleId: "virtual:vike:pageConfigValuesAll:client:/pages/contactUs",
2467        moduleExports: E(() => import("./pages_contactUs.8yb-8lhV.js"), __vite__mapDeps([18,1,2,3,4,5,6,7]))
2468      }),
2469      configValuesSerialized: {
2470        isClientRuntimeLoaded: {
2471          type: "computed",
2472          definedAtData: null,
2473          valueSerialized: {
2474            type: "js-serialized",
2475            value: true
2476          }
2477        },
2478        onBeforeRenderEnv: {
2479          type: "computed",
2480          definedAtData: null,
2481          valueSerialized: {
2482            type: "js-serialized",
2483            value: {
2484              server: true
2485            }
2486          }
2487        },
2488        dataEnv: {
2489          type: "computed",
2490          definedAtData: null,
2491          valueSerialized: {
2492            type: "js-serialized",
2493            value: null
2494          }
2495        },
2496        clientRouting: {
2497          type: "standard",
2498          definedAtData: {
2499            filePathToShowToUser: "vike-react/config",
2500            fileExportPathToShowToUser: [
2501              "default",
2502              "clientRouting"
2503            ]
2504          },
2505          valueSerialized: {
2506            type: "js-serialized",
2507            value: true
2508          }
2509        }
2510      }
2511    },
2512    {
2513      pageId: "/pages/cooperate",
2514      isErrorPage: void 0,
2515      routeFilesystem: {
2516        routeString: "/cooperate",
2517        definedAtLocation: "/pages/cooperate/"
2518      },
2519      loadConfigValuesAll: () => ({
2520        moduleId: "virtual:vike:pageConfigValuesAll:client:/pages/cooperate",
2521        moduleExports: E(() => import("./pages_cooperate.CQgNVjBZ.js"), __vite__mapDeps([19,1,2,3,4,5,6,7]))
2522      }),
2523      configValuesSerialized: {
2524        isClientRuntimeLoaded: {
2525          type: "computed",
2526          definedAtData: null,
2527          valueSerialized: {
2528            type: "js-serialized",
2529            value: true
2530          }
2531        },
2532        onBeforeRenderEnv: {
2533          type: "computed",
2534          definedAtData: null,
2535          valueSerialized: {
2536            type: "js-serialized",
2537            value: {
2538              server: true
2539            }
2540          }
2541        },
2542        dataEnv: {
2543          type: "computed",
2544          definedAtData: null,
2545          valueSerialized: {
2546            type: "js-serialized",
2547            value: null
2548          }
2549        },
2550        clientRouting: {
2551          type: "standard",
2552          definedAtData: {
2553            filePathToShowToUser: "vike-react/config",
2554            fileExportPathToShowToUser: [
2555              "default",
2556              "clientRouting"
2557            ]
2558          },
2559          valueSerialized: {
2560            type: "js-serialized",
2561            value: true
2562          }
2563        }
2564      }
2565    },
2566    {
2567      pageId: "/pages/copyright",
2568      isErrorPage: void 0,
2569      routeFilesystem: {
2570        routeString: "/copyright",
2571        definedAtLocation: "/pages/copyright/"
2572      },
2573      loadConfigValuesAll: () => ({
2574        moduleId: "virtual:vike:pageConfigValuesAll:client:/pages/copyright",
2575        moduleExports: E(() => import("./pages_copyright.BpVaFymp.js"), __vite__mapDeps([20,1,2,3,4,5,6,7]))
2576      }),
2577      configValuesSerialized: {
2578        isClientRuntimeLoaded: {
2579          type: "computed",
2580          definedAtData: null,
2581          valueSerialized: {
2582            type: "js-serialized",
2583            value: true
2584          }
2585        },
2586        onBeforeRenderEnv: {
2587          type: "computed",
2588          definedAtData: null,
2589          valueSerialized: {
2590            type: "js-serialized",
2591            value: {
2592              server: true
2593            }
2594          }
2595        },
2596        dataEnv: {
2597          type: "computed",
2598          definedAtData: null,
2599          valueSerialized: {
2600            type: "js-serialized",
2601            value: null
2602          }
2603        },
2604        clientRouting: {
2605          type: "standard",
2606          definedAtData: {
2607            filePathToShowToUser: "vike-react/config",
2608            fileExportPathToShowToUser: [
2609              "default",
2610              "clientRouting"
2611            ]
2612          },
2613          valueSerialized: {
2614            type: "js-serialized",
2615            value: true
2616          }
2617        }
2618      }
2619    },
2620    {
2621      pageId: "/pages/help-recharge",
2622      isErrorPage: void 0,
2623      routeFilesystem: {
2624        routeString: "/help-recharge",
2625        definedAtLocation: "/pages/help-recharge/"
2626      },
2627      loadConfigValuesAll: () => ({
2628        moduleId: "virtual:vike:pageConfigValuesAll:client:/pages/help-recharge",
2629        moduleExports: E(() => import("./pages_help-recharge.CmK43nRV.js"), __vite__mapDeps([21,1,2,3,4,5,6,7]))
2630      }),
2631      configValuesSerialized: {
2632        isClientRuntimeLoaded: {
2633          type: "computed",
2634          definedAtData: null,
2635          valueSerialized: {
2636            type: "js-serialized",
2637            value: true
2638          }
2639        },
2640        onBeforeRenderEnv: {
2641          type: "computed",
2642          definedAtData: null,
2643          valueSerialized: {
2644            type: "js-serialized",
2645            value: {
2646              server: true
2647            }
2648          }
2649        },
2650        dataEnv: {
2651          type: "computed",
2652          definedAtData: null,
2653          valueSerialized: {
2654            type: "js-serialized",
2655            value: null
2656          }
2657        },
2658        clientRouting: {
2659          type: "standard",
2660          definedAtData: {
2661            filePathToShowToUser: "vike-react/config",
2662            fileExportPathToShowToUser: [
2663              "default",
2664              "clientRouting"
2665            ]
2666          },
2667          valueSerialized: {
2668            type: "js-serialized",
2669            value: true
2670          }
2671        }
2672      }
2673    },
2674    {
2675      pageId: "/pages/help-useGpt",
2676      isErrorPage: void 0,
2677      routeFilesystem: {
2678        routeString: "/help-useGpt",
2679        definedAtLocation: "/pages/help-useGpt/"
2680      },
2681      loadConfigValuesAll: () => ({
2682        moduleId: "virtual:vike:pageConfigValuesAll:client:/pages/help-useGpt",
2683        moduleExports: E(() => import("./pages_help-useGpt.B9pQtMVf.js"), __vite__mapDeps([22,1,2,3,4,5,6,7]))
2684      }),
2685      configValuesSerialized: {
2686        isClientRuntimeLoaded: {
2687          type: "computed",
2688          definedAtData: null,
2689          valueSerialized: {
2690            type: "js-serialized",
2691            value: true
2692          }
2693        },
2694        onBeforeRenderEnv: {
2695          type: "computed",
2696          definedAtData: null,
2697          valueSerialized: {
2698            type: "js-serialized",
2699            value: {
2700              server: true
2701            }
2702          }
2703        },
2704        dataEnv: {
2705          type: "computed",
2706          definedAtData: null,
2707          valueSerialized: {
2708            type: "js-serialized",
2709            value: null
2710          }
2711        },
2712        clientRouting: {
2713          type: "standard",
2714          definedAtData: {
2715            filePathToShowToUs

2715er: "vike-react/config",
2716            fileExportPathToShowToUser: [
2717              "default",
2718              "clientRouting"
2719            ]
2720          },
2721          valueSerialized: {
2722            type: "js-serialized",
2723            value: true
2724          }
2725        }
2726      }
2727    },
2728    {
2729      pageId: "/pages/help-useNetflix",
2730      isErrorPage: void 0,
2731      routeFilesystem: {
2732        routeString: "/help-useNetflix",
2733        definedAtLocation: "/pages/help-useNetflix/"
2734      },
2735      loadConfigValuesAll: () => ({
2736        moduleId: "virtual:vike:pageConfigValuesAll:client:/pages/help-useNetflix",
2737        moduleExports: E(() => import("./pages_help-useNetflix.CXyCqiRX.js"), __vite__mapDeps([23,1,2,3,4,5,6,7]))
2738      }),
2739      configValuesSerialized: {
2740        isClientRuntimeLoaded: {
2741          type: "computed",
2742          definedAtData: null,
2743          valueSerialized: {
2744            type: "js-serialized",
2745            value: true
2746          }
2747        },
2748        onBeforeRenderEnv: {
2749          type: "computed",
2750          definedAtData: null,
2751          valueSerialized: {
2752            type: "js-serialized",
2753            value: {
2754              server: true
2755            }
2756          }
2757        },
2758        dataEnv: {
2759          type: "computed",
2760          definedAtData: null,
2761          valueSerialized: {
2762            type: "js-serialized",
2763            value: null
2764          }
2765        },
2766        clientRouting: {
2767          type: "standard",
2768          definedAtData: {
2769            filePathToShowToUser: "vike-react/config",
2770            fileExportPathToShowToUser: [
2771              "default",
2772              "clientRouting"
2773            ]
2774          },
2775          valueSerialized: {
2776            type: "js-serialized",
2777            value: true
2778          }
2779        }
2780      }
2781    },
2782    {
2783      pageId: "/pages/help-ytbRegion",
2784      isErrorPage: void 0,
2785      routeFilesystem: {
2786        routeString: "/help-ytbRegion",
2787        definedAtLocation: "/pages/help-ytbRegion/"
2788      },
2789      loadConfigValuesAll: () => ({
2790        moduleId: "virtual:vike:pageConfigValuesAll:client:/pages/help-ytbRegion",
2791        moduleExports: E(() => import("./pages_help-ytbRegion.D-jcWGei.js"), __vite__mapDeps([24,1,2,3,4,5,6,7]))
2792      }),
2793      configValuesSerialized: {
2794        isClientRuntimeLoaded: {
2795          type: "computed",
2796          definedAtData: null,
2797          valueSerialized: {
2798            type: "js-serialized",
2799            value: true
2800          }
2801        },
2802        onBeforeRenderEnv: {
2803          type: "computed",
2804          definedAtData: null,
2805          valueSerialized: {
2806            type: "js-serialized",
2807            value: {
2808              server: true
2809            }
2810          }
2811        },
2812        dataEnv: {
2813          type: "computed",
2814          definedAtData: null,
2815          valueSerialized: {
2816            type: "js-serialized",
2817            value: null
2818          }
2819        },
2820        clientRouting: {
2821          type: "standard",
2822          definedAtData: {
2823            filePathToShowToUser: "vike-react/config",
2824            fileExportPathToShowToUser: [
2825              "default",
2826              "clientRouting"
2827            ]
2828          },
2829          valueSerialized: {
2830            type: "js-serialized",
2831            value: true
2832          }
2833        }
2834      }
2835    },
2836    {
2837      pageId: "/pages/index",
2838      isErrorPage: void 0,
2839      routeFilesystem: {
2840        routeString: "/",
2841        definedAtLocation: "/pages/index/"
2842      },
2843      loadConfigValuesAll: () => ({
2844        moduleId: "virtual:vike:pageConfigValuesAll:client:/pages/index",
2845        moduleExports: E(() => import("./pages_index.DCZt-MI_.js"), __vite__mapDeps([25,1,2,3,4,5,6,7]))
2846      }),
2847      configValuesSerialized: {
2848        isClientRuntimeLoaded: {
2849          type: "computed",
2850          definedAtData: null,
2851          valueSerialized: {
2852            type: "js-serialized",
2853            value: true
2854          }
2855        },
2856        onBeforeRenderEnv: {
2857          type: "computed",
2858          definedAtData: null,
2859          valueSerialized: {
2860            type: "js-serialized",
2861            value: {
2862              server: true
2863            }
2864          }
2865        },
2866        dataEnv: {
2867          type: "computed",
2868          definedAtData: null,
2869          valueSerialized: {
2870            type: "js-serialized",
2871            value: null
2872          }
2873        },
2874        clientRouting: {
2875          type: "standard",
2876          definedAtData: {
2877            filePathToShowToUser: "vike-react/config",
2878            fileExportPathToShowToUser: [
2879              "default",
2880              "clientRouting"
2881            ]
2882          },
2883          valueSerialized: {
2884            type: "js-serialized",
2885            value: true
2886          }
2887        }
2888      }
2889    },
2890    {
2891      pageId: "/pages/privacy-policy",
2892      isErrorPage: void 0,
2893      routeFilesystem: {
2894        routeString: "/privacy-policy",
2895        definedAtLocation: "/pages/privacy-policy/"
2896      },
2897      loadConfigValuesAll: () => ({
2898        moduleId: "virtual:vike:pageConfigValuesAll:client:/pages/privacy-policy",
2899        moduleExports: E(() => import("./pages_privacy-policy.DZKHnXsh.js"), __vite__mapDeps([26,1,2,3,4,5,6,7]))
2900      }),
2901      configValuesSerialized: {
2902        isClientRuntimeLoaded: {
2903          type: "computed",
2904          definedAtData: null,
2905          valueSerialized: {
2906            type: "js-serialized",
2907            value: true
2908          }
2909        },
2910        onBeforeRenderEnv: {
2911          type: "computed",
2912          definedAtData: null,
2913          valueSerialized: {
2914            type: "js-serialized",
2915            value: {
2916              server: true
2917            }
2918          }
2919        },
2920        dataEnv: {
2921          type: "computed",
2922          definedAtData: null,
2923          valueSerialized: {
2924            type: "js-serialized",
2925            value: null
2926          }
2927        },
2928        clientRouting: {
2929          type: "standard",
2930          definedAtData: {
2931            filePathToShowToUser: "vike-react/config",
2932            fileExportPathToShowToUser: [
2933              "default",
2934              "clientRouting"
2935            ]
2936          },
2937          valueSerialized: {
2938            type: "js-serialized",
2939            value: true
2940          }
2941        }
2942      }
2943    },
2944    {
2945      pageId: "/pages/product/@slug",
2946      isErrorPage: void 0,
2947      routeFilesystem: {
2948        routeString: "/product/@slug",
2949        definedAtLocation: "/pages/product/@slug/"
2950      },
2951      loadConfigValuesAll: () => ({
2952        moduleId: "virtual:vike:pageConfigValuesAll:client:/pages/product/@slug",
2953        moduleExports: E(() => import("./pages_product_-slug.CLknIk3l.js"), __vite__mapDeps([27,1,2,3,4,5,28,6,7,14,17]))
2954      }),
2955      configValuesSerialized: {
2956        isClientRuntimeLoaded: {
2957          type: "computed",
2958          definedAtData: null,
2959          valueSerialized: {
2960            type: "js-serialized",
2961            value: true
2962          }
2963        },
2964        onBeforeRenderEnv: {
2965          type: "computed",
2966          definedAtData: null,
2967          valueSerialized: {
2968            type: "js-serialized",
2969            value: {
2970              server: true
2971            }
2972          }
2973        },
2974        dataEnv: {
2975          type: "computed",
2976          definedAtData: null,
2977          valueSerialized: {
2978            type: "js-serialized",
2979            value: null
2980          }
2981        },
2982        clientRouting: {
2983          type: "standard",
2984          definedAtData: {
2985            filePathToShowToUser: "vike-react/config",
2986            fileExportPathToShowToUser: [
2987              "default",
2988              "clientRouting"
2989            ]
2990          },
2991          valueSerialized: {
2992            type: "js-serialized",
2993            value: true
2994          }
2995        }
2996      }
2997    },
2998    {
2999      pageId: "/pages/refund-policy",
3000      isErrorPage: void 0,
3001      routeFilesystem: {
3002        routeString: "/refund-policy",
3003        definedAtLocation: "/pages/refund-policy/"
3004      },
3005      loadConfigValuesAll: () => ({
3006        moduleId: "virtual:vike:pageConfigValuesAll:client:/pages/refund-policy",
3007        moduleExports: E(() => import("./pages_refund-policy.DI4H0vQ3.js"), __vite__mapDeps([29,1,2,3,4,5,6,7]))
3008      }),
3009      configValuesSerialized: {
3010        isClientRuntimeLoaded: {
3011          type: "computed",
3012          definedAtData: null,
3013          valueSerialized: {
3014            type: "js-serialized",
3015            value: true
3016          }
3017        },
3018        onBeforeRenderEnv: {
3019          type: "computed",
3020          definedAtData: null,
3021          valueSerialized: {
3022            type: "js-serialized",
3023            value: {
3024              server: true
3025            }
3026          }
3027        },
3028        dataEnv: {
3029          type: "computed",
3030          definedAtData: null,
3031          valueSerialized: {
3032            type: "js-serialized",
3033            value: null
3034          }
3035        },
3036        clientRouting: {
3037          type: "standard",
3038          definedAtData: {
3039            filePathToShowToUser: "vike-react/config",
3040            fileExportPathToShowToUser: [
3041              "default",
3042              "clientRouting"
3043            ]
3044          },
3045          valueSerialized: {
3046            type: "js-serialized",
3047            value: true
3048          }
3049        }
3050      }
3051    },
3052    {
3053      pageId: "/pages/terms",
3054      isErrorPage: void 0,
3055      routeFilesystem: {
3056        routeString: "/terms",
3057        definedAtLocation: "/pages/terms/"
3058      },
3059      loadConfigValuesAll: () => ({
3060        moduleId: "virtual:vike:pageConfigValuesAll:client:/pages/terms",
3061        moduleExports: E(() => import("./pages_terms.Duvwdv5J.js"), __vite__mapDeps([30,1,2,3,4,5,6,7]))
3062      }),
3063      configValuesSerialized: {
3064        isClientRuntimeLoaded: {
3065          type: "computed",
3066          definedAtData: null,
3067          valueSerialized: {
3068            type: "js-serialized",
3069            value: true
3070          }
3071        },
3072        onBeforeRenderEnv: {
3073          type: "computed",
3074          definedAtData: null,
3075          valueSerialized: {
3076            type: "js-serialized",
3077            value: {
3078              server: true
3079            }
3080          }
3081        },
3082        dataEnv: {
3083          type: "computed",
3084          definedAtData: null,
3085          valueSerialized: {
3086            type: "js-serialized",
3087            value: null
3088          }
3089        },
3090        clientRouting: {
3091          type: "standard",
3092          definedAtData: {
3093            filePathToShowToUser: "vike-react/config",
3094            fileExportPathToShowToUser: [
3095              "default",
3096              "clientRouting"
3097            ]
3098          },
3099          valueSerialized: {
3100            type: "js-serialized",
3101            value: true
3102          }
3103        }
3104      }
3105    },
3106    {
3107      pageId: "/pages/@lang/GuideDiscord",
3108      isErrorPage: void 0,
3109      routeFilesystem: {
3110        routeString: "/@lang/GuideDiscord",
3111        definedAtLocation: "/pages/@lang/GuideDiscord/"
3112      },
3113      loadConfigValuesAll: () => ({
3114        moduleId: "virtual:vike:pageConfigValuesAll:client:/pages/@lang/GuideDiscord",
3115        moduleExports: E(() => import("./pages_-lang_GuideDiscord.BCQjQpcH.js"), __vite__mapDeps([31,1,2,3,4,5,6,7]))
3116      }),
3117      configValuesSerialized: {
3118        isClientRuntimeLoaded: {
3119          type: "computed",
3120          definedAtData: null,
3121          valueSerialized: {
3122            type: "js-serialized",
3123            value: true
3124          }
3125        },
3126        onBeforeRenderEnv: {
3127          type: "computed",
3128          definedAtData: null,
3129          valueSerialized: {
3130            type: "js-serialized",
3131            value: {
3132              server: true
3133            }
3134          }
3135        },
3136        dataEnv: {
3137          type: "computed",
3138          definedAtData: null,
3139          valueSerialized: {
3140            type: "js-serialized",
3141            value: null
3142          }
3143        },
3144        route: {
3145          type: "standard",
3146          definedAtData: {
3147            filePathToShowToUser: "/pages/@lang/GuideDiscord/+route.ts",
3148            fileExportPathToShowToUser: []
3149          },
3150          valueSerialized: {
3151            type: "plus-file",
3152            exportValues: uo
3153          }
3154        },
3155        clientRouting: {
3156          type: "standard",
3157          definedAtData: {
3158            filePathToShowToUser: "vike-react/config",
3159            fileExportPathToShowToUser: [
3160              "default",
3161              "clientRouting"
3162            ]
3163          },
3164          valueSerialized: {
3165            type: "js-serialized",
3166            value: true
3167          }
3168        }
3169      }
3170    },
3171    {
3172      pageId: "/pages/@lang/aboutUs",
3173      isErrorPage: void 0,
3174      routeFilesystem: {
3175        routeString: "/@lang/aboutUs",
3176        definedAtLocation: "/pages/@lang/aboutUs/"
3177      },
3178      loadConfigValuesAll: () => ({
3179        moduleId: "virtual:vike:pageConfigValuesAll:client:/pages/@lang/aboutUs",
3180        moduleExports: E(() => import("./pages_-lang_aboutUs.DF_uytW5.js"), __vite__mapDeps([32,1,2,3,4,5,6,7]))
3181      }),
3182      configValuesSerialized: {
3183        isClientRuntimeLoaded: {
3184          type: "computed",
3185          definedAtData: null,
3186          valueSerialized: {
3187            type: "js-serialized",
3188            value: true
3189          }
3190        },
3191        onBeforeRenderEnv: {
3192          type: "computed",
3193          definedAtData: null,
3194          valueSerialized: {
3195            type: "js-serialized",
3196            value: {
3197              server: true
3198            }
3199          }
3200        },
3201        dataEnv: {
3202          type: "computed",
3203          definedAtData: null,
3204          valueSerialized: {
3205            type: "js-serialized",
3206            value: null
3207          }
3208        },
3209        route: {
3210          type: "standard",
3211          definedAtData: {
3212            filePathToShowToUser: "/pages/@lang/aboutUs/+route.ts",
3213            fileExportPathToShowToUser: []
3214          },
3215          valueSerialized: {
3216            type: "plus-file",
3217            exportValues: fo
3218          }
3219        },
3220        clientRouting: {
3221          type: "standard",
3222          definedAtData: {
3223            filePathToShowToUser: "vike-react/config",
3224            fileExportPathToShowToUser: [
3225              "default",
3226              "clientRouting"
3227            ]
3228          },
3229          valueSerialized: {
3230            type: "js-serialized",
3231            value: true
3232          }
3233        }
3234      }
3235    },
3236    {
3237      pageId: "/pages/@lang/affiliate",
3238      isErrorPage: void 0,
3239      routeFilesystem: {
3240        routeString: "/@lang/affiliate",
3241        definedAtLocation: "/pages/@lang/affiliate/"
3242      },
3243      loadConfigValuesAll: () => ({
3244        moduleId: "virtual:vike:pageConfigValuesAll:client:/pages/@lang/affiliate",
3245        moduleExports: E(() => import("./pages_-lang_affiliate.RazzqSfl.js"), __vite__mapDeps([33,1,2,3,4,5,6,7]))
3246      }),
3247      configValuesSerialized: {
3248        isClientRuntimeLoaded: {
3249          type: "computed",
3250          definedAtData: null,
3251          valueSerialized: {
3252            type: "js-serialized",
3253            value: true
3254          }
3255        },
3256        onBeforeRenderEnv: {
3257          type: "computed",
3258          definedAtData: null,
3259          valueSerialized: {
3260            type: "js-serialized",
3261            value: {
3262              server: true
3263            }
3264          }
3265        },
3266        dataEnv: {
3267          type: "computed",
3268          definedAtData: null,
3269          valueSerialized: {
3270            type: "js-serialized",
3271            value: null
3272          }
3273        },
3274        route: {
3275          type: "standard",
3276          definedAtData: {
3277            filePathToShowToUser: "/pages/@lang/affiliate/+route.ts",
3278            fileExportPathToShowToUser: []
3279          },
3280          valueSerialized: {
3281            type: "plus-file",
3282            exportValues: po
3283          }
3284        },
3285        clientRouting: {
3286          type: "standard",
3287          definedAtData: {
3288            filePathToShowToUser: "vike-react/config",
3289            fileExportPathToShowToUser: [
3290              "default",
3291              "clientRouting"
3292            ]
3293          },
3294          valueSerialized: {
3295            type: "js-serialized",
3296            value: true
3297          }
3298        }
3299      }
3300    },
3301    {
3302      pageId: "/pages/@lang/aml-policy",
3303      isErrorPage: void 0,
3304      routeFilesystem: {
3305        routeString: "/@lang/aml-policy",
3306        definedAtLocation: "/pages/@lang/aml-policy/"
3307      },
3308      loadConfigValuesAll: () => ({
3309        moduleId: "virtual:vike:pageConfigValuesAll:client:/pages/@lang/aml-policy",
3310        moduleExports: E(() => import("./pages_-lang_aml-policy.C

3310RdGmQtX.js"), __vite__mapDeps([34,1,2,3,4,5,6,7]))
3311      }),
3312      configValuesSerialized: {
3313        isClientRuntimeLoaded: {
3314          type: "computed",
3315          definedAtData: null,
3316          valueSerialized: {
3317            type: "js-serialized",
3318            value: true
3319          }
3320        },
3321        onBeforeRenderEnv: {
3322          type: "computed",
3323          definedAtData: null,
3324          valueSerialized: {
3325            type: "js-serialized",
3326            value: {
3327              server: true
3328            }
3329          }
3330        },
3331        dataEnv: {
3332          type: "computed",
3333          definedAtData: null,
3334          valueSerialized: {
3335            type: "js-serialized",
3336            value: null
3337          }
3338        },
3339        route: {
3340          type: "standard",
3341          definedAtData: {
3342            filePathToShowToUser: "/pages/@lang/aml-policy/+route.ts",
3343            fileExportPathToShowToUser: []
3344          },
3345          valueSerialized: {
3346            type: "plus-file",
3347            exportValues: yo
3348          }
3349        },
3350        clientRouting: {
3351          type: "standard",
3352          definedAtData: {
3353            filePathToShowToUser: "vike-react/config",
3354            fileExportPathToShowToUser: [
3355              "default",
3356              "clientRouting"
3357            ]
3358          },
3359          valueSerialized: {
3360            type: "js-serialized",
3361            value: true
3362          }
3363        }
3364      }
3365    },
3366    {
3367      pageId: "/pages/@lang/blog",
3368      isErrorPage: void 0,
3369      routeFilesystem: {
3370        routeString: "/@lang/blog",
3371        definedAtLocation: "/pages/@lang/blog/"
3372      },
3373      loadConfigValuesAll: () => ({
3374        moduleId: "virtual:vike:pageConfigValuesAll:client:/pages/@lang/blog",
3375        moduleExports: E(() => import("./pages_-lang_blog.Cqyj7Cj7.js"), __vite__mapDeps([35,1,2,3,4,5,12,13,14]))
3376      }),
3377      configValuesSerialized: {
3378        isClientRuntimeLoaded: {
3379          type: "computed",
3380          definedAtData: null,
3381          valueSerialized: {
3382            type: "js-serialized",
3383            value: true
3384          }
3385        },
3386        onBeforeRenderEnv: {
3387          type: "computed",
3388          definedAtData: null,
3389          valueSerialized: {
3390            type: "js-serialized",
3391            value: {
3392              server: true
3393            }
3394          }
3395        },
3396        dataEnv: {
3397          type: "computed",
3398          definedAtData: null,
3399          valueSerialized: {
3400            type: "js-serialized",
3401            value: null
3402          }
3403        },
3404        route: {
3405          type: "standard",
3406          definedAtData: {
3407            filePathToShowToUser: "/pages/@lang/blog/+route.ts",
3408            fileExportPathToShowToUser: []
3409          },
3410          valueSerialized: {
3411            type: "plus-file",
3412            exportValues: Po
3413          }
3414        },
3415        clientRouting: {
3416          type: "standard",
3417          definedAtData: {
3418            filePathToShowToUser: "vike-react/config",
3419            fileExportPathToShowToUser: [
3420              "default",
3421              "clientRouting"
3422            ]
3423          },
3424          valueSerialized: {
3425            type: "js-serialized",
3426            value: true
3427          }
3428        }
3429      }
3430    },
3431    {
3432      pageId: "/pages/@lang/blog/@slug",
3433      isErrorPage: void 0,
3434      routeFilesystem: {
3435        routeString: "/@lang/blog/@slug",
3436        definedAtLocation: "/pages/@lang/blog/@slug/"
3437      },
3438      loadConfigValuesAll: () => ({
3439        moduleId: "virtual:vike:pageConfigValuesAll:client:/pages/@lang/blog/@slug",
3440        moduleExports: E(() => import("./pages_-lang_blog_-slug.t3H6-sQ8.js"), __vite__mapDeps([36,1,2,3,4,5,16,17,13,7,14]))
3441      }),
3442      configValuesSerialized: {
3443        isClientRuntimeLoaded: {
3444          type: "computed",
3445          definedAtData: null,
3446          valueSerialized: {
3447            type: "js-serialized",
3448            value: true
3449          }
3450        },
3451        onBeforeRenderEnv: {
3452          type: "computed",
3453          definedAtData: null,
3454          valueSerialized: {
3455            type: "js-serialized",
3456            value: {
3457              server: true
3458            }
3459          }
3460        },
3461        dataEnv: {
3462          type: "computed",
3463          definedAtData: null,
3464          valueSerialized: {
3465            type: "js-serialized",
3466            value: null
3467          }
3468        },
3469        route: {
3470          type: "standard",
3471          definedAtData: {
3472            filePathToShowToUser: "/pages/@lang/blog/@slug/+route.ts",
3473            fileExportPathToShowToUser: []
3474          },
3475          valueSerialized: {
3476            type: "plus-file",
3477            exportValues: Ro
3478          }
3479        },
3480        clientRouting: {
3481          type: "standard",
3482          definedAtData: {
3483            filePathToShowToUser: "vike-react/config",
3484            fileExportPathToShowToUser: [
3485              "default",
3486              "clientRouting"
3487            ]
3488          },
3489          valueSerialized: {
3490            type: "js-serialized",
3491            value: true
3492          }
3493        }
3494      }
3495    },
3496    {
3497      pageId: "/pages/@lang/contactUs",
3498      isErrorPage: void 0,
3499      routeFilesystem: {
3500        routeString: "/@lang/contactUs",
3501        definedAtLocation: "/pages/@lang/contactUs/"
3502      },
3503      loadConfigValuesAll: () => ({
3504        moduleId: "virtual:vike:pageConfigValuesAll:client:/pages/@lang/contactUs",
3505        moduleExports: E(() => import("./pages_-lang_contactUs.C-Z7jOKc.js"), __vite__mapDeps([37,1,2,3,4,5,6,7]))
3506      }),
3507      configValuesSerialized: {
3508        isClientRuntimeLoaded: {
3509          type: "computed",
3510          definedAtData: null,
3511          valueSerialized: {
3512            type: "js-serialized",
3513            value: true
3514          }
3515        },
3516        onBeforeRenderEnv: {
3517          type: "computed",
3518          definedAtData: null,
3519          valueSerialized: {
3520            type: "js-serialized",
3521            value: {
3522              server: true
3523            }
3524          }
3525        },
3526        dataEnv: {
3527          type: "computed",
3528          definedAtData: null,
3529          valueSerialized: {
3530            type: "js-serialized",
3531            value: null
3532          }
3533        },
3534        route: {
3535          type: "standard",
3536          definedAtData: {
3537            filePathToShowToUser: "/pages/@lang/contactUs/+route.ts",
3538            fileExportPathToShowToUser: []
3539          },
3540          valueSerialized: {
3541            type: "plus-file",
3542            exportValues: Ao
3543          }
3544        },
3545        clientRouting: {
3546          type: "standard",
3547          definedAtData: {
3548            filePathToShowToUser: "vike-react/config",
3549            fileExportPathToShowToUser: [
3550              "default",
3551              "clientRouting"
3552            ]
3553          },
3554          valueSerialized: {
3555            type: "js-serialized",
3556            value: true
3557          }
3558        }
3559      }
3560    },
3561    {
3562      pageId: "/pages/@lang/cooperate",
3563      isErrorPage: void 0,
3564      routeFilesystem: {
3565        routeString: "/@lang/cooperate",
3566        definedAtLocation: "/pages/@lang/cooperate/"
3567      },
3568      loadConfigValuesAll: () => ({
3569        moduleId: "virtual:vike:pageConfigValuesAll:client:/pages/@lang/cooperate",
3570        moduleExports: E(() => import("./pages_-lang_cooperate.DnR1-maX.js"), __vite__mapDeps([38,1,2,3,4,5,6,7]))
3571      }),
3572      configValuesSerialized: {
3573        isClientRuntimeLoaded: {
3574          type: "computed",
3575          definedAtData: null,
3576          valueSerialized: {
3577            type: "js-serialized",
3578            value: true
3579          }
3580        },
3581        onBeforeRenderEnv: {
3582          type: "computed",
3583          definedAtData: null,
3584          valueSerialized: {
3585            type: "js-serialized",
3586            value: {
3587              server: true
3588            }
3589          }
3590        },
3591        dataEnv: {
3592          type: "computed",
3593          definedAtData: null,
3594          valueSerialized: {
3595            type: "js-serialized",
3596            value: null
3597          }
3598        },
3599        route: {
3600          type: "standard",
3601          definedAtData: {
3602            filePathToShowToUser: "/pages/@lang/cooperate/+route.ts",
3603            fileExportPathToShowToUser: []
3604          },
3605          valueSerialized: {
3606            type: "plus-file",
3607            exportValues: bo
3608          }
3609        },
3610        clientRouting: {
3611          type: "standard",
3612          definedAtData: {
3613            filePathToShowToUser: "vike-react/config",
3614            fileExportPathToShowToUser: [
3615              "default",
3616              "clientRouting"
3617            ]
3618          },
3619          valueSerialized: {
3620            type: "js-serialized",
3621            value: true
3622          }
3623        }
3624      }
3625    },
3626    {
3627      pageId: "/pages/@lang/copyright",
3628      isErrorPage: void 0,
3629      routeFilesystem: {
3630        routeString: "/@lang/copyright",
3631        definedAtLocation: "/pages/@lang/copyright/"
3632      },
3633      loadConfigValuesAll: () => ({
3634        moduleId: "virtual:vike:pageConfigValuesAll:client:/pages/@lang/copyright",
3635        moduleExports: E(() => import("./pages_-lang_copyright._Z_R-XKv.js"), __vite__mapDeps([39,1,2,3,4,5,6,7]))
3636      }),
3637      configValuesSerialized: {
3638        isClientRuntimeLoaded: {
3639          type: "computed",
3640          definedAtData: null,
3641          valueSerialized: {
3642            type: "js-serialized",
3643            value: true
3644          }
3645        },
3646        onBeforeRenderEnv: {
3647          type: "computed",
3648          definedAtData: null,
3649          valueSerialized: {
3650            type: "js-serialized",
3651            value: {
3652              server: true
3653            }
3654          }
3655        },
3656        dataEnv: {
3657          type: "computed",
3658          definedAtData: null,
3659          valueSerialized: {
3660            type: "js-serialized",
3661            value: null
3662          }
3663        },
3664        route: {
3665          type: "standard",
3666          definedAtData: {
3667            filePathToShowToUser: "/pages/@lang/copyright/+route.ts",
3668            fileExportPathToShowToUser: []
3669          },
3670          valueSerialized: {
3671            type: "plus-file",
3672            exportValues: wo
3673          }
3674        },
3675        clientRouting: {
3676          type: "standard",
3677          definedAtData: {
3678            filePathToShowToUser: "vike-react/config",
3679            fileExportPathToShowToUser: [
3680              "default",
3681              "clientRouting"
3682            ]
3683          },
3684          valueSerialized: {
3685            type: "js-serialized",
3686            value: true
3687          }
3688        }
3689      }
3690    },
3691    {
3692      pageId: "/pages/@lang/help-recharge",
3693      isErrorPage: void 0,
3694      routeFilesystem: {
3695        routeString: "/@lang/help-recharge",
3696        definedAtLocation: "/pages/@lang/help-recharge/"
3697      },
3698      loadConfigValuesAll: () => ({
3699        moduleId: "virtual:vike:pageConfigValuesAll:client:/pages/@lang/help-recharge",
3700        moduleExports: E(() => import("./pages_-lang_help-recharge.Cs1Lh99W.js"), __vite__mapDeps([40,1,2,3,4,5,6,7]))
3701      }),
3702      configValuesSerialized: {
3703        isClientRuntimeLoaded: {
3704          type: "computed",
3705          definedAtData: null,
3706          valueSerialized: {
3707            type: "js-serialized",
3708            value: true
3709          }
3710        },
3711        onBeforeRenderEnv: {
3712          type: "computed",
3713          definedAtData: null,
3714          valueSerialized: {
3715            type: "js-serialized",
3716            value: {
3717              server: true
3718            }
3719          }
3720        },
3721        dataEnv: {
3722          type: "computed",
3723          definedAtData: null,
3724          valueSerialized: {
3725            type: "js-serialized",
3726            value: null
3727          }
3728        },
3729        route: {
3730          type: "standard",
3731          definedAtData: {
3732            filePathToShowToUser: "/pages/@lang/help-recharge/+route.ts",
3733            fileExportPathToShowToUser: []
3734          },
3735          valueSerialized: {
3736            type: "plus-file",
3737            exportValues: xo
3738          }
3739        },
3740        clientRouting: {
3741          type: "standard",
3742          definedAtData: {
3743            filePathToShowToUser: "vike-react/config",
3744            fileExportPathToShowToUser: [
3745              "default",
3746              "clientRouting"
3747            ]
3748          },
3749          valueSerialized: {
3750            type: "js-serialized",
3751            value: true
3752          }
3753        }
3754      }
3755    },
3756    {
3757      pageId: "/pages/@lang/help-useGpt",
3758      isErrorPage: void 0,
3759      routeFilesystem: {
3760        routeString: "/@lang/help-useGpt",
3761        definedAtLocation: "/pages/@lang/help-useGpt/"
3762      },
3763      loadConfigValuesAll: () => ({
3764        moduleId: "virtual:vike:pageConfigValuesAll:client:/pages/@lang/help-useGpt",
3765        moduleExports: E(() => import("./pages_-lang_help-useGpt.CrWHC1oD.js"), __vite__mapDeps([41,1,2,3,4,5,6,7]))
3766      }),
3767      configValuesSerialized: {
3768        isClientRuntimeLoaded: {
3769          type: "computed",
3770          definedAtData: null,
3771          valueSerialized: {
3772            type: "js-serialized",
3773            value: true
3774          }
3775        },
3776        onBeforeRenderEnv: {
3777          type: "computed",
3778          definedAtData: null,
3779          valueSerialized: {
3780            type: "js-serialized",
3781            value: {
3782              server: true
3783            }
3784          }
3785        },
3786        dataEnv: {
3787          type: "computed",
3788          definedAtData: null,
3789          valueSerialized: {
3790            type: "js-serialized",
3791            value: null
3792          }
3793        },
3794        route: {
3795          type: "standard",
3796          definedAtData: {
3797            filePathToShowToUser: "/pages/@lang/help-useGpt/+route.ts",
3798            fileExportPathToShowToUser: []
3799          },
3800          valueSerialized: {
3801            type: "plus-file",
3802            exportValues: Io
3803          }
3804        },
3805        clientRouting: {
3806          type: "standard",
3807          definedAtData: {
3808            filePathToShowToUser: "vike-react/config",
3809            fileExportPathToShowToUser: [
3810              "default",
3811              "clientRouting"
3812            ]
3813          },
3814          valueSerialized: {
3815            type: "js-serialized",
3816            value: true
3817          }
3818        }
3819      }
3820    },
3821    {
3822      pageId: "/pages/@lang/help-useNetflix",
3823      isErrorPage: void 0,
3824      routeFilesystem: {
3825        routeString: "/@lang/help-useNetflix",
3826        definedAtLocation: "/pages/@lang/help-useNetflix/"
3827      },
3828      loadConfigValuesAll: () => ({
3829        moduleId: "virtual:vike:pageConfigValuesAll:client:/pages/@lang/help-useNetflix",
3830        moduleExports: E(() => import("./pages_-lang_help-useNetflix.BBRyJO-k.js"), __vite__mapDeps([42,1,2,3,4,5,6,7]))
3831      }),
3832      configValuesSerialized: {
3833        isClientRuntimeLoaded: {
3834          type: "computed",
3835          definedAtData: null,
3836          valueSerialized: {
3837            type: "js-serialized",
3838            value: true
3839          }
3840        },
3841        onBeforeRenderEnv: {
3842          type: "computed",
3843          definedAtData: null,
3844          valueSerialized: {
3845            type: "js-serialized",
3846            value: {
3847              server: true
3848            }
3849          }
3850        },
3851        dataEnv: {
3852          type: "computed",
3853          definedAtData: null,
3854          valueSerialized: {
3855            type: "js-serialized",
3856            value: null
3857          }
3858        },
3859        route: {
3860          type: "standard",
3861          definedAtData: {
3862            filePathToShowToUser: "/pages/@lang/help-useNetflix/+route.ts",
3863            fileExportPathToShowToUser: []
3864          },
3865          valueSerialized: {
3866            type: "plus-file",
3867            exportValues: Oo
3868          }
3869        },
3870        clientRouting: {
3871          type: "standard",
3872          definedAtData: {
3873            filePathToShowToUser: "vike-react/config",
3874            fileExportPathToShowToUser: [
3875              "default",
3876              "clientRouting"
3877            ]
3878          },
3879          valueSerialized: {
3880            type: "js-serialized",
3881            value: true
3882          }
3883        }
3884      }
3885    },
3886    {
3887      pageId: "/pages/@lang/help-ytbRegion",
3888      isErrorPage: void 0,
3889      routeFilesystem: {
3890        routeString: "/@lang/help-ytbRegion",
3891        definedAtLocation: "/pages/@lang/help-ytbRegion/"
3892      },
3893      loadConfigValuesAll: () => ({
3894        moduleId: "virtual:vike:pageConfigValuesAll:client:/pages/@lang/help-ytbRegion",
3895        moduleExports: E(() => import("./pages_-lang_help-ytbRegion.DIA1zTqN.js"), __vite__mapDeps([43,1,2,3,4,5,6,7]))
3896      }),
3897      configValuesSeriali

3897zed: {
3898        isClientRuntimeLoaded: {
3899          type: "computed",
3900          definedAtData: null,
3901          valueSerialized: {
3902            type: "js-serialized",
3903            value: true
3904          }
3905        },
3906        onBeforeRenderEnv: {
3907          type: "computed",
3908          definedAtData: null,
3909          valueSerialized: {
3910            type: "js-serialized",
3911            value: {
3912              server: true
3913            }
3914          }
3915        },
3916        dataEnv: {
3917          type: "computed",
3918          definedAtData: null,
3919          valueSerialized: {
3920            type: "js-serialized",
3921            value: null
3922          }
3923        },
3924        route: {
3925          type: "standard",
3926          definedAtData: {
3927            filePathToShowToUser: "/pages/@lang/help-ytbRegion/+route.ts",
3928            fileExportPathToShowToUser: []
3929          },
3930          valueSerialized: {
3931            type: "plus-file",
3932            exportValues: Fo
3933          }
3934        },
3935        clientRouting: {
3936          type: "standard",
3937          definedAtData: {
3938            filePathToShowToUser: "vike-react/config",
3939            fileExportPathToShowToUser: [
3940              "default",
3941              "clientRouting"
3942            ]
3943          },
3944          valueSerialized: {
3945            type: "js-serialized",
3946            value: true
3947          }
3948        }
3949      }
3950    },
3951    {
3952      pageId: "/pages/@lang/index",
3953      isErrorPage: void 0,
3954      routeFilesystem: {
3955        routeString: "/@lang",
3956        definedAtLocation: "/pages/@lang/index/"
3957      },
3958      loadConfigValuesAll: () => ({
3959        moduleId: "virtual:vike:pageConfigValuesAll:client:/pages/@lang/index",
3960        moduleExports: E(() => import("./pages_-lang_index.pc7R_DM_.js"), __vite__mapDeps([44,1,2,3,4,5,6,7]))
3961      }),
3962      configValuesSerialized: {
3963        isClientRuntimeLoaded: {
3964          type: "computed",
3965          definedAtData: null,
3966          valueSerialized: {
3967            type: "js-serialized",
3968            value: true
3969          }
3970        },
3971        onBeforeRenderEnv: {
3972          type: "computed",
3973          definedAtData: null,
3974          valueSerialized: {
3975            type: "js-serialized",
3976            value: {
3977              server: true
3978            }
3979          }
3980        },
3981        dataEnv: {
3982          type: "computed",
3983          definedAtData: null,
3984          valueSerialized: {
3985            type: "js-serialized",
3986            value: null
3987          }
3988        },
3989        route: {
3990          type: "standard",
3991          definedAtData: {
3992            filePathToShowToUser: "/pages/@lang/index/+route.ts",
3993            fileExportPathToShowToUser: []
3994          },
3995          valueSerialized: {
3996            type: "plus-file",
3997            exportValues: $o
3998          }
3999        },
4000        clientRouting: {
4001          type: "standard",
4002          definedAtData: {
4003            filePathToShowToUser: "vike-react/config",
4004            fileExportPathToShowToUser: [
4005              "default",
4006              "clientRouting"
4007            ]
4008          },
4009          valueSerialized: {
4010            type: "js-serialized",
4011            value: true
4012          }
4013        }
4014      }
4015    },
4016    {
4017      pageId: "/pages/@lang/privacy-policy",
4018      isErrorPage: void 0,
4019      routeFilesystem: {
4020        routeString: "/@lang/privacy-policy",
4021        definedAtLocation: "/pages/@lang/privacy-policy/"
4022      },
4023      loadConfigValuesAll: () => ({
4024        moduleId: "virtual:vike:pageConfigValuesAll:client:/pages/@lang/privacy-policy",
4025        moduleExports: E(() => import("./pages_-lang_privacy-policy.3cVNMbxL.js"), __vite__mapDeps([45,1,2,3,4,5,6,7]))
4026      }),
4027      configValuesSerialized: {
4028        isClientRuntimeLoaded: {
4029          type: "computed",
4030          definedAtData: null,
4031          valueSerialized: {
4032            type: "js-serialized",
4033            value: true
4034          }
4035        },
4036        onBeforeRenderEnv: {
4037          type: "computed",
4038          definedAtData: null,
4039          valueSerialized: {
4040            type: "js-serialized",
4041            value: {
4042              server: true
4043            }
4044          }
4045        },
4046        dataEnv: {
4047          type: "computed",
4048          definedAtData: null,
4049          valueSerialized: {
4050            type: "js-serialized",
4051            value: null
4052          }
4053        },
4054        route: {
4055          type: "standard",
4056          definedAtData: {
4057            filePathToShowToUser: "/pages/@lang/privacy-policy/+route.ts",
4058            fileExportPathToShowToUser: []
4059          },
4060          valueSerialized: {
4061            type: "plus-file",
4062            exportValues: Uo
4063          }
4064        },
4065        clientRouting: {
4066          type: "standard",
4067          definedAtData: {
4068            filePathToShowToUser: "vike-react/config",
4069            fileExportPathToShowToUser: [
4070              "default",
4071              "clientRouting"
4072            ]
4073          },
4074          valueSerialized: {
4075            type: "js-serialized",
4076            value: true
4077          }
4078        }
4079      }
4080    },
4081    {
4082      pageId: "/pages/@lang/product/@slug",
4083      isErrorPage: void 0,
4084      routeFilesystem: {
4085        routeString: "/@lang/product/@slug",
4086        definedAtLocation: "/pages/@lang/product/@slug/"
4087      },
4088      loadConfigValuesAll: () => ({
4089        moduleId: "virtual:vike:pageConfigValuesAll:client:/pages/@lang/product/@slug",
4090        moduleExports: E(() => import("./pages_-lang_product_-slug.Crm6tnuF.js"), __vite__mapDeps([46,1,2,3,4,5,28,6,7,14,17]))
4091      }),
4092      configValuesSerialized: {
4093        isClientRuntimeLoaded: {
4094          type: "computed",
4095          definedAtData: null,
4096          valueSerialized: {
4097            type: "js-serialized",
4098            value: true
4099          }
4100        },
4101        onBeforeRenderEnv: {
4102          type: "computed",
4103          definedAtData: null,
4104          valueSerialized: {
4105            type: "js-serialized",
4106            value: {
4107              server: true
4108            }
4109          }
4110        },
4111        dataEnv: {
4112          type: "computed",
4113          definedAtData: null,
4114          valueSerialized: {
4115            type: "js-serialized",
4116            value: null
4117          }
4118        },
4119        route: {
4120          type: "standard",
4121          definedAtData: {
4122            filePathToShowToUser: "/pages/@lang/product/@slug/+route.ts",
4123            fileExportPathToShowToUser: []
4124          },
4125          valueSerialized: {
4126            type: "plus-file",
4127            exportValues: No
4128          }
4129        },
4130        clientRouting: {
4131          type: "standard",
4132          definedAtData: {
4133            filePathToShowToUser: "vike-react/config",
4134            fileExportPathToShowToUser: [
4135              "default",
4136              "clientRouting"
4137            ]
4138          },
4139          valueSerialized: {
4140            type: "js-serialized",
4141            value: true
4142          }
4143        }
4144      }
4145    },
4146    {
4147      pageId: "/pages/@lang/refund-policy",
4148      isErrorPage: void 0,
4149      routeFilesystem: {
4150        routeString: "/@lang/refund-policy",
4151        definedAtLocation: "/pages/@lang/refund-policy/"
4152      },
4153      loadConfigValuesAll: () => ({
4154        moduleId: "virtual:vike:pageConfigValuesAll:client:/pages/@lang/refund-policy",
4155        moduleExports: E(() => import("./pages_-lang_refund-policy.CMG0XXkF.js"), __vite__mapDeps([47,1,2,3,4,5,6,7]))
4156      }),
4157      configValuesSerialized: {
4158        isClientRuntimeLoaded: {
4159          type: "computed",
4160          definedAtData: null,
4161          valueSerialized: {
4162            type: "js-serialized",
4163            value: true
4164          }
4165        },
4166        onBeforeRenderEnv: {
4167          type: "computed",
4168          definedAtData: null,
4169          valueSerialized: {
4170            type: "js-serialized",
4171            value: {
4172              server: true
4173            }
4174          }
4175        },
4176        dataEnv: {
4177          type: "computed",
4178          definedAtData: null,
4179          valueSerialized: {
4180            type: "js-serialized",
4181            value: null
4182          }
4183        },
4184        route: {
4185          type: "standard",
4186          definedAtData: {
4187            filePathToShowToUser: "/pages/@lang/refund-policy/+route.ts",
4188            fileExportPathToShowToUser: []
4189          },
4190          valueSerialized: {
4191            type: "plus-file",
4192            exportValues: Mo
4193          }
4194        },
4195        clientRouting: {
4196          type: "standard",
4197          definedAtData: {
4198            filePathToShowToUser: "vike-react/config",
4199            fileExportPathToShowToUser: [
4200              "default",
4201              "clientRouting"
4202            ]
4203          },
4204          valueSerialized: {
4205            type: "js-serialized",
4206            value: true
4207          }
4208        }
4209      }
4210    },
4211    {
4212      pageId: "/pages/@lang/terms",
4213      isErrorPage: void 0,
4214      routeFilesystem: {
4215        routeString: "/@lang/terms",
4216        definedAtLocation: "/pages/@lang/terms/"
4217      },
4218      loadConfigValuesAll: () => ({
4219        moduleId: "virtual:vike:pageConfigValuesAll:client:/pages/@lang/terms",
4220        moduleExports: E(() => import("./pages_-lang_terms.dYP7X8Jy.js"), __vite__mapDeps([48,1,2,3,4,5,6,7]))
4221      }),
4222      configValuesSerialized: {
4223        isClientRuntimeLoaded: {
4224          type: "computed",
4225          definedAtData: null,
4226          valueSerialized: {
4227            type: "js-serialized",
4228            value: true
4229          }
4230        },
4231        onBeforeRenderEnv: {
4232          type: "computed",
4233          definedAtData: null,
4234          valueSerialized: {
4235            type: "js-serialized",
4236            value: {
4237              server: true
4238            }
4239          }
4240        },
4241        dataEnv: {
4242          type: "computed",
4243          definedAtData: null,
4244          valueSerialized: {
4245            type: "js-serialized",
4246            value: null
4247          }
4248        },
4249        route: {
4250          type: "standard",
4251          definedAtData: {
4252            filePathToShowToUser: "/pages/@lang/terms/+route.ts",
4253            fileExportPathToShowToUser: []
4254          },
4255          valueSerialized: {
4256            type: "plus-file",
4257            exportValues: Yo
4258          }
4259        },
4260        clientRouting: {
4261          type: "standard",
4262          definedAtData: {
4263            filePathToShowToUser: "vike-react/config",
4264            fileExportPathToShowToUser: [
4265              "default",
4266              "clientRouting"
4267            ]
4268          },
4269          valueSerialized: {
4270            type: "js-serialized",
4271            value: true
4272          }
4273        }
4274      }
4275    },
4276    {
4277      pageId: "/pages/spa",
4278      isErrorPage: void 0,
4279      routeFilesystem: {
4280        routeString: "/spa",
4281        definedAtLocation: "/pages/spa/"
4282      },
4283      loadConfigValuesAll: () => ({
4284        moduleId: "virtual:vike:pageConfigValuesAll:client:/pages/spa",
4285        moduleExports: E(() => import("./pages_spa.C5xTuQKw.js").then(async (m2) => {
4286          await m2.__tla;
4287          return m2;
4288        }).then((e) => e.bX), __vite__mapDeps([49,1,2,3,4,5,28,6,7,14,17,50]))
4289      }),
4290      configValuesSerialized: {
4291        isClientRuntimeLoaded: {
4292          type: "computed",
4293          definedAtData: null,
4294          valueSerialized: {
4295            type: "js-serialized",
4296            value: true
4297          }
4298        },
4299        onBeforeRenderEnv: {
4300          type: "computed",
4301          definedAtData: null,
4302          valueSerialized: {
4303            type: "js-serialized",
4304            value: {
4305              server: true
4306            }
4307          }
4308        },
4309        dataEnv: {
4310          type: "computed",
4311          definedAtData: null,
4312          valueSerialized: {
4313            type: "js-serialized",
4314            value: null
4315          }
4316        },
4317        route: {
4318          type: "standard",
4319          definedAtData: {
4320            filePathToShowToUser: "/pages/spa/+route.ts",
4321            fileExportPathToShowToUser: []
4322          },
4323          valueSerialized: {
4324            type: "plus-file",
4325            exportValues: Zo
4326          }
4327        },
4328        clientRouting: {
4329          type: "standard",
4330          definedAtData: {
4331            filePathToShowToUser: "vike-react/config",
4332            fileExportPathToShowToUser: [
4333              "default",
4334              "clientRouting"
4335            ]
4336          },
4337          valueSerialized: {
4338            type: "js-serialized",
4339            value: true
4340          }
4341        }
4342      }
4343    }
4344  ], na = {
4345    configValuesSerialized: {}
4346  }, ia = Object.assign({}), ra = {
4347    ...ia
4348  };
4349  Ve[".page"] = ra;
4350  const oa = Object.assign({}), aa = {
4351    ...oa
4352  };
4353  ge[".page"] = aa;
4354  const sa = Object.assign({}), la = {
4355    ...sa
4356  };
4357  ge[".page.server"] = la;
4358  const ua = Object.assign({}), da = {
4359    ...ua
4360  };
4361  Pn[".page.route"] = da;
4362  const ca = Object.assign({}), fa = {
4363    ...ca
4364  };
4365  Ve[".page.client"] = fa;
4366  const ga = Object.assign({}), pa = {
4367    ...ga
4368  };
4369  ge[".page.client"] = pa;
4370  const ha = Object.assign({}), ya = {
4371    ...ha
4372  };
4373  En[".page.server"] = ya;
4374  const ma = Object.freeze(Object.defineProperty({
4375    __proto__: null,
4376    neverLoaded: En,
4377    pageConfigGlobalSerialized: na,
4378    pageConfigsSerialized: ta,
4379    pageFilesEager: Pn,
4380    pageFilesExportNamesEager: ge,
4381    pageFilesExportNamesLazy: Qo,
4382    pageFilesLazy: Ve,
4383    pageFilesList: ea
4384  }, Symbol.toStringTag, {
4385    value: "Module"
4386  })), va = eo(ma, true, Sa);
4387  async function Sa(e) {
4388    const { pageRoutes: t, onBeforeRouteHook: n } = await io(e._pageFilesAll, e._pageConfigs, e._pageConfigGlobal, e._allPageIds);
4389    return {
4390      _pageRoutes: t,
4391      _onBeforeRouteHook: n
4392    };
4393  }
4394  async function Rn(e) {
4395    const t = await va(), n = hn();
4396    a(Ie(n));
4397    const i = {
4398      globalContext: t,
4399      _pageFilesAll: t._pageFilesAll,
4400      _pageConfigs: t._pageConfigs,
4401      _pageConfigGlobal: t._pageConfigGlobal,
4402      _allPageIds: t._allPageIds,
4403      _pageRoutes: t._pageRoutes,
4404      _onBeforeRouteHook: t._onBeforeRouteHook,
4405      isClientSide: true,
4406      isPrerendering: false,
4407      urlOriginal: e,
4408      _urlHandler: null,
4409      _urlRewrite: null,
4410      _baseServer: n
4411    }, r = Or(i);
4412    y(i, r);
4413    const o = await Dr(i, t._pageConfigGlobal);
4414    return le(i, o), i;
4415  }
4416  function _n(e, t) {
4417    const n = e.filter((r) => r.pageId === t);
4418    return a(n.length <= 1), n[0] ?? null;
4419  }
4420  async function Pa(e, t) {
4421    if ("isAllLoaded" in e) return e;
4422    const { moduleId: n, moduleExports: i } = e.loadConfigValuesAll(), r = await i;
4423    r || a(false, {
4424      moduleExports: i,
4425      configValuesLoaded: r,
4426      moduleId: n
4427    });
4428    const o = _e(r.configValuesSerialized);
4429    return Object.assign(e.configValues, o), y(e, {
4430      isAllLoaded: true
4431    }), e;
4432  }
4433  const An = "__whileFetchingAssets";
4434  async function Ae(e, t, n, i) {
4435    const r = Fe(t, e), o = _n(n, e);
4436    let s;
4437    const l = false;

4438    try {
4439      s = (await Promise.all([
4440        o && Pa(o, l),
4441        ...r.map((f) => {
4442          var _a2;
4443          return (_a2 = f.loadFile) == null ? void 0 : _a2.call(f);
4444        })
4445      ]))[0];
4446    } catch (c) {
4447      throw Ea(c) && Object.assign(c, {
4448        [An]: true
4449      }), c;
4450    }
4451    const u = xr(r, s, i), d = {};
4452    return y(d, u), y(d, {
4453      _pageFilesLoaded: r
4454    }), d;
4455  }
4456  function Ue(e) {
4457    return e ? e[An] === true : false;
4458  }
4459  function Ea(e) {
4460    return e instanceof Error ? [
4461      "Failed to fetch dynamically imported module",
4462      "error loading dynamically imported module",
4463      "Importing a module script failed",
4464      "error resolving module specifier",
4465      "failed to resolve module"
4466    ].some((n) => e.message.toLowerCase().includes(n.toLowerCase())) : false;
4467  }
4468  function ee(e, t) {
4469    a(!e.startsWith("#"));
4470    const { searchOriginal: n, hashOriginal: i, pathname: r } = ce(e, "/");
4471    let o = `${r}${n || ""}`;
4472    return (t == null ? void 0 : t.withoutHash) || (o += i || ""), a(o.startsWith("/")), o;
4473  }
4474  function Be(e) {
4475    const t = e.getAttribute("href");
4476    return t === null || !Ot(t) || t === "" || ii(t) || Aa(t) || _a(e) || !ba(t) || !Ra(e);
4477  }
4478  function Ra(e) {
4479    if (Ca()) {
4480      const n = e.getAttribute("data-vike-link");
4481      return n !== null && n !== "false";
4482    } else return true;
4483  }
4484  function _a(e) {
4485    const t = e.getAttribute("target"), n = e.getAttribute("rel");
4486    return t === "_blank" || t === "_external" || n === "external" || e.hasAttribute("download");
4487  }
4488  function Aa(e) {
4489    return !!(e.startsWith("#") || e.includes("#") && ee(e, {
4490      withoutHash: true
4491    }) === ee(window.location.href, {
4492      withoutHash: true
4493    }));
4494  }
4495  function Ta(e) {
4496    return e.startsWith("#") ? e === window.location.hash : ee(e) === ee(window.location.href);
4497  }
4498  function ba(e) {
4499    const t = hn();
4500    a(Ie(t));
4501    const { isBaseMissing: n } = ce(e, t);
4502    return !n;
4503  }
4504  function Ca() {
4505    return !!window._disableAutomaticLinkInterception;
4506  }
4507  function Z(e) {
4508    return e.fileType === ".css" ? [] : e.exportNames ? e.exportNames : (a(e.fileExports, e.filePath), Object.keys(e.fileExports));
4509  }
4510  function wa({ pageFilesClientSide: e, pageFilesServerSide: t, pageId: n }) {
4511    return {
4512      isHtmlOnly: i(),
4513      isClientRouting: o()
4514    };
4515    function i() {
4516      return t.some((l) => l.pageId === n && l.fileType === ".page") ? (r(), false) : !(!t.some((l) => l.pageId === n && l.fileType === ".page.server") || e.some((l) => l.pageId === n && l.fileType === ".page.client" && Z(l).includes("render")));
4517    }
4518    function r() {
4519      const s = e.some((l) => Z(l).includes("render"));
4520      h(s, [
4521        "No client-side `render()` hook found.",
4522        "See https://vike.dev/render-modes for more information.",
4523        [
4524          "Loaded client-side page files (none of them `export { render }`):",
4525          ...e.map((l, u) => ` (${u + 1}): ${l.filePath}`)
4526        ].join(`
4527`)
4528      ].join(" "));
4529    }
4530    function o() {
4531      return e.some((l) => Z(l).includes("clientRouting"));
4532    }
4533  }
4534  function za({ pageFilesClientSide: e, pageFilesServerSide: t, isHtmlOnly: n, isClientRouting: i }) {
4535    let r = [];
4536    const o = t.filter((l) => !e.includes(l)), s = [];
4537    if (s.push(...e.map((l) => ({
4538      id: l.filePath,
4539      onlyAssets: false,
4540      eagerlyImported: false
4541    }))), s.push(...o.map((l) => ({
4542      id: l.filePath,
4543      onlyAssets: true,
4544      eagerlyImported: false
4545    }))), n) r = e.map((l) => l.filePath);
4546    else {
4547      const l = xa(i);
4548      s.push({
4549        id: l,
4550        onlyAssets: false,
4551        eagerlyImported: false
4552      }), r = [
4553        l
4554      ];
4555    }
4556    return {
4557      clientEntries: r,
4558      clientDependencies: s
4559    };
4560  }
4561  function xa(e) {
4562    return e ? "@@vike/dist/esm/client/client-routing-runtime/entry.js" : "@@vike/dist/esm/client/server-routing-runtime/entry.js";
4563  }
4564  function ja(e, t) {
4565    let n = Fe(e, t);
4566    const i = Wt(e, t), { isHtmlOnly: r, isClientRouting: o } = wa({
4567      pageFilesClientSide: n,
4568      pageFilesServerSide: i,
4569      pageId: t
4570    });
4571    r && (n = n.filter((u) => u.isEnv("CLIENT_ONLY") && !Z(u).includes("render")), n = Da(n));
4572    const { clientEntries: s, clientDependencies: l } = za({
4573      pageFilesClientSide: n,
4574      pageFilesServerSide: i,
4575      isHtmlOnly: r,
4576      isClientRouting: o
4577    });
4578    return {
4579      isHtmlOnly: r,
4580      isClientRouting: o,
4581      clientEntries: s,
4582      clientDependencies: l,
4583      pageFilesClientSide: n,
4584      pageFilesServerSide: i
4585    };
4586  }
4587  async function Ia(e, t, { sharedPageFilesAlreadyLoaded: n }) {
4588    const i = Fe(e, t);
4589    await Promise.all(i.map(async (r) => {
4590      var _a2;
4591      a(r.isEnv("CLIENT_ONLY") || r.isEnv("CLIENT_AND_SERVER")), await ((_a2 = r.loadExportNames) == null ? void 0 : _a2.call(r));
4592    }));
4593  }
4594  function Da(e) {
4595    const t = [];
4596    for (const n of e) if (t.push(n), Z(n).includes("overrideDefaultPages")) break;
4597    return t;
4598  }
4599  function Oa(e, t, n) {
4600    var _a2, _b;
4601    if (e) {
4602      const i = ((_a2 = q(e, "clientRouting", "boolean")) == null ? void 0 : _a2.value) ?? false;
4603      return {
4604        isClientRuntimeLoaded: ((_b = q(e, "isClientRuntimeLoaded", "boolean")) == null ? void 0 : _b.value) ?? false,
4605        isClientRouting: i
4606      };
4607    } else {
4608      const { isHtmlOnly: i, isClientRouting: r } = ja(t, n);
4609      return {
4610        isClientRuntimeLoaded: !i,
4611        isClientRouting: r
4612      };
4613    }
4614  }
4615  async function Te(e, t) {
4616    await Ia(t._pageFilesAll, e, {
4617      sharedPageFilesAlreadyLoaded: false
4618    });

4619    const n = _n(t._pageConfigs, e), { isClientRuntimeLoaded: i, isClientRouting: r } = Oa(n, t._pageFilesAll, e);
4620    return i && r;
4621  }
4622  const Tn = "@", be = ":";
4623  function ka(e, t = "Invalid") {
4624    let n = `${t} Route String ${K(e)}`;
4625    h(e !== "", `${n} (empty string): set it to ${K("/")} instead`), h([
4626      "/",
4627      "*"
4628    ].includes(e[0]), `${n}: it should start with ${K("/")} or ${K("*")}`), h(!e.includes("**"), `${n}: set it to ${K(e.split("**").join("*"))} instead`);
4629  }
4630  function Ce(e, t) {
4631    ka(e);
4632    const n = He(e), i = n.map((f) => f.param ? "[^/]+" : f.glob ? ".*" : _i(f.static)).map((f) => `(${f})`).join(""), r = new RegExp(`^${i}/?$`), o = t.match(r);
4633    if (!o) return null;
4634    const s = {}, [l, ...u] = o;
4635    let d = 0;
4636    const c = n.filter((f) => f.glob).length > 1;
4637    return n.forEach((f, S) => {
4638      let R = u[S];
4639      if (f.param && (s[f.param] = R), f.glob) {
4640        const P = `*${c ? ++d : ""}`;
4641        s[P] = R;
4642      }
4643    }), {
4644      routeParams: s
4645    };
4646  }
4647  function He(e) {
4648    const t = [], n = (r) => {
4649      const o = t[t.length - 1];
4650      (o == null ? void 0 : o.static) ? o.static += r : t.push({
4651        static: r
4652      });
4653    }, i = e.split("/");
4654    return i.forEach((r, o) => {
4655      o !== 0 && n("/"), La(r) ? (C(!r.startsWith(be), `Outdated Route String ${K(e)}, use ${K(e.split(be).join(Tn))} instead`, {
4656        onlyOnce: true
4657      }), t.push({
4658        param: r.slice(1)
4659      })) : r === "*" && o === i.length - 1 && e !== "*" && e !== "/*" ? t.push({
4660        glob: true
4661      }) : r.split("*").forEach((s, l) => {
4662        l !== 0 && t.push({
4663          glob: true
4664        }), s !== "" && n(s);
4665      });
4666    }), t;
4667  }
4668  function Fa(e) {
4669    const t = [];
4670    return He(e).forEach((i) => {
4671      i.param && t.push(i.param);
4672    }), t;
4673  }
4674  function ae(e) {
4675    const t = He(e), n = (l) => (l == null ? void 0 : l.split("/").filter(Boolean).length) || 0;
4676    let i = 0;
4677    for (const l of t) {
4678      if (!l.static) break;
4679      i += n(l.static);
4680    }
4681    const r = t.map((l) => n(l.static)).reduce((l, u) => l + u, 0), o = t.filter((l) => l.param).length, s = t.filter((l) => l.glob).length;
4682    return {
4683      numberOfStaticPartsBeginning: i,
4684      numberOfStaticParts: r,
4685      numberOfParams: o,
4686      numberOfGlobs: s
4687    };
4688  }
4689  function La(e) {
4690    return e.startsWith(Tn) || e.startsWith(be);
4691  }
4692  function pt(e) {
4693    const n = Ce(e, e);
4694    return a(n), Object.keys(n.routeParams).length === 0;
4695  }
4696  function K(e) {
4697    return Y() ? `'${e}'` : (e === "" && (e = "''"), p.cyan(e));
4698  }
4699  function $a(e) {
4700    e.sort(Va).sort(G((t) => t.routeType === "FUNCTION" && !!t.precedence && t.precedence < 0)).sort(G((t) => t.routeType === "STRING" && pt(t.routeString) === false)).sort(G((t) => t.routeType === "FUNCTION" && !t.precedence)).sort(G((t) => t.routeType === "STRING" && pt(t.routeString) === true)).sort(G((t) => t.routeType === "FILESYSTEM")).sort(G((t) => t.routeType === "FUNCTION" && !!t.precedence && t.precedence > 0));
4701  }
4702  function Va(e, t) {
4703    {
4704      const n = e.precedence ?? 0, i = t.precedence ?? 0;
4705      if (n !== i) return n > i ? -1 : 1;
4706    }
4707    if (!t.routeString || !e.routeString) return 0;
4708    {
4709      const i = ue((r) => ae(r).numberOfStaticPartsBeginning)(e.routeString, t.routeString);
4710      if (i !== 0) return i;
4711    }
4712    {
4713      const i = ue((r) => ae(r).numberOfStaticParts)(e.routeString, t.routeString);
4714      if (i !== 0) return i;
4715    }
4716    {
4717      const i = yi((r) => ae(r).numberOfGlobs)(e.routeString, t.routeString);
4718      if (i !== 0) return i;
4719    }
4720    {
4721      const i = ue((r) => ae(r).numberOfParams)(e.routeString, t.routeString);
4722      if (i !== 0) return i;
4723    }
4724    return 0;
4725  }
4726  async function Ua(e) {
4727    const t = {};
4728    if (!e._onBeforeRouteHook) return null;
4729    const n = await Ba(e._onBeforeRouteHook, e);
4730    return n && (y(t, n), m(t, "pageId", "string") || m(t, "pageId", "null")) ? (m(t, "routeParams") ? a(m(t, "routeParams", "object")) : y(t, {
4731      routeParams: {}
4732    }), y(t, {
4733      _routingProvidedByOnBeforeRouteHook: true,
4734      _debugRouteMatches: "CUSTOM_ROUTING"
4735    }), t) : (y(t, {
4736      _routingProvidedByOnBeforeRouteHook: false
4737    }), t);
4738  }
4739  async function Ba(e, t) {
4740    let n = e.hookFn(t);
4741    mn(n, `The onBeforeRoute() hook ${e.hookFilePath}`), n = await U(() => n, e, t);
4742    const i = `The onBeforeRoute() hook defined by ${e.hookFilePath}`;
4743    if (h(n == null || dr(n, [
4744      "pageContext"
4745    ]) && m(n, "pageContext"), `${i} should return ${p.cyan("null")}, ${p.cyan("undefined")}, or a plain JavaScript object ${p.cyan("{ pageContext: { /* ... */ } }")}`), n == null) return null;
4746    if (h(m(n, "pageContext", "object"), `${i} returned ${p.cyan("{ pageContext }")} but pageContext should be a plain JavaScript object.`), m(n.pageContext, "pageId") && !m(n.pageContext, "pageId", "null")) {
4747      const s = `${i} returned ${p.cyan("{ pageContext: { pageId } }")} but ${p.cyan("pageId")} should be`;
4748      h(m(n.pageContext, "pageId", "string"), `${s} a string or null`), h(t._allPageIds.includes(n.pageContext.pageId), `${s} ${cr(t._allPageIds.map((l) => p.cyan(l)), "or")}`);
4749    }

4750    m(n.pageContext, "routeParams") && vn(n.pageContext, `${i} returned ${p.cyan("{ pageContext: { routeParams } }")} but routeParams should`);
4751    const r = (s) => `${i} returned ${p.cyan(`{ pageContext: { ${s} } }`)} which is deprecated. Return ${p.cyan("{ pageContext: { urlLogical } }")} instead.`;
4752    m(n.pageContext, "url") && (C(false, r("url"), {
4753      onlyOnce: true
4754    }), n.pageContext.urlLogical = n.pageContext.url, delete n.pageContext.url), m(n.pageContext, "urlOriginal") && (C(false, r("urlOriginal"), {
4755      onlyOnce: true
4756    }), n.pageContext.urlLogical = n.pageContext.urlOriginal, delete n.pageContext.urlOriginal), m(n.pageContext, "urlLogical") && oi(n.pageContext.urlLogical, `${i} returned ${p.cyan("{ pageContext: { urlLogical } }")} and ${p.cyan("urlLogical")}`), qt(n.pageContext, {
4757      hookFilePath: e.hookFilePath,
4758      hookName: "onBeforeRoute"
4759    });
4760    const o = {};
4761    return y(o, n.pageContext), o;
4762  }
4763  var se;
4764  function ht(...e) {
4765    var _a2;
4766    se || (se = (_a2 = globalThis.__brillout_debug_createDebugger) == null ? void 0 : _a2.call(globalThis, "vike:routing")), se && se(...e);
4767  }
4768  Y() && ne();
4769  async function bn(e, t) {
4770    ht("Pages routes:", e._pageRoutes), gn(e);
4771    const n = {};
4772    {
4773      const l = await Ua(e);
4774      if (l) {
4775        if (l._routingProvidedByOnBeforeRouteHook) return a(l.pageId), l;
4776        y(n, l);
4777      }
4778      y(e, l);
4779    }
4780    const i = e._allPageIds;
4781    h(i.length > 0, "No page found. You must create at least one page."), a(e._pageFilesAll.length > 0 || e._pageConfigs.length > 0);
4782    const { urlPathname: r }

4782 = e;
4783    a(r.startsWith("/"));
4784    const o = [];
4785    await Promise.all(e._pageRoutes.map(async (l) => {
4786      const { pageId: u, routeType: d } = l;
4787      if (l.routeType === "FILESYSTEM") {
4788        const { routeString: c } = l, f = Ce(c, r);
4789        if (f) {
4790          const { routeParams: S } = f;
4791          o.push({
4792            pageId: u,
4793            routeParams: S,
4794            routeString: c,
4795            routeType: d
4796          });
4797        }
4798        return;
4799      }
4800      if (l.routeType === "STRING") {
4801        const { routeString: c } = l, f = Ce(c, r);
4802        if (f) {
4803          const { routeParams: S } = f;
4804          a(d === "STRING"), o.push({
4805            pageId: u,
4806            routeString: c,
4807            routeParams: S,
4808            routeType: d
4809          });
4810        }
4811        return;
4812      }
4813      if (l.routeType === "FUNCTION") {
4814        const { routeFunction: c, routeDefinedAtString: f } = l, S = await no(c, e, f);
4815        if (S) {
4816          const { routeParams: R, precedence: P } = S;
4817          o.push({
4818            pageId: u,
4819            precedence: P,
4820            routeParams: R,
4821            routeType: d
4822          });
4823        }
4824        return;
4825      }
4826      a(false);
4827    })), $a(o);
4828    const s = o[0] ?? null;
4829    if (ht(`Route matches for URL ${p.cyan(r)} (in precedence order):`, o), y(n, {
4830      _debugRouteMatches: o
4831    }), y(n, {
4832      _routeMatch: s
4833    }), !s) return y(n, {
4834      pageId: null,
4835      routeParams: {}
4836    }), n;
4837    {
4838      const { routeParams: l } = s;
4839      a(J(l)), y(n, {
4840        pageId: s.pageId,
4841        routeParams: s.routeParams
4842      });
4843    }
4844    return n;
4845  }
4846  const Cn = L("client-routing-runtime/getPageContextCurrent.ts", {
4847    pageContextCurrent: null
4848  });
4849  function wn() {
4850    const { pageContextCurrent: e } = Cn;
4851    return e;
4852  }
4853  function yt(e) {
4854    Cn.pageContextCurrent = e;
4855  }
4856  const de = 5e3, mt = {
4857    staticAssets: "hover",
4858    pageContext: de
4859  }, we = {
4860    staticAssets: "hover",
4861    pageContext: false
4862  }, Ha = we;
4863  function We(e, t) {
4864    let n = Ha;
4865    if ("prefetchLinks" in e.exports && h(false, "`export { prefetchLinks }` is deprecated, use `export { prefetchStaticAssets }` instead."), "prefetchStaticAssets" in e.exports) {
4866      const i = e.exports.prefetchStaticAssets;
4867      n.staticAssets = i;
4868    }
4869    if ("prefetch" in e.exports) {
4870      const { prefetch: i } = e.exports;
4871      i === true && (n = mt), i === false && (n = we), Object.assign(n, i), n.pageContext === true && (n.pageContext = de);
4872    }
4873    if (n.staticAssets, t) {
4874      {
4875        let i = t.getAttribute("data-prefetch");
4876        i !== null && (i === "" && (i = "true"), i === "true" && (n = mt), i === "false" && (n = we));
4877      }
4878      {
4879        let i = t.getAttribute("data-prefetch-static-assets");
4880        i !== null && (i === "false" && (n.staticAssets = false), n.staticAssets = i);
4881      }
4882      {
4883        let i = t.getAttribute("data-prefetch-page-context");
4884        if (i !== null) {
4885          i === "" && (i = "true"), i === "true" && (n.pageContext = de), i === "false" && (n.pageContext = false);
4886          const r = parseInt(i, 10);
4887          Number.isNaN(r) || (n.pageContext = r);
4888        }
4889      }
4890    }
4891    return n;
4892  }
4893  ne();
4894  const k = L("client-routing-runtime/prefetch.ts", {
4895    linkPrefetchHandlerAdded: /* @__PURE__ */ new WeakSet(),
4896    addLinkPrefetchHandlers_debounce: null,
4897    mutationObserver: new MutationObserver(Ne),
4898    linkTags: document.getElementsByTagName("A"),
4899    prefetchedPageContexts: {}
4900  });
4901  function Wa(e) {
4902    if (!We(e, null).pageContext) return null;
4903    const n = Ge(e.urlPathname), i = k.prefetchedPageContexts[n];
4904    return !i || i.result.is404ServerSideRouted || xn(i) ? null : i.result.pageContextFromServerHooks;
4905  }
4906  async function Na(e) {
4907    try {
4908      await Ae(e.pageId, e._pageFilesAll, e._pageConfigs, e._pageConfigGlobal);
4909    } catch (t) {
4910      if (Ue(t)) xe(t, true);
4911      else throw t;
4912    }
4913  }
4914  async function Ga(e, t) {
4915    const n = await Ee(e, false);
4916    zn(e, n, t);
4917  }
4918  function vt(e, t) {
4919    Me() && zn(e, t, null);
4920  }
4921  function zn(e, t, n) {
4922    n === null && (n = Ma());
4923    const i = Ge(e.urlPathname);
4924    a(Me()), k.prefetchedPageContexts[i] = {
4925      resultFetchedAt: Date.now(),
4926      resultMaxAge: n,
4927      result: t
4928    };
4929  }
4930  function Ma() {
4931    const e = wn();
4932    if (!e) return 1 / 0;
4933    const t = We(e, null);
4934    return typeof t.pageContext == "number" ? t.pageContext : de;
4935  }
4936  function Ne() {
4937    k.addLinkPrefetchHandlers_debounce && clearTimeout(k.addLinkPrefetchHandlers_debounce), k.addLinkPrefetchHandlers_debounce = setTimeout(() => {
4938      "requestIdleCallback" in window ? requestIdleCallback(St, {
4939        timeout: 300
4940      }) : setTimeout(St, 150);
4941    }, 250);
4942  }
4943  function Ka() {
4944    Ne();
4945  }
4946  function Ya() {
4947    k.mutationObserver.observe(document.body, {
4948      childList: true,
4949      subtree: true
4950    });
4951  }
4952  function Ja() {
4953    k.mutationObserver.disconnect();
4954  }
4955  function St() {
4956    for (let e of k.linkTags) {
4957      if (k.linkPrefetchHandlerAdded.has(e) || (k.linkPrefetchHandlerAdded.add(e), Be(e))) continue;
4958      e.addEventListener("mouseover", () => {
4959        Se(e, "hover");
4960      }, {
4961        passive: true
4962      }), e.addEventListener("touchstart", () => {
4963        Se(e, "hover");
4964      }, {
4965        passive: true
4966      }), new IntersectionObserver((n) => {

4967        n.forEach((i) => {
4968          i.isIntersecting && Se(e, "viewport");
4969        });
4970      }).observe(e);
4971    }
4972  }
4973  async function Se(e, t) {
4974    let n;
4975    const i = wn();
4976    if (i) n = We(i, e);
4977    else if (Me()) n = {
4978      staticAssets: "hover",
4979      pageContext: 1 / 0
4980    };
4981    else return;
4982    if (Be(e)) return;
4983    const r = e.getAttribute("href"), o = await qa(r);
4984    (o == null ? void 0 : o.pageId) && (a(m(o, "pageId", "string")), await Te(o.pageId, o) && await Promise.all([
4985      (async () => {
4986        n.staticAssets === t && await Na(o);
4987      })(),
4988      (async () => {
4989        if (t !== "viewport" && n.pageContext) {
4990          const s = Ge(r), l = k.prefetchedPageContexts[s];
4991          if (!l || xn(l)) {
4992            const u = n.pageContext;
4993            await Ga(o, u);
4994          }
4995        }
4996      })()
4997    ]));
4998  }
4999  function xn(e) {
5000    return Date.now() - e.resultFetchedAt > e.resultMaxAge;
5001  }
5002  async function qa(e) {
5003    const t = await Rn(e);
5004    let n;
5005    try {
5006      n = await bn(t);
5007    } catch {
5008      return null;
5009    }
5010    return y(t, n), t;
5011  }
5012  function Ge(e) {
5013    return e.startsWith("#") && (e = "/"), a(e.startsWith("/"), {
5014      urlPathname: e
5015    }), e.split("#")[0];
5016  }
5017  function Me() {
5018    return "_isBrilloutDocpress" in window;
5019  }
5020  async function Xa(e, t) {
5021    const n = $e(e);
5022    let i = null, r;
5023    i = H(e, "render"), r = "render";
5024    {
5025      const l = H(e, "onRenderClient");
5026      l && (i = l, r = "onRenderClient");
5027    }
5028    if (!i) {
5029      const l = Za(e);
5030      if (a(l), e._pageConfigs.length > 0) h(false, `No onRenderClient() hook defined for URL '${l}', but it's needed, see https://vike.dev/onRenderClient`);
5031      else {
5032        const u = e._pageFilesLoaded.filter((c) => c.fileType === ".page.client");
5033        let d;
5034        u.length === 0 ? d = "No file `*.page.client.*` found for URL " + l : d = "One of the following files should export a render() hook: " + u.map((c) => c.filePath).join(" "), h(false, d);
5035      }
5036    }
5037    a(i);
5038    const o = i.hookFn;
5039    a(r);
5040    const s = await U(() => o(n), i, e);
5041    h(s === void 0, `The ${r}() hook defined by ${i.hookFilePath} isn't allowed to return a value`);
5042  }
5043  function Za(e) {
5044    let t;
5045    try {
5046      t = e.urlPathname ?? e.urlOriginal;
5047    } catch {
5048    }
5049    return t = t ?? window.location.href, t;
5050  }
5051  function Ke(e) {
5052    return ee(window.location.href, e);
5053  }
5054  Dn();
5055  const ze = L("client-routing-runtime/history.ts", {
5056    previous: Ze()
5057  });
5058  function jn() {
5059    const e = In();
5060    if (X(e)) return;
5061    const t = Qa(e);
5062    Xe(t);
5063  }
5064  function Qa(e) {
5065    const t = qe(), n = Je(), i = "browser";
5066    let r;
5067    return e ? r = {
5068      timestamp: e.timestamp ?? t,
5069      scrollPosition: e.scrollPosition ?? n,
5070      triggeredBy: e.triggeredBy ?? i,
5071      _isVikeEnhanced: true
5072    } : r = {
5073      timestamp: t,
5074      scrollPosition: n,
5075      triggeredBy: i,
5076      _isVikeEnhanced: true
5077    }, a(X(r)), r;
5078  }
5079  function Ye() {
5080    const e = In();
5081    return a(X(e), {
5082      state: e
5083    }), e;
5084  }
5085  function In() {
5086    return window.history.state;
5087  }
5088  function Je() {
5089    return {
5090      x: window.scrollX,
5091      y: window.scrollY
5092    };
5093  }
5094  function qe() {
5095    return (/* @__PURE__ */ new Date()).getTime();
5096  }
5097  function Pt() {
5098    const e = Je(), t = Ye();
5099    Xe({
5100      ...t,
5101      scrollPosition: e
5102    });
5103  }
5104  function es(e, t) {
5105    if (t) Xe(Ye(), e);
5106    else {
5107      const n = {
5108        timestamp: qe(),
5109        scrollPosition: null,
5110        triggeredBy: "vike",
5111        _isVikeEnhanced: true
5112      };
5113      window.history.pushState(n, "", e);
5114    }
5115  }
5116  function Xe(e, t) {
5117    const n = t ?? null;
5118    window.history.replaceState(e, "", n);
5119  }
5120  function Et(e, t) {
5121    History.prototype.replaceState.bind(window.history)(e, "", t);
5122  }
5123  function ts() {
5124    [
5125      "pushState",
5126      "replaceState"
5127    ].forEach((e) => {
5128      const t = window.history[e].bind(window.history);
5129      window.history[e] = (n = {}, ...i) => {
5130        h(n == null || w(n), `history.${e}(state) argument state must be an object`);
5131        const r = X(n) ? n : {
5132          _isVikeEnhanced: true,
5133          scrollPosition: Je(),
5134          timestamp: qe(),
5135          triggeredBy: "user",
5136          ...n
5137        };
5138        a(X(r));
5139        const o = t(r, ...i);
5140        return ze.previous = Ze(), o;
5141      };
5142    });
5143  }
5144  function X(e) {
5145    return !!(w(e) && "_isVikeEnhanced" in e);
5146  }
5147  function Ze() {
5148    return {
5149      url: Ke(),
5150      state: Ye()
5151    };
5152  }
5153  function ns() {
5154    const { previous: e } = ze, t = window.history.state !== null;
5155    t || jn(), a(X(window.history.state));
5156    const n = Ze();
5157    return ze.previous = n, {
5158      isHistoryStateEnhanced: t,
5159      previous: e,
5160      current: n
5161    };
5162  }
5163  function Dn() {
5164    jn();
5165  }
5166  function On(e, t) {
5167    if (!e && t && rs(t)) {
5168      is(t);
5169      return;
5170    }
5171    if (e && "x" in e) {
5172      Fn(e);
5173      return;
5174    }
5175    if (e == null ? void 0 : e.preserveScroll) return;
5176    const n = os();
5177    kn(n);
5178  }
5179  function is(e) {
5180    const t = window.history.state;
5181    Et(null, e), a(window.history.state === null), window.location.replace(e), Et(t, e);
5182  }
5183  function rs(e) {
5184    return e.includes("#") && e.includes(":~:text");
5185  }
5186  function kn(e) {
5187    if (!e) Rt();
5188    else {
5189      const t = decodeURIComponent(e), n = document.getElementById(t) || document.getElementsByName(t)[0];
5190      n ? (n.scrollIntoView(), n.focus()) : e === "top" && Rt();
5191    }
5192  }
5193  function Rt() {
5194    Fn({
5195      x: 0,
5196      y: 0
5197    });
5198  }
5199  function Fn(e) {
5200    const t = () => {
5201      window.scrollTo(e.x, e.y);
5202    }, n = () => window.scrollX === e.x && window.scrollY === e.y;
5203    n() || (t(), !n() && requestAnimationFrame(() => {
5204      t(), !n() && setTimeout(async () => {
5205        if (t(), n()) return;
5206        const i = (/* @__PURE__ */ new Date()).getTime();
5207        for (; ; ) if (await si(10), t(), n() || (/* @__PURE__ */ new Date()).getTime() - i > 100) return;
5208      }, 0);
5209    }));
5210  }
5211  function os() {
5212    let { hash: e } = window.location;
5213    return e === "" ? null : (a(e.startsWith("#")), e = e.slice(1), e);
5214  }
5215  function as() {
5216    window.addEventListener("scroll", li(Pt, Math.ceil(1e3 / 3)), {
5217      passive: true
5218    }), Ft(Pt);
5219  }
5220  const Ln = L("client-routing-runtime/scrollRestoration.ts", {});
5221  function ss() {
5222    _t(), Ft(_t), ui(() => Ln.initialRenderIsDone && $n());
5223  }
5224  function ls() {
5225    Ln.initialRenderIsDone = true, $n();
5226  }
5227  function $n() {
5228    "scrollRestoration" in window.history && (window.history.scrollRestoration = "manual");
5229  }
5230  function _t() {
5231    "scrollRestoration" in window.history && (window.history.scrollRestoration = "auto");
5232  }
5233  const b = L("client-routing-runtime/renderPageClientSide.ts", (() => {
5234    const { promise: e, resolve: t } = Lt();
5235    return {
5236      renderCounter: 0,

5237      firstRenderStartPromise: e,
5238      firstRenderStartPromiseResolve: t
5239    };
5240  })()), { firstRenderStartPromise: ws } = b;
5241  async function te(e) {
5242    $t("renderPageClientSide()");
5243    const { urlOriginal: t = Ke(), overwriteLastHistoryEntry: n = false, isBackwardNavigation: i, pageContextsFromRewrite: r = [], redirectCount: o = 0, doNotRenderIfSamePage: s, isClientSideNavigation: l = true, pageContextInitClient: u } = e;
5244    let { scrollTarget: d } = e;
5245    const { previousPageContext: c } = b;
5246    Ja();
5247    const { isRenderOutdated: f, setHydrationCanBeAborted: S, isFirstRender: R } = cs();
5248    if (vr(r.length, o), b.clientRoutingIsDisabled) {
5249      M(t);
5250      return;
5251    }
5252    if (b.firstRenderStartPromiseResolve(), f()) return;
5253    await P();
5254    return;
5255    async function P() {
5256      const _ = async (g) => {
5257        await x({
5258          err: g
5259        });
5260      }, v = await I(false);
5261      if (!f()) {
5262        if (b.isFirstRenderDone && (a(c), ve(c, "onPageTransitionStart"), !b.isTransitioning)) {
5263          b.isTransitioning = true;
5264          const g = H(c, "onPageTransitionStart");
5265          if (g) {
5266            const z = g, { hookFn: D } = z;
5267            try {
5268              await U(() => D(v), z, v);
5269            } catch (A) {
5270              await _(A);
5271              return;
5272            }
5273            if (f()) return;
5274          }
5275        }
5276        if (R) {
5277          const g = Pr();
5278          a(!("urlOriginal" in g)), y(v, g), vt(v, {
5279            pageContextFromServerHooks: g
5280          });
5281        } else {
5282          let g;
5283          try {
5284            g = await bn(v);
5285          } catch (A) {
5286            await _(A);
5287            return;
5288          }
5289          if (f()) return;
5290          if (!g.pageId) {
5291            M(t);
5292            return;
5293          }
5294          a(m(g, "pageId", "string"));
5295          const z = await Te(g.pageId, v);
5296          if (f()) return;
5297          if (!z) {
5298            M(t);
5299            return;
5300          }
5301          const D = g.pageId && (c == null ? void 0 : c.pageId) && g.pageId === c.pageId;
5302          if (s && D) return;
5303          a(!("urlOriginal" in g)), y(v, g);
5304        }
5305        try {
5306          y(v, await Ae(v.pageId, v._pageFilesAll, v._pageConfigs, v._pageConfigGlobal));
5307        } catch (g) {
5308          if (At(g, v, R)) return;
5309          await _(g);
5310          return;
5311        }
5312        if (!f() && (yt(v), v.exports.hydrationCanBeAborted ? S() : C(!Yn(), "You seem to be using React; we recommend setting hydrationCanBeAborted to true, see https://vike.dev/hydrationCanBeAborted", {
5313          onlyOnce: true
5314        }), !f())) if (R) {
5315          a(m(v, "_hasPageContextFromServer", "true"));
5316          let g;
5317          try {
5318            g = await Er(v);
5319          } catch (z) {
5320            await _(z);
5321            return;
5322          }
5323          if (f()) return;
5324          le(v, g), await $(v);
5325        } else {
5326          let g;
5327          const z = Wa(v);
5328          if (z) g = z;
5329          else try {
5330            const A = await Ee(v, false);
5331            if (A.is404ServerSideRouted) return;
5332            g = A.pageContextFromServerHooks, vt(v, A);
5333          } catch (A) {
5334            await _(A);
5335            return;
5336          }
5337          if (f()) return;
5338          a(!("urlOriginal" in g)), y(v, g);
5339          let D;
5340          try {
5341            D = await lt(v, false);
5342          } catch (A) {
5343            await _(A);
5344            return;
5345          }
5346          if (f()) return;
5347          le(v, D), await $(v);
5348        }
5349      }
5350    }
5351    async function I(_) {
5352      const v = await Rn(t);
5353      y(v, {
5354        isBackwardNavigation: i,
5355        isClientSideNavigation: l,
5356        isHydration: R && !_,
5357        previousPageContext: c,
5358        ...u
5359      }), Object.defineProperty(v, "_previousPageContext", {
5360        get() {
5361          return C(false, "pageContext._previousPageContext has been renamed pageContext.previousPageContext", {
5362            showStackTrace: true,
5363            onlyOnce: true
5364          }), c;
5365        },
5366        enumerable: false
5367      });
5368      {
5369        const g = yr(r);
5370        a(!("urlOriginal" in g)), y(v, g);
5371      }
5372      return v;
5373    }
5374    async function x(_) {
5375      const v = (T) => {
5376        Qe(T, _.err) || console.error(T);
5377      };
5378      if ("err" in _) {
5379        const { err: T } = _;
5380        a(T), st(T) || console.error(T);
5381      }
5382      const g = await I(true);
5383      if (f()) return;
5384      if (_.is404 && y(g, {
5385        is404: true
5386      }), _.pageContextError && y(g, _.pageContextError), "err" in _) {
5387        const { err: T } = _;

5388        if (a(!("errorWhileRendering" in g)), y(g, {
5389          errorWhileRendering: T
5390        }), st(T)) {
5391          const V = T._pageContextAbort;
5392          if (V._urlRewrite) {
5393            await te({
5394              ...e,
5395              scrollTarget: void 0,
5396              pageContextsFromRewrite: [
5397                ...r,
5398                V
5399              ]
5400            });
5401            return;
5402          }
5403          if (V._urlRedirect) {
5404            const pe = V._urlRedirect.url;
5405            if (pe.startsWith("/")) await te({
5406              ...e,
5407              scrollTarget: void 0,
5408              urlOriginal: pe,
5409              overwriteLastHistoryEntry: false,
5410              isBackwardNavigation: false,
5411              redirectCount: o + 1
5412            });
5413            else {
5414              M(pe);
5415              return;
5416            }
5417            return;
5418          }
5419          a(V.abortStatusCode), a(!("urlOriginal" in V)), y(g, V), V.abortStatusCode === 404 && y(g, {
5420            is404: true
5421          });
5422        } else y(g, {
5423          is404: false
5424        });
5425      }
5426      const z = Ki(g._pageFilesAll, g._pageConfigs);
5427      if (!z) throw new Error("No error page defined.");
5428      y(g, {
5429        pageId: z
5430      });
5431      const D = await Te(g.pageId, g);
5432      if (f()) return;
5433      if (!D) {
5434        M(t);
5435        return;
5436      }
5437      try {
5438        y(g, await Ae(g.pageId, g._pageFilesAll, g._pageConfigs, g._pageConfigGlobal));
5439      } catch (T) {
5440        if (At(T, g, R)) return;
5441        v(T);
5442        return;
5443      }
5444      if (f()) return;
5445      yt(g);
5446      let A;
5447      try {
5448        const T = await Ee(g, true);
5449        if (T.is404ServerSideRouted) return;
5450        A = T.pageContextFromServerHooks;
5451      } catch (T) {
5452        v(T);
5453        return;
5454      }
5455      if (f()) return;
5456      a(!("urlOriginal" in A)), y(g, A);
5457      let O;
5458      try {
5459        O = await lt(g, true);
5460      } catch (T) {
5461        v(T);
5462        return;
5463      }
5464      f() || (le(g, O), y(g, {
5465        routeParams: {}
5466      }), await $(g, _));
5467    }
5468    async function $(_, v) {
5469      const g = async (A) => {
5470        v ? Qe(A, v.err) || console.error(A) : await x({
5471          err: A
5472        });
5473      };
5474      if (b.onRenderClientPreviousPromise && (await b.onRenderClientPreviousPromise, a(b.onRenderClientPreviousPromise === void 0), f())) return;
5475      ds(t, n), b.previousPageContext = _, a(b.onRenderClientPreviousPromise === void 0);
5476      const z = (async () => {
5477        let A;
5478        try {
5479          await Xa(_, true);
5480        } catch (O) {
5481          A = O;
5482        }
5483        return b.onRenderClientPreviousPromise = void 0, b.isFirstRenderDone = true, A;
5484      })();
5485      b.onRenderClientPreviousPromise = z;
5486      const D = await z;
5487      if (a(b.onRenderClientPreviousPromise === void 0), !(D && (await g(D), !v))) {
5488        if (R && !D) {
5489          ve(_, "onHydrationEnd");
5490          const A = H(_, "onHydrationEnd");
5491          if (A) {
5492            const { hookFn: O } = A;
5493            try {
5494              await U(() => O(_), A, _);
5495            } catch (T) {
5496              if (await g(T), !v) return;
5497            }
5498            if (f(true)) return;
5499          }
5500        }
5501        if (!f(true)) {
5502          if (b.isTransitioning) {
5503            b.isTransitioning = void 0, a(c), ve(c, "onPageTransitionEnd");
5504            const A = H(c, "onPageTransitionEnd");
5505            if (A) {
5506              const { hookFn: O } = A;
5507              try {
5508                await U(() => O(_), A, _);
5509              } catch (T) {
5510                if (await g(T), !v) return;
5511              }
5512              if (f(true)) return;
5513            }
5514          }
5515          if (!d && c) {
5516            const A = Tt(c), O = Tt(_);
5517            O !== false && A !== false && gs(O, A) && (d = {
5518              preserveScroll: true
5519            });
5520          }
5521          On(d, t), ls(), _._hasPageContextFromServer && Rr(_), Ya(), Ne(), b.renderedPageContext = _, us(t);
5522        }
5523      }
5524    }
5525  }
5526  function us(e) {
5527    window._vike ?? (window._vike = {}), window._vike.fullyRenderedUrl = e;
5528  }
5529  function ds(e, t) {
5530    Ke() !== e && es(e, t);
5531  }
5532  function At(e, t, n) {
5533    if (!Ue(e)) return false;

5534    if (n) throw xe(e, false), e;
5535    return xe(e, true), M(t.urlOriginal), true;
5536  }
5537  function xe(e, t) {
5538    a(Ue(e)), b.clientRoutingIsDisabled = true, t && console.log(e), Un(false, [
5539      "Failed to fetch static asset.",
5540      "This usually happens when a new frontend is deployed.",
5541      "Falling back to Server Routing.",
5542      "(The next page navigation will use Server Routing instead of Client Routing.)"
5543    ].filter(Boolean).join(" "), {
5544      onlyOnce: true
5545    });
5546  }
5547  function cs() {
5548    const e = ++b.renderCounter;
5549    a(e >= 1);
5550    let t = false;
5551    return {
5552      isRenderOutdated: (r) => e === 1 && !t && !r ? false : e !== b.renderCounter,
5553      setHydrationCanBeAborted: () => {
5554        t = true;
5555      },
5556      isFirstRender: e === 1
5557    };
5558  }
5559  function fs() {
5560    return b.renderCounter;
5561  }
5562  function Tt(e) {
5563    const t = e.from.configsStandard.keepScrollPosition;
5564    if (!t) return false;
5565    let n = t.value;
5566    const i = t.definedAt;
5567    a(i);
5568    const r = Fa(i);
5569    return N(n) && (n = n(e, {
5570      configDefinedAt: t.definedAt
5571    })), n === true ? [
5572      i,
5573      ...r.map((o) => {
5574        const s = e.routeParams[o];
5575        return a(s), s;
5576      })
5577    ] : n;
5578  }
5579  function gs(e, t) {
5580    return e === t ? true : !Array.isArray(e) || !Array.isArray(t) ? false : e.length === t.length && e.every((n, i) => e[i] === t[i]);
5581  }
5582  function ps() {
5583    window.addEventListener("popstate", hs);
5584  }
5585  async function hs() {
5586    $t("onPopState()");
5587    const { isHistoryStateEnhanced: e, previous: t, current: n } = ns();
5588    if (e) await ys(t, n);
5589    else return;
5590  }
5591  async function ys(e, t) {
5592    const n = t.state.scrollPosition || void 0;
5593    if (bt(t.url) === bt(e.url) && t.url !== e.url) {
5594      On(n);
5595      return;
5596    }
5597    const o = t.state.triggeredBy === "user" || e.state.triggeredBy === "user", s = !t.state.timestamp || !e.state.timestamp ? null : t.state.timestamp < e.state.timestamp;
5598    await te({
5599      scrollTarget: n,
5600      isBackwardNavigation: s,
5601      doNotRenderIfSamePage: o
5602    });
5603  }
5604  function bt(e) {
5605    return e.split("#")[0];
5606  }
5607  function ms() {
5608    document.addEventListener("click", vs);
5609  }
5610  async function vs(e) {
5611    if (!Ss(e)) return;
5612    const t = Ps(e.target);
5613    if (!t) return;
5614    const n = t.getAttribute("href");
5615    if (n === null) return;
5616    if (n.includes("#") && Ta(n)) {
5617      e.preventDefault(), kn(n.split("#")[1]);
5618      return;
5619    }
5620    if (Be(t)) return;
5621    e.preventDefault();
5622    let i;
5623    {
5624      const r = t.getAttribute("keep-scroll-position");
5625      r !== null && (i = {
5626        preserveScroll: r !== "false"
5627      });
5628    }
5629    await te({
5630      scrollTarget: i,
5631      urlOriginal: n,
5632      isBackwardNavigation: false
5633    });
5634  }
5635  function Ss(e) {
5636    return e.button === 0 && !e.ctrlKey && !e.shiftKey && !e.altKey && !e.metaKey;
5637  }
5638  function Ps(e) {
5639    for (; e.tagName !== "A"; ) {
5640      const { parentNode: t } = e;
5641      if (!t) return null;
5642      e = t;
5643    }
5644    return e;
5645  }
5646  async function Es() {
5647    _s();
5648    const e = Rs();
5649    ms(), Ka(), await e;
5650  }
5651  async function Rs() {
5652    a(fs() === 0), await te({
5653      scrollTarget: {
5654        preserveScroll: true
5655      },
5656      isBackwardNavigation: null,
5657      isClientSideNavigation: false
5658    });
5659  }
5660  function _s() {
5661    ss(), ts(), Dn(), as(), ps();
5662  }
5663  ne();
5664  Bn();
5665  Es();
5666});