@depup/nuxt 4.2.2-depup.0

package/dist/app/plugins/restore-state.client.js

@@ -0,0 +1,18 @@
+import destr from "destr";
+import { defineNuxtPlugin, useNuxtApp } from "../nuxt.js";
+export default defineNuxtPlugin({
+  name: "nuxt:restore-state",
+  hooks: {
+    "app:mounted"() {
+      const nuxtApp = useNuxtApp();
+      try {
+        const state = sessionStorage.getItem("nuxt:reload:state");
+        if (state) {
+          sessionStorage.removeItem("nuxt:reload:state");
+          Object.assign(nuxtApp.payload.state, destr(state)?.state);
+        }
+      } catch {
+      }
+    }
+  }
+});

package/dist/app/plugins/revive-payload.client.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../nuxt.js").Plugin<Record<string, unknown>> & import("../nuxt.js").ObjectPlugin<Record<string, unknown>>;
+export default _default;

package/dist/app/plugins/revive-payload.client.js

@@ -0,0 +1,44 @@
+import { reactive, ref, shallowReactive, shallowRef } from "vue";
+import destr from "destr";
+import { definePayloadReviver, getNuxtClientPayload } from "../composables/payload.js";
+import { createError } from "../composables/error.js";
+import { defineNuxtPlugin, useNuxtApp } from "../nuxt.js";
+import { componentIslands } from "#build/nuxt.config.mjs";
+const revivers = [
+  ["NuxtError", (data) => createError(data)],
+  ["EmptyShallowRef", (data) => shallowRef(data === "_" ? void 0 : data === "0n" ? BigInt(0) : destr(data))],
+  ["EmptyRef", (data) => ref(data === "_" ? void 0 : data === "0n" ? BigInt(0) : destr(data))],
+  ["ShallowRef", (data) => shallowRef(data)],
+  ["ShallowReactive", (data) => shallowReactive(data)],
+  ["Ref", (data) => ref(data)],
+  ["Reactive", (data) => reactive(data)]
+];
+if (componentIslands) {
+  revivers.push(["Island", ({ key, params, result }) => {
+    const nuxtApp = useNuxtApp();
+    if (!nuxtApp.isHydrating) {
+      nuxtApp.payload.data[key] ||= $fetch(`/__nuxt_island/${key}.json`, {
+        responseType: "json",
+        ...params ? { params } : {}
+      }).then((r) => {
+        nuxtApp.payload.data[key] = r;
+        return r;
+      });
+    }
+    return {
+      html: "",
+      ...result
+    };
+  }]);
+}
+export default defineNuxtPlugin({
+  name: "nuxt:revive-payload:client",
+  order: -30,
+  async setup(nuxtApp) {
+    for (const [reviver, fn] of revivers) {
+      definePayloadReviver(reviver, fn);
+    }
+    Object.assign(nuxtApp.payload, await nuxtApp.runWithContext(getNuxtClientPayload));
+    delete window.__NUXT__;
+  }
+});

package/dist/app/plugins/revive-payload.server.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../nuxt.js").Plugin<Record<string, unknown>> & import("../nuxt.js").ObjectPlugin<Record<string, unknown>>;
+export default _default;

package/dist/app/plugins/revive-payload.server.js

@@ -0,0 +1,26 @@
+import { isReactive, isRef, isShallow, toRaw } from "vue";
+import { definePayloadReducer } from "../composables/payload.js";
+import { isNuxtError } from "../composables/error.js";
+import { defineNuxtPlugin } from "../nuxt.js";
+import { componentIslands } from "#build/nuxt.config.mjs";
+import { isValidIslandKey } from "./utils.js";
+const reducers = [
+  ["NuxtError", (data) => isNuxtError(data) && data.toJSON()],
+  ["EmptyShallowRef", (data) => isRef(data) && isShallow(data) && !data.value && (typeof data.value === "bigint" ? "0n" : JSON.stringify(data.value) || "_")],
+  ["EmptyRef", (data) => isRef(data) && !data.value && (typeof data.value === "bigint" ? "0n" : JSON.stringify(data.value) || "_")],
+  ["ShallowRef", (data) => isRef(data) && isShallow(data) && data.value],
+  ["ShallowReactive", (data) => isReactive(data) && isShallow(data) && toRaw(data)],
+  ["Ref", (data) => isRef(data) && data.value],
+  ["Reactive", (data) => isReactive(data) && toRaw(data)]
+];
+if (componentIslands) {
+  reducers.push(["Island", (data) => data && data?.__nuxt_island && isValidIslandKey(data.__nuxt_island.key) && data.__nuxt_island]);
+}
+export default defineNuxtPlugin({
+  name: "nuxt:revive-payload:server",
+  setup() {
+    for (const [reducer, fn] of reducers) {
+      definePayloadReducer(reducer, fn);
+    }
+  }
+});

