1const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=["assets/entries/src_pages_catch-all.zP0j-ceq.js","assets/chunks/chunk-CnBNYna8.js","assets/chunks/chunk-CsftmvP9.js","assets/static/src_components_blocks_HeroBlock_heroBlock.styles.9O7JVfzQ.css","assets/static/catch-all.BtGMZYkK.css","assets/static/src_components_features_timeline_modal_PrevNextNav-0f0cd9d2.t3sKkplM.css","assets/static/src_components_features_timeline_timeline-98d03de2.NF94c242.css"])))=>i.map(i=>d[i]); 2import{_ as __vitePreload}from"../chunks/chunk-CnBNYna8.js";function unique(arr){return Array.from(new Set(arr))}function getGlobalObject(key,defaultValue){const globalObjects=getGlobalObjects();return globalObjects[key]=globalObjects[key]||defaultValue}function getGlobalObjects(){const projectKey="_vike";return globalThis[projectKey]=globalThis[projectKey]||{}}const pc=new Proxy({},{get:(_,p)=>s=>p==="code"?`\`${s}\``:p==="string"?`'${s}'`:s}),PROJECT_VERSION="0.4.232";let globalObject$4;globalObject$4??(globalObject$4=genGlobalConfig());function genGlobalConfig(){return getGlobalObject("utils/assertSingleInstance.ts",{instances:[],alreadyLogged:new Set})}function getGlobalObjectSafe(){return globalObject$4??(globalObject$4=genGlobalConfig()),globalObject$4}const clientRuntimesClonflict="Client runtime of both Server Routing and Client Routing loaded https://vike.dev/client-runtimes-conflict",clientNotSingleInstance="Client runtime loaded twice https://vike.dev/client-runtime-duplicated";function assertSingleInstance(){const globalObject2=getGlobalObjectSafe();{const versions=unique(globalObject2.instances);assertWarning$1(versions.length<=1,`vike@${pc.bold(versions[0])} and vike@${pc.bold(versions[1])} loaded which is highly discouraged, see ${pc.underline("https://vike.dev/warning/version-mismatch")}`,{onlyOnce:!0,showStackTrace:!1})}globalObject2.checkSingleInstance&&globalObject2.instances.length>1&&assertWarning$1(!1,clientNotSingleInstance,{onlyOnce:!0,showStackTrace:!0})}function assertSingleInstance_onClientEntryServerRouting(isProduction){const globalObject2=getGlobalObjectSafe();assertWarning$1(globalObject2.isClientRouting!==!0,clientRuntimesClonflict,{onlyOnce:!0,showStackTrace:!0}),assertWarning$1(globalObject2.isClientRouting===void 0,clientNotSingleInstance,{onlyOnce:!0,showStackTrace:!0}),globalObject2.isClientRouting=!1,globalObject2.checkSingleInstance=!0,assertSingleInstance()}function assertSingleInstance_onAssertModuleLoad(){getGlobalObjectSafe().instances.push(PROJECT_VERSION),assertSingleInstance()}function assertWarning$1(condition,errorMessage,{onlyOnce,showStackTrace}){const globalObject2=getGlobalObjectSafe();if(condition)return;const msg=`[Vike][Warning] ${errorMessage}`;{const{alreadyLogged}=globalObject2,key=msg;if(alreadyLogged.has(key))return;alreadyLogged.add(key)}console.warn(showStackTrace?new Error(msg):msg)}function isNodeJS(){return!(typeof process>"u"||!process.cwd||!process.versions||typeof process.versions.node>"u"||!process.release||process.release.name!=="node")}function createErrorWithCleanStackTrace(errorMessage,numberOfStackTraceLinesToRemove2){const err=new Error(errorMessage);return isNodeJS()&&(err.stack=clean(err.stack,numberOfStackTraceLinesToRemove2)),err}function clean(errStack,numberOfStackTraceLinesToRemove2){if(!errStack)return errStack;const stackLines=splitByLine(errStack);let linesRemoved=0;return stackLines.filter(line=>line.includes(" (internal/")||line.includes(" (node:internal")?!1:linesRemoved<numberOfStackTraceLinesToRemove2&&isStackTraceLine(line)?(linesRemoved++,!1):!0).join(` 3`)}function isStackTraceLine(line){return line.startsWith(" at ")}function splitByLine(str){return str.split(/\r?\n/)}function isObject(value){return typeof value=="object"&&value!==null}const globalObject$3=getGlobalObject("utils/assert.ts",{alreadyLogged:new Set,logger(msg,logType){logType==="info"?console.log(msg):console.warn(msg)},showStackTraceList:new WeakSet});assertSingleInstance_onAssertModuleLoad();const projectTag="[vike]",projectTagWithVersion=`[vike@${PROJECT_VERSION}]`,bugTag="Bug",numberOfStackTraceLinesToRemove=2;function assert(condition,debugInfo){var _a;if(condition)return;const debugStr=(()=>
3{if(!debugInfo)return null;const debugInfoSerialized=typeof debugInfo=="string"?debugInfo:JSON.stringify(debugInfo);return pc.dim(`Debug info for Vike maintainers (you can ignore this): ${debugInfoSerialized}`)})();let errMsg=[`You stumbled upon a Vike bug. Go to ${pc.underline("https://github.com/vikejs/vike/issues/new?template=bug.yml")} and copy-paste this error. A maintainer will fix the bug (usually within 24 hours).`,debugStr].filter(Boolean).join(" ");errMsg=addWhitespace(errMsg),errMsg=addPrefixAssertType(errMsg,bugTag),errMsg=addPrefixProjectName(errMsg,!0);const internalError=createErrorWithCleanStackTrace(errMsg,numberOfStackTraceLinesToRemove);throw(_a=globalObject$3.onBeforeLog)==null||_a.call(globalObject$3),internalError}function assertUsage(condition,errMsg,{showStackTrace,exitOnError}={}){var _a;if(condition)return;showStackTrace=showStackTrace||globalObject$3.alwaysShowStackTrace,errMsg=addWhitespace(errMsg),errMsg=addPrefixAssertType(errMsg,"Wrong Usage"),errMsg=addPrefixProjectName(errMsg);const usageError=createErrorWithCleanStackTrace(errMsg,numberOfStackTraceLinesToRemove);if(showStackTrace&&globalObject$3.showStackTraceList.add(usageError),(_a=globalObject$3.onBeforeLog)==null||_a.call(globalObject$3),exitOnError)console.error(showStackTrace?usageError:errMsg),process.exit(1);else throw usageError}function getProjectError(errMsg){return errMsg=addWhitespace(errMsg),errMsg=addPrefixAssertType(errMsg,"Error"),errMsg=addPrefixProjectName(errMsg),createErrorWithCleanStackTrace(errMsg,numberOfStackTraceLinesToRemove)}function assertWarning(condition,msg,{onlyOnce,showStackTrace}){var _a;if(!condition){if(showStackTrace=showStackTrace||globalObject$3.alwaysShowStackTrace,msg=addWhitespace(msg),msg=addPrefixAssertType(msg,"Warning"),msg=addPrefixProjectName(msg),onlyOnce){const{alreadyLogged}=globalObject$3,key=onlyOnce===!0?msg:onlyOnce;if(alreadyLogged.has(key))return;alreadyLogged.add(key)}if((_a=globalObject$3.onBeforeLog)==null||_a.call(globalObject$3),showStackTrace){const err=createErrorWithCleanStackTrace(msg,numberOfStackTraceLinesToRemove);globalObject$3.showStackTraceList.add(err),globalObject$3.logger(err,"warn")}else globalObject$3.logger(msg,"warn")}}function addPrefixAssertType(msg,tag){let prefix=`[${tag}]`;const color=tag==="Warning"?"yellow":"red";return prefix=pc.bold(pc[color](prefix)),`${prefix}${msg}`}function addWhitespace(msg){return msg.startsWith("[")?msg:` ${msg}`}function addPrefixProjectName(msg,showProjectVersion=!1){return`${showProjectVersion?projectTagWithVersion:projectTag}${msg}`}function isBrowser(){return typeof window<"u"&&typeof window.scrollY=="number"}const state=getGlobalObject("utils/assertRouterType.ts",{});function assertServerRouting(){assertNoContradiction(state.isClientRouting!==!0),state.isClientRouting=!1}function assertNoContradiction(noContradiction){assertUsage(isBrowser(),`${pc.cyan("import { something } from 'vike/client/router'")} is forbidden on the server-side`,{showStackTrace:!0}),assertWarning(noContradiction,"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.",{showStackTrace:!0,onlyOnce:!0})}function assertIsBrowser(){assert(isBrowser())}function onLoad(){assertIsBrowser()}function isCallable(thing){return thing instanceof Function||typeof thing=="function"}function isArray(value){return Array.isArray(value)}function isArrayOfStrings(val){return isArray(val)&&val.every(v=>typeof v=="string")}function isObjectOfStrings(val){return isObject(val)&&Object.values(val).every(v=>typeof v=="string")}function hasProp(obj,prop,type){if(!isObject(obj))return!1;if(!(prop in obj))return type==="undefined";if(type===void 0)return!0;const propValue=obj[prop];return type==="undefined"?propValue===void 0:type==="array"?isArray(propValue):type==="object"?isObject(propValue):type==="string[]"?isArrayOfStrings(propValue):type==="string{}"?isObjectOfStrings(propValue):type==="function"?isCallable(propValue):isArray(type)?typeof propValue=="string"&&type.includes(propValue):type==="null"?propValue===null:type==="true"?propValue===!0:type==="false"?propValue===!1:typeof propValue===type}function objectAssign(obj,objAddendum,objAddendumCanBeOriginalObject){objAddendum&&(objAddendumCanBeOriginalObject||assert(!objAddendum._isOriginalObject),Object.defineProperties(obj,Object.getOwnPropertyDescriptors(objAddendum)))}function slice(thing,from,to){return typeof thing=="string"?sliceArray(thing.split(""),from,to).join(""):sliceArray(thing,from,to)}
3function sliceArray(list,from,to){const listSlice=[];let start=from;assert(start>=0&&start<=list.length);let end=list.length+to;for(assert(end>=0&&end<=list.length);!(start===end||(start===list.length&&(start=0),start===end));){const el=list[start];assert(el!==void 0),listSlice.push(el),start++}return listSlice}function parseUrl(url,baseServer){assert(isUrl(url),url),assert(baseServer.startsWith("/"));const{hashString:hashOriginal,withoutHash:urlWithoutHash}=extractHash(url);assert(hashOriginal===null||hashOriginal.startsWith("#"));const hash=hashOriginal===null?"":decodeSafe(hashOriginal.slice(1)),{searchString:searchOriginal,withoutSearch:urlWithoutHashNorSearch}=extractSearch(urlWithoutHash);assert(searchOriginal===null||searchOriginal.startsWith("?"));let searchString="";if(searchOriginal!==null)searchString=searchOriginal;else if(url.startsWith("#")){const baseURI=getBaseURI();searchString=baseURI&&extractSearch(baseURI).searchString||""}const search={},searchAll={};Array.from(new URLSearchParams(searchString)).forEach(([key,val])=>{search[key]=val,searchAll[key]=[...searchAll.hasOwnProperty(key)?searchAll[key]:[],val]});let{protocol,origin,pathnameAbsoluteWithBase}=getPathnameAbsoluteWithBase(urlWithoutHashNorSearch,baseServer);const pathnameOriginal=urlWithoutHashNorSearch.slice((origin||"").length);assertUrlComponents(url,origin,pathnameOriginal,searchOriginal,hashOriginal);let{pathname,isBaseMissing}=removeBaseServer(pathnameAbsoluteWithBase,baseServer);const href=createUrlFromComponents(origin,pathname,searchOriginal,hashOriginal),host=origin?origin.slice(protocol.length):null,{hostname,port}=parseHost(host,url);return pathname=decodePathname(pathname),assert(pathname.startsWith("/")),{href,protocol,hostname,port,origin,pathname,pathnameOriginal,isBaseMissing,search,searchAll,searchOriginal,hash,hashOriginal}}function extractHash(url){const[withoutHash,...parts]=url.split("#");return{hashString:["",...parts].join("#")||null,withoutHash}}function extractSearch(url){const[withoutSearch,...parts]=url.split("?");return{searchString:["",...parts].join("?")||null,withoutSearch}}function decodeSafe(urlComponent){try{return decodeURIComponent(urlComponent)}catch{}try{return decodeURI(urlComponent)}catch{}return urlComponent}function decodePathname(urlPathname){return urlPathname=urlPathname.replace(/\s+$/,""),urlPathname=urlPathname.split("/").map(dir=>decodeSafe(dir).split("/").join("%2F")).join("/"),urlPathname}function getPathnameAbsoluteWithBase(url,baseServer){assert(!url.includes("?")&&!url.includes("#"));{const{protocol,origin,pathname}=parseOrigin(url);if(origin)return{protocol,origin,pathnameAbsoluteWithBase:pathname};assert(pathname===url)}if(url.startsWith("/"))return{protocol:null,origin:null,pathnameAbsoluteWithBase:url};{const baseURI=getBaseURI();let base;return baseURI?base=parseOrigin(baseURI.split("?")[0].split("#")[0]).pathname:base=baseServer,{protocol:null,origin:null,pathnameAbsoluteWithBase:resolveUrlPathnameRelative(url,base)}}}function getBaseURI(){var _a;return typeof window<"u"?(_a=window==null?void 0:window.document)==null?void 0:_a.baseURI:void 0}function parseOrigin(url){if(isUrlWithProtocol(url)){const{protocol,uriWithoutProtocol}=parseProtocol(url);assert(protocol);const[host,...rest]=uriWithoutProtocol.split("/"),origin=protocol+host;return{pathname:"/"+rest.join("/"),origin,protocol}}else return{pathname:url,origin:null,protocol:null}}function parseHost(host,url){const ret={hostname:null,port:null};if(!host)return ret;const parts=host.split(":");if(parts.length>1){const port=parseInt(parts.pop(),10);assert(port||port===0,url),ret.port=port}return ret.hostname=parts.join(":"),ret}function parseProtocol(uri){const[before,...after]=uri.split(":");if(after.length===0||!/^[a-z][a-z0-9\+\-]*$/i.test(before))return{protocol:null,uriWithoutProtocol:uri};let protocol=before+":",uriWithoutProtocol=after.join(":");const SEP2="//";return uriWithoutProtocol.startsWith(SEP2)&&(protocol=protocol+SEP2,uriWithoutProtocol=uriWithoutProtocol.slice(SEP2.length)),{protocol,uriWithoutProtocol}}function isUrlProtocol(protocol){return["ipfs://","ipns://"].includes(protocol)?!1:protocol.endsWith("://")}function resolveUrlPathnameRelative(pathnameRelative,base){const stack=base.split("/"),parts=pathnameRelative.split("/");let baseRestoreTrailingSlash=base.endsWith("/");pathnameRelative.startsWith(".")&&stack.pop();for(const i in parts){const p=parts[i];p==""&&i==="0"||p!="."&&(p==".."?stack.pop():(baseRestoreTrailingSlash=!1,stack.push(p)))}let pathnameAbsolute=stack.join("/");return baseRestoreTrailingSlash&&!pathnameAbsolute.endsWith("/")&&(pathnameAbsolute+="/"),pathnameAbsolute.startsWith("/")||(pathnameAbsolute="/"+pathnameAbsolute),pathnameAbsolute}function removeBaseServer(pathnameAbsoluteWithBase,baseServer){return assert(pathnameAbsoluteWithBase.startsWith("/")),assert(isBaseServer(baseServer)),assert(pathnameAbsoluteWithBase.startsWith("/")),assert(baseServer.startsWith("/")),{pathname:pathnameAbsoluteWithBase,isBaseMissing:!1}}function isBaseServer(baseServer){return baseServer.startsWith("/")}function assertUrlComponents(url,origin,pathnameOriginal,searchOriginal,hashOriginal){const urlRecreated=createUrlFromComponents(origin,pathnameOriginal,searchOriginal,hashOriginal);assert(url===urlRecreated)}function createUrlFromComponents(origin,pathname,search,hash){return`${origin||""}${pathname}${search||""}${hash||""}`}function isUrl(url){return isUrlWithProtocol(url)||url.startsWith("/")||isUrlRelative(url)}function isUrlRelative(url){return[".","?","#"].some(c=>url.startsWith(c))||url===""}function isUrlWithProtocol(url){const{protocol}=parseProtocol(url);return!!protocol&&isUrlProtocol(protocol)}function getPropAccessNotation(key){return typeof key=="string"&&isKeyDotNotationCompatible(key
3)?`.${key}`:`[${JSON.stringify(key)}]`}function isKeyDotNotationCompatible(key){return/^[a-z0-9\$_]+$/i.test(key)}function augmentType(thing,clone){assert(thing===clone)}function changeEnumerable(obj,prop,enumerable){const descriptor=Object.getOwnPropertyDescriptor(obj,prop);Object.defineProperty(obj,prop,{...descriptor,enumerable})}onLoad();const types=[{is:val=>val===void 0,match:str=>str==="!undefined",serialize:()=>"!undefined",deserialize:()=>{}},{is:val=>val===1/0,match:str=>str==="!Infinity",serialize:()=>"!Infinity",deserialize:()=>1/0},{is:val=>val===-1/0,match:str=>str==="!-Infinity",serialize:()=>"!-Infinity",deserialize:()=>-1/0},{is:val=>typeof val=="number"&&isNaN(val),match:str=>str==="!NaN",serialize:()=>"!NaN",deserialize:()=>NaN},{is:val=>val instanceof Date,match:str=>str.startsWith("!Date:"),serialize:val=>"!Date:"+val.toISOString(),deserialize:str=>new Date(str.slice(6))},{is:val=>typeof val=="bigint",match:str=>str.startsWith("!BigInt:"),serialize:val=>"!BigInt:"+val.toString(),deserialize:str=>{if(typeof BigInt>"u")throw new Error("Your JavaScript environement does not support BigInt. Consider adding a polyfill.");return BigInt(str.slice(8))}},{is:val=>val instanceof RegExp,match:str=>str.startsWith("!RegExp:"),serialize:val=>"!RegExp:"+val.toString(),deserialize:str=>{str=str.slice(8);const args=str.match(/\/(.*)\/(.*)?/),pattern=args[1],flags=args[2];return new RegExp(pattern,flags)}},{is:val=>val instanceof Map,match:str=>str.startsWith("!Map:"),serialize:(val,serializer)=>"!Map:"+serializer(Array.from(val.entries())),deserialize:(str,parser)=>new Map(parser(str.slice(5)))},{is:val=>val instanceof Set,match:str=>str.startsWith("!Set:"),serialize:(val,serializer)=>"!Set:"+serializer(Array.from(val.values())),deserialize:(str,parser)=>new Set(parser(str.slice(5)))},{is:val=>typeof val=="string"&&val.startsWith("!"),match:str=>str.startsWith("!"),serialize:val=>"!"+val,deserialize:str=>str.slice(1)}];function parse(str,options={}){const value=JSON.parse(str);return parseTransform(value,options)}function parseTransform(value,options={}){return typeof value=="string"?reviver(value,options):(typeof value=="object"&&value!==null&&Object.entries(value).forEach(([key,val])=>{value[key]=parseTransform(val,options)}),value)}function reviver(value,options){var _a;const parser=str=>parse(str,options);{const res=(_a=options.reviver)==null?void 0:_a.call(options,void 0,value,parser);if(res){if(typeof res.replacement!="string")return res.replacement;if(value=res.replacement,res.resolved)return value}}for(const{match,deserialize}of types)if(match(value))return deserialize(value,parser);return value}const timeoutSecondsDefault=25;function genPromise({timeout:timeoutSeconds=timeoutSecondsDefault}={}){let resolve,reject,finished=!1;const promise_internal=new Promise((resolve_,reject_)=>{resolve=(...args)=>(finished=!0,timeoutClear(),resolve_(...args)),reject=(...args)=>(finished=!0,timeoutClear(),reject_(...args))}),timeoutClear=()=>timeouts.forEach(t=>clearTimeout(t)),timeouts=[];let promise;return timeoutSeconds?promise=new Proxy(promise_internal,{get(target,prop){if(prop==="then"&&!finished){const err=new Error(`Promise hasn't resolved after ${timeoutSeconds} seconds`);timeouts.push(setTimeout(()=>{assert(err.stack),assertWarning(!1,removeStackErrorPrefix(err.stack),{onlyOnce:!1})},timeoutSeconds*1e3))}const value=Reflect.get(target,prop);return typeof value=="function"?value.bind(target):value}}):promise=promise_internal,{promise,resolve,reject}}function removeStackErrorPrefix(errStack){const errorPrefix="Error: ";return errStack.startsWith(errorPrefix)&&(errStack=errStack.slice(errorPrefix.length)),errStack}const htmlElementId_pageContext="vike_pageContext",htmlElementId_globalContext="vike_globalContext";function getPageContextSerializedInHtml(){const pageContextSerializedInHtml=findAndParseJson(htmlElementId_pageContext);return assert(hasProp(pageContextSerializedInHtml,"pageId","string")),assert(hasProp(pageContextSerializedInHtml,"routeParams","string{}")),pageContextSerializedInHtml}function getGlobalContextSerializedInHtml(){return findAndParseJson(htmlElementId_globalContext)}function findAndParseJson(id){const elem=document.getElementById(id);assertUsage(elem,`Couldn't find #${id} (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)`);const jsonStr=elem.textContent;return assert(jsonStr),parse(jsonStr)}function objectReplace(objOld,objNew,except){Object.keys(objOld).filter(key=>
3!0).forEach(key=>delete objOld[key]),Object.defineProperties(objOld,Object.getOwnPropertyDescriptors(objNew))}function makeFirst(getValue){return(element1,element2)=>{const val1=getValue(element1),val2=getValue(element2);if(assert([!0,!1,null].includes(val1)),assert([!0,!1,null].includes(val2)),val1===val2)return 0;if(val1===!0||val2===!1)return-1;if(val2===!0||val1===!1)return 1;assert(!1)}}function makeLast(getValue){return makeFirst(element=>{const val=getValue(element);return val===null?null:!val})}function compareString(str1,str2){return str1.toLowerCase()<str2.toLowerCase()?-1:str1.toLowerCase()>str2.toLowerCase()?1:0}function isNullish(val){return val==null}function isNotNullish(p){return!isNullish(p)}function isPropertyGetter(obj,prop){const descriptor=Object.getOwnPropertyDescriptor(obj,prop);return!!descriptor&&!("value"in descriptor)&&!!descriptor.get}function objectDefineProperty(obj,prop,{get,...args}){Object.defineProperty(obj,prop,{...args,get})}const extJs=["js","cjs","mjs"],extTs=["ts","cts","mts"],extJsOrTs=[...extJs,...extTs],extJsx=["jsx","cjsx","mjsx"],extTsx=["tsx","ctsx","mtsx"],extJsxOrTsx=[...extJsx,...extTsx],extTemplates=["vue","svelte","marko","md","mdx"],scriptFileExtensionList=[...extJsOrTs,...extJsxOrTsx,...extTemplates];function isScriptFile(filePath){return scriptFileExtensionList.some(ext=>filePath.endsWith("."+ext))}function isTemplateFile(filePath){return extTemplates.some(ext=>filePath.endsWith("."+ext))}function getPageFilesClientSide(pageFilesAll,pageId){return determine(pageFilesAll,pageId,!0)}function determine(pageFilesAll,pageId,envIsClient){const env="CLIENT_ONLY",pageFilesRelevant=pageFilesAll.filter(p=>p.isRelevant(pageId)&&p.fileType!==".page.route").sort(getPageFilesSorter(envIsClient,pageId)),getPageIdFile=iso=>{const files=pageFilesRelevant.filter(p=>p.pageId===pageId&&p.isEnv(iso?"CLIENT_AND_SERVER":env));assertUsage(files.length<=1,`Merge the following files into a single file: ${files.map(p=>p.filePath).join(" ")}`);const pageIdFile=files[0];return assert(pageIdFile===void 0||!pageIdFile.isDefaultPageFile),pageIdFile},pageIdFileEnv=getPageIdFile(!1),pageIdFileIso=getPageIdFile(!0),getRendererFile=iso=>pageFilesRelevant.filter(p=>p.isRendererPageFile&&p.isEnv(iso?"CLIENT_AND_SERVER":env))[0],rendererFileEnv=getRendererFile(!1),rendererFileIso=getRendererFile(!0),defaultFilesNonRenderer=pageFilesRelevant.filter(p=>p.isDefaultPageFile&&!p.isRendererPageFile&&(p.isEnv(env)||p.isEnv("CLIENT_AND_SERVER")));return[pageIdFileEnv,pageIdFileIso,...defaultFilesNonRenderer,rendererFileEnv,rendererFileIso].filter(isNotNullish)}function getPageFilesSorter(envIsClient,pageId){const env="CLIENT_ONLY";return(e1,e2)=>{if(!e1.isDefaultPageFile&&e2.isDefaultPageFile)return-1;if(!e2.isDefaultPageFile&&e1.isDefaultPageFile)return 1;{const e1_isRenderer=e1.isRendererPageFile,e2_isRenderer=e2.isRendererPageFile;if(!e1_isRenderer&&e2_isRenderer)return-1;if(!e2_isRenderer&&e1_isRenderer)return 1;assert(e1_isRenderer===e2_isRenderer)}{const e1_distance=getPathDistance(pageId,e1.filePath),e2_distance=getPathDistance(pageId,e2.filePath);if(e1_distance<e2_distance)return-1;if(e2_distance<e1_distance)return 1;assert(e1_distance===e2_distance)}{if(e1.isEnv(env)&&e2.isEnv("CLIENT_AND_SERVER"))return-1;if(e2.isEnv(env)&&e1.isEnv("CLIENT_AND_SERVER"))return 1}return 0}}function getPathDistance(pathA,pathB){let idx=0;for(;idx<pathA.length&&idx<pathB.length&&pathA[idx]===pathB[idx];idx++);const pathAWithoutCommon=pathA.slice(idx),pathBWithoutCommon=pathB.slice(idx),distanceA=pathAWithoutCommon.split("/").length,distanceB=pathBWithoutCommon.split("/").length;return distanceA+distanceB}const enforceTrue=["clientRouting"];function assertExportValues(pageFile){enforceTrue.forEach(exportName=>{if(assert(pageFile.fileExports),!(exportName in pageFile.fileExports))return;const explainer=`The value of \`${exportName}\` is only allowed to be \`true\`.`;assertUsage(pageFile.fileExports[exportName]!==!1,`${pageFile.filePath} has \`export { ${exportName} }\` with the value \`false\` which is prohibited: remove \`export { ${exportName} }\` instead. (${explainer})`),assertUsage(pageFile.fileExports[exportName]===!0,`${pageFile.filePath} has \`export { ${exportName} }\` with a forbidden value. ${explainer}`)})}const forbiddenDefaultExports=["render","clientRouting","prerender","doNotPrerender"];function assertDefaultExports(defaultExportName,filePath){assertUsage(!forbiddenDefaultExports.includes(defaultExportName),`${filePath} has \`export default { ${defaultExportName} }\` which is prohibited, use \`export { ${defaultExportName} }\` instead.`)}function getExportPath(fileExportPathToShowToUser,configName){if(!fileExportPathToShowToUser)return null;let[exportName,...exportObjectPath]=fileExportPathToShowToUser;if(!exportName||exportObjectPath.length===0&&["*","default",configName].includes(exportName))return null;assert(exportName!=="*");let prefix="",suffix="";return exportName==="default"?prefix="export default":(prefix="export",exportObjectPath=[exportName,...exportObjectPath]),exportObjectPath.forEach(prop=>{prefix=`${prefix} { ${prop}`,suffix=` }${suffix}`}),prefix+suffix}function getConfigDefinedAt(sentenceBegin,configName,definedAtData){return`${begin(sentenceBegin,configName)} at ${getDefinedAtString(definedAtData,configName)}`}function getConfigDefinedAtOptional(sentenceBegin,configName,definedAtData){return definedAtData?`${begin(sentenceBegin,configName)} at ${getDefinedAtString(definedAtData,configName)}`:`${begin(sentenceBegin,configName)} internally`}function begin(sentenceBegin,configName){return`${sentenceBegin} ${pc.cyan(configName)} defined`}function getDefinedAtString(definedAtData,configName){let files;return isArray(definedAtData)?files=definedAtData:files=[definedAtData],assert(files.length>=1),files.map(definedAt=>{if(definedAt.definedBy)return getDefinedByString(definedAt,configName);const{filePathToShowToUser,fileExportPathToShowToUser}=definedAt;let s=filePathToShowToUser;const exportPath=getExportPath(fileExportPathToShowToUser,configName);return exportPath&&(s=`${s} > ${pc.cyan(exportPath)}`),s}).join(" / ")}function getDefinedByString(definedAt,configName){if(definedAt.definedBy==="api")return`API call ${pc.cyan(`${definedAt.operation}({ vikeConfig: { ${configName} } })`)}`;const{definedBy}=definedAt;if(definedBy==="cli")return`CLI option ${pc.cyan(`--${configName}`)}`;
3if(definedBy==="env")return`environment variable ${pc.cyan(`VIKE_CONFIG="{${configName}}"`)}`;assert(!1)}function getConfigValueFilePathToShowToUser(definedAtData){if(!definedAtData||isArray(definedAtData)||definedAtData.definedBy)return null;const{filePathToShowToUser}=definedAtData;return assert(filePathToShowToUser),filePathToShowToUser}function getHookFilePathToShowToUser(definedAtData){const filePathToShowToUser=getConfigValueFilePathToShowToUser(definedAtData);return assert(filePathToShowToUser),filePathToShowToUser}function resolveVikeConfigPublicPageEager(pageConfigGlobalValues,pageConfig,pageConfigValues){const vikeConfigPublicPage_=resolveVikeConfigPublic_base({pageConfigGlobalValues,pageConfigValues}),vikeConfigPublicPage=getPublicCopy(vikeConfigPublicPage_);let page;if(pageConfig.isErrorPage)page={...vikeConfigPublicPage,isErrorPage:!0};else{const route=vikeConfigPublicPage.config.route??pageConfig.routeFilesystem.routeString;page={...vikeConfigPublicPage,route}}return[pageConfig.pageId,page]}function getPublicCopy(vikeConfigPublic){return{config:vikeConfigPublic.config,_source:vikeConfigPublic.source,_sources:vikeConfigPublic.sources,_from:vikeConfigPublic.from}}function resolveVikeConfigPublic_base({pageConfigGlobalValues,pageConfigValues}){const configValues={...pageConfigGlobalValues,...pageConfigValues};return resolveVikeConfigPublic_V1Design({configValues})}function resolveVikeConfigPublicGlobal({pageConfigGlobalValues}){const vikeConfigPublicGlobal=resolveVikeConfigPublic_V1Design({configValues:pageConfigGlobalValues});return getPublicCopy(vikeConfigPublicGlobal)}function resolveVikeConfigPublicPageLazy(pageFiles,pageConfig,pageConfigGlobal){const config={},configEntries={},exportsAll={};pageFiles.forEach(pageFile=>{getExportValues(pageFile).forEach(({exportName,exportValue,isFromDefaultExport})=>{assert(exportName!=="default"),exportsAll[exportName]=exportsAll[exportName]??[],exportsAll[exportName].push({exportValue,exportSource:`${pageFile.filePath} > ${isFromDefaultExport?`\`export default { ${exportName} }\``:`\`export { ${exportName} }\``}`,filePath:pageFile.filePath,_filePath:pageFile.filePath,_fileType:pageFile.fileType,_isFromDefaultExport:isFromDefaultExport})})});let source,sources,from;if(pageConfig){const res=resolveVikeConfigPublic_base({pageConfigGlobalValues:pageConfigGlobal.configValues,pageConfigValues:pageConfig.configValues});source=res.source,sources=res.sources,from=res.from,Object.assign(config,res.config),Object.assign(configEntries,res.configEntries),Object.assign(exportsAll,res.exportsAll)}else source={},sources={},from={configsStandard:{},configsCumulative:{},configsComputed:{}};const pageExports={},exports$1={};Object.entries(exportsAll).forEach(([exportName,values])=>{values.forEach(({exportValue,_fileType,_isFromDefaultExport})=>{exports$1[exportName]=exports$1[exportName]??exportValue,_fileType===".page"&&!_isFromDefaultExport&&(exportName in pageExports||(pageExports[exportName]=exportValue))})}),assert(!("default"in exports$1)),assert(!("default"in exportsAll));const pageContextExports={config,from,source,sources,configEntries,exports:exports$1,exportsAll};return objectDefineProperty(pageContextExports,"pageExports",{get:()=>(isBrowser()||assertWarning(!1,"pageContext.pageExports is outdated, use pageContext.exports instead",{onlyOnce:!0,showStackTrace:!0}),pageExports),enumerable:!1,configurable:!0}),pageContextExports}function resolveVikeConfigPublic_V1Design(pageConfig){const config={},configEntries={},exportsAll={},source={},sources={},from={configsStandard:{},configsCumulative:{},configsComputed:{}},addSrc=(src,configName)=>{source[configName]=src,sources[configName]??(sources[configName]=[]),sources[configName].push(src)},addLegacy=(configName,value,definedAtData)=>{const configValueFilePathToShowToUser=getConfigValueFilePathToShowToUser(definedAtData),configDefinedAt=getConfigDefinedAtOptional("Config",configName,definedAtData);configEntries[configName]=configEntries[configName]??[],configEntries[configName].push({configValue:value,configDefinedAt,configDefinedByFile:configValueFilePathToShowToUser});const exportName=configName;exportsAll[exportName]=exportsAll[exportName]??[],exportsAll[exportName].push({exportValue:value,exportSource:configDefinedAt,filePath:configValueFilePathToShowToUser,_filePath:configValueFilePathToShowToUser,_fileType:null,_isFromDefaultExport:null})};
3return Object.entries(pageConfig.configValues).forEach(([configName,configValue])=>{const{value}=configValue;if(config[configName]=config[configName]??value,configValue.type==="standard"){const src={type:"configsStandard",value:configValue.value,definedAt:getDefinedAtString(configValue.definedAtData,configName)};addSrc(src,configName),from.configsStandard[configName]=src,addLegacy(configName,value,configValue.definedAtData)}if(configValue.type==="cumulative"){const src={type:"configsCumulative",definedAt:getDefinedAtString(configValue.definedAtData,configName),values:configValue.value.map((value2,i)=>{const definedAtFile=configValue.definedAtData[i];assert(definedAtFile);const definedAt=getDefinedAtString(definedAtFile,configName);return addLegacy(configName,value2,definedAtFile),{value:value2,definedAt}})};addSrc(src,configName),from.configsCumulative[configName]=src}if(configValue.type==="computed"){const src={type:"configsComputed",definedAt:"Vike",value:configValue.value};addSrc(src,configName),from.configsComputed[configName]=src,addLegacy(configName,value,configValue.definedAtData)}}),{config,configEntries,exportsAll,source,sources,from}}function getExportValues(pageFile){const{filePath,fileExports}=pageFile;assert(fileExports),assert(isScriptFile(filePath));const exportValues=[];return Object.entries(fileExports).sort(makeLast(([exportName])=>exportName==="default")).forEach(([exportName,exportValue])=>{let isFromDefaultExport=exportName==="default";if(isFromDefaultExport)if(isTemplateFile(filePath))exportName="Page";else{assertUsage(isObject(exportValue),`The ${pc.cyan("export default")} of ${filePath} should be an object.`),Object.entries(exportValue).forEach(([defaultExportName,defaultExportValue])=>{assertDefaultExports(defaultExportName,filePath),exportValues.push({exportName:defaultExportName,exportValue:defaultExportValue,isFromDefaultExport})});return}exportValues.push({exportName,exportValue,isFromDefaultExport})}),exportValues.forEach(({exportName,isFromDefaultExport})=>{assert(!(isFromDefaultExport&&forbiddenDefaultExports.includes(exportName)))}),exportValues}function findPageConfig(pageConfigs,pageId){const result=pageConfigs.filter(p=>p.pageId===pageId);return assert(result.length<=1),result[0]??null}const SIDE_EXPORTS_TOLERATE=["$$registrations","_rerender_only"],SIDE_
3EXPORTS_DO_NOT_CHECK=[".md",".mdx"];function assertPlusFileExport(fileExports,filePathToShowToUser,configName){const exportNames=Object.keys(fileExports),isValid=exportName=>exportName==="default"||exportName===configName,exportNamesValid=exportNames.filter(isValid),exportDefault=pc.code("export default"),exportNamed=pc.code(`export { ${configName} }`);exportNamesValid.length===0&&assertUsage(!1,`${filePathToShowToUser} should define ${exportNamed} or ${exportDefault}`),exportNamesValid.length===2&&assertUsage(!1,`${filePathToShowToUser} is ambiguous: remove ${exportDefault} or ${exportNamed}`),assert(exportNamesValid.length===1);const exportNamesInvalid=exportNames.filter(e=>!isValid(e)).filter(exportName=>!SIDE_EXPORTS_TOLERATE.includes(exportName));SIDE_EXPORTS_DO_NOT_CHECK.some(ext=>filePathToShowToUser.endsWith(ext))||exportNamesInvalid.forEach(exportInvalid=>{assertWarning(!1,`${filePathToShowToUser} unexpected ${pc.cyan(`export { ${exportInvalid} }`)}, see https://vike.dev/no-side-exports`,{onlyOnce:!0})})}function parsePageConfigs(pageConfigsSerialized2,pageConfigGlobalSerialized2){const pageConfigs=pageConfigsSerialized2.map(pageConfigSerialized=>{const configValues=parseConfigValuesSerialized(pageConfigSerialized.configValuesSerialized);return assertRouteConfigValue(configValues),{...pageConfigSerialized,configValues}}),pageConfigGlobal={configValues:{}};{const configValues=parseConfigValuesSerialized(pageConfigGlobalSerialized2.configValuesSerialized);Object.assign(pageConfigGlobal.configValues,configValues)}return{pageConfigs,pageConfigGlobal}}function assertRouteConfigValue(configValues){const configName="route",configValue=configValues[configName];if(!configValue)return;const{value,definedAtData}=configValue,configValueType=typeof value;assert(definedAtData);const configDefinedAt=getConfigDefinedAt("Config",configName,definedAtData);assertUsage(configValueType==="string"||isCallable(value),`${configDefinedAt} has an invalid type '${configValueType}': it should be a string or a function instead, see https://vike.dev/route`)}function parseConfigValuesSerialized(configValuesSerialized){const configValues={};return Object.entries(configValuesSerialized).forEach(([configName,configValueSeriliazed])=>{let configValue;if(configValueSeriliazed.type==="cumulative"){const{valueSerialized,...common}=configValueSeriliazed;configValue={value:valueSerialized.map((valueSerializedElement,i)=>{const{value:value2,sideExports}=parseValueSerialized(valueSerializedElement,configName,()=>{const definedAtFile=configValueSeriliazed.definedAtData[i];return assert(definedAtFile),definedAtFile});return addSideExports(sideExports),value2}),...common}}else{const{valueSerialized,...common}=configValueSeriliazed,{value,sideExports}=parseValueSerialized(valueSerialized,configName,()=>{assert(configValueSeriliazed.type!=="computed");const{definedAtData}=configValueSeriliazed;return Array.isArray(definedAtData)?definedAtData[0]:definedAtData});addSideExports(sideExports),configValue={value,...common}}configValues[configName]=configValue}),configValues;function addSideExports(sideExports){sideExports.forEach(sideExport=>{const{configName,configValue}=sideExport;configValues[configName]||(configValues[configName]=configValue)})}}function parseValueSerialized(valueSerialized,configName,getDefinedAtFile){if(valueSerialized.type==="js-serialized"){let{value}=valueSerialized;return value=parseTransform(value),{value,sideExports:[]}}if(valueSerialized.type==="pointer-import"){const{value}=valueSerialized;return{value,sideExports:[]}}if(valueSerialized.type==="plus-file"){const definedAtFile=getDefinedAtFile(),{exportValues}=valueSerialized;assert(!definedAtFile.definedBy),assertPlusFileExport(exportValues,definedAtFile.filePathToShowToUser,configName);let value,valueWasFound=!1;const sideExports=[];return Object.entries(exportValues).forEach(([exportName,exportValue])=>{exportName!=="default"&&exportName!==configName?sideExports.push({configName:exportName,configValue:{type:"standard",value:exportValue,definedAtData:{filePathToShowToUser:definedAtFile.filePathToShowToUser,fileExportPathToShowToUser:[exportName]}}}):(value=exportValue,assert(!valueWasFound),valueWasFound=!0)}),assert(valueWasFound),{value,sideExports}}assert(!1)}async function loadConfigValues(pageConfig,isDev){if("isAllLoaded"in pageConfig)return pageConfig;const{moduleId,moduleExports}=pageConfig.loadConfigLazy(),configValuesLoaded=await moduleExports;configValuesLoaded||assert(!1,{moduleExports,configValuesLoaded,moduleId});const configValues=parseConfigValuesSerialized(configValuesLoaded.configValuesSerialized);return Object.assign(pageConfig.configValues,configValues),objectAssign(pageConfig,{isAllLoaded:!0}),pageConfig}const stamp="__whileFetchingAssets";async function loadPageConfigsLazyClientSide(pageId,pageFilesAll,pageConfigs,pageConfigGlobal){const pageFilesClientSide=getPageFilesClientSide(pageFilesAll,pageId),pageConfig=findPageConfig(pageConfigs,pageId);let pageConfigLoaded;const isDev=!1;try{pageConfigLoaded=(await Promise.all([pageConfig&&loadConfigValues(pageConfig,isDev),...pageFilesClientSide.map(p=>{var _a;return(_a=p.loadFile)==null?void 0:_a.call(p)})]))[0]}catch(err){throw isFetchError(err)&&Object.assign(err,{[stamp]:!0}),err}const pageContextExports=resolveVikeConfigPublicPageLazy(pageFilesClientSide,pageConfigLoaded,pageConfigGlobal),pageContextAddendum={};return objectAssign(pageContextAddendum,pageContextExports),objectAssign(pageContextAddendum,{_pageFilesLoaded:pageFilesClientSide}),pageContextAddendum}function isFetchError(err){return err instanceof Error?["Failed to fetch dynamically imported module","error loading dynamically imported module","Importing a module script failed","error resolving module specifier","failed to resolve module"].some(s=>err.message.toLowerCase().includes(s.toLowerCase())):!1}function normalizeClientSideUrl(url,options){assert(!url.startsWith("#"));const{searchOriginal,hashOriginal,pathname}=parseUrl(url,"/");let urlCurrent=`${pathname}${searchOriginal||""}`;
3return options!=null&&options.withoutHash||(urlCurrent+=hashOriginal||""),assert(urlCurrent.startsWith("/")),urlCurrent}function getCurrentUrl(options){return normalizeClientSideUrl(window.location.href,options)}function humanizeTime(milliseconds){const seconds=milliseconds/1e3;if(seconds<120){const n=round(seconds);return`${n} second${plural(n)}`}{const minutes=seconds/60,n=round(minutes);return`${n} minute${plural(n)}`}}function round(n){let rounded=n.toFixed(1);return rounded.endsWith(".0")&&(rounded=rounded.slice(0,-2)),rounded}function plural(n){return n==="1"?"":"s"}const globalObject$2=getGlobalObject("hooks/getHook.ts",{});function getHookFromPageContext(pageContext,hookName){if(!(hookName in pageContext.exports))return null;const{hooksTimeout}=pageContext.config,hookTimeout=getHookTimeout(hooksTimeout,hookName),hookFn=pageContext.exports[hookName];if(hookFn===null)return null;const file=pageContext.exportsAll[hookName][0];assert(file.exportValue===hookFn);const hookFilePath=file.filePath;return assert(hookFilePath),getHook(hookFn,hookName,hookFilePath,hookTimeout)}function getHookFromPageContextNew(hookName,pageContext){var _a;const{hooksTimeout}=pageContext.config,hookTimeout=getHookTimeout(hooksTimeout,hookName),hooks=[];return(_a=pageContext.exportsAll[hookName])==null||_a.forEach(val=>{const hookFn=val.exportValue;if(hookFn===null)return;const hookFilePath=val.filePath;assert(hookFilePath),hooks.push(getHook(hookFn,hookName,hookFilePath,hookTimeout))}),hooks}function getHookFromPageConfigGlobalCumulative(pageConfigGlobal,hookName){const configValue=pageConfigGlobal.configValues[hookName];if(!(configValue!=null&&configValue.value))return[];const val=configValue.value;return assert(isArray(val)),val.map((v,i)=>{const hookFn=v,hookTimeout=getHookTimeoutGlobal(hookName);assert(isArray(configValue.definedAtData));const hookFilePath=getHookFilePathToShowToUser(configValue.definedAtData[i]);return getHook(hookFn,hookName,hookFilePath,hookTimeout)})}function getHookTimeoutGlobal(hookName){return getHookTimeoutDefault(hookName)}function getHook(hookFn,hookName,hookFilePath,hookTimeout){return assert(hookFilePath),assertHookFn(hookFn,{hookName,hookFilePath}),{hookFn,hookName,hookFilePath,hookTimeout}}function assertHookFn(hookFn,{hookName,hookFilePath}){assert(hookName&&hookFilePath),assert(!hookName.endsWith(")")),assert(!hookFilePath.endsWith(" ")),assertUsage(isCallable(hookFn),`Hook ${hookName}() defined by ${hookFilePath} should be a function`)}function getHookTimeout(hooksTimeoutProvidedByUser,hookName){const hooksTimeoutProvidedbyUserNormalized=getHooksTimeoutProvidedByUserNormalized(hooksTimeoutProvidedByUser);if(hooksTimeoutProvidedbyUserNormalized===!1)return{error:!1,warning:!1};const providedbyUser=hooksTimeoutProvidedbyUserNormalized[hookName],hookTimeout=getHookTimeoutDefault(hookName);return(providedbyUser==null?void 0:providedbyUser.error)!==void 0&&(hookTimeout.error=providedbyUser.error),(providedbyUser==null?void 0:providedbyUser.warning)!==void 0&&(hookTimeout.warning=providedbyUser.warning),hookTimeout}function getHooksTimeoutProvidedByUserNormalized(hooksTimeoutProvidedByUser){if(hooksTimeoutProvidedByUser===void 0)return{};if(hooksTimeoutProvidedByUser===!1)return!1;assertUsage(isObject(hooksTimeoutProvidedByUser),`Setting ${pc.cyan("hooksTimeout")} should be ${pc.cyan("false")} or an object`);const hooksTimeoutProvidedByUserNormalized={};return Object.entries(hooksTimeoutProvidedByUser).forEach(([hookName,hookTimeoutProvidedbyUser])=>{if(hookTimeoutProvidedbyUser===!1){hooksTimeoutProvidedByUserNormalized[hookName]={error:!1,warning:!1};return}assertUsage(isObject(hookTimeoutProvidedbyUser),`Setting ${pc.cyan(`hooksTimeout.${hookName}`)} should be ${pc.cyan("false")} or an object`);const[error,warning]=["error","warning"].map(timeoutName=>{const timeoutVal=hookTimeoutProvidedbyUser[timeoutName];if(timeoutVal===void 0||timeoutVal===!1)return timeoutVal;const errPrefix=`Setting ${pc.cyan(`hooksTimeout.${hookName}.${timeoutName}`)} should be`;return assertUsage(typeof timeoutVal=="number",`${errPrefix} ${pc.cyan("false")} or a number`),assertUsage(timeoutVal>0,`${errPrefix} a positive number`),timeoutVal});hooksTimeoutProvidedByUserNormalized[hookName]={error,warning}}
3),hooksTimeoutProvidedByUserNormalized}function getHookTimeoutDefault(hookName){return hookName==="onBeforeRoute"?{error:5*1e3,warning:1*1e3}:globalObject$2.isPrerendering?{error:120*1e3,warning:30*1e3}:(assert(!hookName.toLowerCase().includes("prerender")),{error:30*1e3,warning:4*1e3})}function addIs404ToPageProps(pageContext){addIs404(pageContext)}function addIs404(pageContext){if(pageContext.is404===void 0||pageContext.is404===null)return;const pageProps=pageContext.pageProps||{};if(!isObject(pageProps)){assertWarning(!1,"pageContext.pageProps should be an object",{showStackTrace:!0,onlyOnce:!0});return}pageProps.is404=pageProps.is404||pageContext.is404,pageContext.pageProps=pageProps}const NOT_SERIALIZABLE="__VIKE__NOT_SERIALIZABLE__";function getProxyForPublicUsage(obj,objName,skipOnInternalProp,fallback){return new Proxy(obj,{get:getTrapGet(obj,objName,skipOnInternalProp,fallback)})}function getTrapGet(obj,objName,skipOnInternalProp,fallback){return function(_,prop){const propStr=String(prop);if(prop==="_isProxyObject")return!0;if(skipOnInternalProp||onInternalProp(propStr,objName),fallback&&!(prop in obj))return fallback(prop);const val=obj[prop];return onNotSerializable(propStr,val,objName),val}}function onNotSerializable(propStr,val,objName){if(val!==NOT_SERIALIZABLE)return;const propName=getPropAccessNotation(propStr);assert(isBrowser()),assertUsage(!1,`Can't access ${objName}${propName} on the client side. Because it can't be serialized, see server logs.`)}function onInternalProp(propStr,objName){isBrowser()||propStr!=="_configFromHook"&&propStr.startsWith("_")&&assertWarning(!1,`Using internal ${objName}.${propStr} which may break in any minor version update. Reach out on GitHub to request official support for your use case.`,{onlyOnce:!0,showStackTrace:!0})}function prepareGlobalContextForPublicUsage(globalContext){return assert(globalContext._isOriginalObject),getProxyForPublicUsage(globalContext,"globalContext")}function preparePageContextForPublicUsage(pageContext){assert(!pageContext._isProxyObject),assert(!pageContext.globalContext),assert(pageContext._isOriginalObject),addIs404ToPageProps(pageContext),"_pageId"in pageContext||Object.defineProperty(pageContext,"_pageId",{get(){return assertWarning(!1,"pageContext._pageId has been renamed to pageContext.pageId",{showStackTrace:!0,onlyOnce:!0}),pageContext.pageId},enumerable:!1}),sortPageContext(pageContext);const globalContextPublic=prepareGlobalContextForPublicUsage(pageContext._globalContext);return getProxyForPublicUsage(pageContext,"pageContext",!0,prop=>{if(prop==="globalContext")return globalContextPublic;if(prop in globalContextPublic)return globalContextPublic[prop]})}function sortPageContext(pageContext){let descriptors=Object.getOwnPropertyDescriptors(pageContext);for(const key of Object.keys(pageContext))delete pageContext[key];descriptors=Object.fromEntries(Object.entries(descriptors).sort(([key1],[key2])=>compareString(key1,key2))),Object.defineProperties(pageContext,descriptors)}function assertPropertyGetters(pageContext){["urlPathname","urlParsed","url","pageExports"].forEach(prop=>{pageContext.prop&&assert(isPropertyGetter(pageContext,prop))})}const globalObject$1=getGlobalObject("utils/execHook.ts",{userHookErrors:new WeakMap,pageContext:null});async function execHookSingle(hook,pageContext,preparePageContextForPublicUsage2){const res=await execHooksErrorHandling([hook],pageContext,preparePageContextForPublicUsage2);
3if("err"in res)throw res.err;const{hookReturn}=res.hooks[0];assertUsage(hookReturn===void 0,`The ${hook.hookName}() hook defined by ${hook.hookFilePath} isn't allowed to return a value`)}async function execHook(hookName,pageContext,preparePageContextForPublicUsage2){const res=await execHookErrorHandling(hookName,pageContext,preparePageContextForPublicUsage2);if("err"in res)throw res.err;return res.hooks}async function execHookErrorHandling(hookName,pageContext,preparePageContextForPublicUsage2){const hooks=getHookFromPageContextNew(hookName,pageContext);return execHooksErrorHandling(hooks,pageContext,preparePageContextForPublicUsage2)}async function execHooksErrorHandling(hooks,pageContext,preparePageContextForPublicUsage2){if(!hooks.length)return{hooks:[]};const pageContextForPublicUsage=preparePageContextForPublicUsage2(pageContext);let hooksWithResult,err;try{hooksWithResult=await Promise.all(hooks.map(async hook=>{const hookReturn=await execHookAsync(()=>hook.hookFn(pageContextForPublicUsage),hook,pageContextForPublicUsage);return{...hook,hookReturn}}))}catch(err_){err=err_}return hooksWithResult?{hooks:hooksWithResult}:{hooks,err}}async function execHookGlobal(hookName,pageConfigGlobal,pageContext,hookArg,prepareForPublicUsage){const hooks=getHookFromPageConfigGlobalCumulative(pageConfigGlobal,hookName),hookArgForPublicUsage=prepareForPublicUsage(hookArg);await Promise.all(hooks.map(async hook=>{await execHookAsync(()=>hook.hookFn(hookArgForPublicUsage),hook,pageContext)}))}function execHookAsync(hookFnCaller,hook,pageContextForPublicUsage){const{hookName,hookFilePath,hookTimeout:{error:timeoutErr,warning:timeoutWarn}}=hook;let resolve,reject;const promise=new Promise((resolve_,reject_)=>{resolve=ret=>{clearTimeouts(),resolve_(ret)},reject=err=>{clearTimeouts(),reject_(err)}}),clearTimeouts=()=>{currentTimeoutWarn&&clearTimeout(currentTimeoutWarn),currentTimeoutErr&&clearTimeout(currentTimeoutErr)},currentTimeoutWarn=isNotDisabled(timeoutWarn)&&setTimeout(()=>{assertWarning(!1,`The ${hookName}() hook defined by ${hookFilePath} is slow: it's taking more than ${humanizeTime(timeoutWarn)} (https://vike.dev/hooksTimeout)`,{onlyOnce:!1})},timeoutWarn),currentTimeoutErr=isNotDisabled(timeoutErr)&&setTimeout(()=>{const err=getProjectError(`The ${hookName}() hook defined by ${hookFilePath} timed out: it didn't finish after ${humanizeTime(timeoutErr)} (https://vike.dev/hooksTimeout)`);reject(err)},timeoutErr);return(async()=>{try{providePageContextInternal(pageContextForPublicUsage);const ret=await hookFnCaller();resolve(ret)}catch(err){isObject(err)&&globalObject$1.userHookErrors.set(err,{hookName,hookFilePath}),reject(err)}})(),promise}function isNotDisabled(timeout){return!!timeout&&timeout!==1/0}function providePageContextInternal(pageContext){globalObject$1.pageContext=pageContext,Promise.resolve().then(()=>{globalObject$1.pageContext=null})}async function createPageContextShared(pageContextCreated,pageConfigGlobal,vikeConfigPublicGlobal){return objectAssign(pageContextCreated,vikeConfigPublicGlobal),await execHookGlobal("onCreatePageContext",pageConfigGlobal,pageContextCreated,pageContextCreated,preparePageContextForPublicUsage),pageContextCreated}function createPageContextObject(){const pageContext={_isOriginalObject:!0,isPageContext:!0};return changeEnumerable(pageContext,"_isOriginalObject",!1),pageContext}function determinePageIdOld(filePath){const pageSuffix=".page.",pageId=slice(filePath.split(pageSuffix),0,-1).join(pageSuffix);return assert(!pageId.includes("\\")),pageId}function isErrorPageId(pageId,_isV1Design){return assert(!pageId.includes("\\")),pageId.includes("/_error")}const fileTypes=[".page",".page.server",".page.route",".page.client",".css"];function determineFileType(filePath){if(filePath.endsWith(".css"))return".css";assert(isScriptFile(filePath),filePath);const parts=filePath.split("/").slice(-1)[0].split("."),suffix1=parts.slice(-3)[0],suffix2=parts.slice(-2)[0];if(suffix2==="page")return".page";if(assert(suffix1==="page",filePath),suffix2==="server")return".page.server";if(suffix2==="client")return".page.client";if(suffix2==="route")return".page.route";assert(!1,filePath)}function getPageFileObject(filePath){const isRelevant=pageId=>pageFile.pageId===pageId||pageFile.isDefaultPageFile&&(isRendererFilePath(pageFile.filePath)||isAncestorDefaultPage(pageId,pageFile.filePath)),fileType=determineFileType(filePath),pageFile={filePath,fileType,isEnv:env=>{if(assert(fileType!==".page.route"),env==="CLIENT_ONLY")return fileType===".page.client"||fileType===".css";if(env==="SERVER_ONLY")return fileType===".page.server";if(env==="CLIENT_AND_SERVER")return fileType===".page";assert(!1)},isRelevant,isDefaultPageFile:isDefaultFilePath(filePath),isRendererPageFile:fileType!==".css"&&isDefaultFilePath(filePath)&&isRendererFilePath(filePath),isErrorPageFile:isErrorPageId(filePath),pageId:determinePageIdOld(filePath)};return pageFile}function isDefaultFilePath(filePath){return isErrorPageId(filePath)?!1:filePath.includes("/_default")}function isRendererFilePath(filePath){return filePath.includes("/renderer/")}function isAncestorDefaultPage(pageId,defaultPageFilePath){assert(!pageId.endsWith("/")),assert(!defaultPageFilePath.endsWith("/")),assert(isDefaultFilePath(defaultPageFilePath));const defaultPageDir=slice(defaultPageFilePath.split("/"),0,-1).filter(filePathSegment=>filePathSegment!=="_default").join("/");return pageId.startsWith(defaultPageDir)}function parseVirtualFileExports(virtualFileExports2){assert(hasProp(virtualFileExports2,"pageFilesLazy","object")),assert(hasProp(virtualFileExports2,"pageFilesEager","object")),assert(hasProp(virtualFileExports2,"pageFilesExportNamesLazy","object")),assert(hasProp(virtualFileExports2,"pageFilesExportNamesEager","object")),assert(hasProp(virtualFileExports2.pageFilesLazy,".page")),assert(hasProp(virtualFileExports2.pageFilesLazy,".page.client")||hasProp(virtualFileExports2.pageFilesLazy,".page.server")),assert(hasProp(virtualFileExports2,"pageFilesList","string[]")),assert(hasProp(virtualFileExports2,"pageConfigsSerialized")),assert(hasProp(virtualFileExports2,"pageConfigGlobalSerialized"));const{pageConfigsSerialized:pageConfigsSerialized2,pageConfigGlobalSerialized:pageConfigGlobalSerialized2}=virtualFileExports2;
3assertPageConfigsSerialized(pageConfigsSerialized2),assertPageConfigGlobalSerialized(pageConfigGlobalSerialized2);const{pageConfigs,pageConfigGlobal}=parsePageConfigs(pageConfigsSerialized2,pageConfigGlobalSerialized2),pageFilesMap={};parseGlobResult(virtualFileExports2.pageFilesLazy).forEach(({filePath,pageFile,globValue})=>{pageFile=pageFilesMap[filePath]=pageFilesMap[filePath]??pageFile;const loadModule=globValue;assertLoadModule(loadModule),pageFile.loadFile=async()=>{"fileExports"in pageFile||(pageFile.fileExports=await loadModule(),assertExportValues(pageFile))}}),parseGlobResult(virtualFileExports2.pageFilesExportNamesLazy).forEach(({filePath,pageFile,globValue})=>{pageFile=pageFilesMap[filePath]=pageFilesMap[filePath]??pageFile;const loadModule=globValue;assertLoadModule(loadModule),pageFile.loadExportNames=async()=>{if(!("exportNames"in pageFile)){const moduleExports=await loadModule();assert(hasProp(moduleExports,"exportNames","string[]"),pageFile.filePath),pageFile.exportNames=moduleExports.exportNames}}}),parseGlobResult(virtualFileExports2.pageFilesEager).forEach(({filePath,pageFile,globValue})=>{pageFile=pageFilesMap[filePath]=pageFilesMap[filePath]??pageFile;const moduleExports=globValue;assert(isObject(moduleExports)),pageFile.fileExports=moduleExports}),parseGlobResult(virtualFileExports2.pageFilesExportNamesEager).forEach(({filePath,pageFile,globValue})=>{pageFile=pageFilesMap[filePath]=pageFilesMap[filePath]??pageFile;const moduleExports=globValue;assert(isObject(moduleExports)),assert(hasProp(moduleExports,"exportNames","string[]"),pageFile.filePath),pageFile.exportNames=moduleExports.exportNames}),virtualFileExports2.pageFilesList.forEach(filePath=>{pageFilesMap[filePath]=pageFilesMap[filePath]??getPageFileObject(filePath)});const pageFilesAll=Object.values(pageFilesMap);return pageFilesAll.forEach(({filePath})=>{assert(!filePath.includes("\\"))}),{pageFilesAll,pageConfigs,pageConfigGlobal}}function parseGlobResult(globObject){const ret=[];return Object.entries(globObject).forEach(([fileType,globFiles])=>{assert(fileTypes.includes(fileType)),assert(isObject(globFiles)),Object.entries(globFiles).forEach(([filePath,globValue])=>{const pageFile=getPageFileObject(filePath);assert(pageFile.fileType===fileType),ret.push({filePath,pageFile,globValue})})}),ret}function assertLoadModule(globValue){assert(isCallable(globValue))}function assertPageConfigsSerialized(pageConfigsSerialized2){assert(isArray(pageConfigsSerialized2)),pageConfigsSerialized2.forEach(pageConfigSerialized=>{assert(isObject(pageConfigSerialized)),assert(hasProp(pageConfigSerialized,"pageId","string")),assert(hasProp(pageConfigSerialized,"routeFilesystem")),assert(hasProp(pageConfigSerialized,"configValuesSerialized"))})}function assertPageConfigGlobalSerialized(pageConfigGlobalSerialized2){assert(hasProp(pageConfigGlobalSerialized2,"configValuesSerialized"))}async function createGlobalContextShared(virtualFileExports2,globalObject2,addGlobalContext){const globalContext=createGlobalContextBase(virtualFileExports2),globalContextAddendum=await(addGlobalContext==null?void 0:addGlobalContext(globalContext));objectAssign(globalContext,globalContextAddendum);const onCreateGlobalContextHooks=getHookFromPageConfigGlobalCumulative(globalContext._pageConfigGlobal,"onCreateGlobalContext");let hooksCalled=!1;return hooksAreEqual(globalObject2.onCreateGlobalContextHooks??[],onCreateGlobalContextHooks)||(globalObject2.onCreateGlobalContextHooks=onCreateGlobalContextHooks,await execHookGlobal("onCreateGlobalContext",globalContext._pageConfigGlobal,null,globalContext,prepareGlobalContextForPublicUsage),hooksCalled=!0),globalObject2.globalContext?hooksCalled?objectReplace(globalObject2.globalContext,globalContext):objectAssign(globalObject2.globalContext,globalContext,!0):globalObject2.globalContext=globalContext,globalObject2.globalContext}function createGlobalContextBase(virtualFileExports2){const{pageFilesAll,allPageIds,pageConfigs,pageConfigGlobal,vikeConfigPublicGlobal,vikeConfigPublicPagesEager}=getConfigsAll(virtualFileExports2),globalContext={isGlobalContext:!0,_isOriginalObject:!0,_virtualFileExports:virtualFileExports2,_pageFilesAll:pageFilesAll,_pageConfigs:pageConfigs,_pageConfigGlobal:pageConfigGlobal,_allPageIds:allPageIds,_vikeConfigPublicGlobal:vikeConfigPublicGlobal,config:vikeConfigPublicGlobal.config,pages:vikeConfigPublicPagesEager};return changeEnumerable(globalContext,"_isOriginalObject",!1),globalContext}function getConfigsAll(virtualFileExports2){const{pageFilesAll,pageConfigs,pageConfigGlobal}=parseVirtualFileExports(virtualFileExports2),allPageIds=getAllPageIds(pageFilesAll,pageConfigs),vikeConfigPublicGlobal=resolveVikeConfigPublicGlobal({pageConfigGlobalValues:pageConfigGlobal.configValues}),vikeConfigPublicPagesEager=Object.fromEntries(pageConfigs.map(pageConfig=>resolveVikeConfigPublicPageEager(pageConfigGlobal.configValues,pageConfig,pageConfig.configValues)));return{pageFilesAll,allPageIds,pageConfigs,pageConfigGlobal,vikeConfigPublicGlobal,vikeConfigPublicPagesEager}}function getAllPageIds(pageFilesAll,pageConfigs){const fileIds=pageFilesAll.filter(({isDefaultPageFile})=>!isDefaultPageFile).map(({pageId})=>pageId),allPageIds=unique(fileIds),allPageIds2=pageConfigs.map(p=>p.pageId);return[...allPageIds,...allPageIds2]}function hooksAreEqual(hooks1,hooks2){const hooksFn1=hooks1.map(hook=>hook.hookFn),hooksFn2=hooks2.map(hook=>hook.hookFn);return hooksFn1.every(hook=>hooksFn2.includes(hook))&&hooksFn2.every(hook=>hooksFn1.includes(hook))}const globalObject=getGlobalObject("createGetGlobalContextClient.ts",(()=>{const{promise:globalContextPromise,resolve:globalContextPromiseResolve}=genPromise();return{globalContextPromise,globalContextPromiseResolve}})());function createGetGlobalContextClient(virtualFileExports2,isClientRouting,addGlobalContext){return assert(globalObject.isClientRouting===void 0||globalObject.isClientRouting===isClientRouting),globalObject.isClientRouting=isClientRouting,getGlobalContext2(),getGlobalContext2;async function getGlobalContext2(){if(globalObject.globalContext&&globalObject.globalContext._virtualFileExports!==virtualFileExports2)return globalObject.globalContext;const globalContext=await createGlobalContextShared(virtualFileExports2,globalObject,async globalContext2=>{const globalContextAddendum={isClientSide:!0};return objectAssign(globalContextAddendum,getGlobalContextSerializedInHtml()),objectAssign(globalContextAddendum,await(addGlobalContext==null?void 0:addGlobalContext(globalContext2))),globalContextAddendum});return assert(globalObject.globalContext),globalObject.globalContextPromiseResolve(globalObject.globalContext),globalContext}}const pageFilesLazy={},pageFilesEager={},pageFilesExportNamesLazy={},pageFilesExportNamesEager={},pageFilesList=[],neverLoaded={},pageConfigsSerialized=[{pageId:"/src/pages/catch-all",isErrorPage:void 0,routeFilesystem:{routeString:"/catch-all",definedAtLocation:"/src/pages/catch-all/"},loadConfigLazy:()=>({moduleId:"virtual:vike:pageConfigLazy:client:/src/pages/catch-all",moduleExports:__vitePreload(()=>import("./src_pages_catch-all.zP0j-ceq.js").then(n=>n.e),__vite__mapDeps([0,1,2,3,4,5,6]))}),configValuesSerialized:{isClientRuntimeLoaded:{type:"computed",definedAtData:null,valueSerialized:{type:"js-serialized",value:!0}},onBeforeRenderEnv:{type:"computed",definedAtData:null,valueSerialized:{type:"js-serialized",value:null}},dataEnv:{type:"computed",definedAtData:null,valueSerialized:{type:"js-serialized",value:null}}}}],pageConfigGlobalSerialized={configValuesSerialized:{}},pageFilesLazyIsomorph1=Object.assign({}),pageFilesLazyIsomorph={...pageFilesLazyIsomorph1};pageFilesLazy[".page"]=pageFilesLazyIsomorph;const pageFilesLazyClient1=Object.assign({}),pageFilesLazyClient={...pageFilesLazyClient1};pageFilesLazy[".page.client"]=pageFilesLazyClient;const neverLoadedServer1=Object.assign({}),neverLoadedServer={...neverLoadedServer1};
3neverLoaded[".page.server"]=neverLoadedServer;const virtualFileExports=Object.freeze(Object.defineProperty({__proto__:null,neverLoaded,pageConfigGlobalSerialized,pageConfigsSerialized,pageFilesEager,pageFilesExportNamesEager,pageFilesExportNamesLazy,pageFilesLazy,pageFilesList},Symbol.toStringTag,{value:"Module"})),getGlobalContextClientInternal=createGetGlobalContextClient(virtualFileExports,!1),urlFirst=getCurrentUrl({withoutHash:!0});async function createPageContextClientSide(){const globalContext=await getGlobalContextClientInternal(),pageContextCreated=createPageContextObject();objectAssign(pageContextCreated,{isClientSide:!0,isPrerendering:!1,isHydration:!0,_globalContext:globalContext,_pageFilesAll:globalContext._pageFilesAll,isBackwardNavigation:null,_hasPageContextFromServer:!0}),objectAssign(pageContextCreated,getPageContextSerializedInHtml());const pageContextAugmented=await createPageContextShared(pageContextCreated,globalContext._pageConfigGlobal,globalContext._vikeConfigPublicGlobal);return augmentType(pageContextCreated,pageContextAugmented),objectAssign(pageContextCreated,await loadPageConfigsLazyClientSide(pageContextCreated.pageId,globalContext._pageFilesAll,globalContext._pageConfigs,globalContext._pageConfigGlobal)),assertPristineUrl(),pageContextCreated}function assertPristineUrl(){const urlCurrent=getCurrentUrl({withoutHash:!0});assertUsage(urlFirst===urlCurrent,`The URL was manipulated before the hydration finished ('${urlFirst}' to '${urlCurrent}'). Ensure the hydration has finished before manipulating the URL. Consider using the onHydrationEnd() hook.`)}async function executeOnRenderClientHook(pageContext,prepareForPublicUsage){let hook=null;hook=getHookFromPageContext(pageContext,"render");{const renderHook=getHookFromPageContext(pageContext,"onRenderClient");renderHook&&(hook=renderHook)}if(!hook){const urlToShowToUser=getUrlToShowToUser(pageContext);if(assert(urlToShowToUser),pageContext._globalContext._pageConfigs.length>0)assertUsage(!1,`No onRenderClient() hook defined for URL '${urlToShowToUser}', but it's needed, see https://vike.dev/onRenderClient`);else{const pageClientsFilesLoaded=pageContext._pageFilesLoaded.filter(p=>p.fileType===".page.client");let errMsg;pageClientsFilesLoaded.length===0?errMsg="No file `*.page.client.*` found for URL "+urlToShowToUser:errMsg="One of the following files should export a render() hook: "+pageClientsFilesLoaded.map(p=>p.filePath).join(" "),assertUsage(!1,errMsg)}}await execHookSingle(hook,pageContext,prepareForPublicUsage)}function getUrlToShowToUser(pageContext){let url;try{url=pageContext.urlPathname??pageContext.urlOriginal}catch{}return url=url??window.location.href,url}function preparePageContextForPublicUsageClientShared(pageContext){var _a,_b;const Page=((_a=pageContext.config)==null?void 0:_a.Page)||((_b=pageContext.exports)==null?void 0:_b.Page);return objectAssign(pageContext,{Page}),assertPropertyGetters(pageContext),supportVueReactiviy(pageContext),preparePageContextForPublicUsageClientMinimal(pageContext)}function preparePageContextForPublicUsageClientMinimal(pageContext){return preparePageContextForPublicUsage(pageContext)}function supportVueReactiviy(pageContext){resolveGetters(pageContext)}function resolveGetters(pageContext){Object.entries(pageContext).forEach(([key,val])=>{delete pageContext[key],pageContext[key]=val})}function preparePageContextForPublicUsageClient(pageContext){return preparePageContextForPublicUsageClientShared(pageContext)}assertServerRouting();assertSingleInstance_onClientEntryServerRouting();hydrate();async function hydrate(){const pageContext=await createPageContextClientSide();await executeOnRenderClientHook(pageContext,preparePageContextForPublicUsageClient),await execHook("onHydrationEnd",pageContext,preparePageContextForPublicUsageClient)}
Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.