@depup/nuxt 4.2.2-depup.0

package/dist/app/composables/route-announcer.js

@@ -0,0 +1,55 @@
+import { getCurrentScope, onScopeDispose, shallowRef } from "vue";
+import { useNuxtApp } from "../nuxt.js";
+import { injectHead } from "./head.js";
+function createRouteAnnouncer(opts = {}) {
+  const message = shallowRef("");
+  const politeness = shallowRef(opts.politeness || "polite");
+  const activeHead = injectHead();
+  function set(messageValue = "", politenessSetting = "polite") {
+    message.value = messageValue;
+    politeness.value = politenessSetting;
+  }
+  function polite(message2) {
+    return set(message2, "polite");
+  }
+  function assertive(message2) {
+    return set(message2, "assertive");
+  }
+  function _updateMessageWithPageHeading() {
+    set(document?.title?.trim(), politeness.value);
+  }
+  function _cleanup() {
+    activeHead?.hooks?.removeHook("dom:rendered", _updateMessageWithPageHeading);
+  }
+  _updateMessageWithPageHeading();
+  activeHead?.hooks?.hook("dom:rendered", () => {
+    _updateMessageWithPageHeading();
+  });
+  return {
+    _cleanup,
+    message,
+    politeness,
+    set,
+    polite,
+    assertive
+  };
+}
+export function useRouteAnnouncer(opts = {}) {
+  const nuxtApp = useNuxtApp();
+  const announcer = nuxtApp._routeAnnouncer ||= createRouteAnnouncer(opts);
+  if (opts.politeness !== announcer.politeness.value) {
+    announcer.politeness.value = opts.politeness || "polite";
+  }
+  if (import.meta.client && getCurrentScope()) {
+    nuxtApp._routeAnnouncerDeps ||= 0;
+    nuxtApp._routeAnnouncerDeps++;
+    onScopeDispose(() => {
+      nuxtApp._routeAnnouncerDeps--;
+      if (nuxtApp._routeAnnouncerDeps === 0) {
+        announcer._cleanup();
+        delete nuxtApp._routeAnnouncer;
+      }
+    });
+  }
+  return announcer;
+}

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

