no message

.output/nitro.json

@@ -0,0 +1,14 @@
+{
+  "date": "2024-01-09T07:54:01.043Z",
+  "preset": "node-server",
+  "framework": {
+    "name": "nuxt",
+    "version": "3.8.2"
+  },
+  "versions": {
+    "nitro": "2.8.1"
+  },
+  "commands": {
+    "preview": "node ./server/index.mjs"
+  }
+}

.output/public/_nuxt/_plugin-vue_export-helper.d68d818f.js

@@ -1 +1 @@
-import{aH as u,r as c,Y as f,U as v,e as d,ay as l,aI as i,aJ as h,a6 as p}from"./entry.6f6364f6.js";function I(a,t={}){const e=t.head||u();if(e)return e.ssr?e.push(a,t):m(e,a,t)}function m(a,t,e={}){const s=c(!1),n=c({});f(()=>{n.value=s.value?{}:h(t)});const r=a.push(n.value,e);return v(n,o=>{r.patch(o)}),p()&&(d(()=>{r.dispose()}),l(()=>{s.value=!0}),i(()=>{s.value=!1})),r}const U=(a,t)=>{const e=a.__vccOpts||a;for(const[s,n]of t)e[s]=n;return e};export{U as _,I as u};
+import{aH as u,r as c,Y as f,U as v,e as d,ay as l,aI as i,aJ as h,a6 as p}from"./entry.7a5e54e2.js";function I(a,t={}){const e=t.head||u();if(e)return e.ssr?e.push(a,t):m(e,a,t)}function m(a,t,e={}){const s=c(!1),n=c({});f(()=>{n.value=s.value?{}:h(t)});const r=a.push(n.value,e);return v(n,o=>{r.patch(o)}),p()&&(d(()=>{r.dispose()}),l(()=>{s.value=!0}),i(()=>{s.value=!1})),r}const U=(a,t)=>{const e=a.__vccOpts||a;for(const[s,n]of t)e[s]=n;return e};export{U as _,I as u};

.output/public/_nuxt/builds/latest.json

@@ -1 +1 @@
-{"id":"84bb74bc-e316-4e19-80d1-dc9af1bce89f","timestamp":1704786774459}
+{"id":"465b9538-8076-4c86-bcfc-7ce83944aabe","timestamp":1704786813614}

.output/public/_nuxt/builds/meta/465b9538-8076-4c86-bcfc-7ce83944aabe.json

@@ -0,0 +1 @@
+{"id":"465b9538-8076-4c86-bcfc-7ce83944aabe","timestamp":1704786813614,"matcher":{"static":{},"wildcard":{},"dynamic":{}},"prerendered":[]}

.output/public/_nuxt/builds/meta/84bb74bc-e316-4e19-80d1-dc9af1bce89f.json

@@ -1 +0,0 @@
-{"id":"84bb74bc-e316-4e19-80d1-dc9af1bce89f","timestamp":1704786774459,"matcher":{"static":{},"wildcard":{},"dynamic":{}},"prerendered":[]}

.output/public/_nuxt/error-500.39079704.js

@@ -1 +1 @@
-import{_ as i,u as r}from"./_plugin-vue_export-helper.ab0d2579.js";import{t as a,v as n,x as e,y as s,C as l,D as d}from"./entry.6f6364f6.js";const c=t=>(l("data-v-df79c84d"),t=t(),d(),t),p={class:"font-sans antialiased bg-white dark:bg-black text-black dark:text-white grid min-h-screen place-content-center overflow-hidden"},f=c(()=>e("div",{class:"fixed -bottom-1/2 left-0 right-0 h-1/2 spotlight"},null,-1)),h={class:"max-w-520px text-center"},m=["textContent"],g=["textContent"],x={__name:"error-500",props:{appName:{type:String,default:"Nuxt"},version:{type:String,default:""},statusCode:{type:Number,default:500},statusMessage:{type:String,default:"Server error"},description:{type:String,default:"This page is temporarily unavailable."}},setup(t){const o=t;return r({title:`${o.statusCode} - ${o.statusMessage} | ${o.appName}`,script:[],style:[{children:'*,:before,:after{-webkit-box-sizing:border-box;box-sizing:border-box;border-width:0;border-style:solid;border-color:#e0e0e0}*{--tw-ring-inset:var(--tw-empty, );--tw-ring-offset-width:0px;--tw-ring-offset-color:#fff;--tw-ring-color:rgba(14, 165, 233, .5);--tw-ring-offset-shadow:0 0 #0000;--tw-ring-shadow:0 0 #0000;--tw-shadow:0 0 #0000}:root{-moz-tab-size:4;-o-tab-size:4;tab-size:4}body{margin:0;font-family:inherit;line-height:inherit}html{-webkit-text-size-adjust:100%;font-family:ui-sans-serif,system-ui,-apple-system,BlinkMacSystemFont,Segoe UI,Roboto,Helvetica Neue,Arial,Noto Sans,sans-serif,"Apple Color Emoji","Segoe UI Emoji",Segoe UI Symbol,"Noto Color Emoji";line-height:1.5}h1,p{margin:0}h1{font-size:inherit;font-weight:inherit}'}]}),(u,b)=>(a(),n("div",p,[f,e("div",h,[e("h1",{class:"text-8xl sm:text-10xl font-medium mb-8",textContent:s(t.statusCode)},null,8,m),e("p",{class:"text-xl px-8 sm:px-0 sm:text-4xl font-light mb-16 leading-tight",textContent:s(t.description)},null,8,g)])]))}},y=i(x,[["__scopeId","data-v-df79c84d"]]);export{y as default};
+import{_ as i,u as r}from"./_plugin-vue_export-helper.d68d818f.js";import{t as a,v as n,x as e,y as s,C as l,D as d}from"./entry.7a5e54e2.js";const c=t=>(l("data-v-df79c84d"),t=t(),d(),t),p={class:"font-sans antialiased bg-white dark:bg-black text-black dark:text-white grid min-h-screen place-content-center overflow-hidden"},f=c(()=>e("div",{class:"fixed -bottom-1/2 left-0 right-0 h-1/2 spotlight"},null,-1)),h={class:"max-w-520px text-center"},m=["textContent"],g=["textContent"],x={__name:"error-500",props:{appName:{type:String,default:"Nuxt"},version:{type:String,default:""},statusCode:{type:Number,default:500},statusMessage:{type:String,default:"Server error"},description:{type:String,default:"This page is temporarily unavailable."}},setup(t){const o=t;return r({title:`${o.statusCode} - ${o.statusMessage} | ${o.appName}`,script:[],style:[{children:'*,:before,:after{-webkit-box-sizing:border-box;box-sizing:border-box;border-width:0;border-style:solid;border-color:#e0e0e0}*{--tw-ring-inset:var(--tw-empty, );--tw-ring-offset-width:0px;--tw-ring-offset-color:#fff;--tw-ring-color:rgba(14, 165, 233, .5);--tw-ring-offset-shadow:0 0 #0000;--tw-ring-shadow:0 0 #0000;--tw-shadow:0 0 #0000}:root{-moz-tab-size:4;-o-tab-size:4;tab-size:4}body{margin:0;font-family:inherit;line-height:inherit}html{-webkit-text-size-adjust:100%;font-family:ui-sans-serif,system-ui,-apple-system,BlinkMacSystemFont,Segoe UI,Roboto,Helvetica Neue,Arial,Noto Sans,sans-serif,"Apple Color Emoji","Segoe UI Emoji",Segoe UI Symbol,"Noto Color Emoji";line-height:1.5}h1,p{margin:0}h1{font-size:inherit;font-weight:inherit}'}]}),(u,b)=>(a(),n("div",p,[f,e("div",h,[e("h1",{class:"text-8xl sm:text-10xl font-medium mb-8",textContent:s(t.statusCode)},null,8,m),e("p",{class:"text-xl px-8 sm:px-0 sm:text-4xl font-light mb-16 leading-tight",textContent:s(t.description)},null,8,g)])]))}},y=i(x,[["__scopeId","data-v-df79c84d"]]);export{y as default};

.output/public/_nuxt/index.fb406a00.js

@@ -1 +1 @@
-import{u as e}from"./entry.6f6364f6.js";const s={__name:"index",setup(r){return e().replace("/index.html"),(u,n)=>null}};export{s as default};
+import{u as e}from"./entry.7a5e54e2.js";const s={__name:"index",setup(r){return e().replace("/index.html"),(u,n)=>null}};export{s as default};

.output/public/_nuxt/masonry.bbccce3d.js

@@ -1,4 +1,4 @@
-import{ao as w,ap as V}from"./cross-icon.b74ea123.js";function j(x,v){for(var d=0;d<v.length;d++){const g=v[d];if(typeof g!="string"&&!Array.isArray(g)){for(const f in g)if(f!=="default"&&!(f in x)){const h=Object.getOwnPropertyDescriptor(g,f);h&&Object.defineProperty(x,f,h.get?h:{enumerable:!0,get:()=>g[f]})}}}return Object.freeze(Object.defineProperty(x,Symbol.toStringTag,{value:"Module"}))}var N={exports:{}},W={exports:{}},L={exports:{}},A;function U(){return A||(A=1,function(x){(function(v,d){x.exports?x.exports=d():v.EvEmitter=d()})(typeof window<"u"?window:w,function(){function v(){}var d=v.prototype;return d.on=function(g,f){if(!(!g||!f)){var h=this._events=this._events||{},a=h[g]=h[g]||[];return a.indexOf(f)==-1&&a.push(f),this}},d.once=function(g,f){if(!(!g||!f)){this.on(g,f);var h=this._onceEvents=this._onceEvents||{},a=h[g]=h[g]||{};return a[f]=!0,this}},d.off=function(g,f){var h=this._events&&this._events[g];if(!(!h||!h.length)){var a=h.indexOf(f);return a!=-1&&h.splice(a,1),this}},d.emitEvent=function(g,f){var h=this._events&&this._events[g];if(!(!h||!h.length)){h=h.slice(0),f=f||[];for(var a=this._onceEvents&&this._onceEvents[g],o=0;o<h.length;o++){var s=h[o],l=a&&a[s];l&&(this.off(g,s),delete a[s]),s.apply(this,f)}return this}},d.allOff=function(){delete this._events,delete this._onceEvents},v})}(L)),L.exports}var C={exports:{}};/*!
+import{ao as w,ap as V}from"./cross-icon.8c14d1c3.js";function j(x,v){for(var d=0;d<v.length;d++){const g=v[d];if(typeof g!="string"&&!Array.isArray(g)){for(const f in g)if(f!=="default"&&!(f in x)){const h=Object.getOwnPropertyDescriptor(g,f);h&&Object.defineProperty(x,f,h.get?h:{enumerable:!0,get:()=>g[f]})}}}return Object.freeze(Object.defineProperty(x,Symbol.toStringTag,{value:"Module"}))}var N={exports:{}},W={exports:{}},L={exports:{}},A;function U(){return A||(A=1,function(x){(function(v,d){x.exports?x.exports=d():v.EvEmitter=d()})(typeof window<"u"?window:w,function(){function v(){}var d=v.prototype;return d.on=function(g,f){if(!(!g||!f)){var h=this._events=this._events||{},a=h[g]=h[g]||[];return a.indexOf(f)==-1&&a.push(f),this}},d.once=function(g,f){if(!(!g||!f)){this.on(g,f);var h=this._onceEvents=this._onceEvents||{},a=h[g]=h[g]||{};return a[f]=!0,this}},d.off=function(g,f){var h=this._events&&this._events[g];if(!(!h||!h.length)){var a=h.indexOf(f);return a!=-1&&h.splice(a,1),this}},d.emitEvent=function(g,f){var h=this._events&&this._events[g];if(!(!h||!h.length)){h=h.slice(0),f=f||[];for(var a=this._onceEvents&&this._onceEvents[g],o=0;o<h.length;o++){var s=h[o],l=a&&a[s];l&&(this.off(g,s),delete a[s]),s.apply(this,f)}return this}},d.allOff=function(){delete this._events,delete this._onceEvents},v})}(L)),L.exports}var C={exports:{}};/*!
  * getSize v2.0.3
  * measure size of elements
  * MIT license

.output/server/chunks/app/_nuxt/_id_-styles.5bc2c698.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"_id_-styles.5bc2c698.mjs","sources":["../../../../../.nuxt/dist/server/_nuxt/_id_-styles-1.mjs-fefef7cc.js","../../../../../.nuxt/dist/server/_nuxt/_id_-styles-2.mjs-55580394.js","../../../../../.nuxt/dist/server/_nuxt/_id_-styles-3.mjs-16c58bd3.js","../../../../../.nuxt/dist/server/_nuxt/_id_-styles-4.mjs-e2dfda26.js","../../../../../.nuxt/dist/server/_nuxt/_id_-styles.5bc2c698.mjs"],"sourcesContent":null,"names":["style_0","style_1","style_2","style_3","style_4"],"mappings":"AAAA,MAAM,sDAAyD,GAAA,uwGAAA;;ACA/D,MAAM,0DAA6D,GAAA,w/CAAA;;ACAnE,MAAM,SAAY,GAAA,y1CAAA;;ACAlB,MAAM,oDAAuD,GAAA,q9sBAAA;;ACK7D,4BAAe,CAACA,sDAAO,EAAEC,0DAAO,EAAEC,SAAO,EAAEC,oDAAO,EAAEC,oDAAO;;;;"}

.output/server/chunks/app/_nuxt/_plugin-vue_export-helper-e3874580.mjs

@@ -0,0 +1,41 @@
+import { ref, watchEffect, watch, getCurrentInstance } from 'vue';
+import { l as injectHead, r as resolveUnrefHeadInput } from '../server.mjs';
+import { composableNames } from '@unhead/shared';
+
+function useHead(input, options = {}) {
+  const head = options.head || injectHead();
+  if (head) {
+    if (!head.ssr)
+      return clientUseHead(head, input, options);
+    return head.push(input, options);
+  }
+}
+function clientUseHead(head, input, options = {}) {
+  const deactivated = ref(false);
+  const resolvedInput = ref({});
+  watchEffect(() => {
+    resolvedInput.value = deactivated.value ? {} : resolveUnrefHeadInput(input);
+  });
+  const entry = head.push(resolvedInput.value, options);
+  watch(resolvedInput, (e) => {
+    entry.patch(e);
+  });
+  getCurrentInstance();
+  return entry;
+}
+const coreComposableNames = [
+  "injectHead"
+];
+({
+  "@unhead/vue": [...coreComposableNames, ...composableNames]
+});
+const _export_sfc = (sfc, props) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props) {
+    target[key] = val;
+  }
+  return target;
+};
+
+export { _export_sfc as _, useHead as u };
+//# sourceMappingURL=_plugin-vue_export-helper-e3874580.mjs.map

.output/server/chunks/app/_nuxt/_plugin-vue_export-helper-e3874580.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"_plugin-vue_export-helper-e3874580.mjs","sources":["../../../../../.nuxt/dist/server/_nuxt/_plugin-vue_export-helper-e3874580.js"],"sourcesContent":null,"names":[],"mappings":";;;;AAGA,SAAS,OAAQ,CAAA,KAAA,EAAO,OAAU,GAAA,EAAI,EAAA;AACpC,EAAM,MAAA,IAAA,GAAO,OAAQ,CAAA,IAAA,IAAQ,UAAW,EAAA,CAAA;AACxC,EAAA,IAAI,IAAM,EAAA;AACR,IAAA,IAAI,CAAC,IAAK,CAAA,GAAA;AACR,MAAO,OAAA,aAAA,CAAc,IAAM,EAAA,KAAA,EAAO,OAAO,CAAA,CAAA;AAC3C,IAAO,OAAA,IAAA,CAAK,IAAK,CAAA,KAAA,EAAO,OAAO,CAAA,CAAA;AAAA,GACjC;AACF,CAAA;AACA,SAAS,aAAc,CAAA,IAAA,EAAM,KAAO,EAAA,OAAA,GAAU,EAAI,EAAA;AAChD,EAAM,MAAA,WAAA,GAAc,IAAI,KAAK,CAAA,CAAA;AAC7B,EAAM,MAAA,aAAA,GAAgB,GAAI,CAAA,EAAE,CAAA,CAAA;AAC5B,EAAA,WAAA,CAAY,MAAM;AAChB,IAAA,aAAA,CAAc,QAAQ,WAAY,CAAA,KAAA,GAAQ,EAAC,GAAI,sBAAsB,KAAK,CAAA,CAAA;AAAA,GAC3E,CAAA,CAAA;AACD,EAAA,MAAM,KAAQ,GAAA,IAAA,CAAK,IAAK,CAAA,aAAA,CAAc,OAAO,OAAO,CAAA,CAAA;AACpD,EAAM,KAAA,CAAA,aAAA,EAAe,CAAC,CAAM,KAAA;AAC1B,IAAA,KAAA,CAAM,MAAM,CAAC,CAAA,CAAA;AAAA,GACd,CAAA,CAAA;AACD,EAAmB,kBAAA,EAAA,CAAA;AACnB,EAAO,OAAA,KAAA,CAAA;AACT,CAAA;AACA,MAAM,mBAAsB,GAAA;AAAA,EAC1B,YAAA;AACF,CAAA,CAAA;AAAA,CACC;AAAA,EACC,aAAe,EAAA,CAAC,GAAG,mBAAA,EAAqB,GAAG,eAAe,CAAA;AAC5D,CAAA,EAAA;AACM,MAAA,WAAA,GAAc,CAAC,GAAA,EAAK,KAAU,KAAA;AAClC,EAAM,MAAA,MAAA,GAAS,IAAI,SAAa,IAAA,GAAA,CAAA;AAChC,EAAA,KAAA,MAAW,CAAC,GAAA,EAAK,GAAG,CAAA,IAAK,KAAO,EAAA;AAC9B,IAAA,MAAA,CAAO,GAAG,CAAI,GAAA,GAAA,CAAA;AAAA,GAChB;AACA,EAAO,OAAA,MAAA,CAAA;AACT;;;;"}

.output/server/chunks/app/_nuxt/entry-styles.582d7478.mjs

@@ -0,0 +1,6 @@
+const app_vue_vue_type_style_index_0_lang = "*{box-sizing:border-box;font-family:PingFangSC-Regular,PingFang SC,sans-serif;margin:0;padding:0}.flexflex{display:flex}.flex1{flex:1}.flexcenter{justify-content:center}.flexacenter,.flexcenter{align-items:center;display:flex}.flexjcenter{display:flex;justify-content:center}.ellipsis{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}body{background-color:#eef2f5}a{text-decoration:none!important}::-webkit-scrollbar{background-color:transparent;width:8px}::-webkit-scrollbar-thumb{background-color:#d7d7d7;border-radius:4px}::-webkit-scrollbar-thumb:hover{background-color:#666}*{scrollbar-color:#d7d7d7 transparent;scrollbar-width:thin}::-moz-scrollbar-thumb{background-color:#d7d7d7}::-moz-scrollbar-thumb:hover{background-color:#666}header.page-header .box .tab-list .item.pitch{color:#72db86!important}header.page-header .box .tab-list .item.pitch:after{background-color:#72db86!important}.avatar-box{background-color:#f4f8ff;border:1px solid #dce0ea;border-radius:10px;flex-direction:column;height:101px;z-index:100}.avatar-box .avatar-mask{cursor:auto;height:100%;left:0;position:fixed;top:0;width:100%;z-index:-1}.avatar-box .avatar-item{color:#333;cursor:pointer;font-size:14px;height:50px}.avatar-box .avatar-item:not(:last-of-type){border-bottom:1px dotted #d7d7d7}.avatar-box .avatar-icon{height:16px;margin-right:5px;width:16px}.el-popover.el-popper.avatar-box-popper{border:none;border-radius:10px;min-width:140px;padding:0}";
+
+const entryStyles_582d7478 = [app_vue_vue_type_style_index_0_lang];
+
+export { entryStyles_582d7478 as default };
+//# sourceMappingURL=entry-styles.582d7478.mjs.map

.output/server/chunks/app/_nuxt/entry-styles.582d7478.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"entry-styles.582d7478.mjs","sources":["../../../../../.nuxt/dist/server/_nuxt/entry-styles-1.mjs-dd00f040.js","../../../../../.nuxt/dist/server/_nuxt/entry-styles.582d7478.mjs"],"sourcesContent":null,"names":["style_0"],"mappings":"AAAA,MAAM,mCAAsC,GAAA,y6CAAA;;ACC5C,6BAAe,CAACA,mCAAO;;;;"}

.output/server/chunks/app/_nuxt/error-404-28503570.mjs

@@ -0,0 +1,283 @@
+import { useSSRContext, mergeProps, withCtx, createTextVNode, toDisplayString, defineComponent, computed, ref, h, resolveComponent } from 'vue';
+import { l as hasProtocol, j as joinURL, p as parseURL, q as parseQuery, r as withTrailingSlash, t as withoutTrailingSlash } from '../../nitro/node-server.mjs';
+import { u as useRouter, n as nuxtLinkDefaults, a as useRuntimeConfig, b as navigateTo } from '../server.mjs';
+import { _ as _export_sfc, u as useHead } from './_plugin-vue_export-helper-e3874580.mjs';
+import { ssrRenderAttrs, ssrInterpolate, ssrRenderComponent } from 'vue/server-renderer';
+import 'node:http';
+import 'node:https';
+import 'fs';
+import 'path';
+import 'node:fs';
+import 'node:url';
+import 'unhead';
+import '@unhead/shared';
+import 'vue-router';
+
+const firstNonUndefined = (...args) => args.find((arg) => arg !== void 0);
+const DEFAULT_EXTERNAL_REL_ATTRIBUTE = "noopener noreferrer";
+/*! @__NO_SIDE_EFFECTS__ */
+// @__NO_SIDE_EFFECTS__
+function defineNuxtLink(options) {
+  const componentName = options.componentName || "NuxtLink";
+  const resolveTrailingSlashBehavior = (to, resolve) => {
+    if (!to || options.trailingSlash !== "append" && options.trailingSlash !== "remove") {
+      return to;
+    }
+    const normalizeTrailingSlash = options.trailingSlash === "append" ? withTrailingSlash : withoutTrailingSlash;
+    if (typeof to === "string") {
+      return normalizeTrailingSlash(to, true);
+    }
+    const path = "path" in to ? to.path : resolve(to).path;
+    return {
+      ...to,
+      name: void 0,
+      // named routes would otherwise always override trailing slash behavior
+      path: normalizeTrailingSlash(path, true)
+    };
+  };
+  return defineComponent({
+    name: componentName,
+    props: {
+      // Routing
+      to: {
+        type: [String, Object],
+        default: void 0,
+        required: false
+      },
+      href: {
+        type: [String, Object],
+        default: void 0,
+        required: false
+      },
+      // Attributes
+      target: {
+        type: String,
+        default: void 0,
+        required: false
+      },
+      rel: {
+        type: String,
+        default: void 0,
+        required: false
+      },
+      noRel: {
+        type: Boolean,
+        default: void 0,
+        required: false
+      },
+      // Prefetching
+      prefetch: {
+        type: Boolean,
+        default: void 0,
+        required: false
+      },
+      noPrefetch: {
+        type: Boolean,
+        default: void 0,
+        required: false
+      },
+      // Styling
+      activeClass: {
+        type: String,
+        default: void 0,
+        required: false
+      },
+      exactActiveClass: {
+        type: String,
+        default: void 0,
+        required: false
+      },
+      prefetchedClass: {
+        type: String,
+        default: void 0,
+        required: false
+      },
+      // Vue Router's `<RouterLink>` additional props
+      replace: {
+        type: Boolean,
+        default: void 0,
+        required: false
+      },
+      ariaCurrentValue: {
+        type: String,
+        default: void 0,
+        required: false
+      },
+      // Edge cases handling
+      external: {
+        type: Boolean,
+        default: void 0,
+        required: false
+      },
+      // Slot API
+      custom: {
+        type: Boolean,
+        default: void 0,
+        required: false
+      }
+    },
+    setup(props, { slots }) {
+      const router = useRouter();
+      const config = useRuntimeConfig();
+      const to = computed(() => {
+        const path = props.to || props.href || "";
+        return resolveTrailingSlashBehavior(path, router.resolve);
+      });
+      const isProtocolURL = computed(() => typeof to.value === "string" && hasProtocol(to.value, { acceptRelative: true }));
+      const isExternal = computed(() => {
+        if (props.external) {
+          return true;
+        }
+        if (props.target && props.target !== "_self") {
+          return true;
+        }
+        if (typeof to.value === "object") {
+          return false;
+        }
+        return to.value === "" || isProtocolURL.value;
+      });
+      const prefetched = ref(false);
+      const el = void 0;
+      const elRef = void 0;
+      return () => {
+        var _a2;
+        var _a, _b;
+        if (!isExternal.value) {
+          const routerLinkProps = {
+            ref: elRef,
+            to: to.value,
+            activeClass: props.activeClass || options.activeClass,
+            exactActiveClass: props.exactActiveClass || options.exactActiveClass,
+            replace: props.replace,
+            ariaCurrentValue: props.ariaCurrentValue,
+            custom: props.custom
+          };
+          if (!props.custom) {
+            if (prefetched.value) {
+              routerLinkProps.class = props.prefetchedClass || options.prefetchedClass;
+            }
+            routerLinkProps.rel = props.rel;
+          }
+          return h(
+            resolveComponent("RouterLink"),
+            routerLinkProps,
+            slots.default
+          );
+        }
+        const href = typeof to.value === "object" ? (_a2 = (_a = router.resolve(to.value)) == null ? void 0 : _a.href) != null ? _a2 : null : to.value && !props.external && !isProtocolURL.value ? resolveTrailingSlashBehavior(joinURL(config.app.baseURL, to.value), router.resolve) : to.value || null;
+        const target = props.target || null;
+        const rel = props.noRel ? null : firstNonUndefined(props.rel, options.externalRelAttribute, href ? DEFAULT_EXTERNAL_REL_ATTRIBUTE : "") || null;
+        const navigate = () => navigateTo(href, { replace: props.replace });
+        if (props.custom) {
+          if (!slots.default) {
+            return null;
+          }
+          return slots.default({
+            href,
+            navigate,
+            get route() {
+              if (!href) {
+                return void 0;
+              }
+              const url = parseURL(href);
+              return {
+                path: url.pathname,
+                fullPath: url.pathname,
+                get query() {
+                  return parseQuery(url.search);
+                },
+                hash: url.hash,
+                // stub properties for compat with vue-router
+                params: {},
+                name: void 0,
+                matched: [],
+                redirectedFrom: void 0,
+                meta: {},
+                href
+              };
+            },
+            rel,
+            target,
+            isExternal: isExternal.value,
+            isActive: false,
+            isExactActive: false
+          });
+        }
+        return h("a", { ref: el, href, rel, target }, (_b = slots.default) == null ? void 0 : _b.call(slots));
+      };
+    }
+  });
+}
+const __nuxt_component_0 = /* @__PURE__ */ defineNuxtLink(nuxtLinkDefaults);
+const _sfc_main = {
+  __name: "error-404",
+  __ssrInlineRender: true,
+  props: {
+    appName: {
+      type: String,
+      default: "Nuxt"
+    },
+    version: {
+      type: String,
+      default: ""
+    },
+    statusCode: {
+      type: Number,
+      default: 404
+    },
+    statusMessage: {
+      type: String,
+      default: "Not Found"
+    },
+    description: {
+      type: String,
+      default: "Sorry, the page you are looking for could not be found."
+    },
+    backHome: {
+      type: String,
+      default: "Go back home"
+    }
+  },
+  setup(__props) {
+    const props = __props;
+    useHead({
+      title: `${props.statusCode} - ${props.statusMessage} | ${props.appName}`,
+      script: [],
+      style: [
+        {
+          children: `*,:before,:after{-webkit-box-sizing:border-box;box-sizing:border-box;border-width:0;border-style:solid;border-color:#e0e0e0}*{--tw-ring-inset:var(--tw-empty, );--tw-ring-offset-width:0px;--tw-ring-offset-color:#fff;--tw-ring-color:rgba(14, 165, 233, .5);--tw-ring-offset-shadow:0 0 #0000;--tw-ring-shadow:0 0 #0000;--tw-shadow:0 0 #0000}:root{-moz-tab-size:4;-o-tab-size:4;tab-size:4}a{color:inherit;text-decoration:inherit}body{margin:0;font-family:inherit;line-height:inherit}html{-webkit-text-size-adjust:100%;font-family:ui-sans-serif,system-ui,-apple-system,BlinkMacSystemFont,Segoe UI,Roboto,Helvetica Neue,Arial,Noto Sans,sans-serif,"Apple Color Emoji","Segoe UI Emoji",Segoe UI Symbol,"Noto Color Emoji";line-height:1.5}h1,p{margin:0}h1{font-size:inherit;font-weight:inherit}`
+        }
+      ]
+    });
+    return (_ctx, _push, _parent, _attrs) => {
+      const _component_NuxtLink = __nuxt_component_0;
+      _push(`<div${ssrRenderAttrs(mergeProps({ class: "font-sans antialiased bg-white dark:bg-black text-black dark:text-white grid min-h-screen place-content-center overflow-hidden" }, _attrs))} data-v-ccd3db62><div class="fixed left-0 right-0 spotlight z-10" data-v-ccd3db62></div><div class="max-w-520px text-center z-20" data-v-ccd3db62><h1 class="text-8xl sm:text-10xl font-medium mb-8" data-v-ccd3db62>${ssrInterpolate(__props.statusCode)}</h1><p class="text-xl px-8 sm:px-0 sm:text-4xl font-light mb-16 leading-tight" data-v-ccd3db62>${ssrInterpolate(__props.description)}</p><div class="w-full flex items-center justify-center" data-v-ccd3db62>`);
+      _push(ssrRenderComponent(_component_NuxtLink, {
+        to: "/",
+        class: "gradient-border text-md sm:text-xl py-2 px-4 sm:py-3 sm:px-6 cursor-pointer"
+      }, {
+        default: withCtx((_, _push2, _parent2, _scopeId) => {
+          if (_push2) {
+            _push2(`${ssrInterpolate(__props.backHome)}`);
+          } else {
+            return [
+              createTextVNode(toDisplayString(__props.backHome), 1)
+            ];
+          }
+        }),
+        _: 1
+      }, _parent));
+      _push(`</div></div></div>`);
+    };
+  }
+};
+const _sfc_setup = _sfc_main.setup;
+_sfc_main.setup = (props, ctx) => {
+  const ssrContext = useSSRContext();
+  (ssrContext.modules || (ssrContext.modules = /* @__PURE__ */ new Set())).add("node_modules/@nuxt/ui-templates/dist/templates/error-404.vue");
+  return _sfc_setup ? _sfc_setup(props, ctx) : void 0;
+};
+const error404 = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-ccd3db62"]]);
+
+export { error404 as default };
+//# sourceMappingURL=error-404-28503570.mjs.map