package/dist/app/plugins/router.d.ts

@@ -0,0 +1,59 @@
+import type { Ref } from 'vue';
+interface Route {
+    /** Percentage encoded pathname section of the URL. */
+    path: string;
+    /** The whole location including the `search` and `hash`. */
+    fullPath: string;
+    /** Object representation of the `search` property of the current location. */
+    query: Record<string, any>;
+    /** Hash of the current location. If present, starts with a `#`. */
+    hash: string;
+    /** Name of the matched record */
+    name: string | null | undefined;
+    /** Object of decoded params extracted from the `path`. */
+    params: Record<string, any>;
+    /**
+     * The location we were initially trying to access before ending up
+     * on the current location.
+     */
+    redirectedFrom: Route | undefined;
+    /** Merged `meta` properties from all of the matched route records. */
+    meta: Record<string, any>;
+    /** compatibility type for vue-router */
+    matched: never[];
+}
+type RouteGuardReturn = void | Error | string | boolean;
+interface RouterHooks {
+    'resolve:before': (to: Route, from: Route) => RouteGuardReturn | Promise<RouteGuardReturn>;
+    'navigate:before': (to: Route, from: Route) => RouteGuardReturn | Promise<RouteGuardReturn>;
+    'navigate:after': (to: Route, from: Route) => void | Promise<void>;
+    'error': (err: any) => void | Promise<void>;
+}
+interface Router {
+    currentRoute: Ref<Route>;
+    isReady: () => Promise<void>;
+    options: Record<string, unknown>;
+    install: () => Promise<void>;
+    push: (url: string) => Promise<void>;
+    replace: (url: string) => Promise<void>;
+    back: () => void;
+    go: (delta: number) => void;
+    forward: () => void;
+    beforeResolve: (guard: RouterHooks['resolve:before']) => () => void;
+    beforeEach: (guard: RouterHooks['navigate:before']) => () => void;
+    afterEach: (guard: RouterHooks['navigate:after']) => () => void;
+    onError: (handler: RouterHooks['error']) => () => void;
+    resolve: (url: string | Partial<Route>) => Route;
+    addRoute: (parentName: string, route: Route) => void;
+    getRoutes: () => any[];
+    hasRoute: (name: string) => boolean;
+    removeRoute: (name: string) => void;
+}
+declare const _default: import("../nuxt.js").Plugin<{
+    route: Route;
+    router: Router;
+}> & import("../nuxt.js").ObjectPlugin<{
+    route: Route;
+    router: Router;
+}>;
+export default _default;

package/dist/app/plugins/router.js