@@ -0,0 +1,96 @@
+import type { NavigationFailure, NavigationGuard, RouteLocationNormalized, RouteLocationRaw, useRoute as _useRoute, useRouter as _useRouter } from 'vue-router';
+import type { PageMeta } from '../../pages/runtime/composables.js';
+import type { NuxtError } from './error.js';
+/** @since 3.0.0 */
+export declare const useRouter: typeof _useRouter;
+/** @since 3.0.0 */
+export declare const useRoute: typeof _useRoute;
+/** @since 3.0.0 */
+export declare const onBeforeRouteLeave: (guard: NavigationGuard) => void;
+/** @since 3.0.0 */
+export declare const onBeforeRouteUpdate: (guard: NavigationGuard) => void;
+export interface RouteMiddleware {
+    (to: RouteLocationNormalized, from: RouteLocationNormalized): ReturnType<NavigationGuard>;
+}
+/** @since 3.0.0 */
+export declare function defineNuxtRouteMiddleware(middleware: RouteMiddleware): RouteMiddleware;
+export interface AddRouteMiddlewareOptions {
+    global?: boolean;
+}
+interface AddRouteMiddleware {
+    (name: string, middleware: RouteMiddleware, options?: AddRouteMiddlewareOptions): void;
+    (middleware: RouteMiddleware): void;
+}
+/** @since 3.0.0 */
+export declare const addRouteMiddleware: AddRouteMiddleware;
+type Without<T, U> = {
+    [P in Exclude<keyof T, keyof U>]?: never;
+};
+type XOR<T, U> = (T | U) extends object ? (Without<T, U> & U) | (Without<U, T> & T) : T | U;
+export type OpenWindowFeatures = {
+    popup?: boolean;
+    noopener?: boolean;
+    noreferrer?: boolean;
+} & XOR<{
+    width?: number;
+}, {
+    innerWidth?: number;
+}> & XOR<{
+    height?: number;
+}, {
+    innerHeight?: number;
+}> & XOR<{
+    left?: number;
+}, {
+    screenX?: number;
+}> & XOR<{
+    top?: number;
+}, {
+    screenY?: number;
+}>;
+export type OpenOptions = {
+    target: '_blank' | '_parent' | '_self' | '_top' | (string & {});
+    windowFeatures?: OpenWindowFeatures;
+};
+export interface NavigateToOptions {
+    /**
+     * Whether or not the given route should replace the current route in the navigation history, rather than push it.
+     */
+    replace?: boolean;
+    /**
+     * The status code to emit with the navigation. Defaults to `302 Found` when used on server side redirects.
+     */
+    redirectCode?: number;
+    /**
+     * Whether or not the given route is a website/resource from a different origin. By default, navigating to external resources without setting `external: true` would result in an error.
+     */
+    external?: boolean;
+    open?: OpenOptions;
+}
+/**
+ * A helper that aids in programmatic navigation within your Nuxt application.
+ *
+ * Can be called on the server and on the client, within pages, route middleware, plugins, and more.
+ * @param {RouteLocationRaw | undefined | null} [to] - The route to navigate to. Accepts a route object, string path, `undefined`, or `null`. Defaults to '/'.
+ * @param {NavigateToOptions} [options] - Optional customization for controlling the behavior of the navigation.
+ * @returns {Promise<void | NavigationFailure | false> | false | void | RouteLocationRaw} The navigation result, which varies depending on context and options.
+ * @see https://nuxt.com/docs/4.x/api/utils/navigate-to
+ * @since 3.0.0
+ */
+export declare const navigateTo: (to: RouteLocationRaw | undefined | null, options?: NavigateToOptions) => Promise<void | NavigationFailure | false> | false | void | RouteLocationRaw;
+/**
+ * This will abort navigation within a Nuxt route middleware handler.
+ * @since 3.0.0
+ */
+export declare const abortNavigation: (err?: string | Partial<NuxtError>) => boolean;
+/** @since 3.0.0 */
+export declare const setPageLayout: (layout: unknown extends PageMeta["layout"] ? string : PageMeta["layout"]) => void;
+/**
+ * @internal
+ */
+export declare function resolveRouteObject(to: Exclude<RouteLocationRaw, string>): string;
+/**
+ * @internal
+ */
+export declare function encodeURL(location: string, isExternalHost?: boolean): string;
+export {};

package/dist/app/composables/router.js