.output/server/chunks/app/_nuxt/error-404-styles.1e0dde27.mjs

@@ -0,0 +1,6 @@
+const error404_vue_vue_type_style_index_0_scoped_ccd3db62_lang = '.spotlight[data-v-ccd3db62]{background:linear-gradient(45deg,#00dc82,#36e4da 50%,#0047e1);bottom:-30vh;filter:blur(20vh);height:40vh}.gradient-border[data-v-ccd3db62]{-webkit-backdrop-filter:blur(10px);backdrop-filter:blur(10px);border-radius:.5rem;position:relative}@media (prefers-color-scheme:light){.gradient-border[data-v-ccd3db62]{background-color:hsla(0,0%,100%,.3)}.gradient-border[data-v-ccd3db62]:before{background:linear-gradient(90deg,#e2e2e2,#e2e2e2 25%,#00dc82 50%,#36e4da 75%,#0047e1)}}@media (prefers-color-scheme:dark){.gradient-border[data-v-ccd3db62]{background-color:hsla(0,0%,8%,.3)}.gradient-border[data-v-ccd3db62]:before{background:linear-gradient(90deg,#303030,#303030 25%,#00dc82 50%,#36e4da 75%,#0047e1)}}.gradient-border[data-v-ccd3db62]:before{background-size:400% auto;border-radius:.5rem;bottom:0;content:"";left:0;-webkit-mask:linear-gradient(#fff 0 0) content-box,linear-gradient(#fff 0 0);mask:linear-gradient(#fff 0 0) content-box,linear-gradient(#fff 0 0);-webkit-mask-composite:xor;mask-composite:exclude;opacity:.5;padding:2px;position:absolute;right:0;top:0;transition:background-position .3s ease-in-out,opacity .2s ease-in-out;width:100%}.gradient-border[data-v-ccd3db62]:hover:before{background-position:-50% 0;opacity:1}.bg-white[data-v-ccd3db62]{--tw-bg-opacity:1;background-color:rgba(255,255,255,var(--tw-bg-opacity))}.cursor-pointer[data-v-ccd3db62]{cursor:pointer}.flex[data-v-ccd3db62]{display:flex}.grid[data-v-ccd3db62]{display:grid}.place-content-center[data-v-ccd3db62]{place-content:center}.items-center[data-v-ccd3db62]{align-items:center}.justify-center[data-v-ccd3db62]{justify-content:center}.font-sans[data-v-ccd3db62]{font-family:ui-sans-serif,system-ui,-apple-system,BlinkMacSystemFont,Segoe UI,Roboto,Helvetica Neue,Arial,Noto Sans,sans-serif,Apple Color Emoji,Segoe UI Emoji,Segoe UI Symbol,Noto Color Emoji}.font-medium[data-v-ccd3db62]{font-weight:500}.font-light[data-v-ccd3db62]{font-weight:300}.text-8xl[data-v-ccd3db62]{font-size:6rem;line-height:1}.text-xl[data-v-ccd3db62]{font-size:1.25rem;line-height:1.75rem}.leading-tight[data-v-ccd3db62]{line-height:1.25}.mb-8[data-v-ccd3db62]{margin-bottom:2rem}.mb-16[data-v-ccd3db62]{margin-bottom:4rem}.max-w-520px[data-v-ccd3db62]{max-width:520px}.min-h-screen[data-v-ccd3db62]{min-height:100vh}.overflow-hidden[data-v-ccd3db62]{overflow:hidden}.px-8[data-v-ccd3db62]{padding-left:2rem;padding-right:2rem}.py-2[data-v-ccd3db62]{padding-bottom:.5rem;padding-top:.5rem}.px-4[data-v-ccd3db62]{padding-left:1rem;padding-right:1rem}.fixed[data-v-ccd3db62]{position:fixed}.left-0[data-v-ccd3db62]{left:0}.right-0[data-v-ccd3db62]{right:0}.text-center[data-v-ccd3db62]{text-align:center}.text-black[data-v-ccd3db62]{--tw-text-opacity:1;color:rgba(0,0,0,var(--tw-text-opacity))}.antialiased[data-v-ccd3db62]{-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale}.w-full[data-v-ccd3db62]{width:100%}.z-10[data-v-ccd3db62]{z-index:10}.z-20[data-v-ccd3db62]{z-index:20}@media (min-width:640px){.sm\\:text-4xl[data-v-ccd3db62]{font-size:2.25rem;line-height:2.5rem}.sm\\:text-xl[data-v-ccd3db62]{font-size:1.25rem;line-height:1.75rem}.sm\\:text-10xl[data-v-ccd3db62]{font-size:10rem;line-height:1}.sm\\:px-0[data-v-ccd3db62]{padding-left:0;padding-right:0}.sm\\:py-3[data-v-ccd3db62]{padding-bottom:.75rem;padding-top:.75rem}.sm\\:px-6[data-v-ccd3db62]{padding-left:1.5rem;padding-right:1.5rem}}@media (prefers-color-scheme:dark){.dark\\:bg-black[data-v-ccd3db62]{--tw-bg-opacity:1;background-color:rgba(0,0,0,var(--tw-bg-opacity))}.dark\\:text-white[data-v-ccd3db62]{--tw-text-opacity:1;color:rgba(255,255,255,var(--tw-text-opacity))}}';
+
+const error404Styles_1e0dde27 = [error404_vue_vue_type_style_index_0_scoped_ccd3db62_lang, error404_vue_vue_type_style_index_0_scoped_ccd3db62_lang];
+
+export { error404Styles_1e0dde27 as default };
+//# sourceMappingURL=error-404-styles.1e0dde27.mjs.map

.output/server/chunks/app/_nuxt/error-404-styles.1e0dde27.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-404-styles.1e0dde27.mjs","sources":["../../../../../.nuxt/dist/server/_nuxt/error-404-styles-1.mjs-e0837f4f.js","../../../../../.nuxt/dist/server/_nuxt/error-404-styles.1e0dde27.mjs"],"sourcesContent":null,"names":["style_0","style_1"],"mappings":"AAAA,MAAM,wDAA2D,GAAA,ukHAAA;;ACEjE,gCAAe,CAACA,wDAAO,EAAEC,wDAAO;;;;"}

.output/server/chunks/app/_nuxt/error-500-1b10eb7c.mjs

@@ -0,0 +1,66 @@
+import { _ as _export_sfc, u as useHead } from './_plugin-vue_export-helper-e3874580.mjs';
+import { useSSRContext, mergeProps } from 'vue';
+import { ssrRenderAttrs, ssrInterpolate } from 'vue/server-renderer';
+import '../server.mjs';
+import '../../nitro/node-server.mjs';
+import 'node:http';
+import 'node:https';
+import 'fs';
+import 'path';
+import 'node:fs';
+import 'node:url';
+import 'unhead';
+import '@unhead/shared';
+import 'vue-router';
+
+const _sfc_main = {
+  __name: "error-500",
+  __ssrInlineRender: true,
+  props: {
+    appName: {
+      type: String,
+      default: "Nuxt"
+    },
+    version: {
+      type: String,
+      default: ""
+    },
+    statusCode: {
+      type: Number,
+      default: 500
+    },
+    statusMessage: {
+      type: String,
+      default: "Server error"
+    },
+    description: {
+      type: String,
+      default: "This page is temporarily unavailable."
+    }
+  },
+  setup(__props) {
+    const props = __props;
+    useHead({
+      title: `${props.statusCode} - ${props.statusMessage} | ${props.appName}`,
+      script: [],
+      style: [
+        {
+          children: `*,:before,:after{-webkit-box-sizing:border-box;box-sizing:border-box;border-width:0;border-style:solid;border-color:#e0e0e0}*{--tw-ring-inset:var(--tw-empty, );--tw-ring-offset-width:0px;--tw-ring-offset-color:#fff;--tw-ring-color:rgba(14, 165, 233, .5);--tw-ring-offset-shadow:0 0 #0000;--tw-ring-shadow:0 0 #0000;--tw-shadow:0 0 #0000}:root{-moz-tab-size:4;-o-tab-size:4;tab-size:4}body{margin:0;font-family:inherit;line-height:inherit}html{-webkit-text-size-adjust:100%;font-family:ui-sans-serif,system-ui,-apple-system,BlinkMacSystemFont,Segoe UI,Roboto,Helvetica Neue,Arial,Noto Sans,sans-serif,"Apple Color Emoji","Segoe UI Emoji",Segoe UI Symbol,"Noto Color Emoji";line-height:1.5}h1,p{margin:0}h1{font-size:inherit;font-weight:inherit}`
+        }
+      ]
+    });
+    return (_ctx, _push, _parent, _attrs) => {
+      _push(`<div${ssrRenderAttrs(mergeProps({ class: "font-sans antialiased bg-white dark:bg-black text-black dark:text-white grid min-h-screen place-content-center overflow-hidden" }, _attrs))} data-v-df79c84d><div class="fixed -bottom-1/2 left-0 right-0 h-1/2 spotlight" data-v-df79c84d></div><div class="max-w-520px text-center" data-v-df79c84d><h1 class="text-8xl sm:text-10xl font-medium mb-8" data-v-df79c84d>${ssrInterpolate(__props.statusCode)}</h1><p class="text-xl px-8 sm:px-0 sm:text-4xl font-light mb-16 leading-tight" data-v-df79c84d>${ssrInterpolate(__props.description)}</p></div></div>`);
+    };
+  }
+};
+const _sfc_setup = _sfc_main.setup;
+_sfc_main.setup = (props, ctx) => {
+  const ssrContext = useSSRContext();
+  (ssrContext.modules || (ssrContext.modules = /* @__PURE__ */ new Set())).add("node_modules/@nuxt/ui-templates/dist/templates/error-500.vue");
+  return _sfc_setup ? _sfc_setup(props, ctx) : void 0;
+};
+const error500 = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-df79c84d"]]);
+
+export { error500 as default };
+//# sourceMappingURL=error-500-1b10eb7c.mjs.map

.output/server/chunks/app/_nuxt/error-500-1b10eb7c.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-500-1b10eb7c.mjs","sources":["../../../../../.nuxt/dist/server/_nuxt/error-500-1b10eb7c.js"],"sourcesContent":null,"names":[],"mappings":";;;;;;;;;;;;;;;AAoBA,MAAM,SAAY,GAAA;AAAA,EAChB,MAAQ,EAAA,WAAA;AAAA,EACR,iBAAmB,EAAA,IAAA;AAAA,EACnB,KAAO,EAAA;AAAA,IACL,OAAS,EAAA;AAAA,MACP,IAAM,EAAA,MAAA;AAAA,MACN,OAAS,EAAA,MAAA;AAAA,KACX;AAAA,IACA,OAAS,EAAA;AAAA,MACP,IAAM,EAAA,MAAA;AAAA,MACN,OAAS,EAAA,EAAA;AAAA,KACX;AAAA,IACA,UAAY,EAAA;AAAA,MACV,IAAM,EAAA,MAAA;AAAA,MACN,OAAS,EAAA,GAAA;AAAA,KACX;AAAA,IACA,aAAe,EAAA;AAAA,MACb,IAAM,EAAA,MAAA;AAAA,MACN,OAAS,EAAA,cAAA;AAAA,KACX;AAAA,IACA,WAAa,EAAA;AAAA,MACX,IAAM,EAAA,MAAA;AAAA,MACN,OAAS,EAAA,uCAAA;AAAA,KACX;AAAA,GACF;AAAA,EACA,MAAM,OAAS,EAAA;AACb,IAAA,MAAM,KAAQ,GAAA,OAAA,CAAA;AACd,IAAQ,OAAA,CAAA;AAAA,MACN,KAAA,EAAO,GAAG,KAAM,CAAA,UAAU,MAAM,KAAM,CAAA,aAAa,CAAM,GAAA,EAAA,KAAA,CAAM,OAAO,CAAA,CAAA;AAAA,MACtE,QAAQ,EAAC;AAAA,MACT,KAAO,EAAA;AAAA,QACL;AAAA,UACE,QAAU,EAAA,CAAA,uuBAAA,CAAA;AAAA,SACZ;AAAA,OACF;AAAA,KACD,CAAA,CAAA;AACD,IAAA,OAAO,CAAC,IAAA,EAAM,KAAO,EAAA,OAAA,EAAS,MAAW,KAAA;AACvC,MAAM,KAAA,CAAA,CAAA,IAAA,EAAO,eAAe,UAAW,CAAA,EAAE,OAAO,gIAAiI,EAAA,EAAG,MAAM,CAAC,CAAC,gOAAgO,cAAe,CAAA,OAAA,CAAQ,UAAU,CAAC,CAAA,gGAAA,EAAmG,eAAe,OAAQ,CAAA,WAAW,CAAC,CAAkB,gBAAA,CAAA,CAAA,CAAA;AAAA,KACxlB,CAAA;AAAA,GACF;AACF,CAAA,CAAA;AACA,MAAM,aAAa,SAAU,CAAA,KAAA,CAAA;AAC7B,SAAU,CAAA,KAAA,GAAQ,CAAC,KAAA,EAAO,GAAQ,KAAA;AAChC,EAAA,MAAM,aAAa,aAAc,EAAA,CAAA;AACjC,EAAC,CAAA,UAAA,CAAW,YAAY,UAAW,CAAA,OAAA,uBAA8B,GAAI,EAAA,CAAA,EAAI,IAAI,8DAA8D,CAAA,CAAA;AAC3I,EAAA,OAAO,UAAa,GAAA,UAAA,CAAW,KAAO,EAAA,GAAG,CAAI,GAAA,KAAA,CAAA,CAAA;AAC/C,CAAA,CAAA;AACM,MAAA,QAAA,+BAAuC,SAAW,EAAA,CAAC,CAAC,WAAa,EAAA,iBAAiB,CAAC,CAAC;;;;"}

.output/server/chunks/app/_nuxt/error-500-styles.cf4b3e80.mjs

@@ -0,0 +1,6 @@
+const error500_vue_vue_type_style_index_0_scoped_df79c84d_lang = ".spotlight[data-v-df79c84d]{background:linear-gradient(45deg,#00dc82,#36e4da 50%,#0047e1);filter:blur(20vh)}.bg-white[data-v-df79c84d]{--tw-bg-opacity:1;background-color:rgba(255,255,255,var(--tw-bg-opacity))}.grid[data-v-df79c84d]{display:grid}.place-content-center[data-v-df79c84d]{place-content:center}.font-sans[data-v-df79c84d]{font-family:ui-sans-serif,system-ui,-apple-system,BlinkMacSystemFont,Segoe UI,Roboto,Helvetica Neue,Arial,Noto Sans,sans-serif,Apple Color Emoji,Segoe UI Emoji,Segoe UI Symbol,Noto Color Emoji}.font-medium[data-v-df79c84d]{font-weight:500}.font-light[data-v-df79c84d]{font-weight:300}.h-1\\/2[data-v-df79c84d]{height:50%}.text-8xl[data-v-df79c84d]{font-size:6rem;line-height:1}.text-xl[data-v-df79c84d]{font-size:1.25rem;line-height:1.75rem}.leading-tight[data-v-df79c84d]{line-height:1.25}.mb-8[data-v-df79c84d]{margin-bottom:2rem}.mb-16[data-v-df79c84d]{margin-bottom:4rem}.max-w-520px[data-v-df79c84d]{max-width:520px}.min-h-screen[data-v-df79c84d]{min-height:100vh}.overflow-hidden[data-v-df79c84d]{overflow:hidden}.px-8[data-v-df79c84d]{padding-left:2rem;padding-right:2rem}.fixed[data-v-df79c84d]{position:fixed}.left-0[data-v-df79c84d]{left:0}.right-0[data-v-df79c84d]{right:0}.-bottom-1\\/2[data-v-df79c84d]{bottom:-50%}.text-center[data-v-df79c84d]{text-align:center}.text-black[data-v-df79c84d]{--tw-text-opacity:1;color:rgba(0,0,0,var(--tw-text-opacity))}.antialiased[data-v-df79c84d]{-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale}@media (min-width:640px){.sm\\:text-4xl[data-v-df79c84d]{font-size:2.25rem;line-height:2.5rem}.sm\\:text-10xl[data-v-df79c84d]{font-size:10rem;line-height:1}.sm\\:px-0[data-v-df79c84d]{padding-left:0;padding-right:0}}@media (prefers-color-scheme:dark){.dark\\:bg-black[data-v-df79c84d]{--tw-bg-opacity:1;background-color:rgba(0,0,0,var(--tw-bg-opacity))}.dark\\:text-white[data-v-df79c84d]{--tw-text-opacity:1;color:rgba(255,255,255,var(--tw-text-opacity))}}";
+
+const error500Styles_cf4b3e80 = [error500_vue_vue_type_style_index_0_scoped_df79c84d_lang, error500_vue_vue_type_style_index_0_scoped_df79c84d_lang];
+
+export { error500Styles_cf4b3e80 as default };
+//# sourceMappingURL=error-500-styles.cf4b3e80.mjs.map

.output/server/chunks/app/_nuxt/error-500-styles.cf4b3e80.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-500-styles.cf4b3e80.mjs","sources":["../../../../../.nuxt/dist/server/_nuxt/error-500-styles-1.mjs-8fa81fcc.js","../../../../../.nuxt/dist/server/_nuxt/error-500-styles.cf4b3e80.mjs"],"sourcesContent":null,"names":["style_0","style_1"],"mappings":"AAAA,MAAM,wDAA2D,GAAA,s6DAAA;;ACEjE,gCAAe,CAACA,wDAAO,EAAEC,wDAAO;;;;"}

.output/server/chunks/app/_nuxt/index-09a76c59.mjs

@@ -0,0 +1,33 @@
+import { u as useRouter } from '../server.mjs';
+import { useSSRContext } from 'vue';
+import '../../nitro/node-server.mjs';
+import 'node:http';
+import 'node:https';
+import 'fs';
+import 'path';
+import 'node:fs';
+import 'node:url';
+import 'unhead';
+import '@unhead/shared';
+import 'vue-router';
+import 'vue/server-renderer';
+
+const _sfc_main = {
+  __name: "index",
+  __ssrInlineRender: true,
+  setup(__props) {
+    const router = useRouter();
+    router.replace("/index.html");
+    return (_ctx, _push, _parent, _attrs) => {
+    };
+  }
+};
+const _sfc_setup = _sfc_main.setup;
+_sfc_main.setup = (props, ctx) => {
+  const ssrContext = useSSRContext();
+  (ssrContext.modules || (ssrContext.modules = /* @__PURE__ */ new Set())).add("pages/index.vue");
+  return _sfc_setup ? _sfc_setup(props, ctx) : void 0;
+};
+
+export { _sfc_main as default };
+//# sourceMappingURL=index-09a76c59.mjs.map

.output/server/chunks/app/_nuxt/index-09a76c59.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-09a76c59.mjs","sources":["../../../../../.nuxt/dist/server/_nuxt/index-09a76c59.js"],"sourcesContent":null,"names":[],"mappings":";;;;;;;;;;;;;;AAkBA,MAAM,SAAY,GAAA;AAAA,EAChB,MAAQ,EAAA,OAAA;AAAA,EACR,iBAAmB,EAAA,IAAA;AAAA,EACnB,MAAM,OAAS,EAAA;AACb,IAAA,MAAM,SAAS,SAAU,EAAA,CAAA;AACzB,IAAA,MAAA,CAAO,QAAQ,aAAa,CAAA,CAAA;AAC5B,IAAA,OAAO,CAAC,IAAA,EAAM,KAAO,EAAA,OAAA,EAAS,MAAW,KAAA;AAAA,KACzC,CAAA;AAAA,GACF;AACF,EAAA;AACA,MAAM,aAAa,SAAU,CAAA,KAAA,CAAA;AAC7B,SAAU,CAAA,KAAA,GAAQ,CAAC,KAAA,EAAO,GAAQ,KAAA;AAChC,EAAA,MAAM,aAAa,aAAc,EAAA,CAAA;AACjC,EAAC,CAAA,UAAA,CAAW,YAAY,UAAW,CAAA,OAAA,uBAA8B,GAAI,EAAA,CAAA,EAAI,IAAI,iBAAiB,CAAA,CAAA;AAC9F,EAAA,OAAO,UAAa,GAAA,UAAA,CAAW,KAAO,EAAA,GAAG,CAAI,GAAA,KAAA,CAAA,CAAA;AAC/C,CAAA;;;;"}

.output/server/chunks/app/_nuxt/index-9bba9a7f.mjs