@@ -0,0 +1,222 @@
+import { computed, defineComponent, h, isReadonly, reactive } from "vue";
+import { isEqual, joinURL, parseQuery, stringifyParsedURL, stringifyQuery, withoutBase } from "ufo";
+import { createError } from "h3";
+import { defineNuxtPlugin, useRuntimeConfig } from "../nuxt.js";
+import { getRouteRules } from "../composables/manifest.js";
+import { clearError, showError } from "../composables/error.js";
+import { navigateTo } from "../composables/router.js";
+import { globalMiddleware } from "#build/middleware";
+import { appManifest as isAppManifestEnabled } from "#build/nuxt.config.mjs";
+function getRouteFromPath(fullPath) {
+  const route = fullPath && typeof fullPath === "object" ? fullPath : {};
+  if (typeof fullPath === "object") {
+    fullPath = stringifyParsedURL({
+      pathname: fullPath.path || "",
+      search: stringifyQuery(fullPath.query || {}),
+      hash: fullPath.hash || ""
+    });
+  }
+  const url = new URL(fullPath.toString(), import.meta.client ? window.location.href : "http://localhost");
+  return {
+    path: url.pathname,
+    fullPath,
+    query: parseQuery(url.search),
+    hash: url.hash,
+    // stub properties for compat with vue-router
+    params: route.params || {},
+    name: void 0,
+    matched: route.matched || [],
+    redirectedFrom: void 0,
+    meta: route.meta || {},
+    href: fullPath
+  };
+}
+export default defineNuxtPlugin({
+  name: "nuxt:router",
+  enforce: "pre",
+  setup(nuxtApp) {
+    const initialURL = import.meta.client ? withoutBase(window.location.pathname, useRuntimeConfig().app.baseURL) + window.location.search + window.location.hash : nuxtApp.ssrContext.url;
+    const routes = [];
+    const hooks = {
+      "navigate:before": [],
+      "resolve:before": [],
+      "navigate:after": [],
+      "error": []
+    };
+    const registerHook = (hook, guard) => {
+      hooks[hook].push(guard);
+      return () => hooks[hook].splice(hooks[hook].indexOf(guard), 1);
+    };
+    const baseURL = useRuntimeConfig().app.baseURL;
+    const route = reactive(getRouteFromPath(initialURL));
+    async function handleNavigation(url, replace) {
+      try {
+        const to = getRouteFromPath(url);
+        for (const middleware of hooks["navigate:before"]) {
+          const result = await middleware(to, route);
+          if (result === false || result instanceof Error) {
+            return;
+          }
+          if (typeof result === "string" && result.length) {
+            return handleNavigation(result, true);
+          }
+        }
+        for (const handler of hooks["resolve:before"]) {
+          await handler(to, route);
+        }
+        Object.assign(route, to);
+        if (import.meta.client) {
+          window.history[replace ? "replaceState" : "pushState"]({}, "", joinURL(baseURL, to.fullPath));
+          if (!nuxtApp.isHydrating) {
+            await nuxtApp.runWithContext(clearError);
+          }
+        }
+        for (const middleware of hooks["navigate:after"]) {
+          await middleware(to, route);
+        }
+      } catch (err) {
+        if (import.meta.dev && !hooks.error.length) {
+          console.warn("No error handlers registered to handle middleware errors. You can register an error handler with `router.onError()`", err);
+        }
+        for (const handler of hooks.error) {
+          await handler(err);
+        }
+      }
+    }
+    const currentRoute = computed(() => route);
+    const router = {
+      currentRoute,
+      isReady: () => Promise.resolve(),
+      // These options provide a similar API to vue-router but have no effect
+      options: {},
+      install: () => Promise.resolve(),
+      // Navigation
+      push: (url) => handleNavigation(url, false),
+      replace: (url) => handleNavigation(url, true),
+      back: () => window.history.go(-1),
+      go: (delta) => window.history.go(delta),
+      forward: () => window.history.go(1),
+      // Guards
+      beforeResolve: (guard) => registerHook("resolve:before", guard),
+      beforeEach: (guard) => registerHook("navigate:before", guard),
+      afterEach: (guard) => registerHook("navigate:after", guard),
+      onError: (handler) => registerHook("error", handler),
+      // Routes
+      resolve: getRouteFromPath,
+      addRoute: (parentName, route2) => {
+        routes.push(route2);
+      },
+      getRoutes: () => routes,
+      hasRoute: (name) => routes.some((route2) => route2.name === name),
+      removeRoute: (name) => {
+        const index = routes.findIndex((route2) => route2.name === name);
+        if (index !== -1) {
+          routes.splice(index, 1);
+        }
+      }
+    };
+    nuxtApp.vueApp.component("RouterLink", defineComponent({
+      functional: true,
+      props: {
+        to: {
+          type: String,
+          required: true
+        },
+        custom: Boolean,
+        replace: Boolean,
+        // Not implemented
+        activeClass: String,
+        exactActiveClass: String,
+        ariaCurrentValue: String
+      },
+      setup: (props, { slots }) => {
+        const navigate = () => handleNavigation(props.to, props.replace);
+        return () => {
+          const route2 = router.resolve(props.to);
+          return props.custom ? slots.default?.({ href: props.to, navigate, route: route2 }) : h("a", { href: props.to, onClick: (e) => {
+            e.preventDefault();
+            return navigate();
+          } }, slots);
+        };
+      }
+    }));
+    if (import.meta.client) {
+      window.addEventListener("popstate", (event) => {
+        const location = event.target.location;
+        router.replace(location.href.replace(location.origin, ""));
+      });
+    }
+    nuxtApp._route = route;
+    nuxtApp._middleware ||= {
+      global: [],
+      named: {}
+    };
+    const initialLayout = nuxtApp.payload.state._layout;
+    nuxtApp.hooks.hookOnce("app:created", async () => {
+      router.beforeEach(async (to, from) => {
+        to.meta = reactive(to.meta || {});
+        if (nuxtApp.isHydrating && initialLayout && !isReadonly(to.meta.layout)) {
+          to.meta.layout = initialLayout;
+        }
+        nuxtApp._processingMiddleware = true;
+        if (import.meta.client || !nuxtApp.ssrContext?.islandContext) {
+          const middlewareEntries = /* @__PURE__ */ new Set([...globalMiddleware, ...nuxtApp._middleware.global]);
+          if (isAppManifestEnabled) {
+            const routeRules = await nuxtApp.runWithContext(() => getRouteRules({ path: to.path }));
+            if (routeRules.appMiddleware) {
+              for (const key in routeRules.appMiddleware) {
+                const guard = nuxtApp._middleware.named[key];
+                if (!guard) {
+                  return;
+                }
+                if (routeRules.appMiddleware[key]) {
+                  middlewareEntries.add(guard);
+                } else {
+                  middlewareEntries.delete(guard);
+                }
+              }
+            }
+          }
+          for (const middleware of middlewareEntries) {
+            if (import.meta.dev) {
+              nuxtApp._processingMiddleware = middleware._path || true;
+            }
+            const result = await nuxtApp.runWithContext(() => middleware(to, from));
+            if (import.meta.server) {
+              if (result === false || result instanceof Error) {
+                const error = result || createError({
+                  statusCode: 404,
+                  statusMessage: `Page Not Found: ${initialURL}`,
+                  data: {
+                    path: initialURL
+                  }
+                });
+                delete nuxtApp._processingMiddleware;
+                return nuxtApp.runWithContext(() => showError(error));
+              }
+            }
+            if (result === true) {
+              continue;
+            }
+            if (result || result === false) {
+              return result;
+            }
+          }
+        }
+      });
+      router.afterEach(() => {
+        delete nuxtApp._processingMiddleware;
+      });
+      await router.replace(initialURL);
+      if (!isEqual(route.fullPath, initialURL)) {
+        await nuxtApp.runWithContext(() => navigateTo(route.fullPath));
+      }
+    });
+    return {
+      provide: {
+        route,
+        router
+      }
+    };
+  }
+});