@@ -0,0 +1,197 @@
+import { getCurrentInstance, hasInjectionContext, inject, onScopeDispose } from "vue";
+import { sanitizeStatusCode } from "h3";
+import { hasProtocol, isScriptProtocol, joinURL, parseQuery, parseURL, withQuery } from "ufo";
+import { useNuxtApp, useRuntimeConfig } from "../nuxt.js";
+import { PageRouteSymbol } from "../components/injections.js";
+import { createError, showError } from "./error.js";
+import { getUserTrace } from "../utils.js";
+export const useRouter = () => {
+  return useNuxtApp()?.$router;
+};
+export const useRoute = () => {
+  if (import.meta.dev && !getCurrentInstance() && isProcessingMiddleware()) {
+    const middleware = useNuxtApp()._processingMiddleware;
+    const trace = getUserTrace().map(({ source, line, column }) => `at ${source}:${line}:${column}`).join("\n");
+    console.warn(`[nuxt] \`useRoute\` was called within middleware${typeof middleware === "string" ? ` (\`${middleware}\`)` : ""}. This may lead to misleading results. Instead, use the (to, from) arguments passed to the middleware to access the new and old routes. Learn more: https://nuxt.com/docs/4.x/directory-structure/app/middleware#accessing-route-in-middleware` + ("\n" + trace));
+  }
+  if (hasInjectionContext()) {
+    return inject(PageRouteSymbol, useNuxtApp()._route);
+  }
+  return useNuxtApp()._route;
+};
+export const onBeforeRouteLeave = (guard) => {
+  const unsubscribe = useRouter().beforeEach((to, from, next) => {
+    if (to === from) {
+      return;
+    }
+    return guard(to, from, next);
+  });
+  onScopeDispose(unsubscribe);
+};
+export const onBeforeRouteUpdate = (guard) => {
+  const unsubscribe = useRouter().beforeEach(guard);
+  onScopeDispose(unsubscribe);
+};
+// @__NO_SIDE_EFFECTS__
+export function defineNuxtRouteMiddleware(middleware) {
+  return middleware;
+}
+export const addRouteMiddleware = (name, middleware, options = {}) => {
+  const nuxtApp = useNuxtApp();
+  const global = options.global || typeof name !== "string";
+  const mw = typeof name !== "string" ? name : middleware;
+  if (!mw) {
+    console.warn("[nuxt] No route middleware passed to `addRouteMiddleware`.", name);
+    return;
+  }
+  if (global) {
+    nuxtApp._middleware.global.push(mw);
+  } else {
+    nuxtApp._middleware.named[name] = mw;
+  }
+};
+const isProcessingMiddleware = () => {
+  try {
+    if (useNuxtApp()._processingMiddleware) {
+      return true;
+    }
+  } catch {
+    return false;
+  }
+  return false;
+};
+const URL_QUOTE_RE = /"/g;
+export const navigateTo = (to, options) => {
+  to ||= "/";
+  const toPath = typeof to === "string" ? to : "path" in to ? resolveRouteObject(to) : useRouter().resolve(to).href;
+  if (import.meta.client && options?.open) {
+    const { target = "_blank", windowFeatures = {} } = options.open;
+    const features = [];
+    for (const [feature, value] of Object.entries(windowFeatures)) {
+      if (value !== void 0) {
+        features.push(`${feature.toLowerCase()}=${value}`);
+      }
+    }
+    open(toPath, target, features.join(", "));
+    return Promise.resolve();
+  }
+  const isExternalHost = hasProtocol(toPath, { acceptRelative: true });
+  const isExternal = options?.external || isExternalHost;
+  if (isExternal) {
+    if (!options?.external) {
+      throw new Error("Navigating to an external URL is not allowed by default. Use `navigateTo(url, { external: true })`.");
+    }
+    const { protocol } = new URL(toPath, import.meta.client ? window.location.href : "http://localhost");
+    if (protocol && isScriptProtocol(protocol)) {
+      throw new Error(`Cannot navigate to a URL with '${protocol}' protocol.`);
+    }
+  }
+  const inMiddleware = isProcessingMiddleware();
+  if (import.meta.client && !isExternal && inMiddleware) {
+    if (options?.replace) {
+      if (typeof to === "string") {
+        const { pathname, search, hash } = parseURL(to);
+        return {
+          path: pathname,
+          ...search && { query: parseQuery(search) },
+          ...hash && { hash },
+          replace: true
+        };
+      }
+      return { ...to, replace: true };
+    }
+    return to;
+  }
+  const router = useRouter();
+  const nuxtApp = useNuxtApp();
+  if (import.meta.server) {
+    if (nuxtApp.ssrContext) {
+      const fullPath = typeof to === "string" || isExternal ? toPath : router.resolve(to).fullPath || "/";
+      const location2 = isExternal ? toPath : joinURL(useRuntimeConfig().app.baseURL, fullPath);
+      const redirect = async function(response) {
+        await nuxtApp.callHook("app:redirected");
+        const encodedLoc = location2.replace(URL_QUOTE_RE, "%22");
+        const encodedHeader = encodeURL(location2, isExternalHost);
+        nuxtApp.ssrContext._renderResponse = {
+          statusCode: sanitizeStatusCode(options?.redirectCode || 302, 302),
+          body: `<!DOCTYPE html><html><head><meta http-equiv="refresh" content="0; url=${encodedLoc}"></head></html>`,
+          headers: { location: encodedHeader }
+        };
+        return response;
+      };
+      if (!isExternal && inMiddleware) {
+        router.afterEach((final) => final.fullPath === fullPath ? redirect(false) : void 0);
+        return to;
+      }
+      return redirect(!inMiddleware ? void 0 : (
+        /* abort route navigation */
+        false
+      ));
+    }
+  }
+  if (isExternal) {
+    nuxtApp._scope.stop();
+    if (options?.replace) {
+      location.replace(toPath);
+    } else {
+      location.href = toPath;
+    }
+    if (inMiddleware) {
+      if (!nuxtApp.isHydrating) {
+        return false;
+      }
+      return new Promise(() => {
+      });
+    }
+    return Promise.resolve();
+  }
+  return options?.replace ? router.replace(to) : router.push(to);
+};
+export const abortNavigation = (err) => {
+  if (import.meta.dev && !isProcessingMiddleware()) {
+    throw new Error("abortNavigation() is only usable inside a route middleware handler.");
+  }
+  if (!err) {
+    return false;
+  }
+  err = createError(err);
+  if (err.fatal) {
+    useNuxtApp().runWithContext(() => showError(err));
+  }
+  throw err;
+};
+export const setPageLayout = (layout) => {
+  const nuxtApp = useNuxtApp();
+  if (import.meta.server) {
+    if (import.meta.dev && getCurrentInstance() && nuxtApp.payload.state._layout !== layout) {
+      console.warn("[warn] [nuxt] `setPageLayout` should not be called to change the layout on the server within a component as this will cause hydration errors.");
+    }
+    nuxtApp.payload.state._layout = layout;
+  }
+  if (import.meta.dev && nuxtApp.isHydrating && nuxtApp.payload.serverRendered && nuxtApp.payload.state._layout !== layout) {
+    console.warn("[warn] [nuxt] `setPageLayout` should not be called to change the layout during hydration as this will cause hydration errors.");
+  }
+  const inMiddleware = isProcessingMiddleware();
+  if (inMiddleware || import.meta.server || nuxtApp.isHydrating) {
+    const unsubscribe = useRouter().beforeResolve((to) => {
+      to.meta.layout = layout;
+      unsubscribe();
+    });
+  }
+  if (!inMiddleware) {
+    useRoute().meta.layout = layout;
+  }
+};
+export function resolveRouteObject(to) {
+  return withQuery(to.path || "", to.query || {}) + (to.hash || "");
+}
+export function encodeURL(location2, isExternalHost = false) {
+  const url = new URL(location2, "http://localhost");
+  if (!isExternalHost) {
+    return url.pathname + url.search + url.hash;
+  }
+  if (location2.startsWith("//")) {
+    return url.toString().replace(url.protocol, "");
+  }
+  return url.toString();
+}

package/dist/app/composables/runtime-hook.d.ts

@@ -0,0 +1,9 @@
+import type { HookCallback } from 'hookable';
+import type { RuntimeNuxtHooks } from '../nuxt.js';
+/**
+ * Registers a runtime hook in a Nuxt application and ensures it is properly disposed of when the scope is destroyed.
+ * @param name - The name of the hook to register.
+ * @param fn - The callback function to be executed when the hook is triggered.
+ * @since 3.14.0
+ */
+export declare function useRuntimeHook<THookName extends keyof RuntimeNuxtHooks>(name: THookName, fn: RuntimeNuxtHooks[THookName] extends HookCallback ? RuntimeNuxtHooks[THookName] : never): void;

package/dist/app/composables/runtime-hook.js

@@ -0,0 +1,7 @@
+import { onScopeDispose } from "vue";
+import { useNuxtApp } from "../nuxt.js";
+export function useRuntimeHook(name, fn) {
+  const nuxtApp = useNuxtApp();
+  const unregister = nuxtApp.hook(name, fn);
+  onScopeDispose(unregister);
+}

package/dist/app/composables/script-stubs.d.ts

@@ -0,0 +1,32 @@
+import type { UseScriptInput } from '@unhead/vue/scripts';
+export declare function useScript<T extends Record<string | symbol, any>>(input: UseScriptInput, options?: Record<string, unknown>): void;
+export declare function useScriptTriggerElement(...args: unknown[]): void;
+export declare function useScriptTriggerConsent(...args: unknown[]): void;
+export declare function useScriptEventPage(...args: unknown[]): void;
+export declare function useScriptGoogleAnalytics(...args: unknown[]): void;
+export declare function useScriptPlausibleAnalytics(...args: unknown[]): void;
+export declare function useScriptCloudflareWebAnalytics(...args: unknown[]): void;
+export declare function useScriptCrisp(...args: unknown[]): void;
+export declare function useScriptFathomAnalytics(...args: unknown[]): void;
+export declare function useScriptMatomoAnalytics(...args: unknown[]): void;
+export declare function useScriptGoogleTagManager(...args: unknown[]): void;
+export declare function useScriptSegment(...args: unknown[]): void;
+export declare function useScriptClarity(...args: unknown[]): void;
+export declare function useScriptMetaPixel(...args: unknown[]): void;
+export declare function useScriptXPixel(...args: unknown[]): void;
+export declare function useScriptIntercom(...args: unknown[]): void;
+export declare function useScriptHotjar(...args: unknown[]): void;
+export declare function useScriptStripe(...args: unknown[]): void;
+export declare function useScriptLemonSqueezy(...args: unknown[]): void;
+export declare function useScriptVimeoPlayer(...args: unknown[]): void;
+export declare function useScriptYouTubeIframe(...args: unknown[]): void;
+export declare function useScriptGoogleMaps(...args: unknown[]): void;
+export declare function useScriptNpm(...args: unknown[]): void;
+export declare function useScriptGoogleAdsense(...args: unknown[]): void;
+export declare function useScriptYouTubePlayer(...args: unknown[]): void;
+export declare function useScriptUmamiAnalytics(...args: unknown[]): void;
+export declare function useScriptSnapchatPixel(...args: unknown[]): void;
+export declare function useScriptRybbitAnalytics(...args: unknown[]): void;
+export declare function useScriptDatabuddyAnalytics(...args: unknown[]): void;
+export declare function useScriptRedditPixel(...args: unknown[]): void;
+export declare function useScriptPayPal(...args: unknown[]): void;

package/dist/app/composables/script-stubs.js

@@ -0,0 +1,104 @@
+import { createError } from "./error.js";
+function renderStubMessage(name) {
+  const message = `\`${name}\` is provided by @nuxt/scripts. Check your console to install it or run 'npx nuxt module add @nuxt/scripts' to install it.`;
+  if (import.meta.client) {
+    throw createError({
+      fatal: true,
+      statusCode: 500,
+      statusMessage: message
+    });
+  }
+}
+export function useScript(input, options) {
+  renderStubMessage("useScript");
+}
+export function useScriptTriggerElement(...args) {
+  renderStubMessage("useScriptTriggerElement");
+}
+export function useScriptTriggerConsent(...args) {
+  renderStubMessage("useScriptTriggerConsent");
+}
+export function useScriptEventPage(...args) {
+  renderStubMessage("useScriptEventPage");
+}
+export function useScriptGoogleAnalytics(...args) {
+  renderStubMessage("useScriptGoogleAnalytics");
+}
+export function useScriptPlausibleAnalytics(...args) {
+  renderStubMessage("useScriptPlausibleAnalytics");
+}
+export function useScriptCloudflareWebAnalytics(...args) {
+  renderStubMessage("useScriptCloudflareWebAnalytics");
+}
+export function useScriptCrisp(...args) {
+  renderStubMessage("useScriptCrisp");
+}
+export function useScriptFathomAnalytics(...args) {
+  renderStubMessage("useScriptFathomAnalytics");
+}
+export function useScriptMatomoAnalytics(...args) {
+  renderStubMessage("useScriptMatomoAnalytics");
+}
+export function useScriptGoogleTagManager(...args) {
+  renderStubMessage("useScriptGoogleTagManager");
+}
+export function useScriptSegment(...args) {
+  renderStubMessage("useScriptSegment");
+}
+export function useScriptClarity(...args) {
+  renderStubMessage("useScriptClarity");
+}
+export function useScriptMetaPixel(...args) {
+  renderStubMessage("useScriptMetaPixel");
+}
+export function useScriptXPixel(...args) {
+  renderStubMessage("useScriptXPixel");
+}
+export function useScriptIntercom(...args) {
+  renderStubMessage("useScriptIntercom");
+}
+export function useScriptHotjar(...args) {
+  renderStubMessage("useScriptHotjar");
+}
+export function useScriptStripe(...args) {
+  renderStubMessage("useScriptStripe");
+}
+export function useScriptLemonSqueezy(...args) {
+  renderStubMessage("useScriptLemonSqueezy");
+}
+export function useScriptVimeoPlayer(...args) {
+  renderStubMessage("useScriptVimeoPlayer");
+}
+export function useScriptYouTubeIframe(...args) {
+  renderStubMessage("useScriptYouTubeIframe");
+}
+export function useScriptGoogleMaps(...args) {
+  renderStubMessage("useScriptGoogleMaps");
+}
+export function useScriptNpm(...args) {
+  renderStubMessage("useScriptNpm");
+}
+export function useScriptGoogleAdsense(...args) {
+  renderStubMessage("useScriptGoogleAdsense");
+}
+export function useScriptYouTubePlayer(...args) {
+  renderStubMessage("useScriptYouTubePlayer");
+}
+export function useScriptUmamiAnalytics(...args) {
+  renderStubMessage("useScriptUmamiAnalytics");
+}
+export function useScriptSnapchatPixel(...args) {
+  renderStubMessage("useScriptSnapchatPixel");
+}
+export function useScriptRybbitAnalytics(...args) {
+  renderStubMessage("useScriptRybbitAnalytics");
+}
+export function useScriptDatabuddyAnalytics(...args) {
+  renderStubMessage("useScriptDatabuddyAnalytics");
+}
+export function useScriptRedditPixel(...args) {
+  renderStubMessage("useScriptRedditPixel");
+}
+export function useScriptPayPal(...args) {
+  renderStubMessage("useScriptPayPal");
+}

package/dist/app/composables/ssr.d.ts

@@ -0,0 +1,33 @@
+import type { H3Event } from 'h3';
+import type { H3Event$Fetch } from 'nitropack/types';
+import type { NuxtApp } from '../nuxt.js';
+/** @since 3.0.0 */
+export declare function useRequestEvent(nuxtApp?: NuxtApp): H3Event<import("h3").EventHandlerRequest> | undefined;
+/** @since 3.0.0 */
+export declare function useRequestHeaders<K extends string = string>(include: K[]): {
+    [key in Lowercase<K>]?: string;
+};
+export declare function useRequestHeaders(): Readonly<Record<string, string>>;
+/** @since 3.9.0 */
+export declare function useRequestHeader(header: string): string | undefined;
+/** @since 3.2.0 */
+export declare function useRequestFetch(): H3Event$Fetch | typeof global.$fetch;
+/** @since 3.0.0 */
+export declare function setResponseStatus(event: H3Event, code?: number, message?: string): void;
+/** @deprecated Pass `event` as first option. */
+export declare function setResponseStatus(code: number, message?: string): void;
+/** @since 3.14.0 */
+export declare function useResponseHeader(header: string): import("vue").Ref<any, any>;
+/** @since 3.8.0 */
+export declare function prerenderRoutes(path: string | string[]): void;
+/**
+ * `onPrehydrate` is a composable lifecycle hook that allows you to run a callback on the client immediately before
+ * Nuxt hydrates the page. This is an advanced feature.
+ *
+ * The callback will be stringified and inlined in the HTML so it should not have any external
+ * dependencies (such as auto-imports) or refer to variables defined outside the callback.
+ *
+ * The callback will run before Nuxt runtime initializes so it should not rely on the Nuxt or Vue context.
+ * @since 3.12.0
+ */
+export declare function onPrehydrate(callback: (el: HTMLElement) => void): void;

package/dist/app/composables/ssr.js

@@ -0,0 +1,113 @@
+import { setResponseStatus as _setResponseStatus, appendHeader, getRequestHeader, getRequestHeaders, getResponseHeader, removeResponseHeader, setResponseHeader } from "h3";
+import { computed, getCurrentInstance, ref } from "vue";
+import { useNuxtApp } from "../nuxt.js";
+import { toArray } from "../utils.js";
+import { useHead } from "./head.js";
+export function useRequestEvent(nuxtApp) {
+  if (import.meta.client) {
+    return;
+  }
+  nuxtApp ||= useNuxtApp();
+  return nuxtApp.ssrContext?.event;
+}
+export function useRequestHeaders(include) {
+  if (import.meta.client) {
+    return {};
+  }
+  const event = useRequestEvent();
+  const _headers = event ? getRequestHeaders(event) : {};
+  if (!include || !event) {
+    return _headers;
+  }
+  const headers = /* @__PURE__ */ Object.create(null);
+  for (const _key of include) {
+    const key = _key.toLowerCase();
+    const header = _headers[key];
+    if (header) {
+      headers[key] = header;
+    }
+  }
+  return headers;
+}
+export function useRequestHeader(header) {
+  if (import.meta.client) {
+    return void 0;
+  }
+  const event = useRequestEvent();
+  return event ? getRequestHeader(event, header) : void 0;
+}
+export function useRequestFetch() {
+  if (import.meta.client) {
+    return globalThis.$fetch;
+  }
+  return useRequestEvent()?.$fetch || globalThis.$fetch;
+}
+export function setResponseStatus(arg1, arg2, arg3) {
+  if (import.meta.client) {
+    return;
+  }
+  if (arg1 && typeof arg1 !== "number") {
+    return _setResponseStatus(arg1, arg2, arg3);
+  }
+  const event = useRequestEvent();
+  if (event) {
+    return _setResponseStatus(event, arg1, arg2);
+  }
+}
+export function useResponseHeader(header) {
+  if (import.meta.client) {
+    if (import.meta.dev) {
+      return computed({
+        get: () => void 0,
+        set: () => console.warn("[nuxt] Setting response headers is not supported in the browser.")
+      });
+    }
+    return ref();
+  }
+  const event = useRequestEvent();
+  return computed({
+    get() {
+      return getResponseHeader(event, header);
+    },
+    set(newValue) {
+      if (!newValue) {
+        return removeResponseHeader(event, header);
+      }
+      return setResponseHeader(event, header, newValue);
+    }
+  });
+}
+export function prerenderRoutes(path) {
+  if (!import.meta.server || !import.meta.prerender) {
+    return;
+  }
+  const paths = toArray(path);
+  appendHeader(useRequestEvent(), "x-nitro-prerender", paths.map((p) => encodeURIComponent(p)).join(", "));
+}
+const PREHYDRATE_ATTR_KEY = "data-prehydrate-id";
+export function onPrehydrate(callback, key) {
+  if (import.meta.client) {
+    return;
+  }
+  if (typeof callback !== "string") {
+    throw new TypeError("[nuxt] To transform a callback into a string, `onPrehydrate` must be processed by the Nuxt build pipeline. If it is called in a third-party library, make sure to add the library to `build.transpile`.");
+  }
+  const vm = getCurrentInstance();
+  if (vm && key) {
+    vm.attrs[PREHYDRATE_ATTR_KEY] ||= "";
+    key = ":" + key + ":";
+    if (!vm.attrs[PREHYDRATE_ATTR_KEY].includes(key)) {
+      vm.attrs[PREHYDRATE_ATTR_KEY] += key;
+    }
+  }
+  const code = vm && key ? `document.querySelectorAll('[${PREHYDRATE_ATTR_KEY}*=${JSON.stringify(key)}]').forEach` + callback : callback + "()";
+  useHead({
+    script: [{
+      key: vm && key ? key : void 0,
+      tagPosition: "bodyClose",
+      tagPriority: "critical",
+      innerHTML: code
+    }]
+  });
+  return vm && key ? vm.attrs[PREHYDRATE_ATTR_KEY] : void 0;
+}

package/dist/app/composables/state.d.ts

@@ -0,0 +1,11 @@
+import type { Ref } from 'vue';
+/**
+ * Create a global reactive ref that will be hydrated but not shared across ssr requests
+ * @since 3.0.0
+ * @param key a unique key ensuring that data fetching can be properly de-duplicated across requests
+ * @param init a function that provides initial value for the state when it's not initiated
+ */
+export declare function useState<T>(key?: string, init?: (() => T | Ref<T>)): Ref<T>;
+export declare function useState<T>(init?: (() => T | Ref<T>)): Ref<T>;
+/** @since 3.6.0 */
+export declare function clearNuxtState(keys?: string | string[] | ((key: string) => boolean)): void;