@@ -0,0 +1,274 @@
+import { b as buildAssetsURL } from '../../handlers/renderer.mjs';
+import { k as getListHttp, o as operateLikeHttp, H as Head, T as Title, M as Meta } from './cross-icon-42ef7441.mjs';
+import { h as handleDate, E as ElMessage, _ as __nuxt_component_3, a as __nuxt_component_4 } from './top-head-41252b2f.mjs';
+import { useSSRContext, mergeProps, unref, inject, ref, watchEffect, nextTick, onUnmounted, withAsyncContext, withCtx, createTextVNode, createVNode } from 'vue';
+import { ssrRenderAttrs, ssrRenderAttr, ssrInterpolate, ssrRenderComponent, ssrRenderList, ssrRenderStyle } from 'vue/server-renderer';
+import { _ as _export_sfc, u as useHead } from './_plugin-vue_export-helper-e3874580.mjs';
+import { e as useRoute, u as useRouter } from '../server.mjs';
+import 'vue-bundle-renderer/runtime';
+import '../../nitro/node-server.mjs';
+import 'node:http';
+import 'node:https';
+import 'fs';
+import 'path';
+import 'node:fs';
+import 'node:url';
+import 'devalue';
+import '@unhead/ssr';
+import 'unhead';
+import '@unhead/shared';
+import 'lodash-unified';
+import '@vue/shared';
+import '@vueuse/core';
+import 'axios';
+import 'qs';
+import '@vue/reactivity';
+import 'vue-router';
+
+const _imports_0$1 = "" + buildAssetsURL("time-icon.fef65a83.svg");
+const _imports_1$1 = "" + buildAssetsURL("time-white-icon.805d0e12.svg");
+const _imports_2 = "" + buildAssetsURL("eye-icon.efcf8c6f.svg");
+const _imports_3 = "" + buildAssetsURL("like-no.23054eaf.svg");
+const _imports_4 = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAEAAAABACAYAAACqaXHeAAAAAXNSR0IArs4c6QAAAERlWElmTU0AKgAAAAgAAYdpAAQAAAABAAAAGgAAAAAAA6ABAAMAAAABAAEAAKACAAQAAAABAAAAQKADAAQAAAABAAAAQAAAAABGUUKwAAAD30lEQVR4AeVa7XXaMBSVDANkBDxB6QRxJmg6QVmANp2gZAOaDBCYoGwQugGZAGUD+F9Q7zPIxxAZy7ZkG0vn5Ejoy/fe954+7HDWgrRbf/8FGPeMySFyIRmf9MOneR3QeB0PufQMkJ+AOAlwlvgqYMEdD6ebswarPwOrs5WaTP7QD5PDPdu/6tvs1bZAAHaTTUcODx6S3aNqS6MhINcP0Z7tcq0csF6IUBBVyerGt8EDdLhO6iASFkg3qVEBEOORGS3+zaxf8V6NCmAOVw4RLhfWCvOZzns2KoBkMjoHdOH38EJb6abGBCCLYgW+NUW+Y7uBad8i/RoTACCjIkA544Mi/U37NiYALDoyBemyXyMCwP0HcP8vLomZzt2IANj+JqYAXferXQCyPi4/zvb1ooLVLgBi/6UoSOqPLVOUGZc3plYBYP17xH6UB0rX3mM9oauvWlebAOT6ONOXsv6R5KYqWd342gQ4un7p4yxugysdgap1/aoTmIzfrcdk+cikb0aft4z6ytXOPeDfejwCSvqrkLgT6xMgpwIQeSx6VeJeiSZUwXbuTACL5GGlYGmbuJoPBrKfbJIndL3w2QlOmtu6B9gmLxn7S0BdpRNl5Xp8a/ogHj5/AIa9/gZ7/RpzlN7uNM+fwUozTX3pqjT2WAA6oR0PKQWA81UvfPqcRnGc50+6rqVlgTfNX+lsEQA0PkDsCHQB8kQrfk8XUUkl3PKGqtzynE6lr+A+CHBCm7QcrCt4CNf9JEAMGMe9KyQNzvuJdoGCrt8gXOuPlpwEeLc+79VMiC/Q2GfF1eC1DlTiE7zHCVvhCosgF75qgHPAkjzASwEQ+vFJ1tsQgOcvyfOxCLp520qTtznhir0ifIGrt61tJn/EtqTcyxCg+McCuFECCCr4lFT8E+cASgifyMekWbBQnH0MgS2MHi+ABzEOUnh0H+CJ9RMBfLoPYPv7KICKBw/yLTgu0zzjNcCf+wBfqO1PiaAWQaEqupyfuz9xVQJ0mbfiRqv/SfwnAvhxH+AzpUQ6jz3Ah/sA3H+aJq7KvoTAW9aJVwkglCJdzHHO0VqfuMYCZKnTETG2/fB5lsVFeUBWewfqeab1iVxagE7eB7D4zS5ZMRGgm/cBPs8L70SASypda1vW1pfmkwjQtfvA8bXXKk1WV04EQKPQdbjWOhzuHkywJwJ06zjMHxH7udYngRIBoNgSv+m+fOWJz/GvOxNTEokAtFoibozcJjX5JlWGmoePDem6GstkvJ8gPyryzEQAGkQnJnwxvaMFJGeS+GHnbobfC8b475yxNpvfD1j5I3AP8P+E06KT/wdPOffX7me6UQAAAABJRU5ErkJggg==";
+const _imports_5 = "" + buildAssetsURL("comment-icon.f7b16ad3.svg");
+const _sfc_main$1 = {
+  __name: "Item",
+  __ssrInlineRender: true,
+  props: {
+    item: Object
+  },
+  emits: ["childEvent"],
+  setup(__props, { emit: __emit }) {
+    const formatNumberWithCommas = (number) => {
+      return number.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+    };
+    return (_ctx, _push, _parent, _attrs) => {
+      _push(`<a${ssrRenderAttrs(mergeProps({
+        class: "box flexflex",
+        target: "_blank",
+        href: `./details/${__props.item["uniqid"]}`
+      }, _attrs))} data-v-7a203ec0><img class="img"${ssrRenderAttr("src", __props.item["schoolimage"])} data-v-7a203ec0><div class="content flexflex" data-v-7a203ec0><div class="name" data-v-7a203ec0>${ssrInterpolate(__props.item["school"])}</div><div class="list flexflex" data-v-7a203ec0>`);
+      if (__props.item["profession"]) {
+        _push(`<div class="item flexacenter" data-v-7a203ec0><div class="item-name" data-v-7a203ec0>\u4E13\u4E1A</div><div class="item-value ellipsis" data-v-7a203ec0>${ssrInterpolate(__props.item["profession"])}</div></div>`);
+      } else {
+        _push(`<!---->`);
+      }
+      if (__props.item["project"]) {
+        _push(`<div class="item flexacenter" data-v-7a203ec0><div class="item-name" data-v-7a203ec0>\u9879\u76EE</div><div class="item-value ellipsis" data-v-7a203ec0>${ssrInterpolate(__props.item["project"])}</div></div>`);
+      } else {
+        _push(`<!---->`);
+      }
+      if (__props.item["interviewtime"]) {
+        _push(`<div class="item flexacenter" data-v-7a203ec0><div class="item-name" data-v-7a203ec0>\u65F6\u95F4</div><div class="item-value ellipsis" data-v-7a203ec0>${ssrInterpolate(__props.item["interviewtime"])}</div></div>`);
+      } else {
+        _push(`<!---->`);
+      }
+      _push(`</div><div class="text-box" data-v-7a203ec0><div class="text" data-v-7a203ec0>${ssrInterpolate(__props.item["message"])}</div><div class="time flexacenter" data-v-7a203ec0><img class="time-icon time-black-icon"${ssrRenderAttr("src", _imports_0$1)} data-v-7a203ec0><img class="time-icon time-white-icon"${ssrRenderAttr("src", _imports_1$1)} data-v-7a203ec0> ${ssrInterpolate(("handleDate" in _ctx ? _ctx.handleDate : unref(handleDate))(__props.item["releasetime"]))}\u53D1\u5E03 </div></div><div class="data-list flexacenter" data-v-7a203ec0><div class="data-item flexacenter" data-v-7a203ec0><img class="data-item-icon"${ssrRenderAttr("src", _imports_2)} data-v-7a203ec0> ${ssrInterpolate(formatNumberWithCommas(__props.item["views"] || 0))}</div><div class="data-item flexacenter" data-v-7a203ec0>`);
+      if (__props.item["islike"] == 0) {
+        _push(`<img class="data-item-icon"${ssrRenderAttr("src", _imports_3)} data-v-7a203ec0>`);
+      } else {
+        _push(`<img class="data-item-icon"${ssrRenderAttr("src", _imports_4)} data-v-7a203ec0>`);
+      }
+      _push(` ${ssrInterpolate(__props.item["likenum"] || 0)}</div><div class="data-item flexacenter" data-v-7a203ec0><img class="data-item-icon"${ssrRenderAttr("src", _imports_5)} data-v-7a203ec0> ${ssrInterpolate(__props.item["commentnum"] || 0)}</div></div></div></a>`);
+    };
+  }
+};
+const _sfc_setup$1 = _sfc_main$1.setup;
+_sfc_main$1.setup = (props, ctx) => {
+  const ssrContext = useSSRContext();
+  (ssrContext.modules || (ssrContext.modules = /* @__PURE__ */ new Set())).add("components/Item.vue");
+  return _sfc_setup$1 ? _sfc_setup$1(props, ctx) : void 0;
+};
+const __nuxt_component_5 = /* @__PURE__ */ _export_sfc(_sfc_main$1, [["__scopeId", "data-v-7a203ec0"]]);
+const _imports_0 = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAAAXNSR0IArs4c6QAAAERlWElmTU0AKgAAAAgAAYdpAAQAAAABAAAAGgAAAAAAA6ABAAMAAAABAAEAAKACAAQAAAABAAAAIKADAAQAAAABAAAAIAAAAACshmLzAAAED0lEQVRYCe2Wu09UQRTGdwlYWWMAIzEhWhCJhRgVAbHzAWil1sT/gKcKLAqG159AYimVgIFSeVOglSYmRhPFEEiIlTQ2sP6+y5zr3OUuLFDqJLPnzHce883MmdmbSPzrLXmQDRgaGjqNfyO9Op1OFyFPuvjVZDK5Dja3tbU10dHR8d3h+4qcCDDxdZL3ku3yvhlxgMwS4nFLS8vMfv57Eujr6zuRn5//goQ3vESf0Sch9BW55vBifMrA6pFnPN9Jxk0Q2fCwiJqVwODg4Hk8J+inXMQYyVIk+xDJkDFgtyogkgK+60wrxDVki4sloMkJmifRcZJsoN/LZTvdhIEYGBioI26UQSF9E/1qHIldBLTtBQUFywRp5Z/y8vJuNjc3r6AfuA0PD5dub29PEVhOX4HERUhEjiMvM6vOHEyTbxxlcuUVcXLcUi56KTs6ItxvEQKqdlgGBYfz/cOu3J9AOcj5wGH1HG+tb48QYNI+Zxxra2ub9h2lc64XSFCVidtYNvnY2CTb/hZ9XGPIPDdcMiTgHplLAnFKSfqN86wEV20s4Nvp26Q7bEE+cSTAu+XHIq+oNqSrhQQw3NmBEl/iqpViOoY9KFp8n7LaLuefkC7MjZPo8o00l1NviEjoNQ1aSACGVx322smIaG1tXSSw1QN7WHU3q20D6zGcPF3t7e1LNvYl8boRatU7IroDwbtOgi9mzJTUxZBPAj2Ff7/5aXJW+szGMTLITVyJ2cIdAChy4JoZ42QmCfPJYfIEV3Ld+RdbnE8gLZCz3vU4mbMn/TiD4zCzBdLLHcwl0A+ylYfsItFuoDP3t918dByqCRvHSeKCXUbaXH8JGIgsiwsWpmrHHp45kK5jeCVFwr8divEbdsu9mwDGOTkzQXhF/GASq3LDakfv5Gb0qkv3fHv6+/vtRnlwoN7WL0cxa4bwCPQlI1As2coKczBJAf2WWWNIPnETB2bpwoIBPujyjTTlBD8DyBTp8KqHBPQZhcOSonBISfqNN/0dJCphX8VVsyc7dBEmm3y4Ke9Dg1PIGewecyzyTvwwe6TiYXkNx2kZkdfj/g8s8CCSvPqke+NiatixeYsPd0AAq5hBTEqH6aj/Zgs7TFMOJn/pYsf9yYVFCAhg4ibECr2QLZ06CgnFKody0b9xPA+RkbaLALugT7AGvDbp5SRY1tFEonIY8F7UKVY56L/QG6mjn5mhkRrwjapatk7VWiocUq+4KSkK6KPvl6lzBc+xUhWcfZR+0+TZ4rISUGJIFEJiBLVeY9f0l6rPbf2xBA8KE5Qw1iOje36Wbm1c2x63cnPYk4A58QjVouvqVRm2l4TMAsQfZRZcXExOBCzQVXQjyWuYpAhpf+Gr6Pqnm2U3Jvx7brH/ZbYd+APZxM/2zgvhdQAAAABJRU5ErkJggg==";
+const _imports_1 = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAEAAAABACAYAAACqaXHeAAAAAXNSR0IArs4c6QAAAERlWElmTU0AKgAAAAgAAYdpAAQAAAABAAAAGgAAAAAAA6ABAAMAAAABAAEAAKACAAQAAAABAAAAQKADAAQAAAABAAAAQAAAAABGUUKwAAADXElEQVR4Ae2bS2vVQBTHm/qqIuJCUARBUbrQhVDwic+Kaz+CGzcuXfsNXPtY9AsIbly4EUSEKnWh7hSLVSqC0PpqSwXRwvV3IInJZO4kuTd37mScgT+ZOedk5vz/OclNbu4dGQktKBAU+J8ViHTkO53OGPZr4AxYr4tpke03uT4Et6MoWlPzLggA+e0EPQWH1OCWj2fIfxIRfmV5jGYHcf8GW9/IC7UT4Lp0sk1XAcsEbMsGedR/RwWMZ/nkKoDyF0E2ZwM8629V+eQEQJ0OAc/VII/Gz1QuulNgIhZhgxrc8vEq+R/mIH/I8shVgDgIeMXmFHgpYw+aVPU0OK6SF26FChBj0rgmyMVwRzJu6XYB4j9bmntI208FOLXGwT3wFSyB++Cgn2wVVhA9Ar4DtS1jOKmE+zWE4AT4pjLPjFfpn/WLdcwGYmXkEx38E6EGef9E6IG8PyL0Qb79IjRAvr0iNEi+fSIMgHx7RBggefdFsEDeXREskndPBDKSe/sfSWYl2/f4F0tiZkv8iXuFznCfHUig6u2tJD0P9oI5GRjaLnyvDf6sa3i3zWRRm7w8FrBfmQARMTuBuyL0Sr6qAHGcmyL0Q76OAE6K0C/5ugI4JUIT5HsRwAkRmiLfqwBDFQHy+4DpayzcaZPP+T2ScLeGv/RTwLDvbvZ/m65m7siXrQe6zVXZziS3zOuk3lLysijRPQsQ719HhKkyooVXY5odjmpsqknet53jDcwn1dH0mDU+M+ckmK0w97GymCoCrJRM8hH/BRvkkzxiEeTb4zeJrct2qYs9NVcR4FEaXezIkT9NQvNF12AtrLnACheBqRJMuVdLkHN2DEynZ/q/jlyMjBc83Qrs09c1QJ2T+eSaoLttnsG+RY1Xx8a3w0kwE22ifwWcBxuB/NDgDkeh7PQgLN+Yaw7L/rw1NxplXnmlXbkxp/zy4yqQ1/pr4AmYYp7cD6KwDb+JAMDUKh2UpphUuQY0tZaT8wQBnDwsFpMKFWBRbCeXChXg5GGxmFSoAItiO7lUqAAnD4vFpEIFWBQ7WepL0tFsF+s+CWrmqGUaRgXcNWRo8hl2a5GL5+B14IHmefgFtsI/OgZNzeqzd0IGorLuZXAJyN/yHoOblP8ftqEFBYICQQFrCvwFEG2wKFYx49sAAAAASUVORK5CYII=";
+const _sfc_main = {
+  __name: "index",
+  __ssrInlineRender: true,
+  async setup(__props) {
+    let __temp, __restore;
+    let isNeedLogin = inject("isNeedLogin");
+    const goLogin = inject("goLogin");
+    useHead({ script: [{ src: "https://app.gter.net/bottom?tpl=header&menukey=mj" }, { src: "https://app.gter.net/bottom?tpl=footer", body: true }] });
+    ref(null);
+    const route = useRoute();
+    let keyword = ref("");
+    keyword.value = route.query["keyword"];
+    watchEffect(() => {
+      if (keyword.value != route.query["keyword"]) {
+        list.value = [];
+        page.value = 1;
+        keyword.value = route.query["keyword"];
+        getList(route.query["keyword"]);
+      }
+    });
+    const handleScroll = () => {
+      const scrollTop = document.documentElement.scrollTop || document.body.scrollTop;
+      if (scrollTop > 200)
+        returnTopState.value = true;
+      else
+        returnTopState.value = false;
+      const scrollHeight = document.documentElement.scrollHeight;
+      const clientHeight = document.documentElement.clientHeight;
+      if (scrollTop + clientHeight >= scrollHeight - 40)
+        getList();
+    };
+    let page = ref(1);
+    let count = ref(0);
+    let list = ref([]);
+    let loading = false;
+    const getList = () => {
+      if (page.value == 0 || loading)
+        return;
+      loading = true;
+      getListHttp({ page: page.value, keyword: keyword.value }).then((res) => {
+        if (res.code != 200) {
+          page.value = 0;
+          ElMessage({
+            message: res.message,
+            type: "error"
+          });
+          return;
+        }
+        let data = res.data;
+        list.value = list.value.concat(data.data || []);
+        if (data.count > list.value.length)
+          page.value++;
+        else
+          page.value = 0;
+        count.value = data["count"];
+        nextTick(() => {
+        });
+      }).finally(() => loading = false);
+    };
+    const handleLike = (token) => {
+      if (isNeedLogin.value) {
+        goLogin();
+        return;
+      }
+      operateLikeHttp({ token }).then((res) => {
+        if (res.code != 200)
+          return;
+        let data = res.data;
+        list.value.forEach((element) => {
+          if (element["token"] == token) {
+            element["islike"] = data["status"];
+            element["likenum"] = data["count"];
+          }
+        });
+        ElMessage.success(res.message);
+      });
+    };
+    onUnmounted(() => {
+      window.removeEventListener("scroll", handleScroll);
+    });
+    useRouter();
+    try {
+      if (true) {
+        [__temp, __restore] = withAsyncContext(() => getListHttp({ page: 1, keyword: keyword.value }).then((res) => {
+          if (res.code != 200) {
+            page.value = 0;
+            ElMessage({
+              message: res.message,
+              type: "error"
+            });
+            return;
+          }
+          let data = res.data;
+          list.value = list.value.concat(data.data || []);
+        })), await __temp, __restore();
+      }
+    } catch (error) {
+    }
+    let returnTopState = ref(false);
+    return (_ctx, _push, _parent, _attrs) => {
+      const _component_Head = Head;
+      const _component_Title = Title;
+      const _component_Meta = Meta;
+      const _component_TopHead = __nuxt_component_3;
+      const _component_empty = __nuxt_component_4;
+      const _component_Item = __nuxt_component_5;
+      _push(`<!--[-->`);
+      _push(ssrRenderComponent(_component_Head, null, {
+        default: withCtx((_, _push2, _parent2, _scopeId) => {
+          if (_push2) {
+            _push2(ssrRenderComponent(_component_Title, null, {
+              default: withCtx((_2, _push3, _parent3, _scopeId2) => {
+                if (_push3) {
+                  _push3(`\u5BC4\u6258\u5929\u4E0B - \u9762\u7ECF\u5206\u4EAB`);
+                } else {
+                  return [
+                    createTextVNode("\u5BC4\u6258\u5929\u4E0B - \u9762\u7ECF\u5206\u4EAB")
+                  ];
+                }
+              }),
+              _: 1
+            }, _parent2, _scopeId));
+            _push2(ssrRenderComponent(_component_Meta, {
+              name: "keyword",
+              content: "\u7559\u5B66\u8D44\u8BAF\uFF0C\u7559\u5B66\u4EA4\u6D41\u8BBA\u575B\uFF0C\u7559\u5B66\u9762\u7ECF\uFF0C\u9762\u8BD5\u7ECF\u9A8C\uFF0C\u5BC4\u6258\u5929\u4E0B"
+            }, null, _parent2, _scopeId));
+          } else {
+            return [
+              createVNode(_component_Title, null, {
+                default: withCtx(() => [
+                  createTextVNode("\u5BC4\u6258\u5929\u4E0B - \u9762\u7ECF\u5206\u4EAB")
+                ]),
+                _: 1
+              }),
+              createVNode(_component_Meta, {
+                name: "keyword",
+                content: "\u7559\u5B66\u8D44\u8BAF\uFF0C\u7559\u5B66\u4EA4\u6D41\u8BBA\u575B\uFF0C\u7559\u5B66\u9762\u7ECF\uFF0C\u9762\u8BD5\u7ECF\u9A8C\uFF0C\u5BC4\u6258\u5929\u4E0B"
+              })
+            ];
+          }
+        }),
+        _: 1
+      }, _parent));
+      _push(ssrRenderComponent(_component_TopHead, null, null, _parent));
+      if (unref(keyword)) {
+        _push(`<div class="search-result flexacenter" data-v-e519568e><div class="keyword flexacenter" data-v-e519568e>${ssrInterpolate(unref(keyword))} <img class="keyword-icon"${ssrRenderAttr("src", _imports_0)} data-v-e519568e></div><div class="halving-line" data-v-e519568e></div><div class="total" data-v-e519568e>\u5171 ${ssrInterpolate(unref(count))} \u6761\u641C\u7D22\u6570\u636E</div></div>`);
+      } else {
+        _push(`<!---->`);
+      }
+      _push(`<div class="content" data-v-e519568e>`);
+      if (unref(list).length == 0 && unref(page) == 0) {
+        _push(`<div class="empty-box flexcenter" data-v-e519568e>`);
+        _push(ssrRenderComponent(_component_empty, { hint: "\u6CA1\u6709\u627E\u5230\u76F8\u5173\u7ED3\u679C\uFF0C\u8BF7\u66F4\u6362\u641C\u7D22\u5173\u952E\u8BCD" }, null, _parent));
+        _push(`</div>`);
+      } else {
+        _push(`<!--[-->`);
+        ssrRenderList(unref(list), (item, index2) => {
+          _push(ssrRenderComponent(_component_Item, {
+            key: index2,
+            item,
+            onHandleLike: handleLike
+          }, null, _parent));
+        });
+        _push(`<!--]-->`);
+      }
+      _push(`</div>`);
+      if (unref(page) == 0 && unref(list).length > 0) {
+        _push(`<div class="in-end" data-v-e519568e>- \u5230\u5E95\u4E86 -</div>`);
+      } else {
+        _push(`<!---->`);
+      }
+      if (unref(returnTopState)) {
+        _push(`<div class="right-returnTop" data-v-e519568e><img${ssrRenderAttr("src", _imports_1)} style="${ssrRenderStyle({ "width": "24px", "height": "24px" })}" data-v-e519568e></div>`);
+      } else {
+        _push(`<!---->`);
+      }
+      _push(`<!--]-->`);
+    };
+  }
+};
+const _sfc_setup = _sfc_main.setup;
+_sfc_main.setup = (props, ctx) => {
+  const ssrContext = useSSRContext();
+  (ssrContext.modules || (ssrContext.modules = /* @__PURE__ */ new Set())).add("pages/index.html/index.vue");
+  return _sfc_setup ? _sfc_setup(props, ctx) : void 0;
+};
+const index = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-e519568e"]]);
+
+export { index as default };
+//# sourceMappingURL=index-9bba9a7f.mjs.map

.output/server/chunks/app/_nuxt/index-styles.5022783c.mjs

@@ -0,0 +1,8 @@
+const Item_vue_vue_type_style_index_0_scoped_7a203ec0_lang = ".box[data-v-7a203ec0]{background-color:#fff;border-radius:8px;cursor:pointer;margin-bottom:20px;padding:20px 19px 25px 20px;width:385px}.box:hover .content .text-box[data-v-7a203ec0]{background:#72db86}.box:hover .content .text-box .text[data-v-7a203ec0],.box:hover .content .text-box .time[data-v-7a203ec0]{color:#fff}.box:hover .content .text-box .time .time-icon.time-black-icon[data-v-7a203ec0]{display:none}.box:hover .content .text-box .time .time-icon.time-white-icon[data-v-7a203ec0]{display:block}.box .img[data-v-7a203ec0]{height:26px;margin-right:10px;width:26px}.box .content[data-v-7a203ec0]{flex-direction:column}.box .content .name[data-v-7a203ec0]{color:#000;font-size:16px;font-weight:650;margin-bottom:16px;margin-top:2px}.box .content .list[data-v-7a203ec0]{flex-direction:column;margin-bottom:14px}.box .content .list .item[data-v-7a203ec0]:not(:last-of-type){margin-bottom:8px}.box .content .list .item .item-name[data-v-7a203ec0]{color:#7f7f7f;font-size:13px;line-height:20px;margin-right:12.5px}.box .content .list .item .item-value[data-v-7a203ec0]{color:#333;font-size:14px;width:255px}.box .content .text-box[data-v-7a203ec0]{background:#f2f2f2;border:1px solid #f6f6f6;border-radius:10px;margin-bottom:11px;padding:12px;transition:all .3s}.box .content .text-box .text[data-v-7a203ec0]{-webkit-line-clamp:2;-webkit-box-orient:vertical;color:#333;display:-webkit-box;font-size:13px;line-height:24px;margin-bottom:12px;overflow:hidden}.box .content .text-box .time[data-v-7a203ec0]{color:#aaa;font-size:13px}.box .content .text-box .time .time-icon[data-v-7a203ec0]{height:20px;margin-right:6px;width:20px}.box .content .text-box .time .time-icon.time-black-icon[data-v-7a203ec0]{display:block}.box .content .text-box .time .time-icon.time-white-icon[data-v-7a203ec0]{display:none}.box .content .data-list[data-v-7a203ec0]{color:#aaa;font-size:12px;justify-content:flex-end}.box .content .data-list .data-item[data-v-7a203ec0]{margin-left:26px}.box .content .data-list .data-item .data-item-icon[data-v-7a203ec0]{margin-right:5px;width:13px}";
+
+const index_vue_vue_type_style_index_0_scoped_e519568e_lang = ".search-result[data-v-e519568e]{margin:0 auto 30px;width:1200px}.search-result .keyword[data-v-e519568e]{color:#fa6b11;cursor:pointer;font-size:14px}.search-result .keyword .keyword-icon[data-v-e519568e]{height:14px;margin-left:9px;width:14px}.search-result .halving-line[data-v-e519568e]{background:#d7d7d7;height:13px;margin:0 20px;width:1px}.search-result .total[data-v-e519568e]{color:#7f7f7f;font-size:13px}.content[data-v-e519568e]{align-items:flex-start;display:flex;flex-wrap:wrap;margin:0 auto 93px;min-height:calc(100vh - 250px);width:1200px}.content .empty-box[data-v-e519568e]{background-color:#fff;border-radius:16px;height:540px;width:1200px}.in-end[data-v-e519568e]{color:#7f7f7f;font-size:12px;margin-bottom:88px;text-align:center}.right-returnTop[data-v-e519568e]{align-items:center;background-color:#323232;border-radius:50%;bottom:85px;cursor:pointer;display:flex;height:50px;justify-content:center;position:fixed;right:calc(50vw - 675px);width:50px;z-index:10}@media screen and (max-width:1360px){.right-returnTop[data-v-e519568e]{right:0!important}}";
+
+const indexStyles_5022783c = [Item_vue_vue_type_style_index_0_scoped_7a203ec0_lang, index_vue_vue_type_style_index_0_scoped_e519568e_lang, index_vue_vue_type_style_index_0_scoped_e519568e_lang];
+
+export { indexStyles_5022783c as default };
+//# sourceMappingURL=index-styles.5022783c.mjs.map

.output/server/chunks/app/_nuxt/index-styles.5022783c.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-styles.5022783c.mjs","sources":["../../../../../.nuxt/dist/server/_nuxt/index-styles-1.mjs-0aa7e70a.js","../../../../../.nuxt/dist/server/_nuxt/index-styles-2.mjs-d2519aac.js","../../../../../.nuxt/dist/server/_nuxt/index-styles.5022783c.mjs"],"sourcesContent":null,"names":["style_0","style_1","style_2"],"mappings":"AAAA,MAAM,oDAAuD,GAAA,ohEAAA;;ACA7D,MAAM,qDAAwD,GAAA,gjCAAA;;ACG9D,6BAAe,CAACA,oDAAO,EAAEC,qDAAO,EAAEC,qDAAO;;;;"}

.output/server/chunks/app/_nuxt/index-styles.bb7f92cc.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-styles.bb7f92cc.mjs","sources":["../../../../../.nuxt/dist/server/_nuxt/index-styles-1.mjs-435ecdca.js","../../../../../.nuxt/dist/server/_nuxt/index-styles-2.mjs-adcb8369.js","../../../../../.nuxt/dist/server/_nuxt/index-styles-3.mjs-9968d331.js","../../../../../.nuxt/dist/server/_nuxt/index-styles-4.mjs-84b05e65.js","../../../../../.nuxt/dist/server/_nuxt/index-styles-5.mjs-ecc1203b.js","../../../../../.nuxt/dist/server/_nuxt/index-styles-6.mjs-e1bdfa32.js","../../../../../.nuxt/dist/server/_nuxt/index-styles.bb7f92cc.mjs"],"sourcesContent":null,"names":["style_0","style_1","style_2","style_3","style_4","style_5","style_6"],"mappings":"AAAA,MAAM,cAAiB,GAAA,8jEAAA;;ACAvB,MAAM,WAAc,GAAA,kzCAAA;;ACApB,MAAM,YAAe,GAAA,k7uBAAA;;ACArB,MAAM,QAAW,GAAA,+zeAAA;;ACAjB,MAAM,gBAAmB,GAAA,EAAA;;ACAzB,MAAM,qDAAwD,GAAA,suJAAA;;ACO9D,6BAAe,CAACA,cAAO,EAAEC,WAAO,EAAEC,YAAO,EAAEC,QAAO,EAAEC,gBAAO,EAAEC,qDAAO,EAAEC,qDAAO;;;;"}

.output/server/chunks/app/_nuxt/island-renderer-1d37df94.mjs

@@ -0,0 +1,43 @@
+import { defineComponent, onErrorCaptured, createVNode } from 'vue';
+import { c as createError } from '../server.mjs';
+import '../../nitro/node-server.mjs';
+import 'node:http';
+import 'node:https';
+import 'fs';
+import 'path';
+import 'node:fs';
+import 'node:url';
+import 'unhead';
+import '@unhead/shared';
+import 'vue-router';
+import 'vue/server-renderer';
+
+const components_islands = {};
+const islandComponents = /* @__PURE__ */ Object.freeze({
+  __proto__: null,
+  default: components_islands
+});
+const islandRenderer = defineComponent({
+  props: {
+    context: {
+      type: Object,
+      required: true
+    }
+  },
+  setup(props) {
+    const component = islandComponents[props.context.name];
+    if (!component) {
+      throw createError({
+        statusCode: 404,
+        statusMessage: `Island component not found: ${props.context.name}`
+      });
+    }
+    onErrorCaptured((e) => {
+      console.log(e);
+    });
+    return () => createVNode(component || "span", { ...props.context.props, "nuxt-ssr-component-uid": "" });
+  }
+});
+
+export { islandRenderer as default };
+//# sourceMappingURL=island-renderer-1d37df94.mjs.map

.output/server/chunks/app/_nuxt/island-renderer-1d37df94.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"island-renderer-1d37df94.mjs","sources":["../../../../../.nuxt/dist/server/_nuxt/island-renderer-1d37df94.js"],"sourcesContent":null,"names":[],"mappings":";;;;;;;;;;;;;;AAkBA,MAAM,qBAAqB,EAAC,CAAA;AAC5B,MAAM,gBAAA,0BAA0C,MAAO,CAAA;AAAA,EACrD,SAAW,EAAA,IAAA;AAAA,EACX,OAAS,EAAA,kBAAA;AACX,CAAC,CAAA,CAAA;AACD,MAAM,iBAAiB,eAAgB,CAAA;AAAA,EACrC,KAAO,EAAA;AAAA,IACL,OAAS,EAAA;AAAA,MACP,IAAM,EAAA,MAAA;AAAA,MACN,QAAU,EAAA,IAAA;AAAA,KACZ;AAAA,GACF;AAAA,EACA,MAAM,KAAO,EAAA;AACX,IAAA,MAAM,SAAY,GAAA,gBAAA,CAAiB,KAAM,CAAA,OAAA,CAAQ,IAAI,CAAA,CAAA;AACrD,IAAA,IAAI,CAAC,SAAW,EAAA;AACd,MAAA,MAAM,WAAY,CAAA;AAAA,QAChB,UAAY,EAAA,GAAA;AAAA,QACZ,aAAe,EAAA,CAAA,4BAAA,EAA+B,KAAM,CAAA,OAAA,CAAQ,IAAI,CAAA,CAAA;AAAA,OACjE,CAAA,CAAA;AAAA,KACH;AACA,IAAA,eAAA,CAAgB,CAAC,CAAM,KAAA;AACrB,MAAA,OAAA,CAAQ,IAAI,CAAC,CAAA,CAAA;AAAA,KACd,CAAA,CAAA;AACD,IAAO,OAAA,MAAM,WAAY,CAAA,SAAA,IAAa,MAAQ,EAAA,EAAE,GAAG,KAAA,CAAM,OAAQ,CAAA,KAAA,EAAO,wBAA0B,EAAA,EAAA,EAAI,CAAA,CAAA;AAAA,GACxG;AACF,CAAC;;;;"}

.output/server/chunks/app/client.manifest.mjs