package/dist/app/plugins/utils.d.ts

@@ -0,0 +1 @@
+export declare function isValidIslandKey(key: string): boolean;

package/dist/app/plugins/utils.js

@@ -0,0 +1,4 @@
+const VALID_ISLAND_KEY_RE = /^[a-z][a-z\d-]*_[a-z\d]+$/i;
+export function isValidIslandKey(key) {
+  return typeof key === "string" && VALID_ISLAND_KEY_RE.test(key) && key.length <= 100;
+}

package/dist/app/plugins/view-transitions.client.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../nuxt.js").Plugin<Record<string, unknown>> & import("../nuxt.js").ObjectPlugin<Record<string, unknown>>;
+export default _default;

package/dist/app/plugins/view-transitions.client.js

@@ -0,0 +1,55 @@
+import { isChangingPage } from "../components/utils.js";
+import { useRouter } from "../composables/router.js";
+import { defineNuxtPlugin } from "../nuxt.js";
+import { appViewTransition as defaultViewTransition } from "#build/nuxt.config.mjs";
+export default defineNuxtPlugin((nuxtApp) => {
+  if (!document.startViewTransition) {
+    return;
+  }
+  let transition;
+  let hasUAVisualTransition = false;
+  let finishTransition;
+  let abortTransition;
+  const resetTransitionState = () => {
+    transition = void 0;
+    hasUAVisualTransition = false;
+    abortTransition = void 0;
+    finishTransition = void 0;
+  };
+  window.addEventListener("popstate", (event) => {
+    hasUAVisualTransition = event.hasUAVisualTransition;
+    if (hasUAVisualTransition) {
+      transition?.skipTransition();
+    }
+  });
+  const router = useRouter();
+  router.beforeResolve(async (to, from) => {
+    const viewTransitionMode = to.meta.viewTransition ?? defaultViewTransition;
+    const prefersReducedMotion = window.matchMedia("(prefers-reduced-motion: reduce)").matches;
+    const prefersNoTransition = prefersReducedMotion && viewTransitionMode !== "always";
+    if (viewTransitionMode === false || prefersNoTransition || hasUAVisualTransition || !isChangingPage(to, from)) {
+      return;
+    }
+    const promise = new Promise((resolve, reject) => {
+      finishTransition = resolve;
+      abortTransition = reject;
+    });
+    let changeRoute;
+    const ready = new Promise((resolve) => changeRoute = resolve);
+    transition = document.startViewTransition(() => {
+      changeRoute();
+      return promise;
+    });
+    transition.finished.then(resetTransitionState);
+    await nuxtApp.callHook("page:view-transition:start", transition);
+    return ready;
+  });
+  nuxtApp.hook("vue:error", () => {
+    abortTransition?.();
+    resetTransitionState();
+  });
+  nuxtApp.hook("page:finish", () => {
+    finishTransition?.();
+    resetTransitionState();
+  });
+});

