@nuxt/scripts 1.0.0-beta.1 → 1.0.0-beta.13

package/dist/runtime/components/ScriptXEmbed.vue

@@ -0,0 +1,76 @@
+<script setup>
+import { useAsyncData } from "nuxt/app";
+import { computed } from "vue";
+import { formatCount, formatTweetDate, proxyXImageUrl } from "../registry/x-embed";
+const props = defineProps({
+  tweetId: { type: String, required: true },
+  apiEndpoint: { type: String, required: false, default: "/api/_scripts/x-embed" },
+  imageProxyEndpoint: { type: String, required: false, default: "/api/_scripts/x-embed-image" },
+  rootAttrs: { type: Object, required: false }
+});
+const cacheKey = computed(() => `x-embed-${props.tweetId}`);
+const { data: tweet, status, error } = useAsyncData(
+  cacheKey,
+  () => $fetch(`${props.apiEndpoint}?id=${props.tweetId}`)
+);
+const slotProps = computed(() => {
+  if (!tweet.value)
+    return null;
+  const t = tweet.value;
+  return {
+    // Raw data
+    tweet: t,
+    // User info
+    userName: t.user.name,
+    userHandle: t.user.screen_name,
+    userAvatar: proxyXImageUrl(t.user.profile_image_url_https, props.imageProxyEndpoint),
+    userAvatarOriginal: t.user.profile_image_url_https,
+    isVerified: t.user.verified || t.user.is_blue_verified,
+    // Tweet content
+    text: t.text,
+    // Formatted values
+    datetime: formatTweetDate(t.created_at),
+    createdAt: new Date(t.created_at),
+    likes: t.favorite_count,
+    likesFormatted: formatCount(t.favorite_count),
+    replies: t.conversation_count,
+    repliesFormatted: formatCount(t.conversation_count),
+    // Media
+    photos: t.photos?.map((p) => ({
+      ...p,
+      proxiedUrl: proxyXImageUrl(p.url, props.imageProxyEndpoint)
+    })),
+    video: t.video ? {
+      ...t.video,
+      posterProxied: proxyXImageUrl(t.video.poster, props.imageProxyEndpoint)
+    } : null,
+    // Links
+    tweetUrl: `https://x.com/${t.user.screen_name}/status/${t.id_str}`,
+    userUrl: `https://x.com/${t.user.screen_name}`,
+    // Quoted tweet
+    quotedTweet: t.quoted_tweet,
+    // Reply context
+    isReply: !!t.parent,
+    replyToUser: t.parent?.user.screen_name,
+    // Helpers
+    proxyImage: (url) => proxyXImageUrl(url, props.imageProxyEndpoint)
+  };
+});
+defineExpose({
+  tweet,
+  status,
+  error
+});
+</script>
+
+<template>
+  <div v-bind="rootAttrs">
+    <slot v-if="status === 'pending'" name="loading">
+      <div>Loading tweet...</div>
+    </slot>
+    <slot v-else-if="status === 'error'" name="error" :error="error">
+      <div>Failed to load tweet</div>
+    </slot>
+    <slot v-else-if="slotProps" v-bind="slotProps" />
+  </div>
+</template>

package/dist/runtime/components/ScriptXEmbed.vue.d.ts

