@depup/nuxt 4.2.2-depup.0

package/dist/app/components/nuxt-island.js

@@ -0,0 +1,331 @@
+import { Fragment, Teleport, computed, createStaticVNode, createVNode, defineComponent, getCurrentInstance, h, nextTick, onBeforeUnmount, onMounted, ref, shallowRef, toRaw, watch, withMemo } from "vue";
+import { debounce } from "perfect-debounce";
+import { hash } from "ohash";
+import { appendResponseHeader } from "h3";
+import { randomUUID } from "uncrypto";
+import { joinURL, withQuery } from "ufo";
+import { useNuxtApp, useRuntimeConfig } from "../nuxt.js";
+import { createError } from "../composables/error.js";
+import { prerenderRoutes, useRequestEvent } from "../composables/ssr.js";
+import { injectHead } from "../composables/head.js";
+import { getFragmentHTML, isEndFragment, isStartFragment } from "./utils.js";
+import { appBaseURL, remoteComponentIslands, selectiveClient } from "#build/nuxt.config.mjs";
+const pKey = "_islandPromises";
+const SSR_UID_RE = /data-island-uid="([^"]*)"/;
+const DATA_ISLAND_UID_RE = /data-island-uid(="")?(?!="[^"])/g;
+const SLOTNAME_RE = /data-island-slot="([^"]*)"/g;
+const SLOT_FALLBACK_RE = / data-island-slot="([^"]*)"[^>]*>/g;
+const ISLAND_SCOPE_ID_RE = /^<[^> ]*/;
+let id = 1;
+const getId = import.meta.client ? () => (id++).toString() : randomUUID;
+const components = import.meta.client ? /* @__PURE__ */ new Map() : void 0;
+async function loadComponents(source = appBaseURL, paths) {
+  if (!paths) {
+    return;
+  }
+  const promises = [];
+  for (const [component, item] of Object.entries(paths)) {
+    if (!components.has(component)) {
+      promises.push((async () => {
+        const chunkSource = joinURL(source, item.chunk);
+        const c = await import(
+          /* @vite-ignore */
+          chunkSource
+        ).then((m) => m.default || m);
+        components.set(component, c);
+      })());
+    }
+  }
+  await Promise.all(promises);
+}
+export default defineComponent({
+  name: "NuxtIsland",
+  inheritAttrs: false,
+  props: {
+    name: {
+      type: String,
+      required: true
+    },
+    lazy: Boolean,
+    props: {
+      type: Object,
+      default: () => void 0
+    },
+    context: {
+      type: Object,
+      default: () => ({})
+    },
+    scopeId: {
+      type: String,
+      default: () => void 0
+    },
+    source: {
+      type: String,
+      default: () => void 0
+    },
+    dangerouslyLoadClientComponents: {
+      type: Boolean,
+      default: false
+    }
+  },
+  emits: ["error"],
+  async setup(props, { slots, expose, emit }) {
+    let canTeleport = import.meta.server;
+    const teleportKey = shallowRef(0);
+    const key = shallowRef(0);
+    const canLoadClientComponent = computed(() => selectiveClient && (props.dangerouslyLoadClientComponents || !props.source));
+    const error = ref(null);
+    const config = useRuntimeConfig();
+    const nuxtApp = useNuxtApp();
+    const filteredProps = computed(() => props.props ? Object.fromEntries(Object.entries(props.props).filter(([key2]) => !key2.startsWith("data-v-"))) : {});
+    const hashId = computed(() => hash([props.name, filteredProps.value, props.context, props.source]).replace(/[-_]/g, ""));
+    const instance = getCurrentInstance();
+    const event = useRequestEvent();
+    let activeHead;
+    const eventFetch = import.meta.server ? event.fetch : globalThis.fetch;
+    const mounted = shallowRef(false);
+    onMounted(() => {
+      mounted.value = true;
+      teleportKey.value++;
+    });
+    onBeforeUnmount(() => {
+      if (activeHead) {
+        activeHead.dispose();
+      }
+    });
+    function setPayload(key2, result) {
+      const toRevive = {};
+      if (result.props) {
+        toRevive.props = result.props;
+      }
+      if (result.slots) {
+        toRevive.slots = result.slots;
+      }
+      if (result.components) {
+        toRevive.components = result.components;
+      }
+      if (result.head) {
+        toRevive.head = result.head;
+      }
+      nuxtApp.payload.data[key2] = {
+        __nuxt_island: {
+          key: key2,
+          ...import.meta.server && import.meta.prerender ? {} : { params: { ...props.context, props: props.props ? JSON.stringify(props.props) : void 0 } },
+          result: toRevive
+        },
+        ...result
+      };
+    }
+    const payloads = {};
+    if (instance.vnode.el) {
+      const slots2 = toRaw(nuxtApp.payload.data[`${props.name}_${hashId.value}`])?.slots;
+      if (slots2) {
+        payloads.slots = slots2;
+      }
+      if (selectiveClient) {
+        const components2 = toRaw(nuxtApp.payload.data[`${props.name}_${hashId.value}`])?.components;
+        if (components2) {
+          payloads.components = components2;
+        }
+      }
+    }
+    const ssrHTML = ref("");
+    if (import.meta.client && instance.vnode?.el) {
+      if (import.meta.dev) {
+        let currentEl = instance.vnode.el;
+        let startEl = null;
+        let isFirstElement = true;
+        while (currentEl) {
+          if (isEndFragment(currentEl)) {
+            if (startEl !== currentEl.previousSibling) {
+              console.warn(`[\`Server components(and islands)\`] "${props.name}" must have a single root element. (HTML comments are considered elements as well.)`);
+            }
+            break;
+          } else if (!isStartFragment(currentEl) && isFirstElement) {
+            isFirstElement = false;
+            if (currentEl.nodeType === 1) {
+              startEl = currentEl;
+            }
+          }
+          currentEl = currentEl.nextSibling;
+        }
+      }
+      ssrHTML.value = getFragmentHTML(instance.vnode.el, true)?.join("") || "";
+      const key2 = `${props.name}_${hashId.value}`;
+      nuxtApp.payload.data[key2] ||= {};
+      nuxtApp.payload.data[key2].html = ssrHTML.value.replaceAll(new RegExp(`data-island-uid="${ssrHTML.value.match(SSR_UID_RE)?.[1] || ""}"`, "g"), `data-island-uid=""`);
+    }
+    const uid = ref(ssrHTML.value.match(SSR_UID_RE)?.[1] || getId());
+    const currentSlots = new Set(Object.keys(slots));
+    const availableSlots = computed(() => new Set([...ssrHTML.value.matchAll(SLOTNAME_RE)].map((m) => m[1])));
+    const html = computed(() => {
+      let html2 = ssrHTML.value;
+      if (props.scopeId) {
+        html2 = html2.replace(ISLAND_SCOPE_ID_RE, (full) => full + " " + props.scopeId);
+      }
+      if (import.meta.client && !canLoadClientComponent.value) {
+        for (const [key2, value] of Object.entries(payloads.components || {})) {
+          html2 = html2.replace(new RegExp(` data-island-uid="${uid.value}" data-island-component="${key2}"[^>]*>`), (full) => {
+            return full + value.html;
+          });
+        }
+      }
+      if (payloads.slots) {
+        return html2.replaceAll(SLOT_FALLBACK_RE, (full, slotName) => {
+          if (!currentSlots.has(slotName)) {
+            return full + (payloads.slots?.[slotName]?.fallback || "");
+          }
+          return full;
+        });
+      }
+      return html2;
+    });
+    const head = injectHead();
+    async function _fetchComponent(force = false) {
+      const key2 = `${props.name}_${hashId.value}`;
+      if (!force && nuxtApp.payload.data[key2]?.html) {
+        return nuxtApp.payload.data[key2];
+      }
+      const url = remoteComponentIslands && props.source ? joinURL(props.source, `/__nuxt_island/${key2}.json`) : `/__nuxt_island/${key2}.json`;
+      if (import.meta.server && import.meta.prerender) {
+        nuxtApp.runWithContext(() => prerenderRoutes(url));
+      }
+      const r = await eventFetch(withQuery(import.meta.dev && import.meta.client || props.source ? url : joinURL(config.app.baseURL ?? "", url), {
+        ...props.context,
+        props: props.props ? JSON.stringify(props.props) : void 0
+      }));
+      if (!r.ok) {
+        throw createError({ statusCode: r.status, statusMessage: r.statusText });
+      }
+      try {
+        const result = await r.json();
+        if (import.meta.server && import.meta.prerender) {
+          const hints = r.headers.get("x-nitro-prerender");
+          if (hints) {
+            appendResponseHeader(event, "x-nitro-prerender", hints);
+          }
+        }
+        setPayload(key2, result);
+        return result;
+      } catch (e) {
+        if (r.status !== 200) {
+          throw new Error(e.toString(), { cause: r });
+        }
+        throw e;
+      }
+    }
+    async function fetchComponent(force = false) {
+      nuxtApp[pKey] ||= {};
+      nuxtApp[pKey][uid.value] ||= _fetchComponent(force).finally(() => {
+        delete nuxtApp[pKey][uid.value];
+      });
+      try {
+        const res = await nuxtApp[pKey][uid.value];
+        ssrHTML.value = res.html.replaceAll(DATA_ISLAND_UID_RE, `data-island-uid="${uid.value}"`);
+        key.value++;
+        error.value = null;
+        payloads.slots = res.slots || {};
+        payloads.components = res.components || {};
+        if (selectiveClient && import.meta.client) {
+          if (canLoadClientComponent.value && res.components) {
+            await loadComponents(props.source, res.components);
+          }
+        }
+        if (res?.head) {
+          if (activeHead) {
+            activeHead.patch(res.head);
+          } else {
+            activeHead = head.push(res.head);
+          }
+        }
+        if (import.meta.client) {
+          nextTick(() => {
+            canTeleport = true;
+            teleportKey.value++;
+          });
+        }
+      } catch (e) {
+        error.value = e;
+        emit("error", e);
+      }
+    }
+    expose({
+      refresh: () => fetchComponent(true)
+    });
+    if (import.meta.hot) {
+      import.meta.hot.on(`nuxt-server-component:${props.name}`, () => {
+        fetchComponent(true);
+      });
+    }
+    if (import.meta.client) {
+      watch(props, debounce(() => fetchComponent(), 100), { deep: true });
+    }
+    if (import.meta.client && !instance.vnode.el && props.lazy) {
+      fetchComponent();
+    } else if (import.meta.server || !instance.vnode.el || !nuxtApp.payload.serverRendered) {
+      await fetchComponent();
+    } else if (selectiveClient && canLoadClientComponent.value) {
+      await loadComponents(props.source, payloads.components);
+    }
+    return (_ctx, _cache) => {
+      if (!html.value || error.value) {
+        return [slots.fallback?.({ error: error.value }) ?? createVNode("div")];
+      }
+      return [
+        withMemo([key.value], () => {
+          return createVNode(Fragment, { key: key.value }, [h(createStaticVNode(html.value || "<div></div>", 1))]);
+        }, _cache, 0),
+        // should away be triggered ONE tick after re-rendering the static node
+        withMemo([teleportKey.value], () => {
+          const teleports = [];
+          const isKeyOdd = teleportKey.value === 0 || !!(teleportKey.value && !(teleportKey.value % 2));
+          if (uid.value && html.value && (import.meta.server || props.lazy ? canTeleport : mounted.value || instance.vnode?.el)) {
+            for (const slot in slots) {
+              if (availableSlots.value.has(slot)) {
+                teleports.push(
+                  createVNode(
+                    Teleport,
+                    // use different selectors for even and odd teleportKey to force trigger the teleport
+                    { to: import.meta.client ? `${isKeyOdd ? "div" : ""}[data-island-uid="${uid.value}"][data-island-slot="${slot}"]` : `uid=${uid.value};slot=${slot}` },
+                    { default: () => (payloads.slots?.[slot]?.props?.length ? payloads.slots[slot].props : [{}]).map((data) => slots[slot]?.(data)) }
+                  )
+                );
+              }
+            }
+            if (selectiveClient) {
+              if (import.meta.server) {
+                if (payloads.components) {
+                  for (const [id2, info] of Object.entries(payloads.components)) {
+                    const { html: html2, slots: slots2 } = info;
+                    let replaced = html2.replaceAll("data-island-uid", `data-island-uid="${uid.value}"`);
+                    for (const slot in slots2) {
+                      replaced = replaced.replaceAll(`data-island-slot="${slot}">`, (full) => full + slots2[slot]);
+                    }
+                    teleports.push(createVNode(Teleport, { to: `uid=${uid.value};client=${id2}` }, {
+                      default: () => [createStaticVNode(replaced, 1)]
+                    }));
+                  }
+                }
+              } else if (canLoadClientComponent.value && payloads.components) {
+                for (const [id2, info] of Object.entries(payloads.components)) {
+                  const { props: props2, slots: slots2 } = info;
+                  const component = components.get(id2);
+                  const vnode = createVNode(Teleport, { to: `${isKeyOdd ? "div" : ""}[data-island-uid='${uid.value}'][data-island-component="${id2}"]` }, {
+                    default: () => {
+                      return [h(component, props2, Object.fromEntries(Object.entries(slots2 || {}).map(([k, v]) => [
+                        k,
+                        () => createStaticVNode(`<div style="display: contents" data-island-uid data-island-slot="${k}">${v}</div>`, 1)
+                      ])))];
+                    }
+                  });
+                  teleports.push(vnode);
+                }
+              }
+            }
+          }
+          return h(Fragment, teleports);
+        }, _cache, 1)
+      ];
+    };
+  }
+});