package/dist/app/plugins/warn.dev.server.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../nuxt.js").Plugin<Record<string, unknown>> & import("../nuxt.js").ObjectPlugin<Record<string, unknown>>;
+export default _default;

package/dist/app/plugins/warn.dev.server.js

@@ -0,0 +1,6 @@
+import { defineNuxtPlugin } from "../nuxt.js";
+export default defineNuxtPlugin((nuxtApp) => {
+  nuxtApp.vueApp.config.warnHandler ??= (msg, _instance, trace) => {
+    console.warn(`[Vue warn]: ${msg}`, trace);
+  };
+});

package/dist/app/types/augments.d.ts

@@ -0,0 +1,49 @@
+import type { UseHeadInput } from '@unhead/vue/types';
+import type { NuxtApp, useNuxtApp } from '../nuxt.js';
+declare global {
+    namespace NodeJS {
+        interface Process {
+            /** @deprecated Use `import.meta.browser` instead. This may be removed in Nuxt v5 or a future major version. */
+            browser: boolean;
+            /** @deprecated Use `import.meta.client` instead. This may be removed in Nuxt v5 or a future major version. */
+            client: boolean;
+            /** @deprecated Use `import.meta.dev` instead. This may be removed in Nuxt v5 or a future major version. */
+            dev: boolean;
+            /** @deprecated Use `import.meta.server` instead. This may be removed in Nuxt v5 or a future major version. */
+            server: boolean;
+            /** @deprecated Use `import.meta.test` instead. This may be removed in Nuxt v5 or a future major version. */
+            test: boolean;
+        }
+    }
+    interface ImportMeta {
+        browser: boolean;
+        client: boolean;
+        dev: boolean;
+        server: boolean;
+        test: boolean;
+    }
+    interface Window {
+        __NUXT__?: Record<string, any> | Record<string, Record<string, any>>;
+        useNuxtApp?: typeof useNuxtApp;
+    }
+}
+declare module 'vue' {
+    interface App<HostElement> {
+        $nuxt: NuxtApp;
+    }
+    interface ComponentCustomProperties {
+        $nuxt: NuxtApp;
+    }
+    interface ComponentInternalInstance {
+        _nuxtOnBeforeMountCbs: Array<() => void | Promise<void>>;
+        _nuxtIdIndex?: Record<string, number>;
+        _nuxtClientOnly?: boolean;
+    }
+    interface ComponentCustomOptions {
+        /**
+         * Available exclusively for `defineNuxtComponent`.
+         * It will not be executed when using `defineComponent`.
+         */
+        head?(nuxtApp: NuxtApp): UseHeadInput;
+    }
+}

package/dist/app/types.d.ts

@@ -0,0 +1,39 @@
+import type { SerializableHead } from '@unhead/vue';
+export type { PageMeta, NuxtPageProps } from '../pages/runtime/index.js';
+export interface NuxtAppLiterals {
+    [key: string]: string;
+}
+export interface NuxtIslandSlotResponse {
+    props: Array<unknown>;
+    fallback?: string;
+}
+export interface NuxtIslandClientResponse {
+    html: string;
+    props: unknown;
+    chunk: string;
+    slots?: Record<string, string>;
+}
+export interface NuxtIslandContext {
+    id?: string;
+    name: string;
+    props?: Record<string, any>;
+    url: string;
+    slots: Record<string, Omit<NuxtIslandSlotResponse, 'fallback'>>;
+    components: Record<string, Omit<NuxtIslandClientResponse, 'html'>>;
+}
+export interface NuxtIslandResponse {
+    id?: string;
+    html: string;
+    head: SerializableHead;
+    props?: Record<string, Record<string, any>>;
+    components?: Record<string, NuxtIslandClientResponse>;
+    slots?: Record<string, NuxtIslandSlotResponse>;
+}
+export interface NuxtRenderHTMLContext {
+    htmlAttrs: string[];
+    head: string[];
+    bodyAttrs: string[];
+    bodyPrepend: string[];
+    body: string[];
+    bodyAppend: string[];
+}