@@ -0,0 +1,625 @@
+const client_manifest = {
+  "__plugin-vue_export-helper.d68d818f.js": {
+    "resourceType": "script",
+    "module": true,
+    "prefetch": true,
+    "preload": true,
+    "file": "_plugin-vue_export-helper.d68d818f.js",
+    "imports": [
+      "node_modules/nuxt/dist/app/entry.js"
+    ]
+  },
+  "_cross-icon.8c14d1c3.js": {
+    "resourceType": "script",
+    "module": true,
+    "prefetch": true,
+    "preload": true,
+    "css": [
+      "cross-icon.a9c3a5f3.css"
+    ],
+    "file": "cross-icon.8c14d1c3.js",
+    "imports": [
+      "node_modules/nuxt/dist/app/entry.js",
+      "__plugin-vue_export-helper.d68d818f.js"
+    ]
+  },
+  "cross-icon.a9c3a5f3.css": {
+    "file": "cross-icon.a9c3a5f3.css",
+    "resourceType": "style",
+    "prefetch": true,
+    "preload": true
+  },
+  "_el-input.06dd9d1f.js": {
+    "resourceType": "script",
+    "module": true,
+    "prefetch": true,
+    "preload": true,
+    "css": [
+      "el-input.8aaeca5d.css"
+    ],
+    "file": "el-input.06dd9d1f.js",
+    "imports": [
+      "node_modules/nuxt/dist/app/entry.js",
+      "_cross-icon.8c14d1c3.js"
+    ]
+  },
+  "el-input.8aaeca5d.css": {
+    "file": "el-input.8aaeca5d.css",
+    "resourceType": "style",
+    "prefetch": true,
+    "preload": true
+  },
+  "_masonry.bbccce3d.js": {
+    "resourceType": "script",
+    "module": true,
+    "prefetch": true,
+    "preload": true,
+    "file": "masonry.bbccce3d.js",
+    "imports": [
+      "_cross-icon.8c14d1c3.js"
+    ],
+    "isDynamicEntry": true
+  },
+  "_top-head.fb652afb.js": {
+    "resourceType": "script",
+    "module": true,
+    "prefetch": true,
+    "preload": true,
+    "assets": [
+      "dot-yellow.4b5e135b.svg",
+      "dot-gray.86cdd7b5.svg",
+      "empty-icon.24a01ae2.svg",
+      "delete-icon.a2ab9c64.svg",
+      "arrow-gray.271dd0d3.svg",
+      "tick-green.2df56f28.svg",
+      "logo-icon.b6345ffb.png",
+      "add-icon.11ba1b26.svg"
+    ],
+    "css": [
+      "top-head.bbe58785.css"
+    ],
+    "file": "top-head.fb652afb.js",
+    "imports": [
+      "node_modules/nuxt/dist/app/entry.js",
+      "__plugin-vue_export-helper.d68d818f.js",
+      "_cross-icon.8c14d1c3.js"
+    ]
+  },
+  "top-head.bbe58785.css": {
+    "file": "top-head.bbe58785.css",
+    "resourceType": "style",
+    "prefetch": true,
+    "preload": true
+  },
+  "dot-yellow.4b5e135b.svg": {
+    "file": "dot-yellow.4b5e135b.svg",
+    "resourceType": "image",
+    "prefetch": true,
+    "mimeType": "image/svg+xml"
+  },
+  "dot-gray.86cdd7b5.svg": {
+    "file": "dot-gray.86cdd7b5.svg",
+    "resourceType": "image",
+    "prefetch": true,
+    "mimeType": "image/svg+xml"
+  },
+  "empty-icon.24a01ae2.svg": {
+    "file": "empty-icon.24a01ae2.svg",
+    "resourceType": "image",
+    "prefetch": true,
+    "mimeType": "image/svg+xml"
+  },
+  "delete-icon.a2ab9c64.svg": {
+    "file": "delete-icon.a2ab9c64.svg",
+    "resourceType": "image",
+    "prefetch": true,
+    "mimeType": "image/svg+xml"
+  },
+  "arrow-gray.271dd0d3.svg": {
+    "file": "arrow-gray.271dd0d3.svg",
+    "resourceType": "image",
+    "prefetch": true,
+    "mimeType": "image/svg+xml"
+  },
+  "tick-green.2df56f28.svg": {
+    "file": "tick-green.2df56f28.svg",
+    "resourceType": "image",
+    "prefetch": true,
+    "mimeType": "image/svg+xml"
+  },
+  "logo-icon.b6345ffb.png": {
+    "file": "logo-icon.b6345ffb.png",
+    "resourceType": "image",
+    "prefetch": true,
+    "mimeType": "image/png"
+  },
+  "add-icon.11ba1b26.svg": {
+    "file": "add-icon.11ba1b26.svg",
+    "resourceType": "image",
+    "prefetch": true,
+    "mimeType": "image/svg+xml"
+  },
+  "assets/img/QR-code-icon.svg": {
+    "resourceType": "image",
+    "prefetch": true,
+    "mimeType": "image/svg+xml",
+    "file": "QR-code-icon.a546cc6a.svg",
+    "src": "assets/img/QR-code-icon.svg"
+  },
+  "assets/img/add-icon.svg": {
+    "resourceType": "image",
+    "prefetch": true,
+    "mimeType": "image/svg+xml",
+    "file": "add-icon.11ba1b26.svg",
+    "src": "assets/img/add-icon.svg"
+  },
+  "assets/img/arrow-gray.svg": {
+    "resourceType": "image",
+    "prefetch": true,
+    "mimeType": "image/svg+xml",
+    "file": "arrow-gray.271dd0d3.svg",
+    "src": "assets/img/arrow-gray.svg"
+  },
+  "assets/img/calendar-icon.svg": {
+    "resourceType": "image",
+    "prefetch": true,
+    "mimeType": "image/svg+xml",
+    "file": "calendar-icon.dc8f3cea.svg",
+    "src": "assets/img/calendar-icon.svg"
+  },
+  "assets/img/coin-icon.png": {
+    "resourceType": "image",
+    "prefetch": true,
+    "mimeType": "image/png",
+    "file": "coin-icon.c9939802.png",
+    "src": "assets/img/coin-icon.png"
+  },
+  "assets/img/collect-icon-colours.svg": {
+    "resourceType": "image",
+    "prefetch": true,
+    "mimeType": "image/svg+xml",
+    "file": "collect-icon-colours.6d2ade7f.svg",
+    "src": "assets/img/collect-icon-colours.svg"
+  },
+  "assets/img/comment-icon-gray.svg": {
+    "resourceType": "image",
+    "prefetch": true,
+    "mimeType": "image/svg+xml",
+    "file": "comment-icon-gray.2c8779f9.svg",
+    "src": "assets/img/comment-icon-gray.svg"
+  },
+  "assets/img/comment-icon.svg": {
+    "resourceType": "image",
+    "prefetch": true,
+    "mimeType": "image/svg+xml",
+    "file": "comment-icon.f7b16ad3.svg",
+    "src": "assets/img/comment-icon.svg"
+  },
+  "assets/img/delete-icon.svg": {
+    "resourceType": "image",
+    "prefetch": true,
+    "mimeType": "image/svg+xml",
+    "file": "delete-icon.a2ab9c64.svg",
+    "src": "assets/img/delete-icon.svg"
+  },
+  "assets/img/dot-gray.svg": {
+    "resourceType": "image",
+    "prefetch": true,
+    "mimeType": "image/svg+xml",
+    "file": "dot-gray.86cdd7b5.svg",
+    "src": "assets/img/dot-gray.svg"
+  },
+  "assets/img/dot-yellow.svg": {
+    "resourceType": "image",
+    "prefetch": true,
+    "mimeType": "image/svg+xml",
+    "file": "dot-yellow.4b5e135b.svg",
+    "src": "assets/img/dot-yellow.svg"
+  },
+  "assets/img/empty-icon.svg": {
+    "resourceType": "image",
+    "prefetch": true,
+    "mimeType": "image/svg+xml",
+    "file": "empty-icon.24a01ae2.svg",
+    "src": "assets/img/empty-icon.svg"
+  },
+  "assets/img/eye-icon-black.svg": {
+    "resourceType": "image",
+    "prefetch": true,
+    "mimeType": "image/svg+xml",
+    "file": "eye-icon-black.f1b22d91.svg",
+    "src": "assets/img/eye-icon-black.svg"
+  },
+  "assets/img/eye-icon.svg": {
+    "resourceType": "image",
+    "prefetch": true,
+    "mimeType": "image/svg+xml",
+    "file": "eye-icon.efcf8c6f.svg",
+    "src": "assets/img/eye-icon.svg"
+  },
+  "assets/img/frame-no.svg": {
+    "resourceType": "image",
+    "prefetch": true,
+    "mimeType": "image/svg+xml",
+    "file": "frame-no.28983b22.svg",
+    "src": "assets/img/frame-no.svg"
+  },
+  "assets/img/frame-pitch.svg": {
+    "resourceType": "image",
+    "prefetch": true,
+    "mimeType": "image/svg+xml",
+    "file": "frame-pitch.02620f32.svg",
+    "src": "assets/img/frame-pitch.svg"
+  },
+  "assets/img/like-no.svg": {
+    "resourceType": "image",
+    "prefetch": true,
+    "mimeType": "image/svg+xml",
+    "file": "like-no.23054eaf.svg",
+    "src": "assets/img/like-no.svg"
+  },
+  "assets/img/logo-icon.png": {
+    "resourceType": "image",
+    "prefetch": true,
+    "mimeType": "image/png",
+    "file": "logo-icon.b6345ffb.png",
+    "src": "assets/img/logo-icon.png"
+  },
+  "assets/img/menu-icon-gray.svg": {
+    "resourceType": "image",
+    "prefetch": true,
+    "mimeType": "image/svg+xml",
+    "file": "menu-icon-gray.d61f02b1.svg",
+    "src": "assets/img/menu-icon-gray.svg"
+  },
+  "assets/img/strategy-icon.svg": {
+    "resourceType": "image",
+    "prefetch": true,
+    "mimeType": "image/svg+xml",
+    "file": "strategy-icon.82b87241.svg",
+    "src": "assets/img/strategy-icon.svg"
+  },
+  "assets/img/tick-green.svg": {
+    "resourceType": "image",
+    "prefetch": true,
+    "mimeType": "image/svg+xml",
+    "file": "tick-green.2df56f28.svg",
+    "src": "assets/img/tick-green.svg"
+  },
+  "assets/img/time-icon.svg": {
+    "resourceType": "image",
+    "prefetch": true,
+    "mimeType": "image/svg+xml",
+    "file": "time-icon.fef65a83.svg",
+    "src": "assets/img/time-icon.svg"
+  },
+  "assets/img/time-white-icon.svg": {
+    "resourceType": "image",
+    "prefetch": true,
+    "mimeType": "image/svg+xml",
+    "file": "time-white-icon.805d0e12.svg",
+    "src": "assets/img/time-white-icon.svg"
+  },
+  "cross-icon.css": {
+    "resourceType": "style",
+    "prefetch": true,
+    "preload": true,
+    "file": "cross-icon.a9c3a5f3.css",
+    "src": "cross-icon.css"
+  },
+  "el-input.css": {
+    "resourceType": "style",
+    "prefetch": true,
+    "preload": true,
+    "file": "el-input.8aaeca5d.css",
+    "src": "el-input.css"
+  },
+  "node_modules/@nuxt/ui-templates/dist/templates/error-404.css": {
+    "resourceType": "style",
+    "prefetch": true,
+    "preload": true,
+    "file": "error-404.7fc72018.css",
+    "src": "node_modules/@nuxt/ui-templates/dist/templates/error-404.css"
+  },
+  "node_modules/@nuxt/ui-templates/dist/templates/error-404.vue": {
+    "resourceType": "script",
+    "module": true,
+    "prefetch": true,
+    "preload": true,
+    "css": [],
+    "file": "error-404.9357a760.js",
+    "imports": [
+      "node_modules/nuxt/dist/app/entry.js",
+      "__plugin-vue_export-helper.d68d818f.js"
+    ],
+    "isDynamicEntry": true,
+    "src": "node_modules/@nuxt/ui-templates/dist/templates/error-404.vue"
+  },
+  "error-404.7fc72018.css": {
+    "file": "error-404.7fc72018.css",
+    "resourceType": "style",
+    "prefetch": true,
+    "preload": true
+  },
+  "node_modules/@nuxt/ui-templates/dist/templates/error-500.css": {
+    "resourceType": "style",
+    "prefetch": true,
+    "preload": true,
+    "file": "error-500.c5df6088.css",
+    "src": "node_modules/@nuxt/ui-templates/dist/templates/error-500.css"
+  },
+  "node_modules/@nuxt/ui-templates/dist/templates/error-500.vue": {
+    "resourceType": "script",
+    "module": true,
+    "prefetch": true,
+    "preload": true,
+    "css": [],
+    "file": "error-500.39079704.js",
+    "imports": [
+      "__plugin-vue_export-helper.d68d818f.js",
+      "node_modules/nuxt/dist/app/entry.js"
+    ],
+    "isDynamicEntry": true,
+    "src": "node_modules/@nuxt/ui-templates/dist/templates/error-500.vue"
+  },
+  "error-500.c5df6088.css": {
+    "file": "error-500.c5df6088.css",
+    "resourceType": "style",
+    "prefetch": true,
+    "preload": true
+  },
+  "node_modules/nuxt/dist/app/entry.css": {
+    "resourceType": "style",
+    "prefetch": true,
+    "preload": true,
+    "file": "entry.8609db93.css",
+    "src": "node_modules/nuxt/dist/app/entry.css"
+  },
+  "node_modules/nuxt/dist/app/entry.js": {
+    "resourceType": "script",
+    "module": true,
+    "prefetch": true,
+    "preload": true,
+    "css": [
+      "entry.8609db93.css"
+    ],
+    "dynamicImports": [
+      "node_modules/@nuxt/ui-templates/dist/templates/error-404.vue",
+      "node_modules/@nuxt/ui-templates/dist/templates/error-500.vue"
+    ],
+    "file": "entry.7a5e54e2.js",
+    "isEntry": true,
+    "src": "node_modules/nuxt/dist/app/entry.js",
+    "_globalCSS": true
+  },
+  "entry.8609db93.css": {
+    "file": "entry.8609db93.css",
+    "resourceType": "style",
+    "prefetch": true,
+    "preload": true
+  },
+  "pages/details/[id].css": {
+    "resourceType": "style",
+    "prefetch": true,
+    "preload": true,
+    "file": "_id_.9c618c95.css",
+    "src": "pages/details/[id].css"
+  },
+  "pages/details/[id].vue": {
+    "resourceType": "script",
+    "module": true,
+    "prefetch": true,
+    "preload": true,
+    "assets": [
+      "menu-icon-gray.d61f02b1.svg",
+      "comment-icon-gray.2c8779f9.svg",
+      "eye-icon-black.f1b22d91.svg",
+      "collect-icon-colours.6d2ade7f.svg",
+      "coin-icon.c9939802.png",
+      "QR-code-icon.a546cc6a.svg",
+      "strategy-icon.82b87241.svg"
+    ],
+    "css": [],
+    "file": "_id_.cf16b145.js",
+    "imports": [
+      "_cross-icon.8c14d1c3.js",
+      "_top-head.fb652afb.js",
+      "_el-input.06dd9d1f.js",
+      "node_modules/nuxt/dist/app/entry.js",
+      "__plugin-vue_export-helper.d68d818f.js"
+    ],
+    "isDynamicEntry": true,
+    "src": "pages/details/[id].vue"
+  },
+  "_id_.9c618c95.css": {
+    "file": "_id_.9c618c95.css",
+    "resourceType": "style",
+    "prefetch": true,
+    "preload": true
+  },
+  "menu-icon-gray.d61f02b1.svg": {
+    "file": "menu-icon-gray.d61f02b1.svg",
+    "resourceType": "image",
+    "prefetch": true,
+    "mimeType": "image/svg+xml"
+  },
+  "comment-icon-gray.2c8779f9.svg": {
+    "file": "comment-icon-gray.2c8779f9.svg",
+    "resourceType": "image",
+    "prefetch": true,
+    "mimeType": "image/svg+xml"
+  },
+  "eye-icon-black.f1b22d91.svg": {
+    "file": "eye-icon-black.f1b22d91.svg",
+    "resourceType": "image",
+    "prefetch": true,
+    "mimeType": "image/svg+xml"
+  },
+  "collect-icon-colours.6d2ade7f.svg": {
+    "file": "collect-icon-colours.6d2ade7f.svg",
+    "resourceType": "image",
+    "prefetch": true,
+    "mimeType": "image/svg+xml"
+  },
+  "coin-icon.c9939802.png": {
+    "file": "coin-icon.c9939802.png",
+    "resourceType": "image",
+    "prefetch": true,
+    "mimeType": "image/png"
+  },
+  "QR-code-icon.a546cc6a.svg": {
+    "file": "QR-code-icon.a546cc6a.svg",
+    "resourceType": "image",
+    "prefetch": true,
+    "mimeType": "image/svg+xml"
+  },
+  "strategy-icon.82b87241.svg": {
+    "file": "strategy-icon.82b87241.svg",
+    "resourceType": "image",
+    "prefetch": true,
+    "mimeType": "image/svg+xml"
+  },
+  "pages/index.html/index.css": {
+    "resourceType": "style",
+    "prefetch": true,
+    "preload": true,
+    "file": "index.8f2c4da9.css",
+    "src": "pages/index.html/index.css"
+  },
+  "pages/index.html/index.vue": {
+    "resourceType": "script",
+    "module": true,
+    "prefetch": true,
+    "preload": true,
+    "assets": [
+      "time-icon.fef65a83.svg",
+      "time-white-icon.805d0e12.svg",
+      "eye-icon.efcf8c6f.svg",
+      "like-no.23054eaf.svg",
+      "comment-icon.f7b16ad3.svg"
+    ],
+    "css": [],
+    "dynamicImports": [
+      "_masonry.bbccce3d.js"
+    ],
+    "file": "index.639dd52b.js",
+    "imports": [
+      "node_modules/nuxt/dist/app/entry.js",
+      "_cross-icon.8c14d1c3.js",
+      "_top-head.fb652afb.js",
+      "__plugin-vue_export-helper.d68d818f.js"
+    ],
+    "isDynamicEntry": true,
+    "src": "pages/index.html/index.vue"
+  },
+  "index.8f2c4da9.css": {
+    "file": "index.8f2c4da9.css",
+    "resourceType": "style",
+    "prefetch": true,
+    "preload": true
+  },
+  "time-icon.fef65a83.svg": {
+    "file": "time-icon.fef65a83.svg",
+    "resourceType": "image",
+    "prefetch": true,
+    "mimeType": "image/svg+xml"
+  },
+  "time-white-icon.805d0e12.svg": {
+    "file": "time-white-icon.805d0e12.svg",
+    "resourceType": "image",
+    "prefetch": true,
+    "mimeType": "image/svg+xml"
+  },
+  "eye-icon.efcf8c6f.svg": {
+    "file": "eye-icon.efcf8c6f.svg",
+    "resourceType": "image",
+    "prefetch": true,
+    "mimeType": "image/svg+xml"
+  },
+  "like-no.23054eaf.svg": {
+    "file": "like-no.23054eaf.svg",
+    "resourceType": "image",
+    "prefetch": true,
+    "mimeType": "image/svg+xml"
+  },
+  "comment-icon.f7b16ad3.svg": {
+    "file": "comment-icon.f7b16ad3.svg",
+    "resourceType": "image",
+    "prefetch": true,
+    "mimeType": "image/svg+xml"
+  },
+  "pages/index.vue": {
+    "resourceType": "script",
+    "module": true,
+    "prefetch": true,
+    "preload": true,
+    "file": "index.fb406a00.js",
+    "imports": [
+      "node_modules/nuxt/dist/app/entry.js"
+    ],
+    "isDynamicEntry": true,
+    "src": "pages/index.vue"
+  },
+  "pages/publish/index.css": {
+    "resourceType": "style",
+    "prefetch": true,
+    "preload": true,
+    "file": "index.6208c35f.css",
+    "src": "pages/publish/index.css"
+  },
+  "pages/publish/index.vue": {
+    "resourceType": "script",
+    "module": true,
+    "prefetch": true,
+    "preload": true,
+    "assets": [
+      "calendar-icon.dc8f3cea.svg",
+      "frame-no.28983b22.svg",
+      "frame-pitch.02620f32.svg"
+    ],
+    "css": [],
+    "file": "index.c306db29.js",
+    "imports": [
+      "_cross-icon.8c14d1c3.js",
+      "node_modules/nuxt/dist/app/entry.js",
+      "_el-input.06dd9d1f.js",
+      "__plugin-vue_export-helper.d68d818f.js"
+    ],
+    "isDynamicEntry": true,
+    "src": "pages/publish/index.vue"
+  },
+  "index.6208c35f.css": {
+    "file": "index.6208c35f.css",
+    "resourceType": "style",
+    "prefetch": true,
+    "preload": true
+  },
+  "calendar-icon.dc8f3cea.svg": {
+    "file": "calendar-icon.dc8f3cea.svg",
+    "resourceType": "image",
+    "prefetch": true,
+    "mimeType": "image/svg+xml"
+  },
+  "frame-no.28983b22.svg": {
+    "file": "frame-no.28983b22.svg",
+    "resourceType": "image",
+    "prefetch": true,
+    "mimeType": "image/svg+xml"
+  },
+  "frame-pitch.02620f32.svg": {
+    "file": "frame-pitch.02620f32.svg",
+    "resourceType": "image",
+    "prefetch": true,
+    "mimeType": "image/svg+xml"
+  },
+  "top-head.css": {
+    "resourceType": "style",
+    "prefetch": true,
+    "preload": true,
+    "file": "top-head.bbe58785.css",
+    "src": "top-head.css"
+  }
+};
+
+export { client_manifest as default };
+//# sourceMappingURL=client.manifest.mjs.map

.output/server/chunks/app/server.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.mjs","sources":["../../../../node_modules/unctx/dist/index.mjs","../../../../.nuxt/dist/server/server.mjs"],"sourcesContent":null,"names":["createContext","asyncHandlers","createNamespace","_globalThis","globalKey","defaultNamespace","asyncHandlersKey"],"mappings":"","x_google_ignoreList":[0]}

.output/server/chunks/app/styles.mjs

@@ -0,0 +1,12 @@
+const interopDefault = r => r.default || r || [];
+const styles = {
+  "node_modules/nuxt/dist/app/entry.js": () => import('./_nuxt/entry-styles.582d7478.mjs').then(interopDefault),
+  "pages/index.html/index.vue": () => import('./_nuxt/index-styles.5022783c.mjs').then(interopDefault),
+  "pages/publish/index.vue": () => import('./_nuxt/index-styles.bb7f92cc.mjs').then(interopDefault),
+  "pages/details/[id].vue": () => import('./_nuxt/_id_-styles.5bc2c698.mjs').then(interopDefault),
+  "node_modules/@nuxt/ui-templates/dist/templates/error-404.vue": () => import('./_nuxt/error-404-styles.1e0dde27.mjs').then(interopDefault),
+  "node_modules/@nuxt/ui-templates/dist/templates/error-500.vue": () => import('./_nuxt/error-500-styles.cf4b3e80.mjs').then(interopDefault)
+};
+
+export { styles as default };
+//# sourceMappingURL=styles.mjs.map

.output/server/chunks/app/styles.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"styles.mjs","sources":["../../../../.nuxt/dist/server/styles.mjs"],"sourcesContent":null,"names":[],"mappings":"AAAA,MAAM,cAAc,GAAG,CAAC,IAAI,CAAC,CAAC,OAAO,IAAI,CAAC,IAAI,GAAE;AAChD,eAAe;AACf,EAAE,qCAAqC,EAAE,MAAM,OAAO,mCAAmC,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC;AAC/G,EAAE,4BAA4B,EAAE,MAAM,OAAO,mCAAmC,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC;AACtG,EAAE,yBAAyB,EAAE,MAAM,OAAO,mCAAmC,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC;AACnG,EAAE,wBAAwB,EAAE,MAAM,OAAO,kCAAkC,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC;AACjG,EAAE,8DAA8D,EAAE,MAAM,OAAO,uCAAuC,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC;AAC5I,EAAE,8DAA8D,EAAE,MAAM,OAAO,uCAAuC,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC;AAC5I;;;;"}

.output/server/chunks/error-500.mjs

@@ -0,0 +1,21 @@
+const _messages = {"appName":"Nuxt","version":"","statusCode":500,"statusMessage":"Server error","description":"This page is temporarily unavailable."};
+const _render = function({ messages }) {
+var __t, __p = '';
+__p += '<!DOCTYPE html><html><head><title>' +
+((__t = ( messages.statusCode )) == null ? '' : __t) +
+' - ' +
+((__t = ( messages.statusMessage )) == null ? '' : __t) +
+' | ' +
+((__t = ( messages.appName )) == null ? '' : __t) +
+'</title><meta charset="utf-8"><meta content="width=device-width,initial-scale=1,minimum-scale=1" name="viewport"><style>.spotlight{background:linear-gradient(45deg, #00DC82 0%, #36E4DA 50%, #0047E1 100%);filter:blur(20vh)}*,:before,:after{-webkit-box-sizing:border-box;box-sizing:border-box;border-width:0;border-style:solid;border-color:#e0e0e0}*{--tw-ring-inset:var(--tw-empty, );--tw-ring-offset-width:0px;--tw-ring-offset-color:#fff;--tw-ring-color:rgba(14, 165, 233, .5);--tw-ring-offset-shadow:0 0 #0000;--tw-ring-shadow:0 0 #0000;--tw-shadow:0 0 #0000}:root{-moz-tab-size:4;-o-tab-size:4;tab-size:4}body{margin:0;font-family:inherit;line-height:inherit}html{-webkit-text-size-adjust:100%;font-family:ui-sans-serif,system-ui,-apple-system,BlinkMacSystemFont,Segoe UI,Roboto,Helvetica Neue,Arial,Noto Sans,sans-serif,"Apple Color Emoji","Segoe UI Emoji",Segoe UI Symbol,"Noto Color Emoji";line-height:1.5}h1,p{margin:0}h1{font-size:inherit;font-weight:inherit}.bg-white{--tw-bg-opacity:1;background-color:rgba(255,255,255,var(--tw-bg-opacity))}.grid{display:-ms-grid;display:grid}.place-content-center{place-content:center}.font-sans{font-family:ui-sans-serif,system-ui,-apple-system,BlinkMacSystemFont,Segoe UI,Roboto,Helvetica Neue,Arial,Noto Sans,sans-serif,"Apple Color Emoji","Segoe UI Emoji",Segoe UI Symbol,"Noto Color Emoji"}.font-medium{font-weight:500}.font-light{font-weight:300}.h-1\\/2{height:50%}.text-8xl{font-size:6rem;line-height:1}.text-xl{font-size:1.25rem;line-height:1.75rem}.leading-tight{line-height:1.25}.mb-8{margin-bottom:2rem}.mb-16{margin-bottom:4rem}.max-w-520px{max-width:520px}.min-h-screen{min-height:100vh}.overflow-hidden{overflow:hidden}.px-8{padding-left:2rem;padding-right:2rem}.fixed{position:fixed}.left-0{left:0}.right-0{right:0}.-bottom-1\\/2{bottom:-50%}.text-center{text-align:center}.text-black{--tw-text-opacity:1;color:rgba(0,0,0,var(--tw-text-opacity))}.antialiased{-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale}@media (min-width: 640px){.sm\\:text-4xl{font-size:2.25rem;line-height:2.5rem}.sm\\:text-10xl{font-size:10rem;line-height:1}.sm\\:px-0{padding-left:0;padding-right:0}}@media (prefers-color-scheme: dark){.dark\\:bg-black{--tw-bg-opacity:1;background-color:rgba(0,0,0,var(--tw-bg-opacity))}.dark\\:text-white{--tw-text-opacity:1;color:rgba(255,255,255,var(--tw-text-opacity))}}</style><script>(function(){const t=document.createElement("link").relList;if(t&&t.supports&&t.supports("modulepreload"))return;for(const e of document.querySelectorAll(\'link[rel="modulepreload"]\'))i(e);new MutationObserver(e=>{for(const r of e)if(r.type==="childList")for(const o of r.addedNodes)o.tagName==="LINK"&&o.rel==="modulepreload"&&i(o)}).observe(document,{childList:!0,subtree:!0});function s(e){const r={};return e.integrity&&(r.integrity=e.integrity),e.referrerPolicy&&(r.referrerPolicy=e.referrerPolicy),e.crossOrigin==="use-credentials"?r.credentials="include":e.crossOrigin==="anonymous"?r.credentials="omit":r.credentials="same-origin",r}function i(e){if(e.ep)return;e.ep=!0;const r=s(e);fetch(e.href,r)}})();</script></head><body class="font-sans antialiased bg-white dark:bg-black text-black dark:text-white grid min-h-screen place-content-center overflow-hidden"><div class="fixed -bottom-1/2 left-0 right-0 h-1/2 spotlight"></div><div class="max-w-520px text-center"><h1 class="text-8xl sm:text-10xl font-medium mb-8">' +
+((__t = ( messages.statusCode )) == null ? '' : __t) +
+'</h1><p class="text-xl px-8 sm:px-0 sm:text-4xl font-light mb-16 leading-tight">' +
+((__t = ( messages.description )) == null ? '' : __t) +
+'</p></div></body></html>';
+return __p
+};
+const _template = (messages) => _render({ messages: { ..._messages, ...messages } });
+const template = _template;
+
+export { template };
+//# sourceMappingURL=error-500.mjs.map

.output/server/chunks/error-500.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-500.mjs","sources":["../../../node_modules/@nuxt/ui-templates/dist/templates/error-500.mjs"],"sourcesContent":null,"names":[],"mappings":"","x_google_ignoreList":[0]}

.output/server/chunks/handlers/renderer.mjs

