@depup/nuxt 4.2.2-depup.0

package/dist/app/components/nuxt-route-announcer.js

@@ -0,0 +1,48 @@
+import { defineComponent, h } from "vue";
+import { useRouteAnnouncer } from "../composables/route-announcer.js";
+export default defineComponent({
+  name: "NuxtRouteAnnouncer",
+  props: {
+    atomic: {
+      type: Boolean,
+      default: false
+    },
+    politeness: {
+      type: String,
+      default: "polite"
+    }
+  },
+  setup(props, { slots, expose }) {
+    const { set, polite, assertive, message, politeness } = useRouteAnnouncer({ politeness: props.politeness });
+    expose({
+      set,
+      polite,
+      assertive,
+      message,
+      politeness
+    });
+    return () => h("span", {
+      class: "nuxt-route-announcer",
+      style: {
+        position: "absolute"
+      }
+    }, h("span", {
+      "role": "alert",
+      "aria-live": politeness.value,
+      "aria-atomic": props.atomic,
+      "style": {
+        "border": "0",
+        "clip": "rect(0 0 0 0)",
+        "clip-path": "inset(50%)",
+        "height": "1px",
+        "width": "1px",
+        "overflow": "hidden",
+        "position": "absolute",
+        "white-space": "nowrap",
+        "word-wrap": "normal",
+        "margin": "-1px",
+        "padding": "0"
+      }
+    }, slots.default ? slots.default({ message: message.value }) : message.value));
+  }
+});

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

@@ -0,0 +1,6 @@
+export declare const NuxtImg: {
+    setup: () => void;
+};
+export declare const NuxtPicture: {
+    setup: () => void;
+};

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

@@ -0,0 +1,14 @@
+import { createError } from "../composables/error.js";
+function renderStubMessage(name) {
+  throw createError({
+    fatal: true,
+    statusCode: 500,
+    statusMessage: `${name} is provided by @nuxt/image. Check your console to install it or run 'npx nuxt module add @nuxt/image'`
+  });
+}
+export const NuxtImg = {
+  setup: () => renderStubMessage("<NuxtImg>")
+};
+export const NuxtPicture = {
+  setup: () => renderStubMessage("<NuxtPicture>")
+};

package/dist/app/components/nuxt-teleport-island-component.d.ts