package/dist/app/utils.d.ts

@@ -0,0 +1,13 @@
+/** @since 3.9.0 */
+export declare function toArray<T>(value: T | T[]): T[];
+export declare function getUserTrace(): {
+    source: string;
+    column?: number;
+    function?: string;
+    line?: number;
+}[];
+export declare function getUserCaller(): {
+    source: string;
+    line: number | undefined;
+    column: number | undefined;
+} | null;

package/dist/app/utils.js

@@ -0,0 +1,34 @@
+import { captureStackTrace } from "errx";
+export function toArray(value) {
+  return Array.isArray(value) ? value : [value];
+}
+const distURL = import.meta.url.replace(/\/app\/.*$/, "/");
+export function getUserTrace() {
+  if (!import.meta.dev) {
+    return [];
+  }
+  const trace = captureStackTrace();
+  const start = trace.findIndex((entry) => !entry.source.startsWith(distURL));
+  const end = [...trace].reverse().findIndex((entry) => !entry.source.includes("node_modules") && !entry.source.startsWith(distURL));
+  if (start === -1 || end === -1) {
+    return [];
+  }
+  return trace.slice(start, -end).map((i) => ({
+    ...i,
+    source: i.source.replace(/^file:\/\//, "")
+  }));
+}
+export function getUserCaller() {
+  if (!import.meta.dev) {
+    return null;
+  }
+  const { source, line, column } = captureStackTrace().find((entry) => !entry.source.startsWith(distURL)) ?? {};
+  if (!source) {
+    return null;
+  }
+  return {
+    source: source.replace(/^file:\/\//, ""),
+    line,
+    column
+  };
+}

package/dist/components/runtime/client-component.d.ts

@@ -0,0 +1,2 @@
+import type { AsyncComponentLoader } from 'vue';
+export declare function createClientPage(loader: AsyncComponentLoader): Promise<any>;

package/dist/components/runtime/client-component.js

@@ -0,0 +1,59 @@
+import { getCurrentInstance, h, onMounted, provide, shallowRef } from "vue";
+import { isPromise } from "@vue/shared";
+import { useNuxtApp } from "#app/nuxt";
+import ServerPlaceholder from "#app/components/server-placeholder";
+import { clientOnlySymbol } from "#app/components/client-only";
+// @__NO_SIDE_EFFECTS__
+export async function createClientPage(loader) {
+  const m = await loader();
+  const c = m.default || m;
+  if (import.meta.dev) {
+    c.__clientOnlyPage = true;
+  }
+  return pageToClientOnly(c);
+}
+const cache = /* @__PURE__ */ new WeakMap();
+function pageToClientOnly(component) {
+  if (import.meta.server) {
+    return ServerPlaceholder;
+  }
+  if (cache.has(component)) {
+    return cache.get(component);
+  }
+  const clone = { ...component };
+  if (clone.render) {
+    clone.render = (ctx, cache2, $props, $setup, $data, $options) => $setup.mounted$ ?? ctx.mounted$ ? h(component.render?.bind(ctx)(ctx, cache2, $props, $setup, $data, $options)) : h("div");
+  } else {
+    clone.template &&= `
+      <template v-if="mounted$">${component.template}</template>
+      <template v-else><div></div></template>
+    `;
+  }
+  clone.setup = (props, ctx) => {
+    const nuxtApp = useNuxtApp();
+    const mounted$ = shallowRef(nuxtApp.isHydrating === false);
+    provide(clientOnlySymbol, true);
+    const vm = getCurrentInstance();
+    if (vm) {
+      vm._nuxtClientOnly = true;
+    }
+    onMounted(() => {
+      mounted$.value = true;
+    });
+    const setupState = component.setup?.(props, ctx) || {};
+    if (isPromise(setupState)) {
+      return Promise.resolve(setupState).then((setupState2) => {
+        if (typeof setupState2 !== "function") {
+          setupState2 ||= {};
+          setupState2.mounted$ = mounted$;
+          return setupState2;
+        }
+        return (...args) => mounted$.value || !nuxtApp.isHydrating ? h(setupState2(...args)) : h("div");
+      });
+    } else {
+      return typeof setupState === "function" ? (...args) => mounted$.value || !nuxtApp.isHydrating ? h(setupState(...args)) : h("div") : Object.assign(setupState, { mounted$ });
+    }
+  };
+  cache.set(component, clone);
+  return clone;
+}