@@ -0,0 +1,82 @@
+import type { HTMLAttributes } from 'vue';
+import type { XEmbedTweetData } from '../registry/x-embed.js';
+type __VLS_Props = {
+    /**
+     * The tweet ID to embed
+     */
+    tweetId: string;
+    /**
+     * Custom API endpoint for fetching tweet data
+     * @default '/_scripts/x-embed'
+     */
+    apiEndpoint?: string;
+    /**
+     * Custom image proxy endpoint
+     * @default '/_scripts/x-embed-image'
+     */
+    imageProxyEndpoint?: string;
+    /**
+     * Root element attributes
+     */
+    rootAttrs?: HTMLAttributes;
+};
+declare var __VLS_1: {}, __VLS_3: {
+    error: import("nuxt/app").NuxtError<unknown> | undefined;
+}, __VLS_5: {
+    tweet: XEmbedTweetData;
+    userName: string;
+    userHandle: string;
+    userAvatar: string;
+    userAvatarOriginal: string;
+    isVerified: boolean | undefined;
+    text: string;
+    datetime: string;
+    createdAt: Date;
+    likes: number;
+    likesFormatted: string;
+    replies: number;
+    repliesFormatted: string;
+    photos: {
+        proxiedUrl: string;
+        url: string;
+        width: number;
+        height: number;
+    }[] | undefined;
+    video: {
+        posterProxied: string;
+        poster: string;
+        variants: Array<{
+            type: string;
+            src: string;
+        }>;
+    } | null;
+    tweetUrl: string;
+    userUrl: string;
+    quotedTweet: XEmbedTweetData | undefined;
+    isReply: boolean;
+    replyToUser: string | undefined;
+    proxyImage: (url: string) => string;
+};
+type __VLS_Slots = {} & {
+    loading?: (props: typeof __VLS_1) => any;
+} & {
+    error?: (props: typeof __VLS_3) => any;
+} & {
+    default?: (props: typeof __VLS_5) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
+    tweet: import("vue").Ref<XEmbedTweetData | undefined, XEmbedTweetData | undefined>;
+    status: import("vue").Ref<import("nuxt/app").AsyncDataRequestStatus, import("nuxt/app").AsyncDataRequestStatus>;
+    error: import("vue").Ref<import("nuxt/app").NuxtError<unknown> | undefined, import("nuxt/app").NuxtError<unknown> | undefined>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    apiEndpoint: string;
+    imageProxyEndpoint: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/ScriptYouTubePlayer.vue

@@ -1,7 +1,7 @@
 <script setup>
-import { computed, onBeforeUnmount, onMounted, ref, watch } from "vue";
 import { defu } from "defu";
 import { useHead } from "nuxt/app";
+import { computed, onBeforeUnmount, onMounted, ref, watch } from "vue";
 import { useScriptTriggerElement } from "../composables/useScriptTriggerElement";
 import { useScriptYouTubePlayer } from "../registry/youtube-player";
 import ScriptAriaLoadingIndicator from "./ScriptAriaLoadingIndicator.vue";
@@ -70,9 +70,11 @@ onMounted(() => {
   onLoaded(async (instance) => {
     if (!isTriggered.value && trigger instanceof Promise) {
       const triggered = await trigger;
-      if (!triggered) return;
+      if (!triggered)
+        return;
     }
-    if (!youtubeEl.value) return;
+    if (!youtubeEl.value)
+      return;
     const YouTube = instance.YT instanceof Promise ? await instance.YT : instance.YT;
     await new Promise((resolve) => {
       if (typeof YT.Player === "undefined")
@@ -80,7 +82,8 @@ onMounted(() => {
       else
         resolve();
     });
-    if (!youtubeEl.value) return;
+    if (!youtubeEl.value)
+      return;
     player.value = new YT.Player(youtubeEl.value, {
       host: !props.cookies ? "https://www.youtube-nocookie.com" : "https://www.youtube.com",
       videoId: props.videoId,

package/dist/runtime/composables/useScript.js

@@ -1,9 +1,14 @@
-import { defu } from "defu";
+import { resolveTrigger } from "#build/nuxt-scripts-trigger-resolver";
 import { useScript as _useScript } from "@unhead/vue/scripts";
-import { reactive } from "vue";
-import { onNuxtReady, useNuxtApp, useRuntimeConfig, injectHead } from "nuxt/app";
+import { defu } from "defu";
+import { injectHead, onNuxtReady, useHead, useNuxtApp, useRuntimeConfig } from "nuxt/app";
+import { ref } from "vue";
 import { logger } from "../logger.js";
-import { resolveTrigger } from "#build/nuxt-scripts-trigger-resolver";
+function ensureScripts(nuxtApp) {
+  if (!nuxtApp.$scripts) {
+    nuxtApp.$scripts = {};
+  }
+}
 function useNuxtScriptRuntimeConfig() {
   return useRuntimeConfig().public["nuxt-scripts"];
 }
@@ -13,6 +18,27 @@ export function resolveScriptKey(input) {
 export function useScript(input, options) {
   input = typeof input === "string" ? { src: input } : input;
   options = defu(options, useNuxtScriptRuntimeConfig()?.defaultScriptOptions);
+  if (options.partytown) {
+    const src = input.src;
+    if (!src) {
+      throw new Error("useScript with partytown requires a src");
+    }
+    useHead({
+      script: [{ src, type: "text/partytown" }]
+    });
+    const nuxtApp2 = useNuxtApp();
+    ensureScripts(nuxtApp2);
+    const status = ref("loaded");
+    const stub = {
+      id: src,
+      status,
+      load: () => Promise.resolve({}),
+      remove: () => false,
+      entry: void 0
+    };
+    nuxtApp2.$scripts[src] = stub;
+    return stub;
+  }
   if (import.meta.dev && options.bundle === "unsupported") {
     console.warn("[Nuxt Scripts] Bundling is not supported for dynamic script sources. Static URLs are required for bundling.");
     options.bundle = false;
@@ -23,13 +49,13 @@ export function useScript(input, options) {
       options.trigger = resolved;
     }
   }
-  const id = String(resolveScriptKey(input));
   const nuxtApp = useNuxtApp();
+  const id = String(resolveScriptKey(input));
   options.head = options.head || injectHead();
   if (!options.head) {
     throw new Error("useScript() has been called without Nuxt context.");
   }
-  nuxtApp.$scripts = nuxtApp.$scripts || reactive({});
+  ensureScripts(nuxtApp);
   const exists = !!nuxtApp.$scripts?.[id];
   const err = options._validate?.();
   if (import.meta.dev && import.meta.client && err) {

package/dist/runtime/composables/useScriptEventPage.js

@@ -1,5 +1,5 @@
-import { useNuxtApp, useRoute, injectHead } from "nuxt/app";
-import { ref, onScopeDispose } from "vue";
+import { injectHead, useNuxtApp, useRoute } from "nuxt/app";
+import { onScopeDispose, ref } from "vue";
 export function useScriptEventPage(onChange) {
   const nuxt = useNuxtApp();
   const route = useRoute();

package/dist/runtime/composables/useScriptTriggerConsent.js

@@ -1,5 +1,5 @@
+import { onNuxtReady, requestIdleCallback, tryUseNuxtApp } from "nuxt/app";
 import { isRef, ref, toValue, watch } from "vue";
-import { tryUseNuxtApp, onNuxtReady, requestIdleCallback } from "nuxt/app";
 export function useScriptTriggerConsent(options) {
   if (import.meta.server)
     return new Promise(() => {

package/dist/runtime/composables/useScriptTriggerElement.js

@@ -2,7 +2,7 @@ import {
   useEventListener,
   useIntersectionObserver
 } from "@vueuse/core";
-import { tryOnScopeDispose, tryOnMounted } from "@vueuse/shared";
+import { tryOnMounted, tryOnScopeDispose } from "@vueuse/shared";
 import { watch } from "vue";
 function useElementVisibilityPromise(element) {
   let observer;

package/dist/runtime/composables/useScriptTriggerIdleTimeout.js

@@ -1,5 +1,5 @@
-import { tryOnScopeDispose } from "@vueuse/shared";
 import { useTimeoutFn } from "@vueuse/core";
+import { tryOnScopeDispose } from "@vueuse/shared";
 import { onNuxtReady } from "nuxt/app";
 export function useScriptTriggerIdleTimeout(options) {
   if (import.meta.server) {

package/dist/runtime/composables/useScriptTriggerServiceWorker.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Create a trigger that loads a script after the service worker is controlling the page.
+ * Falls back to immediate loading if service workers are not supported or after timeout.
+ */
+export declare function useScriptTriggerServiceWorker(options?: {
+    timeout?: number;
+}): Promise<boolean>;

package/dist/runtime/composables/useScriptTriggerServiceWorker.js

@@ -0,0 +1,39 @@
+import { tryOnScopeDispose } from "@vueuse/shared";
+export function useScriptTriggerServiceWorker(options) {
+  if (import.meta.server)
+    return new Promise(() => {
+    });
+  const timeout = options?.timeout ?? 3e3;
+  return new Promise((resolve) => {
+    if (!("serviceWorker" in navigator)) {
+      resolve(true);
+      return;
+    }
+    let resolved = false;
+    const done = () => {
+      if (resolved)
+        return;
+      resolved = true;
+      resolve(true);
+    };
+    if (navigator.serviceWorker.controller) {
+      done();
+      return;
+    }
+    const onControllerChange = () => {
+      navigator.serviceWorker.removeEventListener("controllerchange", onControllerChange);
+      done();
+    };
+    navigator.serviceWorker.addEventListener("controllerchange", onControllerChange);
+    const timer = setTimeout(() => {
+      navigator.serviceWorker.removeEventListener("controllerchange", onControllerChange);
+      console.warn("[nuxt-scripts] Service worker not controlling after timeout, loading scripts anyway");
+      done();
+    }, timeout);
+    tryOnScopeDispose(() => {
+      navigator.serviceWorker.removeEventListener("controllerchange", onControllerChange);
+      clearTimeout(timer);
+      resolve(false);
+    });
+  });
+}

package/dist/runtime/registry/clarity.js

@@ -1,5 +1,5 @@
+import { minLength, object, pipe, string } from "#nuxt-scripts-validator";
 import { useRegistryScript } from "../utils.js";
-import { minLength, object, string, pipe } from "#nuxt-scripts-validator";
 export const ClarityOptions = object({
   /**
    * The Clarity token.
@@ -7,30 +7,26 @@ export const ClarityOptions = object({
   id: pipe(string(), minLength(10))
 });
 export function useScriptClarity(_options) {
-  return useRegistryScript(
-    "clarity",
-    (options) => ({
-      scriptInput: {
-        src: `https://www.clarity.ms/tag/${options.id}`
-      },
-      schema: import.meta.dev ? ClarityOptions : void 0,
-      scriptOptions: {
-        use() {
-          return {
-            // @ts-expect-error untyped
-            clarity: Object.assign(function(...params) {
-              const clarity = window.clarity;
-              return clarity.apply(this, params);
-            }, window.clarity)
-          };
-        }
-      },
-      clientInit: import.meta.server ? void 0 : () => {
-        window.clarity = window.clarity || function(...params) {
-          (window.clarity.q = window.clarity.q || []).push(params);
+  return useRegistryScript("clarity", (options) => ({
+    scriptInput: {
+      src: `https://www.clarity.ms/tag/${options.id}`
+    },
+    schema: import.meta.dev ? ClarityOptions : void 0,
+    scriptOptions: {
+      use() {
+        return {
+          // @ts-expect-error untyped
+          clarity: Object.assign(function(...params) {
+            const clarity = window.clarity;
+            return clarity.apply(this, params);
+          }, window.clarity)
         };
       }
-    }),
-    _options
-  );
+    },
+    clientInit: import.meta.server ? void 0 : () => {
+      window.clarity = window.clarity || function(...params) {
+        (window.clarity.q = window.clarity.q || []).push(params);
+      };
+    }
+  }), _options);
 }

package/dist/runtime/registry/cloudflare-web-analytics.js

@@ -1,5 +1,5 @@
-import { useRegistryScript } from "../utils.js";
 import { boolean, minLength, object, optional, pipe, string } from "#nuxt-scripts-validator";
+import { useRegistryScript } from "../utils.js";
 export const CloudflareWebAnalyticsOptions = object({
   /**
    * The Cloudflare Web Analytics token.

package/dist/runtime/registry/crisp.js

@@ -1,5 +1,5 @@
+import { number, object, optional, string } from "#nuxt-scripts-validator";
 import { useRegistryScript } from "../utils.js";
-import { object, string, optional, number } from "#nuxt-scripts-validator";
 export const CrispOptions = object({
   /**
    * The Crisp ID.

package/dist/runtime/registry/databuddy-analytics.js

@@ -1,5 +1,5 @@
+import { boolean, number, object, optional, string } from "#nuxt-scripts-validator";
 import { useRegistryScript } from "../utils.js";
-import { object, optional, string, boolean, number } from "#nuxt-scripts-validator";
 export const DatabuddyAnalyticsOptions = object({
   // Required
   clientId: string(),

package/dist/runtime/registry/fathom-analytics.js

@@ -1,5 +1,5 @@
-import { useRegistryScript } from "../utils.js";
 import { boolean, literal, object, optional, string, union } from "#nuxt-scripts-validator";
+import { useRegistryScript } from "../utils.js";
 export const FathomAnalyticsOptions = object({
   /**
    * The Fathom Analytics site ID.

package/dist/runtime/registry/google-adsense.js

@@ -1,6 +1,6 @@
+import { boolean, object, optional, string } from "#nuxt-scripts-validator";
 import { useHead } from "nuxt/app";
 import { useRegistryScript } from "../utils.js";
-import { object, string, optional, boolean } from "#nuxt-scripts-validator";
 export const GoogleAdsenseOptions = object({
   /**
    * The Google Adsense ID.

package/dist/runtime/registry/google-analytics.js

@@ -1,6 +1,6 @@
-import { withQuery } from "ufo";
+import { object, optional, string } from "#nuxt-scripts-validator";
 import { useRegistryScript } from "#nuxt-scripts/utils";
-import { object, string, optional } from "#nuxt-scripts-validator";
+import { withQuery } from "ufo";
 export const GoogleAnalyticsOptions = object({
   id: optional(string()),
   // The GA4 measurement ID (format: G-XXXXXXXX)

package/dist/runtime/registry/google-maps.d.ts

@@ -15,7 +15,7 @@ declare global {
     interface Window {
         google: {
             maps: {
-                __ib__(): void;
+                __ib__: () => void;
             };
         };
     }

package/dist/runtime/registry/google-maps.js

@@ -1,6 +1,6 @@
+import { array, literal, object, optional, string, union } from "#nuxt-scripts-validator";
 import { withQuery } from "ufo";
 import { useRegistryScript } from "../utils.js";
-import { array, literal, object, optional, string, union } from "#nuxt-scripts-validator";
 export const GoogleMapsOptions = object({
   apiKey: string(),
   libraries: optional(array(string())),

package/dist/runtime/registry/google-recaptcha.js

@@ -1,6 +1,6 @@
-import { withQuery } from "ufo";
+import { boolean, object, optional, string } from "#nuxt-scripts-validator";
 import { useRegistryScript } from "#nuxt-scripts/utils";
-import { object, string, optional, boolean } from "#nuxt-scripts-validator";
+import { withQuery } from "ufo";
 export const GoogleRecaptchaOptions = object({
   siteKey: string(),
   // Use enterprise.js instead of api.js

package/dist/runtime/registry/google-sign-in.js

@@ -1,5 +1,5 @@
+import { array, boolean, literal, object, optional, string, union } from "#nuxt-scripts-validator";
 import { useRegistryScript } from "#nuxt-scripts/utils";
-import { object, string, optional, boolean, array, union, literal } from "#nuxt-scripts-validator";
 export const GoogleSignInOptions = object({
   clientId: string(),
   // Auto-select credentials if only one is available

package/dist/runtime/registry/google-tag-manager.d.ts

@@ -1,5 +1,5 @@
-import type { GTag } from './google-analytics.js';
 import type { NuxtUseScriptOptions, RegistryScriptInput, UseFunctionType, UseScriptContext } from '#nuxt-scripts/types';
+import type { GTag } from './google-analytics.js';
 /**
  * Improved DataLayer type that better reflects GTM's capabilities
  * Can contain either gtag event parameters or custom data objects

package/dist/runtime/registry/google-tag-manager.js

@@ -1,6 +1,6 @@
-import { withQuery } from "ufo";
+import { boolean, literal, number, object, optional, record, string, union } from "#nuxt-scripts-validator";
 import { useRegistryScript } from "#nuxt-scripts/utils";
-import { object, string, optional, boolean, union, literal, record, number } from "#nuxt-scripts-validator";
+import { withQuery } from "ufo";
 export const GoogleTagManagerOptions = object({
   /** GTM container ID (format: GTM-XXXXXX) */
   id: string(),

package/dist/runtime/registry/hotjar.js

@@ -1,5 +1,5 @@
-import { useRegistryScript } from "../utils.js";
 import { number, object, optional } from "#nuxt-scripts-validator";
+import { useRegistryScript } from "../utils.js";
 export const HotjarOptions = object({
   id: number(),
   sv: optional(number())

package/dist/runtime/registry/instagram-embed.d.ts

@@ -0,0 +1,23 @@
+import type { RegistryScriptInput } from '#nuxt-scripts/types';
+export declare const InstagramEmbedOptions: import("valibot").ObjectSchema<{
+    /**
+     * The Instagram post URL to embed
+     * e.g., https://www.instagram.com/p/ABC123/
+     */
+    readonly postUrl: import("valibot").StringSchema<undefined>;
+    /**
+     * Whether to include captions in the embed
+     * @default true
+     */
+    readonly captions: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+    /**
+     * Custom API endpoint for fetching embed HTML
+     * @default '/api/_scripts/instagram-embed'
+     */
+    readonly apiEndpoint: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+}, undefined>;
+export type InstagramEmbedInput = RegistryScriptInput<typeof InstagramEmbedOptions, false, false, false>;
+/**
+ * Extract the post shortcode from an Instagram URL
+ */
+export declare function extractInstagramShortcode(url: string): string | undefined;

package/dist/runtime/registry/instagram-embed.js

@@ -0,0 +1,22 @@
+import { boolean, object, optional, string } from "#nuxt-scripts-validator";
+export const InstagramEmbedOptions = object({
+  /**
+   * The Instagram post URL to embed
+   * e.g., https://www.instagram.com/p/ABC123/
+   */
+  postUrl: string(),
+  /**
+   * Whether to include captions in the embed
+   * @default true
+   */
+  captions: optional(boolean()),
+  /**
+   * Custom API endpoint for fetching embed HTML
+   * @default '/api/_scripts/instagram-embed'
+   */
+  apiEndpoint: optional(string())
+});
+export function extractInstagramShortcode(url) {
+  const match = url.match(/instagram\.com\/(?:p|reel|tv)\/([^/?]+)/);
+  return match?.[1];
+}

package/dist/runtime/registry/intercom.js

@@ -1,6 +1,6 @@
+import { literal, number, object, optional, string, union } from "#nuxt-scripts-validator";
 import { joinURL } from "ufo";
 import { useRegistryScript } from "../utils.js";
-import { literal, number, object, optional, string, union } from "#nuxt-scripts-validator";
 export const IntercomOptions = object({
   app_id: string(),
   api_base: optional(union([literal("https://api-iam.intercom.io"), literal("https://api-iam.eu.intercom.io"), literal("https://api-iam.au.intercom.io")])),

package/dist/runtime/registry/lemon-squeezy.d.ts

@@ -21,7 +21,6 @@ export type LemonSqueezyEventPayload = {
 export interface LemonSqueezyApi {
     /**
      * Initialises Lemon.js on your page.
-     * @param options - An object with a single property, eventHandler, which is a function that will be called when Lemon.js emits an event.
      */
     Setup: (options: {
         eventHandler: (event: LemonSqueezyEventPayload) => void;

package/dist/runtime/registry/matomo-analytics.js

@@ -1,8 +1,8 @@
+import { boolean, number, object, optional, string, union } from "#nuxt-scripts-validator";
 import { withBase, withHttps, withoutProtocol, withoutTrailingSlash } from "ufo";
-import { useRegistryScript } from "../utils.js";
 import { useScriptEventPage } from "../composables/useScriptEventPage.js";
-import { boolean, object, optional, string, number, union } from "#nuxt-scripts-validator";
 import { logger } from "../logger.js";
+import { useRegistryScript } from "../utils.js";
 export const MatomoAnalyticsOptions = object({
   matomoUrl: optional(string()),
   siteId: optional(union([string(), number()])),

package/dist/runtime/registry/meta-pixel.js

@@ -1,5 +1,5 @@
-import { useRegistryScript } from "../utils.js";
 import { number, object, string, union } from "#nuxt-scripts-validator";
+import { useRegistryScript } from "../utils.js";
 export const MetaPixelOptions = object({
   id: union([string(), number()])
 });

package/dist/runtime/registry/npm.js

@@ -1,6 +1,6 @@
+import { literal, object, optional, string, union } from "#nuxt-scripts-validator";
 import { withBase } from "ufo";
 import { useRegistryScript } from "../utils.js";
-import { object, optional, string, union, literal } from "#nuxt-scripts-validator";
 const PROVIDERS = ["jsdelivr", "cdnjs", "unpkg"];
 const providerValidator = union(PROVIDERS.map((provider) => literal(provider)));
 export const NpmOptions = object({

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

@@ -1,5 +1,5 @@
-import type { PayPalNamespace } from '@paypal/paypal-js';
 import type { RegistryScriptInput } from '#nuxt-scripts/types';
+import type { PayPalNamespace } from '@paypal/paypal-js';
 export interface PayPalApi {
     paypal: PayPalNamespace;
 }

package/dist/runtime/registry/paypal.js

@@ -1,6 +1,6 @@
+import { array, boolean, object, optional, string, union } from "#nuxt-scripts-validator";
 import { withQuery } from "ufo";
 import { useRegistryScript } from "../utils.js";
-import { object, string, optional, array, union, boolean } from "#nuxt-scripts-validator";
 export const PayPalOptions = object({
   clientId: string(),
   buyerCountry: optional(string()),
@@ -27,7 +27,7 @@ export const PayPalOptions = object({
 });
 export function useScriptPayPal(_options) {
   return useRegistryScript("paypal", (options) => {
-    let dataMerchantId = void 0;
+    let dataMerchantId;
     if (Array.isArray(options?.merchantId) && options?.merchantId.length > 1) {
       dataMerchantId = JSON.stringify(options.merchantId);
       options.merchantId = "*";