@depup/nuxt 4.2.2-depup.0

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016-present - Nuxt Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,117 @@
+[![Nuxt banner](https://github.com/nuxt/nuxt/blob/main/.github/assets/banner.svg)](https://nuxt.com)
+
+# Nuxt
+
+<p>
+  <a href="https://www.npmjs.com/package/nuxt"><img src="https://img.shields.io/npm/v/nuxt.svg?style=flat&colorA=18181B&colorB=28CF8D" alt="Version"></a>
+  <a href="https://www.npmjs.com/package/nuxt"><img src="https://img.shields.io/npm/dm/nuxt.svg?style=flat&colorA=18181B&colorB=28CF8D" alt="Downloads"></a>
+  <a href="https://github.com/nuxt/nuxt/blob/main/LICENSE"><img src="https://img.shields.io/github/license/nuxt/nuxt.svg?style=flat&colorA=18181B&colorB=28CF8D" alt="License"></a>
+  <a href="https://nuxt.com"><img src="https://img.shields.io/badge/Nuxt%20Docs-18181B?logo=nuxt" alt="Website"></a>
+  <a href="https://chat.nuxt.dev"><img src="https://img.shields.io/badge/Nuxt%20Discord-18181B?logo=discord" alt="Discord"></a>
+  <a href="https://securityscorecards.dev/"><img src="https://api.securityscorecards.dev/projects/github.com/nuxt/nuxt/badge" alt="Nuxt openssf scorecard score"></a>
+</p>
+
+Nuxt is a free and open-source framework with an intuitive and extendable way to create type-safe, performant and production-grade full-stack web applications and websites with Vue.js.
+
+It provides a number of features that make it easy to build fast, SEO-friendly, and scalable web applications, including:
+- Server-side rendering, static site generation, hybrid rendering and edge-side rendering
+- Automatic routing with code-splitting and pre-fetching
+- Data fetching and state management
+- Search engine optimization and defining meta tags
+- Auto imports of components, composables and utils
+- TypeScript with zero configuration
+- Go full-stack with our server/ directory
+- Extensible with [200+ modules](https://nuxt.com/modules)
+- Deployment to a variety of [hosting platforms](https://nuxt.com/deploy)
+- ...[and much more](https://nuxt.com) 🚀
+
+### Table of Contents
+
+- 🚀 [Getting Started](#getting-started)
+- 💻 [ Vue Development](#vue-development)
+- 📖 [Documentation](#documentation)
+- 🧩 [Modules](#modules)
+- ❤️ [Contribute](#contribute)
+- 🏠 [Local Development](#local-development)
+- 🛟 [Professional Support](#professional-support)
+- 🔗 [Follow Us](#follow-us)
+- ⚖️ [License](#license)
+
+---
+
+## <a name="getting-started">🚀 Getting Started</a>
+
+Use the following command to create a new starter project. This will create a starter project with all the necessary files and dependencies:
+
+```bash
+npm create nuxt@latest <my-project>
+```
+
+> [!TIP]
+> Discover also [nuxt.new](https://nuxt.new): Open a Nuxt starter on CodeSandbox, StackBlitz or locally to get up and running in a few seconds.
+
+## <a name="vue-development">💻 Vue Development</a>
+
+Simple, intuitive and powerful, Nuxt lets you write Vue components in a way that makes sense. Every repetitive task is automated, so you can focus on writing your full-stack Vue application with confidence.
+
+Example of an `app.vue`:
+
+```vue
+<script setup lang="ts">
+useSeoMeta({
+  title: 'Meet Nuxt',
+  description: 'The Intuitive Vue Framework.',
+})
+</script>
+
+<template>
+  <div id="app">
+    <AppHeader />
+    <NuxtPage />
+    <AppFooter />
+  </div>
+</template>
+
+<style scoped>
+#app {
+  background-color: #020420;
+  color: #00DC82;
+}
+</style>
+```
+
+## <a name="documentation">📖 Documentation</a>
+
+We highly recommend you take a look at the [Nuxt documentation](https://nuxt.com/docs) to level up. It’s a great resource for learning more about the framework. It covers everything from getting started to advanced topics.
+
+## <a name="modules">🧩 Modules</a>
+
+Discover our [list of modules](https://nuxt.com/modules) to supercharge your Nuxt project, created by the Nuxt team and community.
+
+## <a name="contribute">❤️ Contribute</a>
+
+We invite you to contribute and help improve Nuxt 💚
+
+Here are a few ways you can get involved:
+- **Reporting Bugs:** If you come across any bugs or issues, please check out the [reporting bugs guide](https://nuxt.com/docs/4.x/community/reporting-bugs) to learn how to submit a bug report.
+- **Suggestions:** Have ideas to enhance Nuxt? We'd love to hear them! Check out the [contribution guide](https://nuxt.com/docs/4.x/community/contribution) to share your suggestions.
+- **Questions:** If you have questions or need assistance, the [getting help guide](https://nuxt.com/docs/4.x/community/getting-help) provides resources to help you out.
+
+## <a name="local-development">🏠 Local Development</a>
+
+Follow the docs to [Set Up Your Local Development Environment](https://nuxt.com/docs/4.x/community/framework-contribution#setup) to contribute to the framework and documentation.
+
+## <a name="professional-support">🛟 Professional Support</a>
+
+- Technical audit & consulting: [Nuxt Experts](https://nuxt.com/enterprise/support)
+- Custom development & more: [Nuxt Agencies Partners](https://nuxt.com/enterprise/agencies)
+
+## <a name="follow-us">🔗 Follow Us</a>
+
+<p valign="center">
+  <a href="https://go.nuxt.com/discord"><img width="20px" src="https://github.com/nuxt/nuxt/blob/main/.github/assets/discord.svg" alt="Discord"></a>&nbsp;&nbsp;<a href="https://go.nuxt.com/x"><img width="20px" src="https://github.com/nuxt/nuxt/blob/main/.github/assets/twitter.svg" alt="Twitter"></a>&nbsp;&nbsp;<a href="https://go.nuxt.com/github"><img width="20px" src="https://github.com/nuxt/nuxt/blob/main/.github/assets/github.svg" alt="GitHub"></a>&nbsp;&nbsp;<a href="https://go.nuxt.com/bluesky"><img width="20px" src="https://github.com/nuxt/nuxt/blob/main/.github/assets/bluesky.svg" alt="Bluesky"></a>
+</p>
+
+## <a name="license">⚖️ License</a>
+
+[MIT](https://github.com/nuxt/nuxt/blob/main/LICENSE)

package/app.d.ts

@@ -0,0 +1 @@
+export * from './dist/app/index'

package/bin/nuxt.mjs

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import '@nuxt/cli/cli'

package/config.cjs

@@ -0,0 +1,7 @@
+function defineNuxtConfig (config) {
+  return config
+}
+
+module.exports = {
+  defineNuxtConfig,
+}

package/config.d.ts

@@ -0,0 +1,8 @@
+import type { ConfigLayerMeta, DefineConfig } from 'c12'
+import type { NuxtConfig } from 'nuxt/schema'
+
+export { NuxtConfig } from 'nuxt/schema'
+
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+export interface DefineNuxtConfig extends DefineConfig<NuxtConfig, ConfigLayerMeta> {}
+export declare const defineNuxtConfig: DefineNuxtConfig

package/config.js

@@ -0,0 +1,5 @@
+function defineNuxtConfig (config) {
+  return config
+}
+
+export { defineNuxtConfig }

package/dist/app/compat/capi.d.ts

@@ -0,0 +1,4 @@
+export * from 'vue';
+export declare const install: () => void;
+export declare function set(target: any, key: string | number | symbol, val: any): any;
+export declare function del(target: any, key: string | number | symbol): void;

package/dist/app/compat/capi.js

@@ -0,0 +1,19 @@
+export * from "vue";
+export const install = () => {
+};
+export function set(target, key, val) {
+  if (Array.isArray(target)) {
+    target.length = Math.max(target.length, key);
+    target.splice(key, 1, val);
+    return val;
+  }
+  target[key] = val;
+  return val;
+}
+export function del(target, key) {
+  if (Array.isArray(target)) {
+    target.splice(key, 1);
+    return;
+  }
+  delete target[key];
+}

package/dist/app/compat/idle-callback.d.ts

@@ -0,0 +1,2 @@
+export declare const requestIdleCallback: Window['requestIdleCallback'];
+export declare const cancelIdleCallback: Window['cancelIdleCallback'];

package/dist/app/compat/idle-callback.js

@@ -0,0 +1,15 @@
+export const requestIdleCallback = import.meta.server ? (() => {
+}) : globalThis.requestIdleCallback || ((cb) => {
+  const start = Date.now();
+  const idleDeadline = {
+    didTimeout: false,
+    timeRemaining: () => Math.max(0, 50 - (Date.now() - start))
+  };
+  return setTimeout(() => {
+    cb(idleDeadline);
+  }, 1);
+});
+export const cancelIdleCallback = import.meta.server ? (() => {
+}) : globalThis.cancelIdleCallback || ((id) => {
+  clearTimeout(id);
+});

package/dist/app/compat/interval.d.ts

@@ -0,0 +1 @@
+export declare const setInterval: typeof globalThis.setInterval | (() => void);

package/dist/app/compat/interval.js

@@ -0,0 +1,11 @@
+import { createError } from "../composables/error.js";
+const intervalError = "[nuxt] `setInterval` should not be used on the server. Consider wrapping it with an `onNuxtReady`, `onBeforeMount` or `onMounted` lifecycle hook, or ensure you only call it in the browser by checking `import.meta.client`.";
+export const setInterval = import.meta.client ? globalThis.setInterval : () => {
+  if (import.meta.dev) {
+    throw createError({
+      statusCode: 500,
+      message: intervalError
+    });
+  }
+  console.error(intervalError);
+};

package/dist/app/compat/vue-demi.d.ts

@@ -0,0 +1,4 @@
+export * from './capi.js';
+export declare const Vue2: undefined;
+export declare const isVue2 = false;
+export declare const isVue3 = true;

package/dist/app/compat/vue-demi.js

@@ -0,0 +1,4 @@
+export * from "./capi.js";
+export const Vue2 = void 0;
+export const isVue2 = false;
+export const isVue3 = true;

package/dist/app/components/client-fallback.client.d.ts

@@ -0,0 +1,50 @@
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    fallbackTag: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    fallback: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    placeholder: {
+        type: StringConstructor;
+    };
+    placeholderTag: {
+        type: StringConstructor;
+    };
+    keepFallback: {
+        type: BooleanConstructor;
+        default: () => boolean;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[] | undefined, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "ssr-error"[], "ssr-error", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    fallbackTag: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    fallback: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    placeholder: {
+        type: StringConstructor;
+    };
+    placeholderTag: {
+        type: StringConstructor;
+    };
+    keepFallback: {
+        type: BooleanConstructor;
+        default: () => boolean;
+    };
+}>> & Readonly<{
+    "onSsr-error"?: ((...args: any[]) => any) | undefined;
+}>, {
+    fallback: string;
+    fallbackTag: string;
+    keepFallback: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/app/components/client-fallback.client.js

@@ -0,0 +1,50 @@
+import { createElementBlock, defineComponent, onMounted, shallowRef, useId } from "vue";
+import { useState } from "../composables/state.js";
+export default defineComponent({
+  name: "NuxtClientFallback",
+  inheritAttrs: false,
+  props: {
+    fallbackTag: {
+      type: String,
+      default: () => "div"
+    },
+    fallback: {
+      type: String,
+      default: () => ""
+    },
+    placeholder: {
+      type: String
+    },
+    placeholderTag: {
+      type: String
+    },
+    keepFallback: {
+      type: Boolean,
+      default: () => false
+    }
+  },
+  emits: ["ssr-error"],
+  setup(props, ctx) {
+    const mounted = shallowRef(false);
+    const ssrFailed = useState(useId());
+    if (ssrFailed.value) {
+      onMounted(() => {
+        mounted.value = true;
+      });
+    }
+    return () => {
+      if (ssrFailed.value) {
+        if (!mounted.value || props.keepFallback) {
+          const slot = ctx.slots.placeholder || ctx.slots.fallback;
+          if (slot) {
+            return slot();
+          }
+          const fallbackStr = props.placeholder || props.fallback;
+          const fallbackTag = props.placeholderTag || props.fallbackTag;
+          return createElementBlock(fallbackTag, null, fallbackStr);
+        }
+      }
+      return ctx.slots.default?.();
+    };
+  }
+});

package/dist/app/components/client-fallback.server.d.ts

@@ -0,0 +1,57 @@
+declare const NuxtClientFallbackServer: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    fallbackTag: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    fallback: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    placeholder: {
+        type: StringConstructor;
+    };
+    placeholderTag: {
+        type: StringConstructor;
+    };
+    keepFallback: {
+        type: BooleanConstructor;
+        default: () => boolean;
+    };
+}>, {
+    ssrFailed: import("vue").ShallowRef<boolean, boolean>;
+    ssrVNodes: {
+        getBuffer(): import("./utils.js").SSRBuffer;
+        push(item: import("./utils.js").SSRBufferItem): void;
+    };
+} | {
+    ssrFailed: boolean;
+    ssrVNodes: never[];
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    'ssr-error'(_error: unknown): true;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    fallbackTag: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    fallback: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    placeholder: {
+        type: StringConstructor;
+    };
+    placeholderTag: {
+        type: StringConstructor;
+    };
+    keepFallback: {
+        type: BooleanConstructor;
+        default: () => boolean;
+    };
+}>> & Readonly<{
+    "onSsr-error"?: ((_error: unknown) => any) | undefined;
+}>, {
+    fallback: string;
+    fallbackTag: string;
+    keepFallback: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default NuxtClientFallbackServer;

package/dist/app/components/client-fallback.server.js

@@ -0,0 +1,80 @@
+import { defineComponent, getCurrentInstance, onErrorCaptured, shallowRef, useId } from "vue";
+import { ssrRenderAttrs, ssrRenderSlot, ssrRenderVNode } from "vue/server-renderer";
+import { isPromise } from "@vue/shared";
+import { useState } from "../composables/state.js";
+import { createBuffer } from "./utils.js";
+const NuxtClientFallbackServer = defineComponent({
+  name: "NuxtClientFallback",
+  inheritAttrs: false,
+  props: {
+    fallbackTag: {
+      type: String,
+      default: () => "div"
+    },
+    fallback: {
+      type: String,
+      default: () => ""
+    },
+    placeholder: {
+      type: String
+    },
+    placeholderTag: {
+      type: String
+    },
+    keepFallback: {
+      type: Boolean,
+      default: () => false
+    }
+  },
+  emits: {
+    "ssr-error"(_error) {
+      return true;
+    }
+  },
+  async setup(_, ctx) {
+    const vm = getCurrentInstance();
+    const ssrFailed = shallowRef(false);
+    const error = useState(useId());
+    onErrorCaptured((err) => {
+      error.value = true;
+      ssrFailed.value = true;
+      ctx.emit("ssr-error", err);
+      return false;
+    });
+    try {
+      const defaultSlot = ctx.slots.default?.();
+      const ssrVNodes = createBuffer();
+      if (defaultSlot) {
+        for (let i = 0; i < defaultSlot.length; i++) {
+          ssrRenderVNode(ssrVNodes.push, defaultSlot[i], vm);
+        }
+      }
+      const buffer = ssrVNodes.getBuffer();
+      if (buffer.hasAsync) {
+        await Promise.all(buffer.filter(isPromise));
+      }
+      return { ssrFailed, ssrVNodes };
+    } catch (ssrError) {
+      error.value = true;
+      ctx.emit("ssr-error", ssrError);
+      return { ssrFailed: true, ssrVNodes: [] };
+    }
+  },
+  ssrRender(ctx, push, parent) {
+    if (ctx.ssrFailed) {
+      const { fallback, placeholder } = ctx.$slots;
+      if (fallback || placeholder) {
+        ssrRenderSlot(ctx.$slots, fallback ? "fallback" : "placeholder", {}, null, push, parent);
+      } else {
+        const content = ctx.placeholder || ctx.fallback;
+        const tag = ctx.placeholderTag || ctx.fallbackTag;
+        push(`<${tag}${ssrRenderAttrs(ctx.$attrs)}>${content}</${tag}>`);
+      }
+    } else {
+      push("<!--[-->");
+      push(ctx.ssrVNodes.getBuffer());
+      push("<!--]-->");
+    }
+  }
+});
+export default NuxtClientFallbackServer;

package/dist/app/components/client-only.d.ts

@@ -0,0 +1,26 @@
+import type { ComponentOptions, InjectionKey, SlotsType, VNode } from 'vue';
+export declare const clientOnlySymbol: InjectionKey<boolean>;
+declare const _default: import("vue").DefineComponent<{
+    placeholder?: any;
+    fallback?: any;
+    placeholderTag?: any;
+    fallbackTag?: any;
+}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> | VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[] | undefined, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{
+    placeholder?: any;
+    fallback?: any;
+    placeholderTag?: any;
+    fallbackTag?: any;
+}> & Readonly<{}>, {}, SlotsType<{
+    default?: () => VNode[];
+    /**
+     * Specify a content to be rendered on the server and displayed until `<ClientOnly>` is mounted in the browser.
+     */
+    fallback?: () => VNode[];
+    placeholder?: () => VNode[];
+}>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;
+export declare function createClientOnly<T extends ComponentOptions>(component: T): any;

package/dist/app/components/client-only.js

@@ -0,0 +1,130 @@
+import { cloneVNode, createElementBlock, defineComponent, getCurrentInstance, h, onMounted, provide, shallowRef } from "vue";
+import { isPromise } from "@vue/shared";
+import { useNuxtApp } from "../nuxt.js";
+import ServerPlaceholder from "./server-placeholder.js";
+import { elToStaticVNode } from "./utils.js";
+export const clientOnlySymbol = Symbol.for("nuxt:client-only");
+const STATIC_DIV = "<div></div>";
+export default defineComponent({
+  name: "ClientOnly",
+  inheritAttrs: false,
+  props: ["fallback", "placeholder", "placeholderTag", "fallbackTag"],
+  ...import.meta.dev && {
+    slots: Object
+  },
+  setup(props, { slots, attrs }) {
+    const mounted = shallowRef(false);
+    onMounted(() => {
+      mounted.value = true;
+    });
+    if (import.meta.dev) {
+      const nuxtApp = useNuxtApp();
+      nuxtApp._isNuxtPageUsed = true;
+      nuxtApp._isNuxtLayoutUsed = true;
+    }
+    const vm = getCurrentInstance();
+    if (vm) {
+      vm._nuxtClientOnly = true;
+    }
+    provide(clientOnlySymbol, true);
+    return () => {
+      if (mounted.value) {
+        const vnodes = slots.default?.();
+        if (vnodes && vnodes.length === 1) {
+          return [cloneVNode(vnodes[0], attrs)];
+        }
+        return vnodes;
+      }
+      const slot = slots.fallback || slots.placeholder;
+      if (slot) {
+        return h(slot);
+      }
+      const fallbackStr = props.fallback || props.placeholder || "";
+      const fallbackTag = props.fallbackTag || props.placeholderTag || "span";
+      return createElementBlock(fallbackTag, attrs, fallbackStr);
+    };
+  }
+});
+const cache = /* @__PURE__ */ new WeakMap();
+// @__NO_SIDE_EFFECTS__
+export function createClientOnly(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) => {
+      if ($setup.mounted$ ?? ctx.mounted$) {
+        const res = component.render?.bind(ctx)(ctx, cache2, $props, $setup, $data, $options);
+        return res.children === null || typeof res.children === "string" ? cloneVNode(res) : h(res);
+      }
+      return elToStaticVNode(ctx._.vnode.el, STATIC_DIV);
+    };
+  } else {
+    clone.template &&= `
+      <template v-if="mounted$">${component.template}</template>
+      <template v-else>${STATIC_DIV}</template>
+    `;
+  }
+  clone.setup = (props, ctx) => {
+    const nuxtApp = useNuxtApp();
+    const mounted$ = shallowRef(nuxtApp.isHydrating === false);
+    const instance = getCurrentInstance();
+    if (nuxtApp.isHydrating) {
+      const attrs = { ...instance.attrs };
+      const directives = extractDirectives(instance);
+      for (const key in attrs) {
+        delete instance.attrs[key];
+      }
+      onMounted(() => {
+        Object.assign(instance.attrs, attrs);
+        instance.vnode.dirs = directives;
+      });
+    }
+    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) => {
+          if (mounted$.value || !nuxtApp.isHydrating) {
+            const res = setupState2(...args);
+            return res.children === null || typeof res.children === "string" ? cloneVNode(res) : h(res);
+          }
+          return elToStaticVNode(instance?.vnode.el, STATIC_DIV);
+        };
+      });
+    } else {
+      if (typeof setupState === "function") {
+        return (...args) => {
+          if (mounted$.value) {
+            const res = setupState(...args);
+            const attrs = clone.inheritAttrs !== false ? ctx.attrs : void 0;
+            return res.children === null || typeof res.children === "string" ? cloneVNode(res, attrs) : h(res, attrs);
+          }
+          return elToStaticVNode(instance?.vnode.el, STATIC_DIV);
+        };
+      }
+      return Object.assign(setupState, { mounted$ });
+    }
+  };
+  cache.set(component, clone);
+  return clone;
+}
+function extractDirectives(instance) {
+  if (!instance || !instance.vnode.dirs) {
+    return null;
+  }
+  const directives = instance.vnode.dirs;
+  instance.vnode.dirs = null;
+  return directives;
+}

package/dist/app/components/dev-only.d.ts

@@ -0,0 +1,11 @@
+import type { SlotsType, VNode } from 'vue';
+declare const _default: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[] | undefined, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, SlotsType<{
+    default?: () => VNode[];
+    /**
+     * If you ever require to have a replacement during production.
+     */
+    fallback?: () => VNode[];
+}>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/app/components/dev-only.js

@@ -0,0 +1,14 @@
+import { defineComponent } from "vue";
+export default defineComponent({
+  name: "DevOnly",
+  inheritAttrs: false,
+  ...import.meta.dev && {
+    slots: Object
+  },
+  setup(_, props) {
+    if (import.meta.dev) {
+      return () => props.slots.default?.();
+    }
+    return () => props.slots.fallback?.();
+  }
+});