@@ -0,0 +1,384 @@
+import { getRequestDependencies, getPreloadLinks, getPrefetchLinks, createRenderer } from 'vue-bundle-renderer/runtime';
+import { e as eventHandler, s as setResponseHeader, a as send, g as getResponseStatus, b as setResponseStatus, c as setResponseHeaders, u as useNitroApp, j as joinURL, d as useRuntimeConfig, f as getQuery, h as createError, i as getRouteRules, k as getResponseStatusText } from '../nitro/node-server.mjs';
+import { stringify, uneval } from 'devalue';
+import { renderToString } from 'vue/server-renderer';
+import { renderSSRHead } from '@unhead/ssr';
+import { version, unref } from 'vue';
+import { createServerHead as createServerHead$1 } from 'unhead';
+import { defineHeadPlugin } from '@unhead/shared';
+
+function defineRenderHandler(handler) {
+  return eventHandler(async (event) => {
+    if (event.path.endsWith("/favicon.ico")) {
+      setResponseHeader(event, "Content-Type", "image/x-icon");
+      return send(
+        event,
+        "data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7"
+      );
+    }
+    const response = await handler(event);
+    if (!response) {
+      const _currentStatus = getResponseStatus(event);
+      setResponseStatus(event, _currentStatus === 200 ? 500 : _currentStatus);
+      return send(
+        event,
+        "No response returned from render handler: " + event.path
+      );
+    }
+    const nitroApp = useNitroApp();
+    await nitroApp.hooks.callHook("render:response", response, { event });
+    if (response.headers) {
+      setResponseHeaders(event, response.headers);
+    }
+    if (response.statusCode || response.statusMessage) {
+      setResponseStatus(event, response.statusCode, response.statusMessage);
+    }
+    return response.body;
+  });
+}
+
+const Vue3 = version.startsWith("3");
+
+function resolveUnref(r) {
+  return typeof r === "function" ? r() : unref(r);
+}
+function resolveUnrefHeadInput(ref, lastKey = "") {
+  if (ref instanceof Promise)
+    return ref;
+  const root = resolveUnref(ref);
+  if (!ref || !root)
+    return root;
+  if (Array.isArray(root))
+    return root.map((r) => resolveUnrefHeadInput(r, lastKey));
+  if (typeof root === "object") {
+    return Object.fromEntries(
+      Object.entries(root).map(([k, v]) => {
+        if (k === "titleTemplate" || k.startsWith("on"))
+          return [k, unref(v)];
+        return [k, resolveUnrefHeadInput(v, k)];
+      })
+    );
+  }
+  return root;
+}
+
+const VueReactivityPlugin = defineHeadPlugin({
+  hooks: {
+    "entries:resolve": function(ctx) {
+      for (const entry of ctx.entries)
+        entry.resolvedInput = resolveUnrefHeadInput(entry.input);
+    }
+  }
+});
+
+const headSymbol = "usehead";
+function vueInstall(head) {
+  const plugin = {
+    install(app) {
+      if (Vue3) {
+        app.config.globalProperties.$unhead = head;
+        app.config.globalProperties.$head = head;
+        app.provide(headSymbol, head);
+      }
+    }
+  };
+  return plugin.install;
+}
+function createServerHead(options = {}) {
+  const head = createServerHead$1(options);
+  head.use(VueReactivityPlugin);
+  head.install = vueInstall(head);
+  return head;
+}
+
+const unheadPlugins = [];
+
+const appHead = {"meta":[{"name":"viewport","content":"width=device-width, initial-scale=1"},{"charset":"utf-8"}],"link":[{"rel":"stylesheet","href":"//bbs.gter.net/data/cache/style_2_common.css?Z62"}],"style":[],"script":[{"src":"//bbs.gter.net/static/js/common.js","body":true,"charset":"gb2312"},{"innerHTML":"\n                    window.userInfoWin = {}\n                    STYLEID = \"2\";\n                    STATICURL = \"static/\";\n                    IMGDIR = \"https://bbs.gter.net/template/archy_plt8/image\";\n                    VERHASH = \"Z62\";\n                    charset = \"gbk\";\n                    discuz_uid = \"0\";\n                    cookiepre = \"4B5x_c0ae_\";\n                    cookiedomain = \"gter.net\";\n                    cookiepath = \"/\";\n                    showusercard = \"1\";\n                    attackevasive = \"0\";\n                    disallowfloat = \"\";\n                    creditnotice = \",\";\n                    defaultstyle = \"\";\n                    REPORTURL = \"aHR0cDovL2Jicy5ndGVyLm5ldC9mb3J1bS5waHA/dGlkPTI0MDYzNTYmZ290bz1sYXN0cG9zdA==\";\n                    SITEURL = \"https://ask.gter.net/\";\n                    JSPATH = \"static/js/\";","type":"text/javascript","charset":"utf-8"}],"noscript":[]};
+
+const appRootId = "__nuxt";
+
+const appRootTag = "div";
+
+function buildAssetsDir() {
+  return useRuntimeConfig().app.buildAssetsDir;
+}
+function buildAssetsURL(...path) {
+  return joinURL(publicAssetsURL(), buildAssetsDir(), ...path);
+}
+function publicAssetsURL(...path) {
+  const publicBase = useRuntimeConfig().app.cdnURL || useRuntimeConfig().app.baseURL;
+  return path.length ? joinURL(publicBase, ...path) : publicBase;
+}
+
+globalThis.__buildAssetsURL = buildAssetsURL;
+globalThis.__publicAssetsURL = publicAssetsURL;
+const getClientManifest = () => import('../app/client.manifest.mjs').then((r) => r.default || r).then((r) => typeof r === "function" ? r() : r);
+const getEntryIds = () => getClientManifest().then((r) => Object.values(r).filter(
+  (r2) => (
+    // @ts-expect-error internal key set by CSS inlining configuration
+    r2._globalCSS
+  )
+).map((r2) => r2.src));
+const getServerEntry = () => import('../app/server.mjs').then((r) => r.default || r);
+const getSSRStyles = lazyCachedFunction(() => import('../app/styles.mjs').then((r) => r.default || r));
+const getSSRRenderer = lazyCachedFunction(async () => {
+  const manifest = await getClientManifest();
+  if (!manifest) {
+    throw new Error("client.manifest is not available");
+  }
+  const createSSRApp = await getServerEntry();
+  if (!createSSRApp) {
+    throw new Error("Server bundle is not available");
+  }
+  const options = {
+    manifest,
+    renderToString: renderToString$1,
+    buildAssetsURL
+  };
+  const renderer = createRenderer(createSSRApp, options);
+  async function renderToString$1(input, context) {
+    const html = await renderToString(input, context);
+    return `<${appRootTag}${` id="${appRootId}"` }>${html}</${appRootTag}>`;
+  }
+  return renderer;
+});
+const getSPARenderer = lazyCachedFunction(async () => {
+  const manifest = await getClientManifest();
+  const spaTemplate = await import('../rollup/_virtual_spa-template.mjs').then((r) => r.template).catch(() => "");
+  const options = {
+    manifest,
+    renderToString: () => `<${appRootTag}${` id="${appRootId}"` }>${spaTemplate}</${appRootTag}>`,
+    buildAssetsURL
+  };
+  const renderer = createRenderer(() => () => {
+  }, options);
+  const result = await renderer.renderToString({});
+  const renderToString = (ssrContext) => {
+    const config = useRuntimeConfig();
+    ssrContext.modules = ssrContext.modules || /* @__PURE__ */ new Set();
+    ssrContext.payload = {
+      _errors: {},
+      serverRendered: false,
+      data: {},
+      state: {}
+    };
+    ssrContext.config = {
+      public: config.public,
+      app: config.app
+    };
+    return Promise.resolve(result);
+  };
+  return {
+    rendererContext: renderer.rendererContext,
+    renderToString
+  };
+});
+const PAYLOAD_URL_RE = /\/_payload(\.[a-zA-Z0-9]+)?.json(\?.*)?$/ ;
+const renderer = defineRenderHandler(async (event) => {
+  const nitroApp = useNitroApp();
+  const ssrError = event.path.startsWith("/__nuxt_error") ? getQuery(event) : null;
+  if (ssrError && ssrError.statusCode) {
+    ssrError.statusCode = parseInt(ssrError.statusCode);
+  }
+  if (ssrError && !("__unenv__" in event.node.req)) {
+    throw createError({
+      statusCode: 404,
+      statusMessage: "Page Not Found: /__nuxt_error"
+    });
+  }
+  const islandContext = void 0;
+  let url = ssrError?.url || islandContext?.url || event.path;
+  const isRenderingPayload = PAYLOAD_URL_RE.test(url) && !islandContext;
+  if (isRenderingPayload) {
+    url = url.substring(0, url.lastIndexOf("/")) || "/";
+    event._path = url;
+    event.node.req.url = url;
+  }
+  const routeOptions = getRouteRules(event);
+  const head = createServerHead({
+    plugins: unheadPlugins
+  });
+  const headEntryOptions = { mode: "server" };
+  head.push(appHead, headEntryOptions);
+  const ssrContext = {
+    url,
+    event,
+    runtimeConfig: useRuntimeConfig(),
+    noSSR: event.context.nuxt?.noSSR || routeOptions.ssr === false && !islandContext || (false),
+    head,
+    error: !!ssrError,
+    nuxt: void 0,
+    /* NuxtApp */
+    payload: ssrError ? { error: ssrError } : {},
+    _payloadReducers: {},
+    islandContext
+  };
+  const renderer = ssrContext.noSSR ? await getSPARenderer() : await getSSRRenderer();
+  const _rendered = await renderer.renderToString(ssrContext).catch(async (error) => {
+    if (ssrContext._renderResponse && error.message === "skipping render") {
+      return {};
+    }
+    const _err = !ssrError && ssrContext.payload?.error || error;
+    await ssrContext.nuxt?.hooks.callHook("app:error", _err);
+    throw _err;
+  });
+  await ssrContext.nuxt?.hooks.callHook("app:rendered", { ssrContext, renderResult: _rendered });
+  if (ssrContext._renderResponse) {
+    return ssrContext._renderResponse;
+  }
+  if (ssrContext.payload?.error && !ssrError) {
+    throw ssrContext.payload.error;
+  }
+  if (isRenderingPayload) {
+    const response2 = renderPayloadResponse(ssrContext);
+    return response2;
+  }
+  {
+    const source = ssrContext.modules ?? ssrContext._registeredComponents;
+    if (source) {
+      for (const id of await getEntryIds()) {
+        source.add(id);
+      }
+    }
+  }
+  const inlinedStyles = await renderInlineStyles(ssrContext.modules ?? ssrContext._registeredComponents ?? []) ;
+  const NO_SCRIPTS = routeOptions.experimentalNoScripts;
+  const { styles, scripts } = getRequestDependencies(ssrContext, renderer.rendererContext);
+  head.push({ style: inlinedStyles });
+  head.push({
+    link: Object.values(styles).map(
+      (resource) => ({ rel: "stylesheet", href: renderer.rendererContext.buildAssetsURL(resource.file) })
+    )
+  }, headEntryOptions);
+  if (!NO_SCRIPTS) {
+    head.push({
+      link: getPreloadLinks(ssrContext, renderer.rendererContext)
+    }, headEntryOptions);
+    head.push({
+      link: getPrefetchLinks(ssrContext, renderer.rendererContext)
+    }, headEntryOptions);
+    head.push({
+      script: renderPayloadJsonScript({ id: "__NUXT_DATA__", ssrContext, data: ssrContext.payload }) 
+    }, {
+      ...headEntryOptions,
+      // this should come before another end of body scripts
+      tagPosition: "bodyClose",
+      tagPriority: "high"
+    });
+  }
+  if (!routeOptions.experimentalNoScripts) {
+    head.push({
+      script: Object.values(scripts).map((resource) => ({
+        type: resource.module ? "module" : null,
+        src: renderer.rendererContext.buildAssetsURL(resource.file),
+        defer: resource.module ? null : true,
+        crossorigin: ""
+      }))
+    }, headEntryOptions);
+  }
+  const { headTags, bodyTags, bodyTagsOpen, htmlAttrs, bodyAttrs } = await renderSSRHead(head);
+  const htmlContext = {
+    island: Boolean(islandContext),
+    htmlAttrs: [htmlAttrs],
+    head: normalizeChunks([headTags, ssrContext.styles]),
+    bodyAttrs: [bodyAttrs],
+    bodyPrepend: normalizeChunks([bodyTagsOpen, ssrContext.teleports?.body]),
+    body: [_rendered.html],
+    bodyAppend: [bodyTags]
+  };
+  await nitroApp.hooks.callHook("render:html", htmlContext, { event });
+  const response = {
+    body: renderHTMLDocument(htmlContext),
+    statusCode: getResponseStatus(event),
+    statusMessage: getResponseStatusText(event),
+    headers: {
+      "content-type": "text/html;charset=utf-8",
+      "x-powered-by": "Nuxt"
+    }
+  };
+  return response;
+});
+function lazyCachedFunction(fn) {
+  let res = null;
+  return () => {
+    if (res === null) {
+      res = fn().catch((err) => {
+        res = null;
+        throw err;
+      });
+    }
+    return res;
+  };
+}
+function normalizeChunks(chunks) {
+  return chunks.filter(Boolean).map((i) => i.trim());
+}
+function joinTags(tags) {
+  return tags.join("");
+}
+function joinAttrs(chunks) {
+  return chunks.join(" ");
+}
+function renderHTMLDocument(html) {
+  return `<!DOCTYPE html>
+<html ${joinAttrs(html.htmlAttrs)}>
+<head>${joinTags(html.head)}</head>
+<body ${joinAttrs(html.bodyAttrs)}>${joinTags(html.bodyPrepend)}${joinTags(html.body)}${joinTags(html.bodyAppend)}</body>
+</html>`;
+}
+async function renderInlineStyles(usedModules) {
+  const styleMap = await getSSRStyles();
+  const inlinedStyles = /* @__PURE__ */ new Set();
+  for (const mod of usedModules) {
+    if (mod in styleMap) {
+      for (const style of await styleMap[mod]()) {
+        inlinedStyles.add(style);
+      }
+    }
+  }
+  return Array.from(inlinedStyles).map((style) => ({ innerHTML: style }));
+}
+function renderPayloadResponse(ssrContext) {
+  return {
+    body: stringify(splitPayload(ssrContext).payload, ssrContext._payloadReducers) ,
+    statusCode: getResponseStatus(ssrContext.event),
+    statusMessage: getResponseStatusText(ssrContext.event),
+    headers: {
+      "content-type": "application/json;charset=utf-8" ,
+      "x-powered-by": "Nuxt"
+    }
+  };
+}
+function renderPayloadJsonScript(opts) {
+  const contents = opts.data ? stringify(opts.data, opts.ssrContext._payloadReducers) : "";
+  const payload = {
+    type: "application/json",
+    id: opts.id,
+    innerHTML: contents,
+    "data-ssr": !(opts.ssrContext.noSSR)
+  };
+  if (opts.src) {
+    payload["data-src"] = opts.src;
+  }
+  return [
+    payload,
+    {
+      innerHTML: `window.__NUXT__={};window.__NUXT__.config=${uneval(opts.ssrContext.config)}`
+    }
+  ];
+}
+function splitPayload(ssrContext) {
+  const { data, prerenderedAt, ...initial } = ssrContext.payload;
+  return {
+    initial: { ...initial, prerenderedAt },
+    payload: { data, prerenderedAt }
+  };
+}
+
+const renderer$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  default: renderer
+});
+
+export { buildAssetsURL as b, renderer$1 as r };
+//# sourceMappingURL=renderer.mjs.map

.output/server/chunks/handlers/renderer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderer.mjs","sources":["../../../../node_modules/nitropack/dist/runtime/renderer.mjs","../../../../node_modules/@unhead/vue/dist/shared/vue.cf295fb1.mjs","../../../../node_modules/nuxt/dist/core/runtime/nitro/paths.js","../../../../node_modules/nuxt/dist/core/runtime/nitro/renderer.js"],"sourcesContent":null,"names":["renderToString","_renderToString"],"mappings":"","x_google_ignoreList":[0,1,2,3]}

.output/server/chunks/nitro/node-server.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-server.mjs","sources":["../../../../node_modules/destr/dist/index.mjs","../../../../node_modules/ufo/dist/index.mjs","../../../../node_modules/radix3/dist/index.mjs","../../../../node_modules/defu/dist/defu.mjs","../../../../node_modules/unenv/runtime/_internal/utils.mjs","../../../../node_modules/unenv/runtime/node/events/_events.mjs","../../../../node_modules/unenv/runtime/node/events/index.mjs","../../../../node_modules/unenv/runtime/node/stream/readable.mjs","../../../../node_modules/unenv/runtime/node/stream/writable.mjs","../../../../node_modules/unenv/runtime/node/stream/duplex.mjs","../../../../node_modules/unenv/runtime/node/net/socket.mjs","../../../../node_modules/unenv/runtime/node/http/_request.mjs","../../../../node_modules/unenv/runtime/node/http/_response.mjs","../../../../node_modules/h3/dist/index.mjs","../../../../node_modules/node-fetch-native/dist/native.mjs","../../../../node_modules/ofetch/dist/shared/ofetch.00501375.mjs","../../../../node_modules/ofetch/dist/node.mjs","../../../../node_modules/unenv/runtime/fetch/call.mjs","../../../../node_modules/unenv/runtime/fetch/index.mjs","../../../../node_modules/hookable/dist/index.mjs","../../../../node_modules/scule/dist/index.mjs","../../../../node_modules/klona/dist/index.mjs","../../../../node_modules/nitropack/dist/runtime/config.mjs","../../../../node_modules/ohash/dist/index.mjs","../../../../node_modules/unstorage/dist/shared/unstorage.8581f561.mjs","../../../../node_modules/unstorage/dist/index.mjs","../../../../node_modules/unstorage/drivers/utils/index.mjs","../../../../node_modules/unstorage/drivers/utils/node-fs.mjs","../../../../node_modules/unstorage/drivers/fs-lite.mjs","../../../../node_modules/nitropack/dist/runtime/storage.mjs","../../../../node_modules/nitropack/dist/runtime/cache.mjs","../../../../node_modules/nitropack/dist/runtime/utils.mjs","../../../../node_modules/nitropack/dist/runtime/route-rules.mjs","../../../../node_modules/nuxt/dist/core/runtime/nitro/error.js","../../../../node_modules/pathe/dist/shared/pathe.92c04245.mjs","../../../../node_modules/nitropack/dist/runtime/static.mjs","../../../../node_modules/nitropack/dist/runtime/app.mjs","../../../../node_modules/nitropack/dist/runtime/lib/http-graceful-shutdown.mjs","../../../../node_modules/nitropack/dist/runtime/shutdown.mjs","../../../../node_modules/nitropack/dist/runtime/entries/node-server.mjs"],"sourcesContent":null,"names":["getQuery","createRouter","EventEmitter","_EventEmitter","createError","nullBodyResponses","createFetch","nodeFetch","Headers","Headers$1","AbortController$1","_inlineAppConfig","normalizeKey","defineDriver","DRIVER_NAME","dirname","fsPromises","resolve","fsp","createRadixRouter","createLocalFetch","gracefulShutdown","HttpsServer","HttpServer"],"mappings":"","x_google_ignoreList":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39]}

.output/server/chunks/rollup/_virtual_spa-template.mjs

@@ -0,0 +1,4 @@
+const template = "";
+
+export { template };
+//# sourceMappingURL=_virtual_spa-template.mjs.map

.output/server/chunks/rollup/_virtual_spa-template.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"_virtual_spa-template.mjs","sources":[],"sourcesContent":null,"names":[],"mappings":";;;;"}

.output/server/index.mjs

@@ -0,0 +1,8 @@
+globalThis._importMeta_={url:import.meta.url,env:process.env};import 'node:http';
+import 'node:https';
+export { v as default } from './chunks/nitro/node-server.mjs';
+import 'fs';
+import 'path';
+import 'node:fs';
+import 'node:url';
+//# sourceMappingURL=index.mjs.map

.output/server/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":null,"names":[],"mappings":";;;;;;"}

.output/server/node_modules/@babel/parser/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@babel/parser",
+  "version": "7.23.5",
+  "description": "A JavaScript parser",
+  "author": "The Babel Team (https://babel.dev/team)",
+  "homepage": "https://babel.dev/docs/en/next/babel-parser",
+  "bugs": "https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A+parser+%28babylon%29%22+is%3Aopen",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "babel",
+    "javascript",
+    "parser",
+    "tc39",
+    "ecmascript",
+    "@babel/parser"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-parser"
+  },
+  "main": "./lib/index.js",
+  "types": "./typings/babel-parser.d.ts",
+  "files": [
+    "bin",
+    "lib",
+    "typings/babel-parser.d.ts",
+    "index.cjs"
+  ],
+  "engines": {
+    "node": ">=6.0.0"
+  },
+  "devDependencies": {
+    "@babel/code-frame": "^7.23.5",
+    "@babel/helper-check-duplicate-nodes": "^7.22.5",
+    "@babel/helper-fixtures": "^7.23.4",
+    "@babel/helper-string-parser": "^7.23.4",
+    "@babel/helper-validator-identifier": "^7.22.20",
+    "charcodes": "^0.2.0"
+  },
+  "bin": "./bin/babel-parser.js",
+  "type": "commonjs"
+}

.output/server/node_modules/@ctrl/tinycolor/dist/conversion.js

@@ -0,0 +1,250 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.numberInputToObject = exports.parseIntFromHex = exports.convertHexToDecimal = exports.convertDecimalToHex = exports.rgbaToArgbHex = exports.rgbaToHex = exports.rgbToHex = exports.hsvToRgb = exports.rgbToHsv = exports.hslToRgb = exports.rgbToHsl = exports.rgbToRgb = void 0;
+var util_js_1 = require("./util.js");
+// `rgbToHsl`, `rgbToHsv`, `hslToRgb`, `hsvToRgb` modified from:
+// <http://mjijackson.com/2008/02/rgb-to-hsl-and-rgb-to-hsv-color-model-conversion-algorithms-in-javascript>
+/**
+ * Handle bounds / percentage checking to conform to CSS color spec
+ * <http://www.w3.org/TR/css3-color/>
+ * *Assumes:* r, g, b in [0, 255] or [0, 1]
+ * *Returns:* { r, g, b } in [0, 255]
+ */
+function rgbToRgb(r, g, b) {
+    return {
+        r: (0, util_js_1.bound01)(r, 255) * 255,
+        g: (0, util_js_1.bound01)(g, 255) * 255,
+        b: (0, util_js_1.bound01)(b, 255) * 255,
+    };
+}
+exports.rgbToRgb = rgbToRgb;
+/**
+ * Converts an RGB color value to HSL.
+ * *Assumes:* r, g, and b are contained in [0, 255] or [0, 1]
+ * *Returns:* { h, s, l } in [0,1]
+ */
+function rgbToHsl(r, g, b) {
+    r = (0, util_js_1.bound01)(r, 255);
+    g = (0, util_js_1.bound01)(g, 255);
+    b = (0, util_js_1.bound01)(b, 255);
+    var max = Math.max(r, g, b);
+    var min = Math.min(r, g, b);
+    var h = 0;
+    var s = 0;
+    var l = (max + min) / 2;
+    if (max === min) {
+        s = 0;
+        h = 0; // achromatic
+    }
+    else {
+        var d = max - min;
+        s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+        switch (max) {
+            case r:
+                h = (g - b) / d + (g < b ? 6 : 0);
+                break;
+            case g:
+                h = (b - r) / d + 2;
+                break;
+            case b:
+                h = (r - g) / d + 4;
+                break;
+            default:
+                break;
+        }
+        h /= 6;
+    }
+    return { h: h, s: s, l: l };
+}
+exports.rgbToHsl = rgbToHsl;
+function hue2rgb(p, q, t) {
+    if (t < 0) {
+        t += 1;
+    }
+    if (t > 1) {
+        t -= 1;
+    }
+    if (t < 1 / 6) {
+        return p + (q - p) * (6 * t);
+    }
+    if (t < 1 / 2) {
+        return q;
+    }
+    if (t < 2 / 3) {
+        return p + (q - p) * (2 / 3 - t) * 6;
+    }
+    return p;
+}
+/**
+ * Converts an HSL color value to RGB.
+ *
+ * *Assumes:* h is contained in [0, 1] or [0, 360] and s and l are contained [0, 1] or [0, 100]
+ * *Returns:* { r, g, b } in the set [0, 255]
+ */
+function hslToRgb(h, s, l) {
+    var r;
+    var g;
+    var b;
+    h = (0, util_js_1.bound01)(h, 360);
+    s = (0, util_js_1.bound01)(s, 100);
+    l = (0, util_js_1.bound01)(l, 100);
+    if (s === 0) {
+        // achromatic
+        g = l;
+        b = l;
+        r = l;
+    }
+    else {
+        var q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+        var p = 2 * l - q;
+        r = hue2rgb(p, q, h + 1 / 3);
+        g = hue2rgb(p, q, h);
+        b = hue2rgb(p, q, h - 1 / 3);
+    }
+    return { r: r * 255, g: g * 255, b: b * 255 };
+}
+exports.hslToRgb = hslToRgb;
+/**
+ * Converts an RGB color value to HSV
+ *
+ * *Assumes:* r, g, and b are contained in the set [0, 255] or [0, 1]
+ * *Returns:* { h, s, v } in [0,1]
+ */
+function rgbToHsv(r, g, b) {
+    r = (0, util_js_1.bound01)(r, 255);
+    g = (0, util_js_1.bound01)(g, 255);
+    b = (0, util_js_1.bound01)(b, 255);
+    var max = Math.max(r, g, b);
+    var min = Math.min(r, g, b);
+    var h = 0;
+    var v = max;
+    var d = max - min;
+    var s = max === 0 ? 0 : d / max;
+    if (max === min) {
+        h = 0; // achromatic
+    }
+    else {
+        switch (max) {
+            case r:
+                h = (g - b) / d + (g < b ? 6 : 0);
+                break;
+            case g:
+                h = (b - r) / d + 2;
+                break;
+            case b:
+                h = (r - g) / d + 4;
+                break;
+            default:
+                break;
+        }
+        h /= 6;
+    }
+    return { h: h, s: s, v: v };
+}
+exports.rgbToHsv = rgbToHsv;
+/**
+ * Converts an HSV color value to RGB.
+ *
+ * *Assumes:* h is contained in [0, 1] or [0, 360] and s and v are contained in [0, 1] or [0, 100]
+ * *Returns:* { r, g, b } in the set [0, 255]
+ */
+function hsvToRgb(h, s, v) {
+    h = (0, util_js_1.bound01)(h, 360) * 6;
+    s = (0, util_js_1.bound01)(s, 100);
+    v = (0, util_js_1.bound01)(v, 100);
+    var i = Math.floor(h);
+    var f = h - i;
+    var p = v * (1 - s);
+    var q = v * (1 - f * s);
+    var t = v * (1 - (1 - f) * s);
+    var mod = i % 6;
+    var r = [v, q, p, p, t, v][mod];
+    var g = [t, v, v, q, p, p][mod];
+    var b = [p, p, t, v, v, q][mod];
+    return { r: r * 255, g: g * 255, b: b * 255 };
+}
+exports.hsvToRgb = hsvToRgb;
+/**
+ * Converts an RGB color to hex
+ *
+ * Assumes r, g, and b are contained in the set [0, 255]
+ * Returns a 3 or 6 character hex
+ */
+function rgbToHex(r, g, b, allow3Char) {
+    var hex = [
+        (0, util_js_1.pad2)(Math.round(r).toString(16)),
+        (0, util_js_1.pad2)(Math.round(g).toString(16)),
+        (0, util_js_1.pad2)(Math.round(b).toString(16)),
+    ];
+    // Return a 3 character hex if possible
+    if (allow3Char &&
+        hex[0].startsWith(hex[0].charAt(1)) &&
+        hex[1].startsWith(hex[1].charAt(1)) &&
+        hex[2].startsWith(hex[2].charAt(1))) {
+        return hex[0].charAt(0) + hex[1].charAt(0) + hex[2].charAt(0);
+    }
+    return hex.join('');
+}
+exports.rgbToHex = rgbToHex;
+/**
+ * Converts an RGBA color plus alpha transparency to hex
+ *
+ * Assumes r, g, b are contained in the set [0, 255] and
+ * a in [0, 1]. Returns a 4 or 8 character rgba hex
+ */
+// eslint-disable-next-line max-params
+function rgbaToHex(r, g, b, a, allow4Char) {
+    var hex = [
+        (0, util_js_1.pad2)(Math.round(r).toString(16)),
+        (0, util_js_1.pad2)(Math.round(g).toString(16)),
+        (0, util_js_1.pad2)(Math.round(b).toString(16)),
+        (0, util_js_1.pad2)(convertDecimalToHex(a)),
+    ];
+    // Return a 4 character hex if possible
+    if (allow4Char &&
+        hex[0].startsWith(hex[0].charAt(1)) &&
+        hex[1].startsWith(hex[1].charAt(1)) &&
+        hex[2].startsWith(hex[2].charAt(1)) &&
+        hex[3].startsWith(hex[3].charAt(1))) {
+        return hex[0].charAt(0) + hex[1].charAt(0) + hex[2].charAt(0) + hex[3].charAt(0);
+    }
+    return hex.join('');
+}
+exports.rgbaToHex = rgbaToHex;
+/**
+ * Converts an RGBA color to an ARGB Hex8 string
+ * Rarely used, but required for "toFilter()"
+ */
+function rgbaToArgbHex(r, g, b, a) {
+    var hex = [
+        (0, util_js_1.pad2)(convertDecimalToHex(a)),
+        (0, util_js_1.pad2)(Math.round(r).toString(16)),
+        (0, util_js_1.pad2)(Math.round(g).toString(16)),
+        (0, util_js_1.pad2)(Math.round(b).toString(16)),
+    ];
+    return hex.join('');
+}
+exports.rgbaToArgbHex = rgbaToArgbHex;
+/** Converts a decimal to a hex value */
+function convertDecimalToHex(d) {
+    return Math.round(parseFloat(d) * 255).toString(16);
+}
+exports.convertDecimalToHex = convertDecimalToHex;
+/** Converts a hex value to a decimal */
+function convertHexToDecimal(h) {
+    return parseIntFromHex(h) / 255;
+}
+exports.convertHexToDecimal = convertHexToDecimal;
+/** Parse a base-16 hex value into a base-10 integer */
+function parseIntFromHex(val) {
+    return parseInt(val, 16);
+}
+exports.parseIntFromHex = parseIntFromHex;
+function numberInputToObject(color) {
+    return {
+        r: color >> 16,
+        g: (color & 0xff00) >> 8,
+        b: color & 0xff,
+    };
+}
+exports.numberInputToObject = numberInputToObject;

.output/server/node_modules/@ctrl/tinycolor/dist/css-color-names.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.names = void 0;
+// https://github.com/bahamas10/css-color-names/blob/master/css-color-names.json
+/**
+ * @hidden
+ */
+exports.names = {
+    aliceblue: '#f0f8ff',
+    antiquewhite: '#faebd7',
+    aqua: '#00ffff',
+    aquamarine: '#7fffd4',
+    azure: '#f0ffff',
+    beige: '#f5f5dc',
+    bisque: '#ffe4c4',
+    black: '#000000',
+    blanchedalmond: '#ffebcd',
+    blue: '#0000ff',
+    blueviolet: '#8a2be2',
+    brown: '#a52a2a',
+    burlywood: '#deb887',
+    cadetblue: '#5f9ea0',
+    chartreuse: '#7fff00',
+    chocolate: '#d2691e',
+    coral: '#ff7f50',
+    cornflowerblue: '#6495ed',
+    cornsilk: '#fff8dc',
+    crimson: '#dc143c',
+    cyan: '#00ffff',
+    darkblue: '#00008b',
+    darkcyan: '#008b8b',
+    darkgoldenrod: '#b8860b',
+    darkgray: '#a9a9a9',
+    darkgreen: '#006400',
+    darkgrey: '#a9a9a9',
+    darkkhaki: '#bdb76b',
+    darkmagenta: '#8b008b',
+    darkolivegreen: '#556b2f',
+    darkorange: '#ff8c00',
+    darkorchid: '#9932cc',
+    darkred: '#8b0000',
+    darksalmon: '#e9967a',
+    darkseagreen: '#8fbc8f',
+    darkslateblue: '#483d8b',
+    darkslategray: '#2f4f4f',
+    darkslategrey: '#2f4f4f',
+    darkturquoise: '#00ced1',
+    darkviolet: '#9400d3',
+    deeppink: '#ff1493',
+    deepskyblue: '#00bfff',
+    dimgray: '#696969',
+    dimgrey: '#696969',
+    dodgerblue: '#1e90ff',
+    firebrick: '#b22222',
+    floralwhite: '#fffaf0',
+    forestgreen: '#228b22',
+    fuchsia: '#ff00ff',
+    gainsboro: '#dcdcdc',
+    ghostwhite: '#f8f8ff',
+    goldenrod: '#daa520',
+    gold: '#ffd700',
+    gray: '#808080',
+    green: '#008000',
+    greenyellow: '#adff2f',
+    grey: '#808080',
+    honeydew: '#f0fff0',
+    hotpink: '#ff69b4',
+    indianred: '#cd5c5c',
+    indigo: '#4b0082',
+    ivory: '#fffff0',
+    khaki: '#f0e68c',
+    lavenderblush: '#fff0f5',
+    lavender: '#e6e6fa',
+    lawngreen: '#7cfc00',
+    lemonchiffon: '#fffacd',
+    lightblue: '#add8e6',
+    lightcoral: '#f08080',
+    lightcyan: '#e0ffff',
+    lightgoldenrodyellow: '#fafad2',
+    lightgray: '#d3d3d3',
+    lightgreen: '#90ee90',
+    lightgrey: '#d3d3d3',
+    lightpink: '#ffb6c1',
+    lightsalmon: '#ffa07a',
+    lightseagreen: '#20b2aa',
+    lightskyblue: '#87cefa',
+    lightslategray: '#778899',
+    lightslategrey: '#778899',
+    lightsteelblue: '#b0c4de',
+    lightyellow: '#ffffe0',
+    lime: '#00ff00',
+    limegreen: '#32cd32',
+    linen: '#faf0e6',
+    magenta: '#ff00ff',
+    maroon: '#800000',
+    mediumaquamarine: '#66cdaa',
+    mediumblue: '#0000cd',
+    mediumorchid: '#ba55d3',
+    mediumpurple: '#9370db',
+    mediumseagreen: '#3cb371',
+    mediumslateblue: '#7b68ee',
+    mediumspringgreen: '#00fa9a',
+    mediumturquoise: '#48d1cc',
+    mediumvioletred: '#c71585',
+    midnightblue: '#191970',
+    mintcream: '#f5fffa',
+    mistyrose: '#ffe4e1',
+    moccasin: '#ffe4b5',
+    navajowhite: '#ffdead',
+    navy: '#000080',
+    oldlace: '#fdf5e6',
+    olive: '#808000',
+    olivedrab: '#6b8e23',
+    orange: '#ffa500',
+    orangered: '#ff4500',
+    orchid: '#da70d6',
+    palegoldenrod: '#eee8aa',
+    palegreen: '#98fb98',
+    paleturquoise: '#afeeee',
+    palevioletred: '#db7093',
+    papayawhip: '#ffefd5',
+    peachpuff: '#ffdab9',
+    peru: '#cd853f',
+    pink: '#ffc0cb',
+    plum: '#dda0dd',
+    powderblue: '#b0e0e6',
+    purple: '#800080',
+    rebeccapurple: '#663399',
+    red: '#ff0000',
+    rosybrown: '#bc8f8f',
+    royalblue: '#4169e1',
+    saddlebrown: '#8b4513',
+    salmon: '#fa8072',
+    sandybrown: '#f4a460',
+    seagreen: '#2e8b57',
+    seashell: '#fff5ee',
+    sienna: '#a0522d',
+    silver: '#c0c0c0',
+    skyblue: '#87ceeb',
+    slateblue: '#6a5acd',
+    slategray: '#708090',
+    slategrey: '#708090',
+    snow: '#fffafa',
+    springgreen: '#00ff7f',
+    steelblue: '#4682b4',
+    tan: '#d2b48c',
+    teal: '#008080',
+    thistle: '#d8bfd8',
+    tomato: '#ff6347',
+    turquoise: '#40e0d0',
+    violet: '#ee82ee',
+    wheat: '#f5deb3',
+    white: '#ffffff',
+    whitesmoke: '#f5f5f5',
+    yellow: '#ffff00',
+    yellowgreen: '#9acd32',
+};

