@nuxt/scripts 0.1.12 → 0.2.0

package/dist/runtime/registry/plausible-analytics.d.ts

@@ -0,0 +1,20 @@
+import type { RegistryScriptInput } from '#nuxt-scripts';
+export declare const PlausibleAnalyticsOptions: import("valibot").ObjectSchema<{
+    domain: import("valibot").StringSchema<string>;
+    extension: import("valibot").OptionalSchema<import("valibot").UnionSchema<(import("valibot").UnionSchema<(import("valibot").LiteralSchema<"hash", "hash"> | import("valibot").LiteralSchema<"outbound-links", "outbound-links"> | import("valibot").LiteralSchema<"file-downloads", "file-downloads"> | import("valibot").LiteralSchema<"tagged-events", "tagged-events"> | import("valibot").LiteralSchema<"revenue", "revenue"> | import("valibot").LiteralSchema<"pageview-props", "pageview-props"> | import("valibot").LiteralSchema<"compat", "compat"> | import("valibot").LiteralSchema<"local", "local"> | import("valibot").LiteralSchema<"manual", "manual">)[], "manual" | "hash" | "outbound-links" | "file-downloads" | "tagged-events" | "revenue" | "pageview-props" | "compat" | "local"> | import("valibot").ArraySchema<import("valibot").UnionSchema<(import("valibot").LiteralSchema<"hash", "hash"> | import("valibot").LiteralSchema<"outbound-links", "outbound-links"> | import("valibot").LiteralSchema<"file-downloads", "file-downloads"> | import("valibot").LiteralSchema<"tagged-events", "tagged-events"> | import("valibot").LiteralSchema<"revenue", "revenue"> | import("valibot").LiteralSchema<"pageview-props", "pageview-props"> | import("valibot").LiteralSchema<"compat", "compat"> | import("valibot").LiteralSchema<"local", "local"> | import("valibot").LiteralSchema<"manual", "manual">)[], "manual" | "hash" | "outbound-links" | "file-downloads" | "tagged-events" | "revenue" | "pageview-props" | "compat" | "local">, ("manual" | "hash" | "outbound-links" | "file-downloads" | "tagged-events" | "revenue" | "pageview-props" | "compat" | "local")[]>)[], "manual" | "hash" | "outbound-links" | "file-downloads" | "tagged-events" | "revenue" | "pageview-props" | "compat" | "local" | ("manual" | "hash" | "outbound-links" | "file-downloads" | "tagged-events" | "revenue" | "pageview-props" | "compat" | "local")[]>, undefined, "manual" | "hash" | "outbound-links" | "file-downloads" | "tagged-events" | "revenue" | "pageview-props" | "compat" | "local" | ("manual" | "hash" | "outbound-links" | "file-downloads" | "tagged-events" | "revenue" | "pageview-props" | "compat" | "local")[] | undefined>;
+}, undefined, {
+    domain: string;
+    extension?: "manual" | "hash" | "outbound-links" | "file-downloads" | "tagged-events" | "revenue" | "pageview-props" | "compat" | "local" | ("manual" | "hash" | "outbound-links" | "file-downloads" | "tagged-events" | "revenue" | "pageview-props" | "compat" | "local")[] | undefined;
+}>;
+export type PlausibleAnalyticsInput = RegistryScriptInput<typeof PlausibleAnalyticsOptions, false>;
+export interface PlausibleAnalyticsApi {
+    plausible: ((event: '404', options: Record<string, any>) => void) & ((event: 'event', options: Record<string, any>) => void) & ((...params: any[]) => void) & {
+        q: any[];
+    };
+}
+declare global {
+    interface Window {
+        plausible: PlausibleAnalyticsApi;
+    }
+}
+export declare function useScriptPlausibleAnalytics<T extends PlausibleAnalyticsApi>(_options?: PlausibleAnalyticsInput): any;

package/dist/runtime/registry/plausible-analytics.mjs