package/dist/app/components/nuxt-layout.d.ts

@@ -0,0 +1,14 @@
+import type { DefineComponent, ExtractPublicPropTypes, MaybeRef, PropType } from 'vue';
+import type { PageMeta } from '../../pages/runtime/composables.js';
+declare const nuxtLayoutProps: {
+    name: {
+        type: PropType<unknown extends PageMeta["layout"] ? MaybeRef<string | false> : PageMeta["layout"]>;
+        default: null;
+    };
+    fallback: {
+        type: PropType<unknown extends PageMeta["layout"] ? MaybeRef<string> : PageMeta["layout"]>;
+        default: null;
+    };
+};
+declare const _default: DefineComponent<ExtractPublicPropTypes<typeof nuxtLayoutProps>>;
+export default _default;

package/dist/app/components/nuxt-layout.js

@@ -0,0 +1,171 @@
+import { Suspense, computed, defineComponent, h, inject, mergeProps, nextTick, onMounted, provide, shallowReactive, shallowRef, unref } from "vue";
+import { useRoute, useRouter } from "../composables/router.js";
+import { useNuxtApp } from "../nuxt.js";
+import { _wrapInTransition } from "./utils.js";
+import { LayoutMetaSymbol, PageRouteSymbol } from "./injections.js";
+import { useRoute as useVueRouterRoute } from "#build/pages";
+import layouts from "#build/layouts";
+import { appLayoutTransition as defaultLayoutTransition } from "#build/nuxt.config.mjs";
+const LayoutLoader = defineComponent({
+  name: "LayoutLoader",
+  inheritAttrs: false,
+  props: {
+    name: String,
+    layoutProps: Object
+  },
+  setup(props, context) {
+    return () => h(layouts[props.name], props.layoutProps, context.slots);
+  }
+});
+const nuxtLayoutProps = {
+  name: {
+    type: [String, Boolean, Object],
+    default: null
+  },
+  fallback: {
+    type: [String, Object],
+    default: null
+  }
+};
+export default defineComponent({
+  name: "NuxtLayout",
+  inheritAttrs: false,
+  props: nuxtLayoutProps,
+  setup(props, context) {
+    const nuxtApp = useNuxtApp();
+    const injectedRoute = inject(PageRouteSymbol);
+    const shouldUseEagerRoute = !injectedRoute || injectedRoute === useRoute();
+    const route = shouldUseEagerRoute ? useVueRouterRoute() : injectedRoute;
+    const layout = computed(() => {
+      let layout2 = unref(props.name) ?? route?.meta.layout ?? "default";
+      if (layout2 && !(layout2 in layouts)) {
+        if (import.meta.dev && layout2 !== "default") {
+          console.warn(`Invalid layout \`${layout2}\` selected.`);
+        }
+        if (props.fallback) {
+          layout2 = unref(props.fallback);
+        }
+      }
+      return layout2;
+    });
+    const layoutRef = shallowRef();
+    context.expose({ layoutRef });
+    const done = nuxtApp.deferHydration();
+    if (import.meta.client && nuxtApp.isHydrating) {
+      const removeErrorHook = nuxtApp.hooks.hookOnce("app:error", done);
+      useRouter().beforeEach(removeErrorHook);
+    }
+    if (import.meta.dev) {
+      nuxtApp._isNuxtLayoutUsed = true;
+    }
+    let lastLayout;
+    return () => {
+      const hasLayout = layout.value && layout.value in layouts;
+      const transitionProps = route?.meta.layoutTransition ?? defaultLayoutTransition;
+      const previouslyRenderedLayout = lastLayout;
+      lastLayout = layout.value;
+      return _wrapInTransition(hasLayout && transitionProps, {
+        default: () => h(Suspense, { suspensible: true, onResolve: () => {
+          nextTick(done);
+        } }, {
+          default: () => h(
+            LayoutProvider,
+            {
+              layoutProps: mergeProps(context.attrs, { ref: layoutRef }),
+              key: layout.value || void 0,
+              name: layout.value,
+              shouldProvide: !props.name,
+              isRenderingNewLayout: (name) => {
+                return name !== previouslyRenderedLayout && name === layout.value;
+              },
+              hasTransition: !!transitionProps
+            },
+            context.slots
+          )
+        })
+      }).default();
+    };
+  }
+});
+const LayoutProvider = defineComponent({
+  name: "NuxtLayoutProvider",
+  inheritAttrs: false,
+  props: {
+    name: {
+      type: [String, Boolean]
+    },
+    layoutProps: {
+      type: Object
+    },
+    hasTransition: {
+      type: Boolean
+    },
+    shouldProvide: {
+      type: Boolean
+    },
+    isRenderingNewLayout: {
+      type: Function,
+      required: true
+    }
+  },
+  setup(props, context) {
+    const name = props.name;
+    if (props.shouldProvide) {
+      provide(LayoutMetaSymbol, {
+        isCurrent: (route) => name === (route.meta.layout ?? "default")
+      });
+    }
+    const injectedRoute = inject(PageRouteSymbol);
+    const isNotWithinNuxtPage = injectedRoute && injectedRoute === useRoute();
+    if (isNotWithinNuxtPage) {
+      const vueRouterRoute = useVueRouterRoute();
+      const reactiveChildRoute = {};
+      for (const _key in vueRouterRoute) {
+        const key = _key;
+        Object.defineProperty(reactiveChildRoute, key, {
+          enumerable: true,
+          get: () => {
+            return props.isRenderingNewLayout(props.name) ? vueRouterRoute[key] : injectedRoute[key];
+          }
+        });
+      }
+      provide(PageRouteSymbol, shallowReactive(reactiveChildRoute));
+    }
+    let vnode;
+    if (import.meta.dev && import.meta.client) {
+      onMounted(() => {
+        nextTick(() => {
+          if (["#comment", "#text"].includes(vnode?.el?.nodeName)) {
+            if (name) {
+              console.warn(`[nuxt] \`${name}\` layout does not have a single root node and will cause errors when navigating between routes.`);
+            } else {
+              console.warn("[nuxt] `<NuxtLayout>` needs to be passed a single root node in its default slot.");
+            }
+          }
+        });
+      });
+    }
+    return () => {
+      if (!name || typeof name === "string" && !(name in layouts)) {
+        if (import.meta.dev && import.meta.client && props.hasTransition) {
+          vnode = context.slots.default?.();
+          return vnode;
+        }
+        return context.slots.default?.();
+      }
+      if (import.meta.dev && import.meta.client && props.hasTransition) {
+        vnode = h(
+          LayoutLoader,
+          { key: name, layoutProps: props.layoutProps, name },
+          context.slots
+        );
+        return vnode;
+      }
+      return h(
+        LayoutLoader,
+        { key: name, layoutProps: props.layoutProps, name },
+        context.slots
+      );
+    };
+  }
+});