.output/server/node_modules/@ctrl/tinycolor/dist/format-input.js

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidCSSUnit = exports.stringInputToObject = exports.inputToRGB = void 0;
+/* eslint-disable @typescript-eslint/no-redundant-type-constituents */
+var conversion_js_1 = require("./conversion.js");
+var css_color_names_js_1 = require("./css-color-names.js");
+var util_js_1 = require("./util.js");
+/**
+ * Given a string or object, convert that input to RGB
+ *
+ * Possible string inputs:
+ * ```
+ * "red"
+ * "#f00" or "f00"
+ * "#ff0000" or "ff0000"
+ * "#ff000000" or "ff000000"
+ * "rgb 255 0 0" or "rgb (255, 0, 0)"
+ * "rgb 1.0 0 0" or "rgb (1, 0, 0)"
+ * "rgba (255, 0, 0, 1)" or "rgba 255, 0, 0, 1"
+ * "rgba (1.0, 0, 0, 1)" or "rgba 1.0, 0, 0, 1"
+ * "hsl(0, 100%, 50%)" or "hsl 0 100% 50%"
+ * "hsla(0, 100%, 50%, 1)" or "hsla 0 100% 50%, 1"
+ * "hsv(0, 100%, 100%)" or "hsv 0 100% 100%"
+ * ```
+ */
+function inputToRGB(color) {
+    var rgb = { r: 0, g: 0, b: 0 };
+    var a = 1;
+    var s = null;
+    var v = null;
+    var l = null;
+    var ok = false;
+    var format = false;
+    if (typeof color === 'string') {
+        color = stringInputToObject(color);
+    }
+    if (typeof color === 'object') {
+        if (isValidCSSUnit(color.r) && isValidCSSUnit(color.g) && isValidCSSUnit(color.b)) {
+            rgb = (0, conversion_js_1.rgbToRgb)(color.r, color.g, color.b);
+            ok = true;
+            format = String(color.r).substr(-1) === '%' ? 'prgb' : 'rgb';
+        }
+        else if (isValidCSSUnit(color.h) && isValidCSSUnit(color.s) && isValidCSSUnit(color.v)) {
+            s = (0, util_js_1.convertToPercentage)(color.s);
+            v = (0, util_js_1.convertToPercentage)(color.v);
+            rgb = (0, conversion_js_1.hsvToRgb)(color.h, s, v);
+            ok = true;
+            format = 'hsv';
+        }
+        else if (isValidCSSUnit(color.h) && isValidCSSUnit(color.s) && isValidCSSUnit(color.l)) {
+            s = (0, util_js_1.convertToPercentage)(color.s);
+            l = (0, util_js_1.convertToPercentage)(color.l);
+            rgb = (0, conversion_js_1.hslToRgb)(color.h, s, l);
+            ok = true;
+            format = 'hsl';
+        }
+        if (Object.prototype.hasOwnProperty.call(color, 'a')) {
+            a = color.a;
+        }
+    }
+    a = (0, util_js_1.boundAlpha)(a);
+    return {
+        ok: ok,
+        format: color.format || format,
+        r: Math.min(255, Math.max(rgb.r, 0)),
+        g: Math.min(255, Math.max(rgb.g, 0)),
+        b: Math.min(255, Math.max(rgb.b, 0)),
+        a: a,
+    };
+}
+exports.inputToRGB = inputToRGB;
+// <http://www.w3.org/TR/css3-values/#integers>
+var CSS_INTEGER = '[-\\+]?\\d+%?';
+// <http://www.w3.org/TR/css3-values/#number-value>
+var CSS_NUMBER = '[-\\+]?\\d*\\.\\d+%?';
+// Allow positive/negative integer/number.  Don't capture the either/or, just the entire outcome.
+var CSS_UNIT = "(?:".concat(CSS_NUMBER, ")|(?:").concat(CSS_INTEGER, ")");
+// Actual matching.
+// Parentheses and commas are optional, but not required.
+// Whitespace can take the place of commas or opening paren
+var PERMISSIVE_MATCH3 = "[\\s|\\(]+(".concat(CSS_UNIT, ")[,|\\s]+(").concat(CSS_UNIT, ")[,|\\s]+(").concat(CSS_UNIT, ")\\s*\\)?");
+var PERMISSIVE_MATCH4 = "[\\s|\\(]+(".concat(CSS_UNIT, ")[,|\\s]+(").concat(CSS_UNIT, ")[,|\\s]+(").concat(CSS_UNIT, ")[,|\\s]+(").concat(CSS_UNIT, ")\\s*\\)?");
+var matchers = {
+    CSS_UNIT: new RegExp(CSS_UNIT),
+    rgb: new RegExp('rgb' + PERMISSIVE_MATCH3),
+    rgba: new RegExp('rgba' + PERMISSIVE_MATCH4),
+    hsl: new RegExp('hsl' + PERMISSIVE_MATCH3),
+    hsla: new RegExp('hsla' + PERMISSIVE_MATCH4),
+    hsv: new RegExp('hsv' + PERMISSIVE_MATCH3),
+    hsva: new RegExp('hsva' + PERMISSIVE_MATCH4),
+    hex3: /^#?([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,
+    hex6: /^#?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/,
+    hex4: /^#?([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,
+    hex8: /^#?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/,
+};
+/**
+ * Permissive string parsing.  Take in a number of formats, and output an object
+ * based on detected format.  Returns `{ r, g, b }` or `{ h, s, l }` or `{ h, s, v}`
+ */
+function stringInputToObject(color) {
+    color = color.trim().toLowerCase();
+    if (color.length === 0) {
+        return false;
+    }
+    var named = false;
+    if (css_color_names_js_1.names[color]) {
+        color = css_color_names_js_1.names[color];
+        named = true;
+    }
+    else if (color === 'transparent') {
+        return { r: 0, g: 0, b: 0, a: 0, format: 'name' };
+    }
+    // Try to match string input using regular expressions.
+    // Keep most of the number bounding out of this function - don't worry about [0,1] or [0,100] or [0,360]
+    // Just return an object and let the conversion functions handle that.
+    // This way the result will be the same whether the tinycolor is initialized with string or object.
+    var match = matchers.rgb.exec(color);
+    if (match) {
+        return { r: match[1], g: match[2], b: match[3] };
+    }
+    match = matchers.rgba.exec(color);
+    if (match) {
+        return { r: match[1], g: match[2], b: match[3], a: match[4] };
+    }
+    match = matchers.hsl.exec(color);
+    if (match) {
+        return { h: match[1], s: match[2], l: match[3] };
+    }
+    match = matchers.hsla.exec(color);
+    if (match) {
+        return { h: match[1], s: match[2], l: match[3], a: match[4] };
+    }
+    match = matchers.hsv.exec(color);
+    if (match) {
+        return { h: match[1], s: match[2], v: match[3] };
+    }
+    match = matchers.hsva.exec(color);
+    if (match) {
+        return { h: match[1], s: match[2], v: match[3], a: match[4] };
+    }
+    match = matchers.hex8.exec(color);
+    if (match) {
+        return {
+            r: (0, conversion_js_1.parseIntFromHex)(match[1]),
+            g: (0, conversion_js_1.parseIntFromHex)(match[2]),
+            b: (0, conversion_js_1.parseIntFromHex)(match[3]),
+            a: (0, conversion_js_1.convertHexToDecimal)(match[4]),
+            format: named ? 'name' : 'hex8',
+        };
+    }
+    match = matchers.hex6.exec(color);
+    if (match) {
+        return {
+            r: (0, conversion_js_1.parseIntFromHex)(match[1]),
+            g: (0, conversion_js_1.parseIntFromHex)(match[2]),
+            b: (0, conversion_js_1.parseIntFromHex)(match[3]),
+            format: named ? 'name' : 'hex',
+        };
+    }
+    match = matchers.hex4.exec(color);
+    if (match) {
+        return {
+            r: (0, conversion_js_1.parseIntFromHex)(match[1] + match[1]),
+            g: (0, conversion_js_1.parseIntFromHex)(match[2] + match[2]),
+            b: (0, conversion_js_1.parseIntFromHex)(match[3] + match[3]),
+            a: (0, conversion_js_1.convertHexToDecimal)(match[4] + match[4]),
+            format: named ? 'name' : 'hex8',
+        };
+    }
+    match = matchers.hex3.exec(color);
+    if (match) {
+        return {
+            r: (0, conversion_js_1.parseIntFromHex)(match[1] + match[1]),
+            g: (0, conversion_js_1.parseIntFromHex)(match[2] + match[2]),
+            b: (0, conversion_js_1.parseIntFromHex)(match[3] + match[3]),
+            format: named ? 'name' : 'hex',
+        };
+    }
+    return false;
+}
+exports.stringInputToObject = stringInputToObject;
+/**
+ * Check to see if it looks like a CSS unit
+ * (see `matchers` above for definition).
+ */
+function isValidCSSUnit(color) {
+    return Boolean(matchers.CSS_UNIT.exec(String(color)));
+}
+exports.isValidCSSUnit = isValidCSSUnit;

.output/server/node_modules/@ctrl/tinycolor/dist/from-ratio.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.legacyRandom = exports.fromRatio = void 0;
+var index_js_1 = require("./index.js");
+var util_js_1 = require("./util.js");
+/**
+ * If input is an object, force 1 into "1.0" to handle ratios properly
+ * String input requires "1.0" as input, so 1 will be treated as 1
+ */
+function fromRatio(ratio, opts) {
+    var newColor = {
+        r: (0, util_js_1.convertToPercentage)(ratio.r),
+        g: (0, util_js_1.convertToPercentage)(ratio.g),
+        b: (0, util_js_1.convertToPercentage)(ratio.b),
+    };
+    if (ratio.a !== undefined) {
+        newColor.a = Number(ratio.a);
+    }
+    return new index_js_1.TinyColor(newColor, opts);
+}
+exports.fromRatio = fromRatio;
+/** old random function */
+function legacyRandom() {
+    return new index_js_1.TinyColor({
+        r: Math.random(),
+        g: Math.random(),
+        b: Math.random(),
+    });
+}
+exports.legacyRandom = legacyRandom;

.output/server/node_modules/@ctrl/tinycolor/dist/index.js

@@ -0,0 +1,512 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tinycolor = exports.TinyColor = void 0;
+var conversion_js_1 = require("./conversion.js");
+var css_color_names_js_1 = require("./css-color-names.js");
+var format_input_1 = require("./format-input");
+var util_js_1 = require("./util.js");
+var TinyColor = /** @class */ (function () {
+    function TinyColor(color, opts) {
+        if (color === void 0) { color = ''; }
+        if (opts === void 0) { opts = {}; }
+        var _a;
+        // If input is already a tinycolor, return itself
+        if (color instanceof TinyColor) {
+            // eslint-disable-next-line no-constructor-return
+            return color;
+        }
+        if (typeof color === 'number') {
+            color = (0, conversion_js_1.numberInputToObject)(color);
+        }
+        this.originalInput = color;
+        var rgb = (0, format_input_1.inputToRGB)(color);
+        this.originalInput = color;
+        this.r = rgb.r;
+        this.g = rgb.g;
+        this.b = rgb.b;
+        this.a = rgb.a;
+        this.roundA = Math.round(100 * this.a) / 100;
+        this.format = (_a = opts.format) !== null && _a !== void 0 ? _a : rgb.format;
+        this.gradientType = opts.gradientType;
+        // Don't let the range of [0,255] come back in [0,1].
+        // Potentially lose a little bit of precision here, but will fix issues where
+        // .5 gets interpreted as half of the total, instead of half of 1
+        // If it was supposed to be 128, this was already taken care of by `inputToRgb`
+        if (this.r < 1) {
+            this.r = Math.round(this.r);
+        }
+        if (this.g < 1) {
+            this.g = Math.round(this.g);
+        }
+        if (this.b < 1) {
+            this.b = Math.round(this.b);
+        }
+        this.isValid = rgb.ok;
+    }
+    TinyColor.prototype.isDark = function () {
+        return this.getBrightness() < 128;
+    };
+    TinyColor.prototype.isLight = function () {
+        return !this.isDark();
+    };
+    /**
+     * Returns the perceived brightness of the color, from 0-255.
+     */
+    TinyColor.prototype.getBrightness = function () {
+        // http://www.w3.org/TR/AERT#color-contrast
+        var rgb = this.toRgb();
+        return (rgb.r * 299 + rgb.g * 587 + rgb.b * 114) / 1000;
+    };
+    /**
+     * Returns the perceived luminance of a color, from 0-1.
+     */
+    TinyColor.prototype.getLuminance = function () {
+        // http://www.w3.org/TR/2008/REC-WCAG20-20081211/#relativeluminancedef
+        var rgb = this.toRgb();
+        var R;
+        var G;
+        var B;
+        var RsRGB = rgb.r / 255;
+        var GsRGB = rgb.g / 255;
+        var BsRGB = rgb.b / 255;
+        if (RsRGB <= 0.03928) {
+            R = RsRGB / 12.92;
+        }
+        else {
+            // eslint-disable-next-line prefer-exponentiation-operator
+            R = Math.pow((RsRGB + 0.055) / 1.055, 2.4);
+        }
+        if (GsRGB <= 0.03928) {
+            G = GsRGB / 12.92;
+        }
+        else {
+            // eslint-disable-next-line prefer-exponentiation-operator
+            G = Math.pow((GsRGB + 0.055) / 1.055, 2.4);
+        }
+        if (BsRGB <= 0.03928) {
+            B = BsRGB / 12.92;
+        }
+        else {
+            // eslint-disable-next-line prefer-exponentiation-operator
+            B = Math.pow((BsRGB + 0.055) / 1.055, 2.4);
+        }
+        return 0.2126 * R + 0.7152 * G + 0.0722 * B;
+    };
+    /**
+     * Returns the alpha value of a color, from 0-1.
+     */
+    TinyColor.prototype.getAlpha = function () {
+        return this.a;
+    };
+    /**
+     * Sets the alpha value on the current color.
+     *
+     * @param alpha - The new alpha value. The accepted range is 0-1.
+     */
+    TinyColor.prototype.setAlpha = function (alpha) {
+        this.a = (0, util_js_1.boundAlpha)(alpha);
+        this.roundA = Math.round(100 * this.a) / 100;
+        return this;
+    };
+    /**
+     * Returns whether the color is monochrome.
+     */
+    TinyColor.prototype.isMonochrome = function () {
+        var s = this.toHsl().s;
+        return s === 0;
+    };
+    /**
+     * Returns the object as a HSVA object.
+     */
+    TinyColor.prototype.toHsv = function () {
+        var hsv = (0, conversion_js_1.rgbToHsv)(this.r, this.g, this.b);
+        return { h: hsv.h * 360, s: hsv.s, v: hsv.v, a: this.a };
+    };
+    /**
+     * Returns the hsva values interpolated into a string with the following format:
+     * "hsva(xxx, xxx, xxx, xx)".
+     */
+    TinyColor.prototype.toHsvString = function () {
+        var hsv = (0, conversion_js_1.rgbToHsv)(this.r, this.g, this.b);
+        var h = Math.round(hsv.h * 360);
+        var s = Math.round(hsv.s * 100);
+        var v = Math.round(hsv.v * 100);
+        return this.a === 1 ? "hsv(".concat(h, ", ").concat(s, "%, ").concat(v, "%)") : "hsva(".concat(h, ", ").concat(s, "%, ").concat(v, "%, ").concat(this.roundA, ")");
+    };
+    /**
+     * Returns the object as a HSLA object.
+     */
+    TinyColor.prototype.toHsl = function () {
+        var hsl = (0, conversion_js_1.rgbToHsl)(this.r, this.g, this.b);
+        return { h: hsl.h * 360, s: hsl.s, l: hsl.l, a: this.a };
+    };
+    /**
+     * Returns the hsla values interpolated into a string with the following format:
+     * "hsla(xxx, xxx, xxx, xx)".
+     */
+    TinyColor.prototype.toHslString = function () {
+        var hsl = (0, conversion_js_1.rgbToHsl)(this.r, this.g, this.b);
+        var h = Math.round(hsl.h * 360);
+        var s = Math.round(hsl.s * 100);
+        var l = Math.round(hsl.l * 100);
+        return this.a === 1 ? "hsl(".concat(h, ", ").concat(s, "%, ").concat(l, "%)") : "hsla(".concat(h, ", ").concat(s, "%, ").concat(l, "%, ").concat(this.roundA, ")");
+    };
+    /**
+     * Returns the hex value of the color.
+     * @param allow3Char will shorten hex value to 3 char if possible
+     */
+    TinyColor.prototype.toHex = function (allow3Char) {
+        if (allow3Char === void 0) { allow3Char = false; }
+        return (0, conversion_js_1.rgbToHex)(this.r, this.g, this.b, allow3Char);
+    };
+    /**
+     * Returns the hex value of the color -with a # prefixed.
+     * @param allow3Char will shorten hex value to 3 char if possible
+     */
+    TinyColor.prototype.toHexString = function (allow3Char) {
+        if (allow3Char === void 0) { allow3Char = false; }
+        return '#' + this.toHex(allow3Char);
+    };
+    /**
+     * Returns the hex 8 value of the color.
+     * @param allow4Char will shorten hex value to 4 char if possible
+     */
+    TinyColor.prototype.toHex8 = function (allow4Char) {
+        if (allow4Char === void 0) { allow4Char = false; }
+        return (0, conversion_js_1.rgbaToHex)(this.r, this.g, this.b, this.a, allow4Char);
+    };
+    /**
+     * Returns the hex 8 value of the color -with a # prefixed.
+     * @param allow4Char will shorten hex value to 4 char if possible
+     */
+    TinyColor.prototype.toHex8String = function (allow4Char) {
+        if (allow4Char === void 0) { allow4Char = false; }
+        return '#' + this.toHex8(allow4Char);
+    };
+    /**
+     * Returns the shorter hex value of the color depends on its alpha -with a # prefixed.
+     * @param allowShortChar will shorten hex value to 3 or 4 char if possible
+     */
+    TinyColor.prototype.toHexShortString = function (allowShortChar) {
+        if (allowShortChar === void 0) { allowShortChar = false; }
+        return this.a === 1 ? this.toHexString(allowShortChar) : this.toHex8String(allowShortChar);
+    };
+    /**
+     * Returns the object as a RGBA object.
+     */
+    TinyColor.prototype.toRgb = function () {
+        return {
+            r: Math.round(this.r),
+            g: Math.round(this.g),
+            b: Math.round(this.b),
+            a: this.a,
+        };
+    };
+    /**
+     * Returns the RGBA values interpolated into a string with the following format:
+     * "RGBA(xxx, xxx, xxx, xx)".
+     */
+    TinyColor.prototype.toRgbString = function () {
+        var r = Math.round(this.r);
+        var g = Math.round(this.g);
+        var b = Math.round(this.b);
+        return this.a === 1 ? "rgb(".concat(r, ", ").concat(g, ", ").concat(b, ")") : "rgba(".concat(r, ", ").concat(g, ", ").concat(b, ", ").concat(this.roundA, ")");
+    };
+    /**
+     * Returns the object as a RGBA object.
+     */
+    TinyColor.prototype.toPercentageRgb = function () {
+        var fmt = function (x) { return "".concat(Math.round((0, util_js_1.bound01)(x, 255) * 100), "%"); };
+        return {
+            r: fmt(this.r),
+            g: fmt(this.g),
+            b: fmt(this.b),
+            a: this.a,
+        };
+    };
+    /**
+     * Returns the RGBA relative values interpolated into a string
+     */
+    TinyColor.prototype.toPercentageRgbString = function () {
+        var rnd = function (x) { return Math.round((0, util_js_1.bound01)(x, 255) * 100); };
+        return this.a === 1
+            ? "rgb(".concat(rnd(this.r), "%, ").concat(rnd(this.g), "%, ").concat(rnd(this.b), "%)")
+            : "rgba(".concat(rnd(this.r), "%, ").concat(rnd(this.g), "%, ").concat(rnd(this.b), "%, ").concat(this.roundA, ")");
+    };
+    /**
+     * The 'real' name of the color -if there is one.
+     */
+    TinyColor.prototype.toName = function () {
+        if (this.a === 0) {
+            return 'transparent';
+        }
+        if (this.a < 1) {
+            return false;
+        }
+        var hex = '#' + (0, conversion_js_1.rgbToHex)(this.r, this.g, this.b, false);
+        for (var _i = 0, _a = Object.entries(css_color_names_js_1.names); _i < _a.length; _i++) {
+            var _b = _a[_i], key = _b[0], value = _b[1];
+            if (hex === value) {
+                return key;
+            }
+        }
+        return false;
+    };
+    TinyColor.prototype.toString = function (format) {
+        var formatSet = Boolean(format);
+        format = format !== null && format !== void 0 ? format : this.format;
+        var formattedString = false;
+        var hasAlpha = this.a < 1 && this.a >= 0;
+        var needsAlphaFormat = !formatSet && hasAlpha && (format.startsWith('hex') || format === 'name');
+        if (needsAlphaFormat) {
+            // Special case for "transparent", all other non-alpha formats
+            // will return rgba when there is transparency.
+            if (format === 'name' && this.a === 0) {
+                return this.toName();
+            }
+            return this.toRgbString();
+        }
+        if (format === 'rgb') {
+            formattedString = this.toRgbString();
+        }
+        if (format === 'prgb') {
+            formattedString = this.toPercentageRgbString();
+        }
+        if (format === 'hex' || format === 'hex6') {
+            formattedString = this.toHexString();
+        }
+        if (format === 'hex3') {
+            formattedString = this.toHexString(true);
+        }
+        if (format === 'hex4') {
+            formattedString = this.toHex8String(true);
+        }
+        if (format === 'hex8') {
+            formattedString = this.toHex8String();
+        }
+        if (format === 'name') {
+            formattedString = this.toName();
+        }
+        if (format === 'hsl') {
+            formattedString = this.toHslString();
+        }
+        if (format === 'hsv') {
+            formattedString = this.toHsvString();
+        }
+        return formattedString || this.toHexString();
+    };
+    TinyColor.prototype.toNumber = function () {
+        return (Math.round(this.r) << 16) + (Math.round(this.g) << 8) + Math.round(this.b);
+    };
+    TinyColor.prototype.clone = function () {
+        return new TinyColor(this.toString());
+    };
+    /**
+     * Lighten the color a given amount. Providing 100 will always return white.
+     * @param amount - valid between 1-100
+     */
+    TinyColor.prototype.lighten = function (amount) {
+        if (amount === void 0) { amount = 10; }
+        var hsl = this.toHsl();
+        hsl.l += amount / 100;
+        hsl.l = (0, util_js_1.clamp01)(hsl.l);
+        return new TinyColor(hsl);
+    };
+    /**
+     * Brighten the color a given amount, from 0 to 100.
+     * @param amount - valid between 1-100
+     */
+    TinyColor.prototype.brighten = function (amount) {
+        if (amount === void 0) { amount = 10; }
+        var rgb = this.toRgb();
+        rgb.r = Math.max(0, Math.min(255, rgb.r - Math.round(255 * -(amount / 100))));
+        rgb.g = Math.max(0, Math.min(255, rgb.g - Math.round(255 * -(amount / 100))));
+        rgb.b = Math.max(0, Math.min(255, rgb.b - Math.round(255 * -(amount / 100))));
+        return new TinyColor(rgb);
+    };
+    /**
+     * Darken the color a given amount, from 0 to 100.
+     * Providing 100 will always return black.
+     * @param amount - valid between 1-100
+     */
+    TinyColor.prototype.darken = function (amount) {
+        if (amount === void 0) { amount = 10; }
+        var hsl = this.toHsl();
+        hsl.l -= amount / 100;
+        hsl.l = (0, util_js_1.clamp01)(hsl.l);
+        return new TinyColor(hsl);
+    };
+    /**
+     * Mix the color with pure white, from 0 to 100.
+     * Providing 0 will do nothing, providing 100 will always return white.
+     * @param amount - valid between 1-100
+     */
+    TinyColor.prototype.tint = function (amount) {
+        if (amount === void 0) { amount = 10; }
+        return this.mix('white', amount);
+    };
+    /**
+     * Mix the color with pure black, from 0 to 100.
+     * Providing 0 will do nothing, providing 100 will always return black.
+     * @param amount - valid between 1-100
+     */
+    TinyColor.prototype.shade = function (amount) {
+        if (amount === void 0) { amount = 10; }
+        return this.mix('black', amount);
+    };
+    /**
+     * Desaturate the color a given amount, from 0 to 100.
+     * Providing 100 will is the same as calling greyscale
+     * @param amount - valid between 1-100
+     */
+    TinyColor.prototype.desaturate = function (amount) {
+        if (amount === void 0) { amount = 10; }
+        var hsl = this.toHsl();
+        hsl.s -= amount / 100;
+        hsl.s = (0, util_js_1.clamp01)(hsl.s);
+        return new TinyColor(hsl);
+    };
+    /**
+     * Saturate the color a given amount, from 0 to 100.
+     * @param amount - valid between 1-100
+     */
+    TinyColor.prototype.saturate = function (amount) {
+        if (amount === void 0) { amount = 10; }
+        var hsl = this.toHsl();
+        hsl.s += amount / 100;
+        hsl.s = (0, util_js_1.clamp01)(hsl.s);
+        return new TinyColor(hsl);
+    };
+    /**
+     * Completely desaturates a color into greyscale.
+     * Same as calling `desaturate(100)`
+     */
+    TinyColor.prototype.greyscale = function () {
+        return this.desaturate(100);
+    };
+    /**
+     * Spin takes a positive or negative amount within [-360, 360] indicating the change of hue.
+     * Values outside of this range will be wrapped into this range.
+     */
+    TinyColor.prototype.spin = function (amount) {
+        var hsl = this.toHsl();
+        var hue = (hsl.h + amount) % 360;
+        hsl.h = hue < 0 ? 360 + hue : hue;
+        return new TinyColor(hsl);
+    };
+    /**
+     * Mix the current color a given amount with another color, from 0 to 100.
+     * 0 means no mixing (return current color).
+     */
+    TinyColor.prototype.mix = function (color, amount) {
+        if (amount === void 0) { amount = 50; }
+        var rgb1 = this.toRgb();
+        var rgb2 = new TinyColor(color).toRgb();
+        var p = amount / 100;
+        var rgba = {
+            r: (rgb2.r - rgb1.r) * p + rgb1.r,
+            g: (rgb2.g - rgb1.g) * p + rgb1.g,
+            b: (rgb2.b - rgb1.b) * p + rgb1.b,
+            a: (rgb2.a - rgb1.a) * p + rgb1.a,
+        };
+        return new TinyColor(rgba);
+    };
+    TinyColor.prototype.analogous = function (results, slices) {
+        if (results === void 0) { results = 6; }
+        if (slices === void 0) { slices = 30; }
+        var hsl = this.toHsl();
+        var part = 360 / slices;
+        var ret = [this];
+        for (hsl.h = (hsl.h - ((part * results) >> 1) + 720) % 360; --results;) {
+            hsl.h = (hsl.h + part) % 360;
+            ret.push(new TinyColor(hsl));
+        }
+        return ret;
+    };
+    /**
+     * taken from https://github.com/infusion/jQuery-xcolor/blob/master/jquery.xcolor.js
+     */
+    TinyColor.prototype.complement = function () {
+        var hsl = this.toHsl();
+        hsl.h = (hsl.h + 180) % 360;
+        return new TinyColor(hsl);
+    };
+    TinyColor.prototype.monochromatic = function (results) {
+        if (results === void 0) { results = 6; }
+        var hsv = this.toHsv();
+        var h = hsv.h;
+        var s = hsv.s;
+        var v = hsv.v;
+        var res = [];
+        var modification = 1 / results;
+        while (results--) {
+            res.push(new TinyColor({ h: h, s: s, v: v }));
+            v = (v + modification) % 1;
+        }
+        return res;
+    };
+    TinyColor.prototype.splitcomplement = function () {
+        var hsl = this.toHsl();
+        var h = hsl.h;
+        return [
+            this,
+            new TinyColor({ h: (h + 72) % 360, s: hsl.s, l: hsl.l }),
+            new TinyColor({ h: (h + 216) % 360, s: hsl.s, l: hsl.l }),
+        ];
+    };
+    /**
+     * Compute how the color would appear on a background
+     */
+    TinyColor.prototype.onBackground = function (background) {
+        var fg = this.toRgb();
+        var bg = new TinyColor(background).toRgb();
+        var alpha = fg.a + bg.a * (1 - fg.a);
+        return new TinyColor({
+            r: (fg.r * fg.a + bg.r * bg.a * (1 - fg.a)) / alpha,
+            g: (fg.g * fg.a + bg.g * bg.a * (1 - fg.a)) / alpha,
+            b: (fg.b * fg.a + bg.b * bg.a * (1 - fg.a)) / alpha,
+            a: alpha,
+        });
+    };
+    /**
+     * Alias for `polyad(3)`
+     */
+    TinyColor.prototype.triad = function () {
+        return this.polyad(3);
+    };
+    /**
+     * Alias for `polyad(4)`
+     */
+    TinyColor.prototype.tetrad = function () {
+        return this.polyad(4);
+    };
+    /**
+     * Get polyad colors, like (for 1, 2, 3, 4, 5, 6, 7, 8, etc...)
+     * monad, dyad, triad, tetrad, pentad, hexad, heptad, octad, etc...
+     */
+    TinyColor.prototype.polyad = function (n) {
+        var hsl = this.toHsl();
+        var h = hsl.h;
+        var result = [this];
+        var increment = 360 / n;
+        for (var i = 1; i < n; i++) {
+            result.push(new TinyColor({ h: (h + i * increment) % 360, s: hsl.s, l: hsl.l }));
+        }
+        return result;
+    };
+    /**
+     * compare color vs current color
+     */
+    TinyColor.prototype.equals = function (color) {
+        return this.toRgbString() === new TinyColor(color).toRgbString();
+    };
+    return TinyColor;
+}());
+exports.TinyColor = TinyColor;
+// kept for backwards compatability with v1
+function tinycolor(color, opts) {
+    if (color === void 0) { color = ''; }
+    if (opts === void 0) { opts = {}; }
+    return new TinyColor(color, opts);
+}
+exports.tinycolor = tinycolor;