@@ -0,0 +1,35 @@
+import { array, literal, object, optional, string, union } from "valibot";
+import { registryScript } from "../utils.mjs";
+import { PlausibleAnalyticsScriptResolver } from "../../registry";
+const extensions = [
+  literal("hash"),
+  literal("outbound-links"),
+  literal("file-downloads"),
+  literal("tagged-events"),
+  literal("revenue"),
+  literal("pageview-props"),
+  literal("compat"),
+  literal("local"),
+  literal("manual")
+];
+export const PlausibleAnalyticsOptions = object({
+  domain: string(),
+  // required
+  extension: optional(union([union(extensions), array(union(extensions))]))
+});
+export function useScriptPlausibleAnalytics(_options) {
+  return registryScript("plausibleAnalytics", (options) => {
+    return {
+      scriptInput: {
+        "src": PlausibleAnalyticsScriptResolver(options),
+        "data-domain": options?.domain
+      },
+      schema: PlausibleAnalyticsOptions,
+      scriptOptions: {
+        use() {
+          return { plausible: window.plausible };
+        }
+      }
+    };
+  }, _options);
+}

package/dist/runtime/registry/segment.d.ts

@@ -1,4 +1,4 @@
-import type { NuxtUseScriptIntegrationOptions, ScriptDynamicSrcInput } from '#nuxt-scripts';
+import type { RegistryScriptInput } from '#nuxt-scripts';
 export declare const SegmentOptions: import("valibot").ObjectSchema<{
     writeKey: import("valibot").StringSchema<string>;
     analyticsKey: import("valibot").OptionalSchema<import("valibot").StringSchema<string>, undefined, string | undefined>;
@@ -6,7 +6,7 @@ export declare const SegmentOptions: import("valibot").ObjectSchema<{
     writeKey: string;
     analyticsKey?: string | undefined;
 }>;
-export type SegmentInput = ScriptDynamicSrcInput<typeof SegmentOptions>;
+export type SegmentInput = RegistryScriptInput<typeof SegmentOptions>;
 export interface SegmentApi {
     analytics: {
         track: (event: string, properties?: Record<string, any>) => void;
@@ -21,4 +21,4 @@ declare global {
     interface Window extends SegmentApi {
     }
 }
-export declare function useScriptSegment<T extends SegmentApi>(options?: SegmentInput, _scriptOptions?: NuxtUseScriptIntegrationOptions): any;
+export declare function useScriptSegment<T extends SegmentApi>(_options?: SegmentInput): any;

package/dist/runtime/registry/segment.mjs

@@ -1,41 +1,41 @@
 import { object, optional, string } from "valibot";
-import { useScript, validateScriptInputSchema } from "#imports";
+import { registryScript } from "../utils.mjs";
+import { SegmentScriptResolver } from "../../registry";
 export const SegmentOptions = object({
   writeKey: string(),
   analyticsKey: optional(string())
 });
-export function useScriptSegment(options, _scriptOptions) {
-  const scriptOptions = _scriptOptions || {};
-  scriptOptions.beforeInit = () => {
-    import.meta.dev && validateScriptInputSchema(SegmentOptions, options);
-    if (import.meta.client) {
-      window.analytics = window.analytics || [];
-      window.analytics.methods = ["track", "page", "identify", "group", "alias", "reset"];
-      window.analytics.factory = function(method) {
-        return function(...params) {
-          const args = Array.prototype.slice.call(params);
-          args.unshift(method);
-          window.analytics.push(args);
-          return window.analytics;
-        };
-      };
-      for (let i = 0; i < window.analytics.methods.length; i++) {
-        const key = window.analytics.methods[i];
-        window.analytics[key] = window.analytics.factory(key);
+export function useScriptSegment(_options) {
+  return registryScript("segment", (options) => {
+    const analyticsKey = options?.analyticsKey || "analytics";
+    return {
+      scriptInput: {
+        "data-global-segment-analytics-key": analyticsKey,
+        "src": SegmentScriptResolver(options)
+      },
+      schema: SegmentOptions,
+      scriptOptions: {
+        use() {
+          return { analytics: window[analyticsKey] };
+        },
+        clientInit: import.meta.server ? void 0 : () => {
+          window.analytics = window.analytics || [];
+          window.analytics.methods = ["track", "page", "identify", "group", "alias", "reset"];
+          window.analytics.factory = function(method) {
+            return function(...params) {
+              const args = Array.prototype.slice.call(params);
+              args.unshift(method);
+              window.analytics.push(args);
+              return window.analytics;
+            };
+          };
+          for (let i = 0; i < window.analytics.methods.length; i++) {
+            const key = window.analytics.methods[i];
+            window.analytics[key] = window.analytics.factory(key);
+          }
+          window.analytics.page();
+        }
       }
-      window.analytics.page();
-    }
-    _scriptOptions?.beforeInit?.();
-  };
-  const analyticsKey = options?.analyticsKey || "analytics";
-  return useScript({
-    "key": "segment",
-    "data-global-segment-analytics-key": analyticsKey,
-    "src": options?.src || `https://cdn.segment.com/analytics.js/v1/${options?.writeKey}/analytics.min.js`
-  }, {
-    ...scriptOptions,
-    use() {
-      return { analytics: window[analyticsKey] };
-    }
-  });
+    };
+  }, _options);
 }

package/dist/runtime/registry/stripe.d.ts

@@ -0,0 +1,16 @@
+import type { Stripe } from '@types/stripe-v3';
+import type { RegistryScriptInput } from '#nuxt-scripts';
+export declare const StripeOptions: import("valibot").ObjectSchema<{
+    advancedFraudSignals: import("valibot").OptionalSchema<import("valibot").BooleanSchema<boolean>, undefined, boolean | undefined>;
+}, undefined, {
+    advancedFraudSignals?: boolean | undefined;
+}>;
+export type StripeInput = RegistryScriptInput<typeof StripeOptions, false>;
+export interface StripeApi {
+    Stripe: Stripe;
+}
+declare global {
+    interface Window extends StripeApi {
+    }
+}
+export declare function useScriptStripe<T extends StripeApi>(_options?: StripeInput): any;

package/dist/runtime/registry/stripe.mjs

@@ -0,0 +1,27 @@
+import { boolean, object, optional } from "valibot";
+import { withQuery } from "ufo";
+import { registryScript } from "../utils.mjs";
+export const StripeOptions = object({
+  advancedFraudSignals: optional(boolean())
+});
+export function useScriptStripe(_options) {
+  return registryScript("stripe", (options) => ({
+    scriptInput: {
+      src: withQuery(
+        `https://js.stripe.com/v3/`,
+        typeof options?.advancedFraudSignals === "boolean" && !options?.advancedFraudSignals ? { advancedFraudSignals: false } : {}
+      ),
+      // opt-out of privacy defaults
+      // @ts-expect-error TODO add types
+      crossorigin: null,
+      // @ts-expect-error TODO add types
+      referrerpolicy: null
+    },
+    schema: StripeOptions,
+    scriptOptions: {
+      use() {
+        return { Stripe: window.Stripe };
+      }
+    }
+  }), _options);
+}

package/dist/runtime/registry/vimeo-player.d.ts

@@ -0,0 +1,13 @@
+import type VimeoPlayer from 'vimeo__player';
+import type { RegistryScriptInput } from '#nuxt-scripts';
+export interface VimeoPlayerApi {
+    Player: VimeoPlayer;
+}
+export declare const VimeoPlayerOptions: import("valibot").ObjectSchema<{}, undefined, {}>;
+export type VimeoPlayerInput = RegistryScriptInput<typeof VimeoPlayerOptions>;
+declare global {
+    interface Window {
+        Vimeo: VimeoPlayerApi;
+    }
+}
+export declare function useScriptVimeoPlayer<T extends VimeoPlayerApi>(_options?: VimeoPlayerInput): any;

package/dist/runtime/registry/vimeo-player.mjs

@@ -0,0 +1,45 @@
+import { object } from "valibot";
+import { registryScript } from "../utils.mjs";
+import { useHead } from "#imports";
+export const VimeoPlayerOptions = object({});
+export function useScriptVimeoPlayer(_options) {
+  return registryScript("vimeoPlayer", () => ({
+    scriptInput: {
+      src: "https://player.vimeo.com/api/player.js"
+    },
+    schema: VimeoPlayerOptions,
+    scriptOptions: {
+      use() {
+        let Player;
+        if (import.meta.client) {
+          Player = function(...params) {
+            return new window.Vimeo.Player(...params);
+          };
+        }
+        return { Player };
+      }
+    },
+    beforeInit() {
+      useHead({
+        link: [
+          {
+            rel: "preconnect",
+            href: "https://player.vimeo.com"
+          },
+          {
+            rel: "preconnect",
+            href: "https://i.vimeocdn.com"
+          },
+          {
+            rel: "preconnect",
+            href: "https://f.vimeocdn.com"
+          },
+          {
+            rel: "preconnect",
+            href: "https://fresnel.vimeocdn.com"
+          }
+        ]
+      });
+    }
+  }), _options);
+}

package/dist/runtime/registry/x-pixel.d.ts

@@ -0,0 +1,39 @@
+import type { RegistryScriptInput } from '#nuxt-scripts';
+interface ContentProperties {
+    content_type?: string | null;
+    content_id?: string | number | null;
+    content_name?: string | null;
+    content_price?: string | number | null;
+    num_items?: string | number | null;
+    content_group_id?: string | number | null;
+}
+interface EventObjectProperties {
+    value?: string | number | null;
+    currency?: string | null;
+    conversion_id?: string | number | null;
+    email_address?: string | null;
+    phone_number?: string | null;
+    contents: ContentProperties[];
+}
+type TwqFns = ((event: 'event', eventId: string, data?: EventObjectProperties) => void) & ((event: 'config', id: string) => void) & ((event: string, ...params: any[]) => void);
+export interface XPixelApi {
+    twq: TwqFns & {
+        loaded: boolean;
+        version: string;
+        queue: any[];
+    };
+}
+declare global {
+    interface Window extends XPixelApi {
+    }
+}
+export declare const XPixelOptions: import("valibot").ObjectSchema<{
+    id: import("valibot").StringSchema<string>;
+    version: import("valibot").OptionalSchema<import("valibot").StringSchema<string>, undefined, string | undefined>;
+}, undefined, {
+    id: string;
+    version?: string | undefined;
+}>;
+export type XPixelInput = RegistryScriptInput<typeof XPixelOptions>;
+export declare function useScriptXPixel<T extends XPixelApi>(_options?: XPixelInput): any;
+export {};

package/dist/runtime/registry/x-pixel.mjs

@@ -0,0 +1,28 @@
+import { object, optional, string } from "valibot";
+import { registryScript } from "../utils.mjs";
+export const XPixelOptions = object({
+  id: string(),
+  version: optional(string())
+});
+export function useScriptXPixel(_options) {
+  return registryScript("xPixel", (options) => ({
+    scriptInput: {
+      src: "https://static.ads-twitter.com/uwt.js"
+    },
+    schema: XPixelOptions,
+    scriptOptions: {
+      use() {
+        return { twq: window.twq };
+      },
+      clientInit: import.meta.server ? void 0 : () => {
+        const s = window.twq = function(...params) {
+          s.exe ? s.exe(s, ...params) : s.queue.push(params);
+        };
+        s.version = options?.version || "1.1";
+        s.queue = [
+          ["config", options?.id]
+        ];
+      }
+    }
+  }), _options);
+}

package/dist/runtime/registry/youtube-iframe.d.ts

@@ -0,0 +1,13 @@
+import type YT from '@types/youtube';
+import type { RegistryScriptInput } from '#nuxt-scripts';
+export interface YouTubeIframeApi {
+    YT: typeof YT;
+}
+declare global {
+    interface Window extends YouTubeIframeApi {
+        onYouTubeIframeAPIReady: () => void;
+    }
+}
+export declare const YouTubeIframeOptions: import("valibot").ObjectSchema<{}, undefined, {}>;
+export type YouTubeIFrameInput = RegistryScriptInput<typeof YouTubeIframeOptions>;
+export declare function useScriptYouTubeIframe<T extends YouTubeIframeApi>(_options: YouTubeIFrameInput): any;

package/dist/runtime/registry/youtube-iframe.mjs

@@ -0,0 +1,54 @@
+import { object } from "valibot";
+import { registryScript } from "../utils.mjs";
+import { useHead } from "#imports";
+export const YouTubeIframeOptions = object({
+  // no options afaik
+});
+export function useScriptYouTubeIframe(_options) {
+  let readyPromise = Promise.resolve();
+  return registryScript("youtubeIframe", () => ({
+    scriptInput: {
+      src: "https://www.youtube.com/iframe_api",
+      // opt-out of privacy defaults
+      // @ts-expect-error TODO add types
+      crossorigin: null
+    },
+    schema: YouTubeIframeOptions,
+    scriptOptions: {
+      use() {
+        return {
+          YT: readyPromise.then(() => {
+            return window.YT;
+          })
+        };
+      },
+      clientInit: import.meta.server ? void 0 : () => {
+        readyPromise = new Promise((resolve) => {
+          window.onYouTubeIframeAPIReady = resolve;
+        });
+      },
+      beforeInit() {
+        useHead({
+          link: [
+            {
+              rel: "preconnect",
+              href: "https://www.youtube-nocookie.com"
+            },
+            {
+              rel: "preconnect",
+              href: "https://www.google.com"
+            },
+            {
+              rel: "preconnect",
+              href: "https://googleads.g.doubleclick.net"
+            },
+            {
+              rel: "preconnect",
+              href: "https://static.doubleclick.net"
+            }
+          ]
+        });
+      }
+    }
+  }), _options);
+}

package/dist/runtime/types.d.ts

@@ -10,6 +10,13 @@ import type { FathomAnalyticsInput } from './registry/fathom-analytics';
 import type { HotjarInput } from './registry/hotjar';
 import type { IntercomInput } from './registry/intercom';
 import type { ConfettiInput } from './registry/confetti';
+import type { GoogleAnalyticsInput } from '~/src/runtime/registry/google-analytics';
+import type { GoogleMapsInput } from '~/src/runtime/registry/google-maps';
+import type { GoogleTagManagerInput } from '~/src/runtime/registry/google-tag-manager';
+import type { MatomoAnalyticsInput } from '~/src/runtime/registry/matomo-analytics';
+import type { StripeInput } from '~/src/runtime/registry/stripe';
+import type { VimeoInput } from '~/src/runtime/registry/vimeo';
+import type { XPixelInput } from '~/src/runtime/registry/x-pixel';
 export type NuxtUseScriptOptions<T = any> = Omit<UseScriptOptions<T>, 'trigger'> & {
     /**
      * The trigger to load the script:
@@ -22,14 +29,10 @@ export type NuxtUseScriptOptions<T = any> = Omit<UseScriptOptions<T>, 'trigger'>
      * Should the script be bundled as an asset and loaded from your server. This is useful for improving the
      * performance by avoiding the extra DNS lookup and reducing the number of requests. It also
      * improves privacy by not sharing the user's IP address with third-party servers.
-     * - `bundle` - Bundle the script as an asset.
-     * - `null` - Do not bundle the script.
+     * - `true` - Bundle the script as an asset.
+     * - `false` - Do not bundle the script. (default)
      */
-    assetStrategy?: null | 'bundle';
-    /**
-     * A hook to run when a script does not exist and will be initialized for the first time.
-     */
-    beforeInit?: () => void;
+    bundle?: boolean;
 };
 export type NuxtUseScriptIntegrationOptions = Omit<NuxtUseScriptOptions, 'use'>;
 export type NuxtUseScriptInput = UseScriptInput;
@@ -62,22 +65,35 @@ export interface NuxtAppScript {
         at: number;
     }[];
 }
-export type ScriptRegistryEntry<T> = T | [T, NuxtUseScriptOptions<T>];
+export type ScriptRegistryEntry<T> = true | T | [T, NuxtUseScriptOptions<T>];
 export interface ScriptRegistry {
     cloudflareWebAnalytics?: ScriptRegistryEntry<CloudflareWebAnalyticsInput>;
     confetti?: ScriptRegistryEntry<ConfettiInput>;
     facebookPixel?: ScriptRegistryEntry<FacebookPixelInput>;
     fathomAnalytics?: ScriptRegistryEntry<FathomAnalyticsInput>;
+    googleAnalytics?: ScriptRegistryEntry<GoogleAnalyticsInput>;
+    googleMaps?: ScriptRegistryEntry<GoogleMapsInput>;
+    googleTagManager?: ScriptRegistryEntry<GoogleTagManagerInput>;
     hotjar?: ScriptRegistryEntry<HotjarInput>;
     intercom?: ScriptRegistryEntry<IntercomInput>;
+    matomoAnalytics?: ScriptRegistryEntry<MatomoAnalyticsInput>;
     segment?: ScriptRegistryEntry<SegmentInput>;
+    stripe?: ScriptRegistryEntry<StripeInput>;
+    vimeo?: ScriptRegistryEntry<VimeoInput>;
+    xPixel?: ScriptRegistryEntry<XPixelInput>;
 }
-export type ScriptDynamicSrcInput<T extends ObjectSchema<any>> = Input<T> & {
-    src?: string;
+export type RegistryScriptInput<T extends ObjectSchema<any>, Bundelable extends boolean = true> = Input<T> & {
+    scriptInput?: UseScriptInput;
+    scriptOptions?: Bundelable extends true ? Omit<NuxtUseScriptOptions, 'use'> : Omit<NuxtUseScriptOptions, 'bundle' | 'use'>;
 };
-export type RegistryScripts = (Import & {
+export type RegistryScripts = {
+    import: Import;
+    scriptBundling?: false | ((options?: any) => string);
+    label?: string;
     src?: string | false;
-    module?: '@nuxt/scripts' | string;
-    key?: string;
-    transform?: (options: any) => string;
-})[];
+    category?: string;
+    logo?: string | {
+        light: string;
+        dark: string;
+    };
+}[];

package/dist/runtime/utils.d.ts

@@ -1 +1,12 @@
+import type { Input, ObjectSchema } from 'valibot';
+import type { UseScriptInput } from '@unhead/vue';
+import type { NuxtUseScriptOptions, RegistryScriptInput } from '#nuxt-scripts';
 export declare function mockFallbackScript(name: string, module: string): any;
+type OptionsFn<O extends ObjectSchema<any>> = (options: Input<O>) => ({
+    scriptInput?: UseScriptInput;
+    scriptOptions?: NuxtUseScriptOptions;
+    schema?: O;
+    clientInit?: () => void;
+});
+export declare function registryScript<T extends Record<string | symbol, any>, O extends ObjectSchema<any>>(key: string, optionsFn: OptionsFn<O>, _userOptions?: RegistryScriptInput<O>): any;
+export {};

package/dist/runtime/utils.mjs

@@ -1,5 +1,34 @@
-import { useScript } from "#imports";
+import { defu } from "defu";
+import { parse } from "valibot";
+import { createError, useRuntimeConfig, useScript } from "#imports";
 export function mockFallbackScript(name, module) {
   console.error(`${name} is provided by ${module}. Check your console to install it or run 'npx nuxi@latest module add ${module}'`);
   return useScript("", { trigger: "manual" });
 }
+function validateScriptInputSchema(schema, options) {
+  if (import.meta.dev) {
+    try {
+      parse(schema, options);
+    } catch (e) {
+      createError({
+        cause: e,
+        message: "Invalid script options"
+      });
+    }
+  }
+}
+export function registryScript(key, optionsFn, _userOptions) {
+  const runtimeConfig = useRuntimeConfig().public.scripts || {};
+  const runtimeOptions = runtimeConfig[key];
+  const userOptions = Object.assign(_userOptions || {}, runtimeOptions || {});
+  const options = optionsFn(userOptions);
+  const scriptInput = defu({ key }, options.scriptInput);
+  const scriptOptions = Object.assign(_userOptions?.scriptOptions || {}, options.scriptOptions || {});
+  const init = scriptOptions.beforeInit;
+  scriptOptions.beforeInit = () => {
+    import.meta.dev && options.schema && validateScriptInputSchema(options.schema, userOptions);
+    init?.();
+    import.meta.client && options.clientInit?.();
+  };
+  return useScript(scriptInput, scriptOptions);
+}

package/package.json

@@ -1,9 +1,8 @@
 {
   "name": "@nuxt/scripts",
   "type": "module",
-  "version": "0.1.12",
-  "packageManager": "pnpm@8.15.6",
-  "description": "Next-gen Scripts for Nuxt",
+  "version": "0.2.0",
+  "description": "Load third-party scripts with better performance, privacy and DX in Nuxt Apps.",
   "author": {
     "website": "https://harlanzw.com",
     "name": "Harlan Wilton",
@@ -38,22 +37,29 @@
     ]
   },
   "dependencies": {
-    "@nuxt/devtools-kit": "^1.1.5",
-    "@nuxt/devtools-ui-kit": "^1.1.5",
-    "@nuxt/kit": "^3.11.1",
-    "@unhead/vue": "^1.9.4",
+    "@nuxt/devtools-kit": "^1.2.0",
+    "@nuxt/devtools-ui-kit": "^1.2.0",
+    "@nuxt/kit": "^3.11.2",
+    "@types/google.maps": "^3.55.7",
+    "@types/stripe-v3": "^3.1.33",
+    "@types/vimeo__player": "^2.18.3",
+    "@types/youtube": "^0.0.50",
+    "@unhead/vue": "^1.9.7",
     "consola": "^3.2.3",
     "defu": "^6.1.4",
     "estree-walker": "^3.0.3",
     "h3": "^1.11.1",
-    "magic-string": "^0.30.8",
+    "magic-string": "^0.30.10",
+    "mlly": "^1.6.1",
     "ofetch": "^1.3.4",
     "ohash": "^1.1.3",
     "pathe": "^1.1.2",
-    "pkg-types": "^1.0.3",
-    "shiki": "^1.2.3",
+    "pkg-types": "^1.1.0",
+    "semver": "^7.6.0",
+    "shiki": "^1.3.0",
     "sirv": "^2.0.4",
     "std-env": "^3.7.0",
+    "third-party-capital": "^1.0.28",
     "ufo": "^1.5.3",
     "unimport": "^3.7.1",
     "unplugin": "^1.10.1",
@@ -61,22 +67,27 @@
     "valibot": "^0.30.0"
   },
   "devDependencies": {
-    "@antfu/eslint-config": "2.11.6",
-    "@nuxt/devtools-ui-kit": "^1.1.5",
-    "@nuxt/module-builder": "^0.5.5",
-    "@nuxt/test-utils": "3.12.0",
-    "@unhead/schema": "^1.9.4",
+    "@antfu/eslint-config": "2.15.0",
+    "@nuxt/devtools-ui-kit": "^1.2.0",
+    "@nuxt/module-builder": "^0.6.0",
+    "@nuxt/test-utils": "3.12.1",
+    "@unhead/schema": "^1.9.7",
     "acorn-loose": "^8.4.0",
     "bumpp": "^9.4.0",
-    "eslint": "8.57.0",
-    "nuxt": "^3.11.1",
-    "nuxt-scripts-devtools": "latest",
-    "playwright-core": "^1.42.1",
-    "typescript": "^5.4.3",
-    "vitest": "^1.4.0"
+    "eslint": "9.1.1",
+    "nuxt": "^3.11.2",
+    "playwright-core": "^1.43.1",
+    "typescript": "^5.4.5",
+    "vitest": "^1.5.2",
+    "vue": "^3.4.25",
+    "vue-router": "^4.3.2"
   },
   "resolutions": {
-    "@nuxt/scripts": "workspace:*"
+    "nuxt-scripts-devtools": "workspace:*",
+    "@nuxt/scripts": "workspace:*",
+    "nuxt": "^3.11.2",
+    "vue": "^3.4.25",
+    "vue-router": "^4.3.2"
   },
   "scripts": {
     "build": "pnpm prepack",
@@ -86,7 +97,7 @@
     "dev:ssl": "nuxi dev playground --https",
     "dev:prepare": "nuxt-module-build build --stub && nuxt-module-build prepare && nuxi prepare playground",
     "typecheck": "pnpm dlx vue-tsc --noEmit",
-    "release": "pnpm build && bumpp && pnpm -r publish --no-git-checks",
+    "release": "pnpm build && bumpp && pnpm publish --no-git-checks",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
     "test": "true",