@@ -0,0 +1,22 @@
+import type { InjectionKey } from 'vue';
+export declare const NuxtTeleportIslandSymbol: InjectionKey<false | string>;
+/**
+ * component only used with componentsIsland
+ * this teleport the component in SSR only if it needs to be hydrated on client
+ */
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    nuxtClient: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[] | undefined, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    nuxtClient: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{}>, {
+    nuxtClient: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

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

@@ -0,0 +1,38 @@
+import { Teleport, defineComponent, h, inject, provide, useId } from "vue";
+import { useNuxtApp } from "../nuxt.js";
+import paths from "#build/component-chunk";
+import { buildAssetsURL } from "#internal/nuxt/paths";
+export const NuxtTeleportIslandSymbol = Symbol("NuxtTeleportIslandComponent");
+export default defineComponent({
+  name: "NuxtTeleportIslandComponent",
+  inheritAttrs: false,
+  props: {
+    nuxtClient: {
+      type: Boolean,
+      default: false
+    }
+  },
+  setup(props, { slots }) {
+    const nuxtApp = useNuxtApp();
+    const to = useId();
+    if (!nuxtApp.ssrContext?.islandContext || !props.nuxtClient || inject(NuxtTeleportIslandSymbol, false)) {
+      return () => slots.default?.();
+    }
+    provide(NuxtTeleportIslandSymbol, to);
+    const islandContext = nuxtApp.ssrContext.islandContext;
+    return () => {
+      const slot = slots.default()[0];
+      const slotType = slot.type;
+      const name = slotType.__name || slotType.name;
+      islandContext.components[to] = {
+        chunk: import.meta.dev ? buildAssetsURL(paths[name]) : paths[name],
+        props: slot.props || {}
+      };
+      return [h("div", {
+        "style": "display: contents;",
+        "data-island-uid": "",
+        "data-island-component": to
+      }, []), h(Teleport, { to }, slot)];
+    };
+  }
+});

package/dist/app/components/nuxt-teleport-island-slot.d.ts

@@ -0,0 +1,32 @@
+import type { VNode } from 'vue';
+/**
+ * component only used within islands for slot teleport
+ */
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    name: {
+        type: StringConstructor;
+        required: true;
+    };
+    /**
+     * must be an array to handle v-for
+     */
+    props: {
+        type: () => Array<any>;
+    };
+}>, (() => VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> | undefined) | (() => VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[]), {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    name: {
+        type: StringConstructor;
+        required: true;
+    };
+    /**
+     * must be an array to handle v-for
+     */
+    props: {
+        type: () => Array<any>;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

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

@@ -0,0 +1,53 @@
+import { Teleport, createVNode, defineComponent, h, inject } from "vue";
+import { useNuxtApp } from "../nuxt.js";
+import { NuxtTeleportIslandSymbol } from "./nuxt-teleport-island-component.js";
+export default defineComponent({
+  name: "NuxtTeleportIslandSlot",
+  inheritAttrs: false,
+  props: {
+    name: {
+      type: String,
+      required: true
+    },
+    /**
+     * must be an array to handle v-for
+     */
+    props: {
+      type: Object
+    }
+  },
+  setup(props, { slots }) {
+    const nuxtApp = useNuxtApp();
+    const islandContext = nuxtApp.ssrContext?.islandContext;
+    if (!islandContext) {
+      return () => slots.default?.()[0];
+    }
+    const componentName = inject(NuxtTeleportIslandSymbol, false);
+    islandContext.slots[props.name] = {
+      props: props.props || []
+    };
+    return () => {
+      const vnodes = [];
+      if (nuxtApp.ssrContext?.islandContext && slots.default) {
+        vnodes.push(h("div", {
+          "style": "display: contents;",
+          "data-island-uid": "",
+          "data-island-slot": props.name
+        }, {
+          // Teleport in slot to not be hydrated client-side with the staticVNode
+          default: () => [createVNode(Teleport, { to: `island-slot=${componentName};${props.name}` }, slots.default?.())]
+        }));
+      } else {
+        vnodes.push(h("div", {
+          "style": "display: contents;",
+          "data-island-uid": "",
+          "data-island-slot": props.name
+        }));
+      }
+      if (slots.fallback) {
+        vnodes.push(h(Teleport, { to: `island-fallback=${props.name}` }, slots.fallback()));
+      }
+      return vnodes;
+    };
+  }
+});

package/dist/app/components/nuxt-time.d.vue.ts

@@ -0,0 +1,37 @@
+export interface NuxtTimeProps {
+    locale?: string;
+    datetime: string | number | Date;
+    localeMatcher?: 'best fit' | 'lookup';
+    weekday?: 'long' | 'short' | 'narrow';
+    era?: 'long' | 'short' | 'narrow';
+    year?: 'numeric' | '2-digit';
+    month?: 'numeric' | '2-digit' | 'long' | 'short' | 'narrow';
+    day?: 'numeric' | '2-digit';
+    hour?: 'numeric' | '2-digit';
+    minute?: 'numeric' | '2-digit';
+    second?: 'numeric' | '2-digit';
+    timeZoneName?: 'short' | 'long' | 'shortOffset' | 'longOffset' | 'shortGeneric' | 'longGeneric';
+    formatMatcher?: 'best fit' | 'basic';
+    hour12?: boolean;
+    timeZone?: string;
+    calendar?: string;
+    dayPeriod?: 'narrow' | 'short' | 'long';
+    numberingSystem?: string;
+    dateStyle?: 'full' | 'long' | 'medium' | 'short';
+    timeStyle?: 'full' | 'long' | 'medium' | 'short';
+    hourCycle?: 'h11' | 'h12' | 'h23' | 'h24';
+    relative?: boolean;
+    numeric?: 'always' | 'auto';
+    relativeStyle?: 'long' | 'short' | 'narrow';
+    title?: boolean | string;
+}
+declare global {
+    interface Window {
+        _nuxtTimeNow?: number;
+    }
+}
+declare const __VLS_export: import("vue").DefineComponent<NuxtTimeProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<NuxtTimeProps> & Readonly<{}>, {
+    hour12: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/app/components/nuxt-time.vue

@@ -0,0 +1,148 @@
+<script setup>
+import { computed, getCurrentInstance, onBeforeUnmount, ref } from "vue";
+import { onPrehydrate } from "../composables/ssr";
+import { useNuxtApp } from "../nuxt";
+const props = defineProps({
+  locale: { type: String, required: false },
+  datetime: { type: [String, Number, Date], required: true },
+  localeMatcher: { type: String, required: false },
+  weekday: { type: String, required: false },
+  era: { type: String, required: false },
+  year: { type: String, required: false },
+  month: { type: String, required: false },
+  day: { type: String, required: false },
+  hour: { type: String, required: false },
+  minute: { type: String, required: false },
+  second: { type: String, required: false },
+  timeZoneName: { type: String, required: false },
+  formatMatcher: { type: String, required: false },
+  hour12: { type: Boolean, required: false, default: void 0 },
+  timeZone: { type: String, required: false },
+  calendar: { type: String, required: false },
+  dayPeriod: { type: String, required: false },
+  numberingSystem: { type: String, required: false },
+  dateStyle: { type: String, required: false },
+  timeStyle: { type: String, required: false },
+  hourCycle: { type: String, required: false },
+  relative: { type: Boolean, required: false },
+  numeric: { type: String, required: false },
+  relativeStyle: { type: String, required: false },
+  title: { type: [Boolean, String], required: false }
+});
+const el = getCurrentInstance()?.vnode.el;
+const renderedDate = el?.getAttribute("datetime");
+const _locale = el?.getAttribute("data-locale");
+const nuxtApp = useNuxtApp();
+const date = computed(() => {
+  const date2 = props.datetime;
+  if (renderedDate && nuxtApp.isHydrating) {
+    return new Date(renderedDate);
+  }
+  if (!props.datetime) {
+    return /* @__PURE__ */ new Date();
+  }
+  return new Date(date2);
+});
+const now = ref(import.meta.client && nuxtApp.isHydrating && window._nuxtTimeNow ? new Date(window._nuxtTimeNow) : /* @__PURE__ */ new Date());
+if (import.meta.client && props.relative) {
+  const handler = () => {
+    now.value = /* @__PURE__ */ new Date();
+  };
+  const interval = setInterval(handler, 1e3);
+  onBeforeUnmount(() => clearInterval(interval));
+}
+const formatter = computed(() => {
+  const { locale: propsLocale, relative, relativeStyle, ...rest } = props;
+  if (relative) {
+    return new Intl.RelativeTimeFormat(_locale ?? propsLocale, { ...rest, style: relativeStyle });
+  }
+  return new Intl.DateTimeFormat(_locale ?? propsLocale, rest);
+});
+const formattedDate = computed(() => {
+  if (!props.relative) {
+    return formatter.value.format(date.value);
+  }
+  const diffInSeconds = (date.value.getTime() - now.value.getTime()) / 1e3;
+  const units = [
+    { unit: "second", seconds: 1, threshold: 60 },
+    // 60 seconds → minute
+    { unit: "minute", seconds: 60, threshold: 60 },
+    // 60 minutes → hour
+    { unit: "hour", seconds: 3600, threshold: 24 },
+    // 24 hours → day
+    { unit: "day", seconds: 86400, threshold: 30 },
+    // ~30 days → month
+    { unit: "month", seconds: 2592e3, threshold: 12 },
+    // 12 months → year
+    { unit: "year", seconds: 31536e3, threshold: Infinity }
+  ];
+  const { unit, seconds } = units.find(({ seconds: seconds2, threshold }) => Math.abs(diffInSeconds / seconds2) < threshold) || units[units.length - 1];
+  const value = diffInSeconds / seconds;
+  return formatter.value.format(Math.round(value), unit);
+});
+const isoDate = computed(() => date.value.toISOString());
+const title = computed(() => props.title === true ? isoDate.value : typeof props.title === "string" ? props.title : void 0);
+const dataset = {};
+if (import.meta.server) {
+  for (const prop in props) {
+    if (prop !== "datetime") {
+      const value = props?.[prop];
+      if (value) {
+        const propInKebabCase = prop.split(/(?=[A-Z])/).join("-");
+        dataset[`data-${propInKebabCase}`] = props?.[prop];
+      }
+    }
+  }
+  onPrehydrate((el2) => {
+    const now2 = window._nuxtTimeNow ||= Date.now();
+    const toCamelCase = (name, index) => {
+      if (index > 0) {
+        return name[0].toUpperCase() + name.slice(1);
+      }
+      return name;
+    };
+    const date2 = new Date(el2.getAttribute("datetime"));
+    const options = {};
+    for (const name of el2.getAttributeNames()) {
+      if (name.startsWith("data-")) {
+        let optionName = name.slice(5).split("-").map(toCamelCase).join("");
+        if (optionName === "relativeStyle") {
+          optionName = "style";
+        }
+        options[optionName] = el2.getAttribute(name);
+      }
+    }
+    if (options.relative) {
+      const diffInSeconds = (date2.getTime() - now2) / 1e3;
+      const units = [
+        { unit: "second", seconds: 1, threshold: 60 },
+        // 60 seconds → minute
+        { unit: "minute", seconds: 60, threshold: 60 },
+        // 60 minutes → hour
+        { unit: "hour", seconds: 3600, threshold: 24 },
+        // 24 hours → day
+        { unit: "day", seconds: 86400, threshold: 30 },
+        // ~30 days → month
+        { unit: "month", seconds: 2592e3, threshold: 12 },
+        // 12 months → year
+        { unit: "year", seconds: 31536e3, threshold: Infinity }
+      ];
+      const { unit, seconds } = units.find(({ seconds: seconds2, threshold }) => Math.abs(diffInSeconds / seconds2) < threshold) || units[units.length - 1];
+      const value = diffInSeconds / seconds;
+      const formatter2 = new Intl.RelativeTimeFormat(options.locale, options);
+      el2.textContent = formatter2.format(Math.round(value), unit);
+    } else {
+      const formatter2 = new Intl.DateTimeFormat(options.locale, options);
+      el2.textContent = formatter2.format(date2);
+    }
+  });
+}
+</script>
+
+<template>
+  <time
+    v-bind="dataset"
+    :datetime="isoDate"
+    :title="title"
+  >{{ formattedDate }}</time>
+</template>

package/dist/app/components/nuxt-time.vue.d.ts

@@ -0,0 +1,37 @@
+export interface NuxtTimeProps {
+    locale?: string;
+    datetime: string | number | Date;
+    localeMatcher?: 'best fit' | 'lookup';
+    weekday?: 'long' | 'short' | 'narrow';
+    era?: 'long' | 'short' | 'narrow';
+    year?: 'numeric' | '2-digit';
+    month?: 'numeric' | '2-digit' | 'long' | 'short' | 'narrow';
+    day?: 'numeric' | '2-digit';
+    hour?: 'numeric' | '2-digit';
+    minute?: 'numeric' | '2-digit';
+    second?: 'numeric' | '2-digit';
+    timeZoneName?: 'short' | 'long' | 'shortOffset' | 'longOffset' | 'shortGeneric' | 'longGeneric';
+    formatMatcher?: 'best fit' | 'basic';
+    hour12?: boolean;
+    timeZone?: string;
+    calendar?: string;
+    dayPeriod?: 'narrow' | 'short' | 'long';
+    numberingSystem?: string;
+    dateStyle?: 'full' | 'long' | 'medium' | 'short';
+    timeStyle?: 'full' | 'long' | 'medium' | 'short';
+    hourCycle?: 'h11' | 'h12' | 'h23' | 'h24';
+    relative?: boolean;
+    numeric?: 'always' | 'auto';
+    relativeStyle?: 'long' | 'short' | 'narrow';
+    title?: boolean | string;
+}
+declare global {
+    interface Window {
+        _nuxtTimeNow?: number;
+    }
+}
+declare const __VLS_export: import("vue").DefineComponent<NuxtTimeProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<NuxtTimeProps> & Readonly<{}>, {
+    hour12: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/app/components/route-provider.d.ts

@@ -0,0 +1,48 @@
+import type { Ref, VNode } from 'vue';
+import type { RouteLocationNormalizedLoaded } from 'vue-router';
+export declare const defineRouteProvider: (name?: string) => import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    route: {
+        type: () => RouteLocationNormalizedLoaded;
+        required: true;
+    };
+    vnode: () => VNode;
+    vnodeRef: () => Ref<any>;
+    renderKey: StringConstructor;
+    trackRootNodes: BooleanConstructor;
+}>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> | undefined, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    route: {
+        type: () => RouteLocationNormalizedLoaded;
+        required: true;
+    };
+    vnode: () => VNode;
+    vnodeRef: () => Ref<any>;
+    renderKey: StringConstructor;
+    trackRootNodes: BooleanConstructor;
+}>> & Readonly<{}>, {
+    trackRootNodes: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export declare const RouteProvider: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    route: {
+        type: () => RouteLocationNormalizedLoaded;
+        required: true;
+    };
+    vnode: () => VNode;
+    vnodeRef: () => Ref<any>;
+    renderKey: StringConstructor;
+    trackRootNodes: BooleanConstructor;
+}>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> | undefined, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    route: {
+        type: () => RouteLocationNormalizedLoaded;
+        required: true;
+    };
+    vnode: () => VNode;
+    vnodeRef: () => Ref<any>;
+    renderKey: StringConstructor;
+    trackRootNodes: BooleanConstructor;
+}>> & Readonly<{}>, {
+    trackRootNodes: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/dist/app/components/route-provider.js

@@ -0,0 +1,49 @@
+import { defineComponent, h, nextTick, onMounted, provide, shallowReactive } from "vue";
+import { PageRouteSymbol } from "./injections.js";
+export const defineRouteProvider = (name = "RouteProvider") => defineComponent({
+  name,
+  props: {
+    route: {
+      type: Object,
+      required: true
+    },
+    vnode: Object,
+    vnodeRef: Object,
+    renderKey: String,
+    trackRootNodes: Boolean
+  },
+  setup(props) {
+    const previousKey = props.renderKey;
+    const previousRoute = props.route;
+    const route = {};
+    for (const key in props.route) {
+      Object.defineProperty(route, key, {
+        get: () => previousKey === props.renderKey ? props.route[key] : previousRoute[key],
+        enumerable: true
+      });
+    }
+    provide(PageRouteSymbol, shallowReactive(route));
+    let vnode;
+    if (import.meta.dev && import.meta.client && props.trackRootNodes) {
+      onMounted(() => {
+        nextTick(() => {
+          if (["#comment", "#text"].includes(vnode?.el?.nodeName)) {
+            const filename = vnode?.type?.__file;
+            console.warn(`[nuxt] \`${filename}\` does not have a single root node and will cause errors when navigating between routes.`);
+          }
+        });
+      });
+    }
+    return () => {
+      if (!props.vnode) {
+        return props.vnode;
+      }
+      if (import.meta.dev && import.meta.client) {
+        vnode = h(props.vnode, { ref: props.vnodeRef });
+        return vnode;
+      }
+      return h(props.vnode, { ref: props.vnodeRef });
+    };
+  }
+});
+export const RouteProvider = defineRouteProvider();

package/dist/app/components/server-placeholder.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/app/components/server-placeholder.js

@@ -0,0 +1,7 @@
+import { createElementBlock, defineComponent } from "vue";
+export default defineComponent({
+  name: "ServerPlaceholder",
+  render() {
+    return createElementBlock("div");
+  }
+});

package/dist/app/components/test-component-wrapper.d.ts

@@ -0,0 +1,4 @@
+declare const _default: (url: string) => import("vue").DefineComponent<{}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[], {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/app/components/test-component-wrapper.js

@@ -0,0 +1,27 @@
+import { defineComponent, h } from "vue";
+import { parseQuery } from "vue-router";
+import { resolve } from "pathe";
+import destr from "destr";
+import { devRootDir } from "#build/nuxt.config.mjs";
+export default (url) => defineComponent({
+  name: "NuxtTestComponentWrapper",
+  inheritAttrs: false,
+  async setup(props, { attrs }) {
+    const query = parseQuery(new URL(url, "http://localhost").search);
+    const urlProps = query.props ? destr(query.props) : {};
+    const path = resolve(query.path);
+    if (!path.startsWith(devRootDir)) {
+      throw new Error(`[nuxt] Cannot access path outside of project root directory: \`${path}\`.`);
+    }
+    const comp = await import(
+      /* @vite-ignore */
+      path
+    ).then((r) => r.default);
+    return () => [
+      h("div", "Component Test Wrapper for " + path),
+      h("div", { id: "nuxt-component-root" }, [
+        h(comp, { ...attrs, ...props, ...urlProps })
+      ])
+    ];
+  }
+});

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

@@ -0,0 +1,48 @@
+import type { RendererNode, VNode } from 'vue';
+import type { RouteLocationNormalized } from 'vue-router';
+/**
+ * Internal utility
+ * @private
+ */
+export declare const _wrapInTransition: (props: any, children: any) => {
+    default: () => any;
+};
+/**
+ * Utility used within router guards
+ * return true if the route has been changed with a page change during navigation
+ */
+export declare function isChangingPage(to: RouteLocationNormalized, from: RouteLocationNormalized): boolean;
+export type SSRBuffer = SSRBufferItem[] & {
+    hasAsync?: boolean;
+};
+export type SSRBufferItem = string | SSRBuffer | Promise<SSRBuffer>;
+/**
+ * create buffer retrieved from @vue/server-renderer
+ * @see https://github.com/vuejs/core/blob/9617dd4b2abc07a5dc40de6e5b759e851b4d0da1/packages/server-renderer/src/render.ts#L57
+ * @private
+ */
+export declare function createBuffer(): {
+    getBuffer(): SSRBuffer;
+    push(item: SSRBufferItem): void;
+};
+/**
+ * helper for NuxtIsland to generate a correct array for scoped data
+ */
+export declare function vforToArray(source: any): any[];
+/**
+ * Retrieve the HTML content from an element
+ * Handles `<!--[-->` Fragment elements
+ * @param element the element to retrieve the HTML
+ * @param withoutSlots purge all slots from the HTML string retrieved
+ * @returns {string[]|undefined} An array of string which represent the content of each element. Use `.join('')` to retrieve a component vnode.el HTML
+ */
+export declare function getFragmentHTML(element: RendererNode | null, withoutSlots?: boolean): string[] | undefined;
+/**
+ * Return a static vnode from an element
+ * Default to a div if the element is not found and if a fallback is not provided
+ * @param el renderer node retrieved from the component internal instance
+ * @param staticNodeFallback fallback string to use if the element is not found. Must be a valid HTML string
+ */
+export declare function elToStaticVNode(el: RendererNode | null, staticNodeFallback?: string): VNode;
+export declare function isStartFragment(element: RendererNode): boolean;
+export declare function isEndFragment(element: RendererNode): boolean;