.output/server/node_modules/@ctrl/tinycolor/dist/interfaces.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

.output/server/node_modules/@ctrl/tinycolor/dist/public_api.js

@@ -0,0 +1,28 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var index_js_1 = require("./index.js");
+__exportStar(require("./index.js"), exports);
+__exportStar(require("./css-color-names.js"), exports);
+__exportStar(require("./readability.js"), exports);
+__exportStar(require("./to-ms-filter.js"), exports);
+__exportStar(require("./from-ratio.js"), exports);
+__exportStar(require("./format-input.js"), exports);
+__exportStar(require("./random.js"), exports);
+__exportStar(require("./interfaces.js"), exports);
+__exportStar(require("./conversion.js"), exports);
+// kept for backwards compatability with v1
+exports.default = index_js_1.tinycolor;

.output/server/node_modules/@ctrl/tinycolor/dist/random.js

@@ -0,0 +1,282 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bounds = exports.random = void 0;
+/* eslint-disable @typescript-eslint/no-redundant-type-constituents */
+// randomColor by David Merfield under the CC0 license
+// https://github.com/davidmerfield/randomColor/
+var index_js_1 = require("./index.js");
+function random(options) {
+    if (options === void 0) { options = {}; }
+    // Check if we need to generate multiple colors
+    if (options.count !== undefined &&
+        options.count !== null) {
+        var totalColors = options.count;
+        var colors = [];
+        options.count = undefined;
+        while (totalColors > colors.length) {
+            // Since we're generating multiple colors,
+            // incremement the seed. Otherwise we'd just
+            // generate the same color each time...
+            options.count = null;
+            if (options.seed) {
+                options.seed += 1;
+            }
+            colors.push(random(options));
+        }
+        options.count = totalColors;
+        return colors;
+    }
+    // First we pick a hue (H)
+    var h = pickHue(options.hue, options.seed);
+    // Then use H to determine saturation (S)
+    var s = pickSaturation(h, options);
+    // Then use S and H to determine brightness (B).
+    var v = pickBrightness(h, s, options);
+    var res = { h: h, s: s, v: v };
+    if (options.alpha !== undefined) {
+        res.a = options.alpha;
+    }
+    // Then we return the HSB color in the desired format
+    return new index_js_1.TinyColor(res);
+}
+exports.random = random;
+function pickHue(hue, seed) {
+    var hueRange = getHueRange(hue);
+    var res = randomWithin(hueRange, seed);
+    // Instead of storing red as two seperate ranges,
+    // we group them, using negative numbers
+    if (res < 0) {
+        res = 360 + res;
+    }
+    return res;
+}
+function pickSaturation(hue, options) {
+    if (options.hue === 'monochrome') {
+        return 0;
+    }
+    if (options.luminosity === 'random') {
+        return randomWithin([0, 100], options.seed);
+    }
+    var saturationRange = getColorInfo(hue).saturationRange;
+    var sMin = saturationRange[0];
+    var sMax = saturationRange[1];
+    switch (options.luminosity) {
+        case 'bright':
+            sMin = 55;
+            break;
+        case 'dark':
+            sMin = sMax - 10;
+            break;
+        case 'light':
+            sMax = 55;
+            break;
+        default:
+            break;
+    }
+    return randomWithin([sMin, sMax], options.seed);
+}
+function pickBrightness(H, S, options) {
+    var bMin = getMinimumBrightness(H, S);
+    var bMax = 100;
+    switch (options.luminosity) {
+        case 'dark':
+            bMax = bMin + 20;
+            break;
+        case 'light':
+            bMin = (bMax + bMin) / 2;
+            break;
+        case 'random':
+            bMin = 0;
+            bMax = 100;
+            break;
+        default:
+            break;
+    }
+    return randomWithin([bMin, bMax], options.seed);
+}
+function getMinimumBrightness(H, S) {
+    var lowerBounds = getColorInfo(H).lowerBounds;
+    for (var i = 0; i < lowerBounds.length - 1; i++) {
+        var s1 = lowerBounds[i][0];
+        var v1 = lowerBounds[i][1];
+        var s2 = lowerBounds[i + 1][0];
+        var v2 = lowerBounds[i + 1][1];
+        if (S >= s1 && S <= s2) {
+            var m = (v2 - v1) / (s2 - s1);
+            var b = v1 - m * s1;
+            return m * S + b;
+        }
+    }
+    return 0;
+}
+function getHueRange(colorInput) {
+    var num = parseInt(colorInput, 10);
+    if (!Number.isNaN(num) && num < 360 && num > 0) {
+        return [num, num];
+    }
+    if (typeof colorInput === 'string') {
+        var namedColor = exports.bounds.find(function (n) { return n.name === colorInput; });
+        if (namedColor) {
+            var color = defineColor(namedColor);
+            if (color.hueRange) {
+                return color.hueRange;
+            }
+        }
+        var parsed = new index_js_1.TinyColor(colorInput);
+        if (parsed.isValid) {
+            var hue = parsed.toHsv().h;
+            return [hue, hue];
+        }
+    }
+    return [0, 360];
+}
+function getColorInfo(hue) {
+    // Maps red colors to make picking hue easier
+    if (hue >= 334 && hue <= 360) {
+        hue -= 360;
+    }
+    for (var _i = 0, bounds_1 = exports.bounds; _i < bounds_1.length; _i++) {
+        var bound = bounds_1[_i];
+        var color = defineColor(bound);
+        if (color.hueRange && hue >= color.hueRange[0] && hue <= color.hueRange[1]) {
+            return color;
+        }
+    }
+    throw Error('Color not found');
+}
+function randomWithin(range, seed) {
+    if (seed === undefined) {
+        return Math.floor(range[0] + Math.random() * (range[1] + 1 - range[0]));
+    }
+    // Seeded random algorithm from http://indiegamr.com/generate-repeatable-random-numbers-in-js/
+    var max = range[1] || 1;
+    var min = range[0] || 0;
+    seed = (seed * 9301 + 49297) % 233280;
+    var rnd = seed / 233280.0;
+    return Math.floor(min + rnd * (max - min));
+}
+function defineColor(bound) {
+    var sMin = bound.lowerBounds[0][0];
+    var sMax = bound.lowerBounds[bound.lowerBounds.length - 1][0];
+    var bMin = bound.lowerBounds[bound.lowerBounds.length - 1][1];
+    var bMax = bound.lowerBounds[0][1];
+    return {
+        name: bound.name,
+        hueRange: bound.hueRange,
+        lowerBounds: bound.lowerBounds,
+        saturationRange: [sMin, sMax],
+        brightnessRange: [bMin, bMax],
+    };
+}
+/**
+ * @hidden
+ */
+exports.bounds = [
+    {
+        name: 'monochrome',
+        hueRange: null,
+        lowerBounds: [
+            [0, 0],
+            [100, 0],
+        ],
+    },
+    {
+        name: 'red',
+        hueRange: [-26, 18],
+        lowerBounds: [
+            [20, 100],
+            [30, 92],
+            [40, 89],
+            [50, 85],
+            [60, 78],
+            [70, 70],
+            [80, 60],
+            [90, 55],
+            [100, 50],
+        ],
+    },
+    {
+        name: 'orange',
+        hueRange: [19, 46],
+        lowerBounds: [
+            [20, 100],
+            [30, 93],
+            [40, 88],
+            [50, 86],
+            [60, 85],
+            [70, 70],
+            [100, 70],
+        ],
+    },
+    {
+        name: 'yellow',
+        hueRange: [47, 62],
+        lowerBounds: [
+            [25, 100],
+            [40, 94],
+            [50, 89],
+            [60, 86],
+            [70, 84],
+            [80, 82],
+            [90, 80],
+            [100, 75],
+        ],
+    },
+    {
+        name: 'green',
+        hueRange: [63, 178],
+        lowerBounds: [
+            [30, 100],
+            [40, 90],
+            [50, 85],
+            [60, 81],
+            [70, 74],
+            [80, 64],
+            [90, 50],
+            [100, 40],
+        ],
+    },
+    {
+        name: 'blue',
+        hueRange: [179, 257],
+        lowerBounds: [
+            [20, 100],
+            [30, 86],
+            [40, 80],
+            [50, 74],
+            [60, 60],
+            [70, 52],
+            [80, 44],
+            [90, 39],
+            [100, 35],
+        ],
+    },
+    {
+        name: 'purple',
+        hueRange: [258, 282],
+        lowerBounds: [
+            [20, 100],
+            [30, 87],
+            [40, 79],
+            [50, 70],
+            [60, 65],
+            [70, 59],
+            [80, 52],
+            [90, 45],
+            [100, 42],
+        ],
+    },
+    {
+        name: 'pink',
+        hueRange: [283, 334],
+        lowerBounds: [
+            [20, 100],
+            [30, 90],
+            [40, 86],
+            [60, 84],
+            [80, 80],
+            [90, 75],
+            [100, 73],
+        ],
+    },
+];

.output/server/node_modules/@ctrl/tinycolor/dist/readability.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mostReadable = exports.isReadable = exports.readability = void 0;
+var index_js_1 = require("./index.js");
+// Readability Functions
+// ---------------------
+// <http://www.w3.org/TR/2008/REC-WCAG20-20081211/#contrast-ratiodef (WCAG Version 2)
+/**
+ * AKA `contrast`
+ *
+ * Analyze the 2 colors and returns the color contrast defined by (WCAG Version 2)
+ */
+function readability(color1, color2) {
+    var c1 = new index_js_1.TinyColor(color1);
+    var c2 = new index_js_1.TinyColor(color2);
+    return ((Math.max(c1.getLuminance(), c2.getLuminance()) + 0.05) /
+        (Math.min(c1.getLuminance(), c2.getLuminance()) + 0.05));
+}
+exports.readability = readability;
+/**
+ * Ensure that foreground and background color combinations meet WCAG2 guidelines.
+ * The third argument is an object.
+ *      the 'level' property states 'AA' or 'AAA' - if missing or invalid, it defaults to 'AA';
+ *      the 'size' property states 'large' or 'small' - if missing or invalid, it defaults to 'small'.
+ * If the entire object is absent, isReadable defaults to {level:"AA",size:"small"}.
+ *
+ * Example
+ * ```ts
+ * new TinyColor().isReadable('#000', '#111') => false
+ * new TinyColor().isReadable('#000', '#111', { level: 'AA', size: 'large' }) => false
+ * ```
+ */
+function isReadable(color1, color2, wcag2) {
+    var _a, _b;
+    if (wcag2 === void 0) { wcag2 = { level: 'AA', size: 'small' }; }
+    var readabilityLevel = readability(color1, color2);
+    switch (((_a = wcag2.level) !== null && _a !== void 0 ? _a : 'AA') + ((_b = wcag2.size) !== null && _b !== void 0 ? _b : 'small')) {
+        case 'AAsmall':
+        case 'AAAlarge':
+            return readabilityLevel >= 4.5;
+        case 'AAlarge':
+            return readabilityLevel >= 3;
+        case 'AAAsmall':
+            return readabilityLevel >= 7;
+        default:
+            return false;
+    }
+}
+exports.isReadable = isReadable;
+/**
+ * Given a base color and a list of possible foreground or background
+ * colors for that base, returns the most readable color.
+ * Optionally returns Black or White if the most readable color is unreadable.
+ *
+ * @param baseColor - the base color.
+ * @param colorList - array of colors to pick the most readable one from.
+ * @param args - and object with extra arguments
+ *
+ * Example
+ * ```ts
+ * new TinyColor().mostReadable('#123', ['#124", "#125'], { includeFallbackColors: false }).toHexString(); // "#112255"
+ * new TinyColor().mostReadable('#123', ['#124", "#125'],{ includeFallbackColors: true }).toHexString();  // "#ffffff"
+ * new TinyColor().mostReadable('#a8015a', ["#faf3f3"], { includeFallbackColors:true, level: 'AAA', size: 'large' }).toHexString(); // "#faf3f3"
+ * new TinyColor().mostReadable('#a8015a', ["#faf3f3"], { includeFallbackColors:true, level: 'AAA', size: 'small' }).toHexString(); // "#ffffff"
+ * ```
+ */
+function mostReadable(baseColor, colorList, args) {
+    if (args === void 0) { args = { includeFallbackColors: false, level: 'AA', size: 'small' }; }
+    var bestColor = null;
+    var bestScore = 0;
+    var includeFallbackColors = args.includeFallbackColors, level = args.level, size = args.size;
+    for (var _i = 0, colorList_1 = colorList; _i < colorList_1.length; _i++) {
+        var color = colorList_1[_i];
+        var score = readability(baseColor, color);
+        if (score > bestScore) {
+            bestScore = score;
+            bestColor = new index_js_1.TinyColor(color);
+        }
+    }
+    if (isReadable(baseColor, bestColor, { level: level, size: size }) || !includeFallbackColors) {
+        return bestColor;
+    }
+    args.includeFallbackColors = false;
+    return mostReadable(baseColor, ['#fff', '#000'], args);
+}
+exports.mostReadable = mostReadable;

.output/server/node_modules/@ctrl/tinycolor/dist/to-ms-filter.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toMsFilter = void 0;
+var conversion_js_1 = require("./conversion.js");
+var index_js_1 = require("./index.js");
+/**
+ * Returns the color represented as a Microsoft filter for use in old versions of IE.
+ */
+function toMsFilter(firstColor, secondColor) {
+    var color = new index_js_1.TinyColor(firstColor);
+    var hex8String = '#' + (0, conversion_js_1.rgbaToArgbHex)(color.r, color.g, color.b, color.a);
+    var secondHex8String = hex8String;
+    var gradientType = color.gradientType ? 'GradientType = 1, ' : '';
+    if (secondColor) {
+        var s = new index_js_1.TinyColor(secondColor);
+        secondHex8String = '#' + (0, conversion_js_1.rgbaToArgbHex)(s.r, s.g, s.b, s.a);
+    }
+    return "progid:DXImageTransform.Microsoft.gradient(".concat(gradientType, "startColorstr=").concat(hex8String, ",endColorstr=").concat(secondHex8String, ")");
+}
+exports.toMsFilter = toMsFilter;

.output/server/node_modules/@ctrl/tinycolor/dist/util.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pad2 = exports.convertToPercentage = exports.boundAlpha = exports.isPercentage = exports.isOnePointZero = exports.clamp01 = exports.bound01 = void 0;
+/**
+ * Take input from [0, n] and return it as [0, 1]
+ * @hidden
+ */
+function bound01(n, max) {
+    if (isOnePointZero(n)) {
+        n = '100%';
+    }
+    var isPercent = isPercentage(n);
+    n = max === 360 ? n : Math.min(max, Math.max(0, parseFloat(n)));
+    // Automatically convert percentage into number
+    if (isPercent) {
+        n = parseInt(String(n * max), 10) / 100;
+    }
+    // Handle floating point rounding errors
+    if (Math.abs(n - max) < 0.000001) {
+        return 1;
+    }
+    // Convert into [0, 1] range if it isn't already
+    if (max === 360) {
+        // If n is a hue given in degrees,
+        // wrap around out-of-range values into [0, 360] range
+        // then convert into [0, 1].
+        n = (n < 0 ? (n % max) + max : n % max) / parseFloat(String(max));
+    }
+    else {
+        // If n not a hue given in degrees
+        // Convert into [0, 1] range if it isn't already.
+        n = (n % max) / parseFloat(String(max));
+    }
+    return n;
+}
+exports.bound01 = bound01;
+/**
+ * Force a number between 0 and 1
+ * @hidden
+ */
+function clamp01(val) {
+    return Math.min(1, Math.max(0, val));
+}
+exports.clamp01 = clamp01;
+/**
+ * Need to handle 1.0 as 100%, since once it is a number, there is no difference between it and 1
+ * <http://stackoverflow.com/questions/7422072/javascript-how-to-detect-number-as-a-decimal-including-1-0>
+ * @hidden
+ */
+function isOnePointZero(n) {
+    return typeof n === 'string' && n.indexOf('.') !== -1 && parseFloat(n) === 1;
+}
+exports.isOnePointZero = isOnePointZero;
+/**
+ * Check to see if string passed in is a percentage
+ * @hidden
+ */
+function isPercentage(n) {
+    return typeof n === 'string' && n.indexOf('%') !== -1;
+}
+exports.isPercentage = isPercentage;
+/**
+ * Return a valid alpha value [0,1] with all invalid values being set to 1
+ * @hidden
+ */
+function boundAlpha(a) {
+    a = parseFloat(a);
+    if (isNaN(a) || a < 0 || a > 1) {
+        a = 1;
+    }
+    return a;
+}
+exports.boundAlpha = boundAlpha;
+/**
+ * Replace a decimal with it's percentage value
+ * @hidden
+ */
+function convertToPercentage(n) {
+    if (n <= 1) {
+        return "".concat(Number(n) * 100, "%");
+    }
+    return n;
+}
+exports.convertToPercentage = convertToPercentage;
+/**
+ * Force a hex value to have 2 characters
+ * @hidden
+ */
+function pad2(c) {
+    return c.length === 1 ? '0' + c : String(c);
+}
+exports.pad2 = pad2;

.output/server/node_modules/@ctrl/tinycolor/package.json

@@ -0,0 +1,80 @@
+{
+  "name": "@ctrl/tinycolor",
+  "version": "3.6.1",
+  "description": "Fast, small color manipulation and conversion for JavaScript",
+  "author": "Scott Cooper <scttcper@gmail.com>",
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT",
+  "homepage": "https://tinycolor.vercel.app",
+  "repository": "scttcper/tinycolor",
+  "keywords": [
+    "typescript",
+    "color",
+    "manipulation",
+    "tinycolor",
+    "hsa",
+    "rgb"
+  ],
+  "main": "dist/public_api.js",
+  "module": "dist/module/public_api.js",
+  "typings": "dist/public_api.d.ts",
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "scripts": {
+    "build:demo": "rollup -c rollup.demo.js",
+    "watch:demo": "rollup -c rollup.demo.js -w",
+    "lint": "eslint --ext .js,.ts, .",
+    "lint:fix": "eslint --fix --ext .js,.ts, .",
+    "prepare": "npm run build",
+    "build": "del-cli dist && tsc -p tsconfig.build.json && tsc -p tsconfig.module.json && ts-node build",
+    "build:docs": "typedoc --out demo/public/docs --hideGenerator --tsconfig tsconfig.build.json src/public_api.ts",
+    "test": "jest",
+    "test:ci": "jest --ci --runInBand --reporters=default --reporters=jest-junit --coverage",
+    "test:watch": "jest --watch"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@babel/plugin-transform-modules-commonjs": "7.19.6",
+    "@babel/preset-typescript": "7.18.6",
+    "@ctrl/eslint-config": "3.5.6",
+    "@jest/globals": "29.3.1",
+    "@types/node": "18.11.11",
+    "del-cli": "5.0.0",
+    "jest": "29.3.1",
+    "jest-junit": "15.0.0",
+    "rollup": "2.70.1",
+    "rollup-plugin-livereload": "2.0.5",
+    "rollup-plugin-serve": "1.1.0",
+    "rollup-plugin-sourcemaps": "0.6.3",
+    "rollup-plugin-terser": "7.0.2",
+    "rollup-plugin-typescript2": "0.34.1",
+    "ts-node": "10.9.1",
+    "typedoc": "0.23.21",
+    "typescript": "4.9.3"
+  },
+  "jest": {
+    "testEnvironment": "node",
+    "coverageProvider": "v8",
+    "moduleNameMapper": {
+      "(.+)\\.js": "$1"
+    }
+  },
+  "babel": {
+    "presets": [
+      "@babel/preset-typescript"
+    ],
+    "plugins": [
+      "@babel/plugin-transform-modules-commonjs"
+    ]
+  },
+  "release": {
+    "branch": "master"
+  },
+  "engines": {
+    "node": ">=10"
+  }
+}

.output/server/node_modules/@unhead/dom/dist/index.mjs

@@ -0,0 +1,133 @@
+import { HasElementTags, hashTag, normaliseProps, tagDedupeKey, defineHeadPlugin } from '@unhead/shared';
+
+async function elementToTag($el) {
+  const tag = {
+    tag: $el.tagName.toLowerCase(),
+    props: await normaliseProps(
+      $el.getAttributeNames().reduce((props, name) => ({ ...props, [name]: $el.getAttribute(name) }), {})
+    ),
+    innerHTML: $el.innerHTML
+  };
+  tag._d = tagDedupeKey(tag);
+  return tag;
+}
+async function renderDOMHead(head, options = {}) {
+  const dom = options.document || head.resolvedOptions.document;
+  if (!dom)
+    return;
+  const beforeRenderCtx = { shouldRender: head.dirty, tags: [] };
+  await head.hooks.callHook("dom:beforeRender", beforeRenderCtx);
+  if (!beforeRenderCtx.shouldRender)
+    return;
+  const tags = (await head.resolveTags()).map((tag) => ({
+    tag,
+    id: HasElementTags.includes(tag.tag) ? hashTag(tag) : tag.tag,
+    shouldRender: true
+  }));
+  let state = head._dom;
+  if (!state) {
+    state = {
+      elMap: { htmlAttrs: dom.documentElement, bodyAttrs: dom.body }
+    };
+    for (const key of ["body", "head"]) {
+      const children = dom?.[key]?.children;
+      for (const c of [...children].filter((c2) => HasElementTags.includes(c2.tagName.toLowerCase())))
+        state.elMap[c.getAttribute("data-hid") || hashTag(await elementToTag(c))] = c;
+    }
+  }
+  state.pendingSideEffects = { ...state.sideEffects || {} };
+  state.sideEffects = {};
+  function track(id, scope, fn) {
+    const k = `${id}:${scope}`;
+    state.sideEffects[k] = fn;
+    delete state.pendingSideEffects[k];
+  }
+  function trackCtx({ id, $el, tag }) {
+    const isAttrTag = tag.tag.endsWith("Attrs");
+    state.elMap[id] = $el;
+    if (!isAttrTag) {
+      ["textContent", "innerHTML"].forEach((k) => {
+        tag[k] && tag[k] !== $el[k] && ($el[k] = tag[k]);
+      });
+      track(id, "el", () => {
+        state.elMap[id].remove();
+        delete state.elMap[id];
+      });
+    }
+    Object.entries(tag.props).forEach(([k, value]) => {
+      const ck = `attr:${k}`;
+      if (k === "class") {
+        for (const c of (value || "").split(" ").filter(Boolean)) {
+          isAttrTag && track(id, `${ck}:${c}`, () => $el.classList.remove(c));
+          !$el.classList.contains(c) && $el.classList.add(c);
+        }
+      } else {
+        $el.getAttribute(k) !== value && $el.setAttribute(k, value === true ? "" : String(value));
+        isAttrTag && track(id, ck, () => $el.removeAttribute(k));
+      }
+    });
+  }
+  const pending = [];
+  const frag = {
+    bodyClose: void 0,
+    bodyOpen: void 0,
+    head: void 0
+  };
+  for (const ctx of tags) {
+    const { tag, shouldRender, id } = ctx;
+    if (!shouldRender)
+      continue;
+    if (tag.tag === "title") {
+      dom.title = tag.textContent;
+      continue;
+    }
+    ctx.$el = ctx.$el || state.elMap[id];
+    if (ctx.$el)
+      trackCtx(ctx);
+    else
+      HasElementTags.includes(tag.tag) && pending.push(ctx);
+  }
+  for (const ctx of pending) {
+    const pos = ctx.tag.tagPosition || "head";
+    ctx.$el = dom.createElement(ctx.tag.tag);
+    trackCtx(ctx);
+    frag[pos] = frag[pos] || dom.createDocumentFragment();
+    frag[pos].appendChild(ctx.$el);
+  }
+  for (const ctx of tags)
+    await head.hooks.callHook("dom:renderTag", ctx, dom, track);
+  frag.head && dom.head.appendChild(frag.head);
+  frag.bodyOpen && dom.body.insertBefore(frag.bodyOpen, dom.body.firstChild);
+  frag.bodyClose && dom.body.appendChild(frag.bodyClose);
+  Object.values(state.pendingSideEffects).forEach((fn) => fn());
+  head._dom = state;
+  head.dirty = false;
+  await head.hooks.callHook("dom:rendered", { renders: tags });
+}
+
+async function debouncedRenderDOMHead(head, options = {}) {
+  const fn = options.delayFn || ((fn2) => setTimeout(fn2, 10));
+  return head._domUpdatePromise = head._domUpdatePromise || new Promise((resolve) => fn(async () => {
+    await renderDOMHead(head, options);
+    delete head._domUpdatePromise;
+    resolve();
+  }));
+}
+
+// @__NO_SIDE_EFFECTS__
+function DomPlugin(options) {
+  return defineHeadPlugin((head) => {
+    const initialPayload = head.resolvedOptions.document?.head.querySelector('script[id="unhead:payload"]')?.innerHTML || false;
+    initialPayload && head.push(JSON.parse(initialPayload));
+    return {
+      mode: "client",
+      hooks: {
+        "entries:updated": function(head2) {
+          debouncedRenderDOMHead(head2, options);
+        }
+      }
+    };
+  });
+}
+
+export { DomPlugin, debouncedRenderDOMHead, renderDOMHead };

.output/server/node_modules/@unhead/dom/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@unhead/dom",
+  "type": "module",
+  "version": "1.8.8",
+  "author": "Harlan Wilton <harlan@harlanzw.com>",
+  "license": "MIT",
+  "funding": "https://github.com/sponsors/harlan-zw",
+  "homepage": "https://unhead.unjs.io",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/unjs/unhead.git",
+    "directory": "packages/dom"
+  },
+  "bugs": {
+    "url": "https://github.com/unjs/unhead/issues"
+  },
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "main": "dist/index.cjs",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@unhead/shared": "1.8.8",
+    "@unhead/schema": "1.8.8"
+  },
+  "scripts": {
+    "build": "unbuild .",
+    "stub": "unbuild . --stub",
+    "export:sizes": "npx export-size . -r"
+  }
+}

.output/server/node_modules/@unhead/shared/dist/index.mjs