package/dist/app/components/nuxt-link.d.ts

@@ -0,0 +1,101 @@
+import type { AllowedComponentProps, AnchorHTMLAttributes, DefineSetupFnComponent, SlotsType, UnwrapRef, VNode, VNodeProps } from 'vue';
+import type { RouteLocation, RouteLocationRaw, RouterLinkProps, UseLinkReturn } from 'vue-router';
+import type { NuxtApp } from '../nuxt.js';
+/**
+ * `<NuxtLink>` is a drop-in replacement for both Vue Router's `<RouterLink>` component and HTML's `<a>` tag.
+ * @see https://nuxt.com/docs/4.x/api/components/nuxt-link
+ */
+export interface NuxtLinkProps<CustomProp extends boolean = false> extends Omit<RouterLinkProps, 'to'> {
+    custom?: CustomProp;
+    /**
+     * Route Location the link should navigate to when clicked on.
+     */
+    to?: RouteLocationRaw;
+    /**
+     * An alias for `to`. If used with `to`, `href` will be ignored
+     */
+    href?: NuxtLinkProps['to'];
+    /**
+     * Forces the link to be considered as external (true) or internal (false). This is helpful to handle edge-cases
+     */
+    external?: boolean;
+    /**
+     * Where to display the linked URL, as the name for a browsing context.
+     */
+    target?: '_blank' | '_parent' | '_self' | '_top' | (string & {}) | null;
+    /**
+     * A rel attribute value to apply on the link. Defaults to "noopener noreferrer" for external links.
+     */
+    rel?: 'noopener' | 'noreferrer' | 'nofollow' | 'sponsored' | 'ugc' | (string & {}) | null;
+    /**
+     * If set to true, no rel attribute will be added to the link
+     */
+    noRel?: boolean;
+    /**
+     * A class to apply to links that have been prefetched.
+     */
+    prefetchedClass?: string;
+    /**
+     * When enabled will prefetch middleware, layouts and payloads of links in the viewport.
+     */
+    prefetch?: boolean;
+    /**
+     * Allows controlling when to prefetch links. By default, prefetch is triggered only on visibility.
+     */
+    prefetchOn?: 'visibility' | 'interaction' | Partial<{
+        visibility: boolean;
+        interaction: boolean;
+    }>;
+    /**
+     * Escape hatch to disable `prefetch` attribute.
+     */
+    noPrefetch?: boolean;
+    /**
+     * An option to either add or remove trailing slashes in the `href` for this specific link.
+     * Overrides the global `trailingSlash` option if provided.
+     */
+    trailingSlash?: 'append' | 'remove';
+}
+/**
+ * Create a NuxtLink component with given options as defaults.
+ * @see https://nuxt.com/docs/4.x/api/components/nuxt-link
+ */
+export interface NuxtLinkOptions extends Partial<Pick<RouterLinkProps, 'activeClass' | 'exactActiveClass'>>, Partial<Pick<NuxtLinkProps, 'prefetch' | 'prefetchedClass'>> {
+    /**
+     * The name of the component.
+     * @default "NuxtLink"
+     */
+    componentName?: string;
+    /**
+     * A default `rel` attribute value applied on external links. Defaults to `"noopener noreferrer"`. Set it to `""` to disable.
+     */
+    externalRelAttribute?: string | null;
+    /**
+     * An option to either add or remove trailing slashes in the `href`.
+     * If unset or not matching the valid values `append` or `remove`, it will be ignored.
+     */
+    trailingSlash?: 'append' | 'remove';
+    /**
+     * Allows controlling default setting for when to prefetch links. By default, prefetch is triggered only on visibility.
+     */
+    prefetchOn?: Exclude<NuxtLinkProps['prefetchOn'], string>;
+}
+type NuxtLinkDefaultSlotProps<CustomProp extends boolean = false> = CustomProp extends true ? {
+    href: string;
+    navigate: (e?: MouseEvent) => Promise<void>;
+    prefetch: (nuxtApp?: NuxtApp) => Promise<void>;
+    route: (RouteLocation & {
+        href: string;
+    }) | undefined;
+    rel: string | null;
+    target: '_blank' | '_parent' | '_self' | '_top' | (string & {}) | null;
+    isExternal: boolean;
+    isActive: false;
+    isExactActive: false;
+} : UnwrapRef<UseLinkReturn>;
+type NuxtLinkSlots<CustomProp extends boolean = false> = {
+    default?: (props: NuxtLinkDefaultSlotProps<CustomProp>) => VNode[];
+};
+export declare function defineNuxtLink(options: NuxtLinkOptions): (new <CustomProp extends boolean = false>(props: NuxtLinkProps<CustomProp> & VNodeProps & AllowedComponentProps & Omit<AnchorHTMLAttributes, keyof NuxtLinkProps<CustomProp>>) => InstanceType<DefineSetupFnComponent<NuxtLinkProps<CustomProp> & VNodeProps & AllowedComponentProps & Omit<AnchorHTMLAttributes, keyof NuxtLinkProps<CustomProp>>, [], SlotsType<NuxtLinkSlots<CustomProp>>>>) & Record<string, any>;
+declare const _default: (new <CustomProp extends boolean = false>(props: NuxtLinkProps<CustomProp> & VNodeProps & AllowedComponentProps & Omit<AnchorHTMLAttributes, keyof NuxtLinkProps<CustomProp>>) => InstanceType<DefineSetupFnComponent<NuxtLinkProps<CustomProp> & VNodeProps & AllowedComponentProps & Omit<AnchorHTMLAttributes, keyof NuxtLinkProps<CustomProp>>, [], SlotsType<NuxtLinkSlots<CustomProp>>>>) & Record<string, any>;
+export default _default;