@@ -0,0 +1,640 @@
+function asArray$1(value) {
+  return Array.isArray(value) ? value : [value];
+}
+
+const SelfClosingTags = ["meta", "link", "base"];
+const TagsWithInnerContent = ["title", "titleTemplate", "script", "style", "noscript"];
+const HasElementTags = [
+  "base",
+  "meta",
+  "link",
+  "style",
+  "script",
+  "noscript"
+];
+const ValidHeadTags = [
+  "title",
+  "titleTemplate",
+  "templateParams",
+  "base",
+  "htmlAttrs",
+  "bodyAttrs",
+  "meta",
+  "link",
+  "style",
+  "script",
+  "noscript"
+];
+const UniqueTags = ["base", "title", "titleTemplate", "bodyAttrs", "htmlAttrs", "templateParams"];
+const TagConfigKeys = ["tagPosition", "tagPriority", "tagDuplicateStrategy", "children", "innerHTML", "textContent", "processTemplateParams"];
+const IsBrowser = typeof window !== "undefined";
+const composableNames = [
+  "getActiveHead",
+  "useHead",
+  "useSeoMeta",
+  "useHeadSafe",
+  "useServerHead",
+  "useServerSeoMeta",
+  "useServerHeadSafe"
+];
+
+function defineHeadPlugin(plugin) {
+  return plugin;
+}
+
+function hashCode(s) {
+  let h = 9;
+  for (let i = 0; i < s.length; )
+    h = Math.imul(h ^ s.charCodeAt(i++), 9 ** 9);
+  return ((h ^ h >>> 9) + 65536).toString(16).substring(1, 8).toLowerCase();
+}
+function hashTag(tag) {
+  return tag._h || hashCode(tag._d ? tag._d : `${tag.tag}:${tag.textContent || tag.innerHTML || ""}:${Object.entries(tag.props).map(([key, value]) => `${key}:${String(value)}`).join(",")}`);
+}
+
+function tagDedupeKey(tag, fn) {
+  const { props, tag: tagName } = tag;
+  if (UniqueTags.includes(tagName))
+    return tagName;
+  if (tagName === "link" && props.rel === "canonical")
+    return "canonical";
+  if (props.charset)
+    return "charset";
+  const name = ["id"];
+  if (tagName === "meta")
+    name.push(...["name", "property", "http-equiv"]);
+  for (const n of name) {
+    if (typeof props[n] !== "undefined") {
+      const val = String(props[n]);
+      if (fn && !fn(val))
+        return false;
+      return `${tagName}:${n}:${val}`;
+    }
+  }
+  return false;
+}
+
+function resolveTitleTemplate(template, title) {
+  if (template == null)
+    return title || null;
+  if (typeof template === "function")
+    return template(title);
+  return template;
+}
+
+function asArray(input) {
+  return Array.isArray(input) ? input : [input];
+}
+const InternalKeySymbol = "_$key";
+function packObject(input, options) {
+  const keys = Object.keys(input);
+  let [k, v] = keys;
+  options = options || {};
+  options.key = options.key || k;
+  options.value = options.value || v;
+  options.resolveKey = options.resolveKey || ((k2) => k2);
+  const resolveKey = (index) => {
+    const arr = asArray(options?.[index]);
+    return arr.find((k2) => {
+      if (typeof k2 === "string" && k2.includes(".")) {
+        return k2;
+      }
+      return k2 && keys.includes(k2);
+    });
+  };
+  const resolveValue = (k2, input2) => {
+    if (k2.includes(".")) {
+      const paths = k2.split(".");
+      let val = input2;
+      for (const path of paths)
+        val = val[path];
+      return val;
+    }
+    return input2[k2];
+  };
+  k = resolveKey("key") || k;
+  v = resolveKey("value") || v;
+  const dedupeKeyPrefix = input.key ? `${InternalKeySymbol}${input.key}-` : "";
+  let keyValue = resolveValue(k, input);
+  keyValue = options.resolveKey(keyValue);
+  return {
+    [`${dedupeKeyPrefix}${keyValue}`]: resolveValue(v, input)
+  };
+}
+
+function packArray(input, options) {
+  const packed = {};
+  for (const i of input) {
+    const packedObj = packObject(i, options);
+    const pKey = Object.keys(packedObj)[0];
+    const isDedupeKey = pKey.startsWith(InternalKeySymbol);
+    if (!isDedupeKey && packed[pKey]) {
+      packed[pKey] = Array.isArray(packed[pKey]) ? packed[pKey] : [packed[pKey]];
+      packed[pKey].push(Object.values(packedObj)[0]);
+    } else {
+      packed[isDedupeKey ? pKey.split("-").slice(1).join("-") || pKey : pKey] = packedObj[pKey];
+    }
+  }
+  return packed;
+}
+
+function unpackToArray(input, options) {
+  const unpacked = [];
+  const kFn = options.resolveKeyData || ((ctx) => ctx.key);
+  const vFn = options.resolveValueData || ((ctx) => ctx.value);
+  for (const [k, v] of Object.entries(input)) {
+    unpacked.push(...(Array.isArray(v) ? v : [v]).map((i) => {
+      const ctx = { key: k, value: i };
+      const val = vFn(ctx);
+      if (typeof val === "object")
+        return unpackToArray(val, options);
+      if (Array.isArray(val))
+        return val;
+      return {
+        [typeof options.key === "function" ? options.key(ctx) : options.key]: kFn(ctx),
+        [typeof options.value === "function" ? options.value(ctx) : options.value]: val
+      };
+    }).flat());
+  }
+  return unpacked;
+}
+
+function unpackToString(value, options) {
+  return Object.entries(value).map(([key, value2]) => {
+    if (typeof value2 === "object")
+      value2 = unpackToString(value2, options);
+    if (options.resolve) {
+      const resolved = options.resolve({ key, value: value2 });
+      if (resolved)
+        return resolved;
+    }
+    if (typeof value2 === "number")
+      value2 = value2.toString();
+    if (typeof value2 === "string" && options.wrapValue) {
+      value2 = value2.replace(new RegExp(options.wrapValue, "g"), `\\${options.wrapValue}`);
+      value2 = `${options.wrapValue}${value2}${options.wrapValue}`;
+    }
+    return `${key}${options.keyValueSeparator || ""}${value2}`;
+  }).join(options.entrySeparator || "");
+}
+
+const p = (p2) => ({ keyValue: p2, metaKey: "property" });
+const k = (p2) => ({ keyValue: p2 });
+const MetaPackingSchema = {
+  appleItunesApp: {
+    unpack: {
+      entrySeparator: ", ",
+      resolve({ key, value }) {
+        return `${fixKeyCase(key)}=${value}`;
+      }
+    }
+  },
+  articleExpirationTime: p("article:expiration_time"),
+  articleModifiedTime: p("article:modified_time"),
+  articlePublishedTime: p("article:published_time"),
+  bookReleaseDate: p("book:release_date"),
+  charset: {
+    metaKey: "charset"
+  },
+  contentSecurityPolicy: {
+    unpack: {
+      entrySeparator: "; ",
+      resolve({ key, value }) {
+        return `${fixKeyCase(key)} ${value}`;
+      }
+    },
+    metaKey: "http-equiv"
+  },
+  contentType: {
+    metaKey: "http-equiv"
+  },
+  defaultStyle: {
+    metaKey: "http-equiv"
+  },
+  fbAppId: p("fb:app_id"),
+  msapplicationConfig: k("msapplication-Config"),
+  msapplicationTileColor: k("msapplication-TileColor"),
+  msapplicationTileImage: k("msapplication-TileImage"),
+  ogAudioSecureUrl: p("og:audio:secure_url"),
+  ogAudioUrl: p("og:audio"),
+  ogImageSecureUrl: p("og:image:secure_url"),
+  ogImageUrl: p("og:image"),
+  ogSiteName: p("og:site_name"),
+  ogVideoSecureUrl: p("og:video:secure_url"),
+  ogVideoUrl: p("og:video"),
+  profileFirstName: p("profile:first_name"),
+  profileLastName: p("profile:last_name"),
+  profileUsername: p("profile:username"),
+  refresh: {
+    metaKey: "http-equiv",
+    unpack: {
+      entrySeparator: ";",
+      resolve({ key, value }) {
+        if (key === "seconds")
+          return `${value}`;
+      }
+    }
+  },
+  robots: {
+    unpack: {
+      entrySeparator: ", ",
+      resolve({ key, value }) {
+        if (typeof value === "boolean")
+          return `${fixKeyCase(key)}`;
+        else
+          return `${fixKeyCase(key)}:${value}`;
+      }
+    }
+  },
+  xUaCompatible: {
+    metaKey: "http-equiv"
+  }
+};
+const openGraphNamespaces = [
+  "og",
+  "book",
+  "article",
+  "profile"
+];
+function resolveMetaKeyType(key) {
+  const fKey = fixKeyCase(key).split(":")[0];
+  if (openGraphNamespaces.includes(fKey))
+    return "property";
+  return MetaPackingSchema[key]?.metaKey || "name";
+}
+function resolveMetaKeyValue(key) {
+  return MetaPackingSchema[key]?.keyValue || fixKeyCase(key);
+}
+function fixKeyCase(key) {
+  const updated = key.replace(/([A-Z])/g, "-$1").toLowerCase();
+  const fKey = updated.split("-")[0];
+  if (openGraphNamespaces.includes(fKey) || fKey === "twitter")
+    return key.replace(/([A-Z])/g, ":$1").toLowerCase();
+  return updated;
+}
+function changeKeyCasingDeep(input) {
+  if (Array.isArray(input)) {
+    return input.map((entry) => changeKeyCasingDeep(entry));
+  }
+  if (typeof input !== "object" || Array.isArray(input))
+    return input;
+  const output = {};
+  for (const [key, value] of Object.entries(input))
+    output[fixKeyCase(key)] = changeKeyCasingDeep(value);
+  return output;
+}
+function resolvePackedMetaObjectValue(value, key) {
+  const definition = MetaPackingSchema[key];
+  if (key === "refresh")
+    return `${value.seconds};url=${value.url}`;
+  return unpackToString(
+    changeKeyCasingDeep(value),
+    {
+      keyValueSeparator: "=",
+      entrySeparator: ", ",
+      resolve({ value: value2, key: key2 }) {
+        if (value2 === null)
+          return "";
+        if (typeof value2 === "boolean")
+          return `${key2}`;
+      },
+      ...definition?.unpack
+    }
+  );
+}
+const ObjectArrayEntries = ["og:image", "og:video", "og:audio", "twitter:image"];
+function sanitize(input) {
+  const out = {};
+  Object.entries(input).forEach(([k2, v]) => {
+    if (String(v) !== "false" && k2)
+      out[k2] = v;
+  });
+  return out;
+}
+function handleObjectEntry(key, v) {
+  const value = sanitize(v);
+  const fKey = fixKeyCase(key);
+  const attr = resolveMetaKeyType(fKey);
+  if (ObjectArrayEntries.includes(fKey)) {
+    const input = {};
+    Object.entries(value).forEach(([k2, v2]) => {
+      input[`${key}${k2 === "url" ? "" : `${k2.charAt(0).toUpperCase()}${k2.slice(1)}`}`] = v2;
+    });
+    return unpackMeta(input).sort((a, b) => (a[attr]?.length || 0) - (b[attr]?.length || 0));
+  }
+  return [{ [attr]: fKey, ...value }];
+}
+function unpackMeta(input) {
+  const extras = [];
+  const primitives = {};
+  Object.entries(input).forEach(([key, value]) => {
+    if (!Array.isArray(value)) {
+      if (typeof value === "object" && value) {
+        if (ObjectArrayEntries.includes(fixKeyCase(key))) {
+          extras.push(...handleObjectEntry(key, value));
+          return;
+        }
+        primitives[key] = sanitize(value);
+      } else {
+        primitives[key] = value;
+      }
+      return;
+    }
+    value.forEach((v) => {
+      extras.push(...typeof v === "string" ? unpackMeta({ [key]: v }) : handleObjectEntry(key, v));
+    });
+  });
+  const meta = unpackToArray(primitives, {
+    key({ key }) {
+      return resolveMetaKeyType(key);
+    },
+    value({ key }) {
+      return key === "charset" ? "charset" : "content";
+    },
+    resolveKeyData({ key }) {
+      return resolveMetaKeyValue(key);
+    },
+    resolveValueData({ value, key }) {
+      if (value === null)
+        return "_null";
+      if (typeof value === "object")
+        return resolvePackedMetaObjectValue(value, key);
+      return typeof value === "number" ? value.toString() : value;
+    }
+  });
+  return [...extras, ...meta].map((m) => {
+    if (m.content === "_null")
+      m.content = null;
+    return m;
+  });
+}
+function packMeta(inputs) {
+  const mappedPackingSchema = Object.entries(MetaPackingSchema).map(([key, value]) => [key, value.keyValue]);
+  return packArray(inputs, {
+    key: ["name", "property", "httpEquiv", "http-equiv", "charset"],
+    value: ["content", "charset"],
+    resolveKey(k2) {
+      let key = mappedPackingSchema.filter((sk) => sk[1] === k2)?.[0]?.[0] || k2;
+      const replacer = (_, letter) => letter?.toUpperCase();
+      key = key.replace(/:([a-z])/g, replacer).replace(/-([a-z])/g, replacer);
+      return key;
+    }
+  });
+}
+
+const WhitelistAttributes = {
+  htmlAttrs: ["id", "class", "lang", "dir"],
+  bodyAttrs: ["id", "class"],
+  meta: ["id", "name", "property", "charset", "content"],
+  noscript: ["id", "textContent"],
+  script: ["id", "type", "textContent"],
+  link: ["id", "color", "crossorigin", "fetchpriority", "href", "hreflang", "imagesrcset", "imagesizes", "integrity", "media", "referrerpolicy", "rel", "sizes", "type"]
+};
+function acceptDataAttrs(value) {
+  const filtered = {};
+  Object.keys(value || {}).filter((a) => a.startsWith("data-")).forEach((a) => {
+    filtered[a] = value[a];
+  });
+  return filtered;
+}
+function whitelistSafeInput(input) {
+  const filtered = {};
+  Object.keys(input).forEach((key) => {
+    const tagValue = input[key];
+    if (!tagValue)
+      return;
+    switch (key) {
+      case "title":
+      case "titleTemplate":
+      case "templateParams":
+        filtered[key] = tagValue;
+        break;
+      case "htmlAttrs":
+      case "bodyAttrs":
+        filtered[key] = acceptDataAttrs(tagValue);
+        WhitelistAttributes[key].forEach((a) => {
+          if (tagValue[a])
+            filtered[key][a] = tagValue[a];
+        });
+        break;
+      case "meta":
+        if (Array.isArray(tagValue)) {
+          filtered[key] = tagValue.map((meta) => {
+            const safeMeta = acceptDataAttrs(meta);
+            WhitelistAttributes.meta.forEach((key2) => {
+              if (meta[key2])
+                safeMeta[key2] = meta[key2];
+            });
+            return safeMeta;
+          }).filter((meta) => Object.keys(meta).length > 0);
+        }
+        break;
+      case "link":
+        if (Array.isArray(tagValue)) {
+          filtered[key] = tagValue.map((meta) => {
+            const link = acceptDataAttrs(meta);
+            WhitelistAttributes.link.forEach((key2) => {
+              const val = meta[key2];
+              if (key2 === "rel" && ["stylesheet", "canonical", "modulepreload", "prerender", "preload", "prefetch"].includes(val))
+                return;
+              if (key2 === "href") {
+                if (val.includes("javascript:") || val.includes("data:"))
+                  return;
+                link[key2] = val;
+              } else if (val) {
+                link[key2] = val;
+              }
+            });
+            return link;
+          }).filter((link) => Object.keys(link).length > 1 && !!link.rel);
+        }
+        break;
+      case "noscript":
+        if (Array.isArray(tagValue)) {
+          filtered[key] = tagValue.map((meta) => {
+            const noscript = acceptDataAttrs(meta);
+            WhitelistAttributes.noscript.forEach((key2) => {
+              if (meta[key2])
+                noscript[key2] = meta[key2];
+            });
+            return noscript;
+          }).filter((meta) => Object.keys(meta).length > 0);
+        }
+        break;
+      case "script":
+        if (Array.isArray(tagValue)) {
+          filtered[key] = tagValue.map((script) => {
+            const safeScript = acceptDataAttrs(script);
+            WhitelistAttributes.script.forEach((s) => {
+              if (script[s]) {
+                if (s === "textContent") {
+                  try {
+                    const jsonVal = typeof script[s] === "string" ? JSON.parse(script[s]) : script[s];
+                    safeScript[s] = JSON.stringify(jsonVal, null, 0);
+                  } catch (e) {
+                  }
+                } else {
+                  safeScript[s] = script[s];
+                }
+              }
+            });
+            return safeScript;
+          }).filter((meta) => Object.keys(meta).length > 0);
+        }
+        break;
+    }
+  });
+  return filtered;
+}
+
+async function normaliseTag(tagName, input, e) {
+  const tag = {
+    tag: tagName,
+    props: await normaliseProps(
+      // explicitly check for an object
+      // @ts-expect-error untyped
+      typeof input === "object" && typeof input !== "function" && !(input instanceof Promise) ? { ...input } : { [["script", "noscript", "style"].includes(tagName) ? "innerHTML" : "textContent"]: input },
+      ["templateParams", "titleTemplate"].includes(tagName)
+    )
+  };
+  TagConfigKeys.forEach((k) => {
+    const val = typeof tag.props[k] !== "undefined" ? tag.props[k] : e[k];
+    if (typeof val !== "undefined") {
+      if (!["innerHTML", "textContent", "children"].includes(k) || TagsWithInnerContent.includes(tag.tag)) {
+        tag[k === "children" ? "innerHTML" : k] = val;
+      }
+      delete tag.props[k];
+    }
+  });
+  if (tag.props.body) {
+    tag.tagPosition = "bodyClose";
+    delete tag.props.body;
+  }
+  if (tag.tag === "script") {
+    if (typeof tag.innerHTML === "object") {
+      tag.innerHTML = JSON.stringify(tag.innerHTML);
+      tag.props.type = tag.props.type || "application/json";
+    }
+  }
+  return Array.isArray(tag.props.content) ? tag.props.content.map((v) => ({ ...tag, props: { ...tag.props, content: v } })) : tag;
+}
+function normaliseClassProp(v) {
+  if (typeof v === "object" && !Array.isArray(v)) {
+    v = Object.keys(v).filter((k) => v[k]);
+  }
+  return (Array.isArray(v) ? v.join(" ") : v).split(" ").filter((c) => c.trim()).filter(Boolean).join(" ");
+}
+async function normaliseProps(props, virtual) {
+  for (const k of Object.keys(props)) {
+    if (k === "class") {
+      props[k] = normaliseClassProp(props[k]);
+      continue;
+    }
+    if (props[k] instanceof Promise)
+      props[k] = await props[k];
+    if (!virtual && !TagConfigKeys.includes(k)) {
+      const v = String(props[k]);
+      const isDataKey = k.startsWith("data-");
+      if (v === "true" || v === "") {
+        props[k] = isDataKey ? "true" : true;
+      } else if (!props[k]) {
+        if (isDataKey && v === "false")
+          props[k] = "false";
+        else
+          delete props[k];
+      }
+    }
+  }
+  return props;
+}
+const TagEntityBits = 10;
+async function normaliseEntryTags(e) {
+  const tagPromises = [];
+  Object.entries(e.resolvedInput).filter(([k, v]) => typeof v !== "undefined" && ValidHeadTags.includes(k)).forEach(([k, value]) => {
+    const v = asArray$1(value);
+    tagPromises.push(...v.map((props) => normaliseTag(k, props, e)).flat());
+  });
+  return (await Promise.all(tagPromises)).flat().filter(Boolean).map((t, i) => {
+    t._e = e._i;
+    e.mode && (t._m = e.mode);
+    t._p = (e._i << TagEntityBits) + i;
+    return t;
+  });
+}
+
+const TAG_WEIGHTS = {
+  // tags
+  base: -10,
+  title: 10
+};
+const TAG_ALIASES = {
+  // relative scores to their default values
+  critical: -80,
+  high: -10,
+  low: 20
+};
+function tagWeight(tag) {
+  let weight = 100;
+  const priority = tag.tagPriority;
+  if (typeof priority === "number")
+    return priority;
+  if (tag.tag === "meta") {
+    if (tag.props["http-equiv"] === "content-security-policy")
+      weight = -30;
+    if (tag.props.charset)
+      weight = -20;
+    if (tag.props.name === "viewport")
+      weight = -15;
+  } else if (tag.tag === "link" && tag.props.rel === "preconnect") {
+    weight = 20;
+  } else if (tag.tag in TAG_WEIGHTS) {
+    weight = TAG_WEIGHTS[tag.tag];
+  }
+  if (typeof priority === "string" && priority in TAG_ALIASES) {
+    return weight + TAG_ALIASES[priority];
+  }
+  return weight;
+}
+const SortModifiers = [{ prefix: "before:", offset: -1 }, { prefix: "after:", offset: 1 }];
+
+const NetworkEvents = ["onload", "onerror", "onabort", "onprogress", "onloadstart"];
+
+const sepSub = "%separator";
+function processTemplateParams(s, p, sep) {
+  if (typeof s !== "string" || !s.includes("%"))
+    return s;
+  function sub(token) {
+    let val;
+    if (["s", "pageTitle"].includes(token)) {
+      val = p.pageTitle;
+    } else if (token.includes(".")) {
+      val = token.split(".").reduce((acc, key) => acc ? acc[key] || void 0 : void 0, p);
+    } else {
+      val = p[token];
+    }
+    return typeof val !== "undefined" ? (val || "").replace(/"/g, '\\"') : false;
+  }
+  let decoded = s;
+  try {
+    decoded = decodeURI(s);
+  } catch {
+  }
+  const tokens = (decoded.match(/%(\w+\.+\w+)|%(\w+)/g) || []).sort().reverse();
+  tokens.forEach((token) => {
+    const re = sub(token.slice(1));
+    if (typeof re === "string") {
+      s = s.replace(new RegExp(`\\${token}(\\W|$)`, "g"), (_, args) => `${re}${args}`).trim();
+    }
+  });
+  if (s.includes(sepSub)) {
+    if (s.endsWith(sepSub))
+      s = s.slice(0, -sepSub.length).trim();
+    if (s.startsWith(sepSub))
+      s = s.slice(sepSub.length).trim();
+    s = s.replace(new RegExp(`\\${sepSub}\\s*\\${sepSub}`, "g"), sepSub);
+    s = processTemplateParams(s, { separator: sep }, sep);
+  }
+  return s;
+}
+
+export { HasElementTags, IsBrowser, NetworkEvents, SelfClosingTags, SortModifiers, TAG_ALIASES, TAG_WEIGHTS, TagConfigKeys, TagEntityBits, TagsWithInnerContent, UniqueTags, ValidHeadTags, asArray$1 as asArray, composableNames, defineHeadPlugin, hashCode, hashTag, normaliseClassProp, normaliseEntryTags, normaliseProps, normaliseTag, packMeta, processTemplateParams, resolveMetaKeyType, resolveMetaKeyValue, resolvePackedMetaObjectValue, resolveTitleTemplate, tagDedupeKey, tagWeight, unpackMeta, whitelistSafeInput };

.output/server/node_modules/@unhead/shared/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@unhead/shared",
+  "type": "module",
+  "version": "1.8.8",
+  "author": "Harlan Wilton <harlan@harlanzw.com>",
+  "license": "MIT",
+  "funding": "https://github.com/sponsors/harlan-zw",
+  "homepage": "https://unhead.unjs.io",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/unjs/unhead.git",
+    "directory": "packages/schema"
+  },
+  "bugs": {
+    "url": "https://github.com/unjs/unhead/issues"
+  },
+  "keywords": [
+    "head",
+    "meta tags",
+    "types"
+  ],
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "main": "dist/index.cjs",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@unhead/schema": "1.8.8"
+  },
+  "devDependencies": {
+    "packrup": "^0.1.0"
+  },
+  "scripts": {
+    "build": "unbuild .",
+    "stub": "unbuild . --stub",
+    "export:sizes": "npx export-size . -r"
+  }
+}

.output/server/node_modules/@unhead/ssr/dist/index.mjs

@@ -0,0 +1,84 @@
+import { TagsWithInnerContent, SelfClosingTags } from '@unhead/shared';
+
+function encodeAttribute(value) {
+  return String(value).replace(/"/g, """);
+}
+function propsToString(props) {
+  const attrs = [];
+  for (const [key, value] of Object.entries(props)) {
+    if (value !== false && value !== null)
+      attrs.push(value === true ? key : `${key}="${encodeAttribute(value)}"`);
+  }
+  return `${attrs.length > 0 ? " " : ""}${attrs.join(" ")}`;
+}
+
+function escapeHtml(str) {
+  return str.replace(/[&<>"'/]/g, (char) => {
+    switch (char) {
+      case "&":
+        return "&amp;";
+      case "<":
+        return "&lt;";
+      case ">":
+        return "&gt;";
+      case '"':
+        return "&quot;";
+      case "'":
+        return "&#x27;";
+      case "/":
+        return "&#x2F;";
+      default:
+        return char;
+    }
+  });
+}
+function tagToString(tag) {
+  const attrs = propsToString(tag.props);
+  const openTag = `<${tag.tag}${attrs}>`;
+  if (!TagsWithInnerContent.includes(tag.tag))
+    return SelfClosingTags.includes(tag.tag) ? openTag : `${openTag}</${tag.tag}>`;
+  let content = String(tag.innerHTML || "");
+  if (tag.textContent)
+    content = escapeHtml(String(tag.textContent));
+  return SelfClosingTags.includes(tag.tag) ? openTag : `${openTag}${content}</${tag.tag}>`;
+}
+
+function ssrRenderTags(tags) {
+  const schema = { htmlAttrs: {}, bodyAttrs: {}, tags: { head: [], bodyClose: [], bodyOpen: [] } };
+  for (const tag of tags) {
+    if (tag.tag === "htmlAttrs" || tag.tag === "bodyAttrs") {
+      schema[tag.tag] = { ...schema[tag.tag], ...tag.props };
+      continue;
+    }
+    schema.tags[tag.tagPosition || "head"].push(tagToString(tag));
+  }
+  return {
+    headTags: schema.tags.head.join("\n"),
+    bodyTags: schema.tags.bodyClose.join("\n"),
+    bodyTagsOpen: schema.tags.bodyOpen.join("\n"),
+    htmlAttrs: propsToString(schema.htmlAttrs),
+    bodyAttrs: propsToString(schema.bodyAttrs)
+  };
+}
+
+async function renderSSRHead(head) {
+  const beforeRenderCtx = { shouldRender: true };
+  await head.hooks.callHook("ssr:beforeRender", beforeRenderCtx);
+  if (!beforeRenderCtx.shouldRender) {
+    return {
+      headTags: "",
+      bodyTags: "",
+      bodyTagsOpen: "",
+      htmlAttrs: "",
+      bodyAttrs: ""
+    };
+  }
+  const ctx = { tags: await head.resolveTags() };
+  await head.hooks.callHook("ssr:render", ctx);
+  const html = ssrRenderTags(ctx.tags);
+  const renderCtx = { tags: ctx.tags, html };
+  await head.hooks.callHook("ssr:rendered", renderCtx);
+  return renderCtx.html;
+}
+
+export { escapeHtml, propsToString, renderSSRHead, ssrRenderTags, tagToString };

.output/server/node_modules/@unhead/ssr/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@unhead/ssr",
+  "type": "module",
+  "version": "1.8.8",
+  "author": "Harlan Wilton <harlan@harlanzw.com>",
+  "license": "MIT",
+  "funding": "https://github.com/sponsors/harlan-zw",
+  "homepage": "https://unhead.unjs.io",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/unjs/unhead.git",
+    "directory": "packages/ssr"
+  },
+  "bugs": {
+    "url": "https://github.com/unjs/unhead/issues"
+  },
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "main": "dist/index.cjs",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@unhead/schema": "1.8.8",
+    "@unhead/shared": "1.8.8"
+  },
+  "scripts": {
+    "build": "unbuild .",
+    "stub": "unbuild . --stub",
+    "export:sizes": "npx export-size . -r"
+  }
+}

.output/server/node_modules/@vue/compiler-core/index.js

@@ -0,0 +1,7 @@
+'use strict'
+
+if (process.env.NODE_ENV === 'production') {
+  module.exports = require('./dist/compiler-core.cjs.prod.js')
+} else {
+  module.exports = require('./dist/compiler-core.cjs.js')
+}

.output/server/node_modules/@vue/compiler-core/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@vue/compiler-core",
+  "version": "3.3.10",
+  "description": "@vue/compiler-core",
+  "main": "index.js",
+  "module": "dist/compiler-core.esm-bundler.js",
+  "types": "dist/compiler-core.d.ts",
+  "files": [
+    "index.js",
+    "dist"
+  ],
+  "buildOptions": {
+    "name": "VueCompilerCore",
+    "compat": true,
+    "formats": [
+      "esm-bundler",
+      "cjs"
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vuejs/core.git",
+    "directory": "packages/compiler-core"
+  },
+  "keywords": [
+    "vue"
+  ],
+  "author": "Evan You",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/vuejs/core/issues"
+  },
+  "homepage": "https://github.com/vuejs/core/tree/main/packages/compiler-core#readme",
+  "dependencies": {
+    "@babel/parser": "^7.23.5",
+    "estree-walker": "^2.0.2",
+    "source-map-js": "^1.0.2",
+    "@vue/shared": "3.3.10"
+  },
+  "devDependencies": {
+    "@babel/types": "^7.23.5"
+  }
+}

.output/server/node_modules/@vue/compiler-dom/index.js

@@ -0,0 +1,7 @@
+'use strict'
+
+if (process.env.NODE_ENV === 'production') {
+  module.exports = require('./dist/compiler-dom.cjs.prod.js')
+} else {
+  module.exports = require('./dist/compiler-dom.cjs.js')
+}

.output/server/node_modules/@vue/compiler-dom/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@vue/compiler-dom",
+  "version": "3.3.10",
+  "description": "@vue/compiler-dom",
+  "main": "index.js",
+  "module": "dist/compiler-dom.esm-bundler.js",
+  "types": "dist/compiler-dom.d.ts",
+  "unpkg": "dist/compiler-dom.global.js",
+  "jsdelivr": "dist/compiler-dom.global.js",
+  "files": [
+    "index.js",
+    "dist"
+  ],
+  "sideEffects": false,
+  "buildOptions": {
+    "name": "VueCompilerDOM",
+    "compat": true,
+    "formats": [
+      "esm-bundler",
+      "esm-browser",
+      "cjs",
+      "global"
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vuejs/core.git",
+    "directory": "packages/compiler-dom"
+  },
+  "keywords": [
+    "vue"
+  ],
+  "author": "Evan You",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/vuejs/core/issues"
+  },
+  "homepage": "https://github.com/vuejs/core/tree/main/packages/compiler-dom#readme",
+  "dependencies": {
+    "@vue/shared": "3.3.10",
+    "@vue/compiler-core": "3.3.10"
+  }
+}

.output/server/node_modules/@vue/compiler-ssr/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@vue/compiler-ssr",
+  "version": "3.3.10",
+  "description": "@vue/compiler-ssr",
+  "main": "dist/compiler-ssr.cjs.js",
+  "types": "dist/compiler-ssr.d.ts",
+  "files": [
+    "dist"
+  ],
+  "buildOptions": {
+    "prod": false,
+    "formats": [
+      "cjs"
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vuejs/core.git",
+    "directory": "packages/compiler-ssr"
+  },
+  "keywords": [
+    "vue"
+  ],
+  "author": "Evan You",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/vuejs/core/issues"
+  },
+  "homepage": "https://github.com/vuejs/core/tree/main/packages/compiler-ssr#readme",
+  "dependencies": {
+    "@vue/shared": "3.3.10",
+    "@vue/compiler-dom": "3.3.10"
+  }
+}

.output/server/node_modules/@vue/devtools-api/lib/cjs/api/api.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

.output/server/node_modules/@vue/devtools-api/lib/cjs/api/app.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });