@nuxt/scripts 1.0.0-beta.24 → 1.0.0-beta.26

package/dist/runtime/components/GoogleMaps/ScriptGoogleMapsPolygon.vue

@@ -1,7 +1,6 @@
 <script setup>
-import { whenever } from "@vueuse/core";
-import { inject, onUnmounted } from "vue";
-import { MAP_INJECTION_KEY } from "./ScriptGoogleMaps.vue";
+import { watch } from "vue";
+import { useGoogleMapsResource } from "./useGoogleMapsResource";
 const props = defineProps({
   options: { type: Object, required: false }
 });
@@ -21,36 +20,28 @@ const eventsWithMapMouseEventPayload = [
   "dragend",
   "dragstart"
 ];
-const mapContext = inject(MAP_INJECTION_KEY, void 0);
-let polygon;
-whenever(() => mapContext?.map.value && mapContext.mapsApi.value, () => {
-  polygon = new mapContext.mapsApi.value.Polygon({
-    map: mapContext.map.value,
-    ...props.options
-  });
-  setupPolygonEventListeners(polygon);
-  whenever(() => props.options, (options) => {
-    polygon?.setOptions(options);
-  }, {
-    deep: true
-  });
-}, {
-  immediate: true,
-  once: true
-});
-onUnmounted(() => {
-  if (!polygon || !mapContext?.mapsApi.value) {
-    return;
+const polygon = useGoogleMapsResource({
+  create({ mapsApi, map }) {
+    const p = new mapsApi.Polygon({ map, ...props.options });
+    setupEventListeners(p);
+    return p;
+  },
+  cleanup(p, { mapsApi }) {
+    mapsApi.event.clearInstanceListeners(p);
+    p.setMap(null);
   }
-  mapContext.mapsApi.value.event.clearInstanceListeners(polygon);
-  polygon.setMap(null);
 });
-function setupPolygonEventListeners(polygon2) {
+watch(() => props.options, (options) => {
+  if (polygon.value && options) {
+    polygon.value.setOptions(options);
+  }
+}, { deep: true });
+function setupEventListeners(p) {
   eventsWithPolyMouseEventPayload.forEach((event) => {
-    polygon2.addListener(event, (payload) => emit(event, payload));
+    p.addListener(event, (payload) => emit(event, payload));
   });
   eventsWithMapMouseEventPayload.forEach((event) => {
-    polygon2.addListener(event, (payload) => emit(event, payload));
+    p.addListener(event, (payload) => emit(event, payload));
   });
 }
 </script>

package/dist/runtime/components/GoogleMaps/ScriptGoogleMapsPolyline.vue

@@ -1,7 +1,6 @@
 <script setup>
-import { whenever } from "@vueuse/core";
-import { inject, onUnmounted } from "vue";
-import { MAP_INJECTION_KEY } from "./ScriptGoogleMaps.vue";
+import { watch } from "vue";
+import { useGoogleMapsResource } from "./useGoogleMapsResource";
 const props = defineProps({
   options: { type: Object, required: false }
 });
@@ -21,36 +20,28 @@ const eventsWithMapMouseEventPayload = [
   "dragend",
   "dragstart"
 ];
-const mapContext = inject(MAP_INJECTION_KEY, void 0);
-let polyline;
-whenever(() => mapContext?.map.value && mapContext.mapsApi.value, () => {
-  polyline = new mapContext.mapsApi.value.Polyline({
-    map: mapContext.map.value,
-    ...props.options
-  });
-  setupPolylineEventListeners(polyline);
-  whenever(() => props.options, (options) => {
-    polyline?.setOptions(options);
-  }, {
-    deep: true
-  });
-}, {
-  immediate: true,
-  once: true
-});
-onUnmounted(() => {
-  if (!polyline || !mapContext?.mapsApi.value) {
-    return;
+const polyline = useGoogleMapsResource({
+  create({ mapsApi, map }) {
+    const p = new mapsApi.Polyline({ map, ...props.options });
+    setupEventListeners(p);
+    return p;
+  },
+  cleanup(p, { mapsApi }) {
+    mapsApi.event.clearInstanceListeners(p);
+    p.setMap(null);
   }
-  mapContext.mapsApi.value.event.clearInstanceListeners(polyline);
-  polyline.setMap(null);
 });
-function setupPolylineEventListeners(polyline2) {
+watch(() => props.options, (options) => {
+  if (polyline.value && options) {
+    polyline.value.setOptions(options);
+  }
+}, { deep: true });
+function setupEventListeners(p) {
   eventsWithPolyMouseEventPayload.forEach((event) => {
-    polyline2.addListener(event, (payload) => emit(event, payload));
+    p.addListener(event, (payload) => emit(event, payload));
   });
   eventsWithMapMouseEventPayload.forEach((event) => {
-    polyline2.addListener(event, (payload) => emit(event, payload));
+    p.addListener(event, (payload) => emit(event, payload));
   });
 }
 </script>

package/dist/runtime/components/GoogleMaps/ScriptGoogleMapsRectangle.vue

@@ -1,7 +1,6 @@
 <script setup>
-import { whenever } from "@vueuse/core";
-import { inject, onUnmounted } from "vue";
-import { MAP_INJECTION_KEY } from "./ScriptGoogleMaps.vue";
+import { watch } from "vue";
+import { useGoogleMapsResource } from "./useGoogleMapsResource";
 const props = defineProps({
   options: { type: Object, required: false }
 });
@@ -22,36 +21,28 @@ const eventsWithMapMouseEventPayload = [
   "mouseover",
   "mouseup"
 ];
-const mapContext = inject(MAP_INJECTION_KEY, void 0);
-let rectangle;
-whenever(() => mapContext?.map.value && mapContext.mapsApi.value, () => {
-  rectangle = new mapContext.mapsApi.value.Rectangle({
-    map: mapContext.map.value,
-    ...props.options
-  });
-  setupRectangleEventListeners(rectangle);
-  whenever(() => props.options, (options) => {
-    rectangle?.setOptions(options);
-  }, {
-    deep: true
-  });
-}, {
-  immediate: true,
-  once: true
-});
-onUnmounted(() => {
-  if (!rectangle || !mapContext?.mapsApi.value) {
-    return;
+const rectangle = useGoogleMapsResource({
+  create({ mapsApi, map }) {
+    const r = new mapsApi.Rectangle({ map, ...props.options });
+    setupEventListeners(r);
+    return r;
+  },
+  cleanup(r, { mapsApi }) {
+    mapsApi.event.clearInstanceListeners(r);
+    r.setMap(null);
   }
-  mapContext.mapsApi.value.event.clearInstanceListeners(rectangle);
-  rectangle.setMap(null);
 });
-function setupRectangleEventListeners(rectangle2) {
+watch(() => props.options, (options) => {
+  if (rectangle.value && options) {
+    rectangle.value.setOptions(options);
+  }
+}, { deep: true });
+function setupEventListeners(r) {
   eventsWithoutPayload.forEach((event) => {
-    rectangle2.addListener(event, () => emit(event));
+    r.addListener(event, () => emit(event));
   });
   eventsWithMapMouseEventPayload.forEach((event) => {
-    rectangle2.addListener(event, (payload) => emit(event, payload));
+    r.addListener(event, (payload) => emit(event, payload));
   });
 }
 </script>

package/dist/runtime/components/GoogleMaps/injectionKeys.d.ts

@@ -0,0 +1,11 @@
+import type { InjectionKey, Ref, ShallowRef } from 'vue';
+export declare const MAP_INJECTION_KEY: InjectionKey<{
+    map: ShallowRef<google.maps.Map | undefined>;
+    mapsApi: Ref<typeof google.maps | undefined>;
+}>;
+export declare const ADVANCED_MARKER_ELEMENT_INJECTION_KEY: InjectionKey<{
+    advancedMarkerElement: ShallowRef<google.maps.marker.AdvancedMarkerElement | undefined>;
+}>;
+export declare const MARKER_INJECTION_KEY: InjectionKey<{
+    marker: ShallowRef<google.maps.Marker | undefined>;
+}>;

package/dist/runtime/components/GoogleMaps/injectionKeys.js

@@ -0,0 +1,3 @@
+export const MAP_INJECTION_KEY = Symbol("map");
+export const ADVANCED_MARKER_ELEMENT_INJECTION_KEY = Symbol("marker");
+export const MARKER_INJECTION_KEY = Symbol("marker");

package/dist/runtime/components/GoogleMaps/useGoogleMapsResource.d.ts

@@ -0,0 +1,26 @@
+import type { ShallowRef } from 'vue';
+export interface GoogleMapsResourceContext {
+    map: google.maps.Map;
+    mapsApi: typeof google.maps;
+}
+/**
+ * Composable for safely managing Google Maps resource lifecycle.
+ *
+ * Handles the common pattern: wait for map readiness → async create → cleanup on unmount.
+ *
+ * Safety guarantees:
+ * - No watchers created after `await` (prevents orphaned watchers that leak memory)
+ * - Unmount guard prevents resource creation after component unmount
+ * - Resources created during the async gap are immediately cleaned up
+ * - Resource ref is always nulled on unmount to allow GC
+ */
+export declare function useGoogleMapsResource<T>({ ready, create, cleanup, }: {
+    /** Additional readiness condition beyond map + mapsApi being available */
+    ready?: () => boolean;
+    /** Create the Google Maps resource. Receives map context snapshot. May be async. */
+    create: (ctx: GoogleMapsResourceContext) => Promise<T> | T;
+    /** Clean up the resource. Called on unmount, or immediately if resource was created after unmount. */
+    cleanup?: (resource: T, ctx: {
+        mapsApi: typeof google.maps;
+    }) => void;
+}): ShallowRef<T | undefined>;

package/dist/runtime/components/GoogleMaps/useGoogleMapsResource.js

@@ -0,0 +1,37 @@
+import { whenever } from "@vueuse/core";
+import { inject, onUnmounted, ref, shallowRef } from "vue";
+import { MAP_INJECTION_KEY } from "./injectionKeys.js";
+export function useGoogleMapsResource({
+  ready,
+  create,
+  cleanup
+}) {
+  const mapContext = inject(MAP_INJECTION_KEY, void 0);
+  const resource = shallowRef(void 0);
+  const isUnmounted = ref(false);
+  whenever(
+    () => mapContext?.map.value && mapContext.mapsApi.value && (!ready || ready()),
+    async () => {
+      const result = await create({
+        map: mapContext.map.value,
+        mapsApi: mapContext.mapsApi.value
+      });
+      if (isUnmounted.value) {
+        if (cleanup && mapContext?.mapsApi.value) {
+          cleanup(result, { mapsApi: mapContext.mapsApi.value });
+        }
+        return;
+      }
+      resource.value = result;
+    },
+    { immediate: true, once: true }
+  );
+  onUnmounted(() => {
+    isUnmounted.value = true;
+    if (resource.value && cleanup && mapContext?.mapsApi.value) {
+      cleanup(resource.value, { mapsApi: mapContext.mapsApi.value });
+    }
+    resource.value = void 0;
+  });
+  return resource;
+}

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

@@ -1,12 +1,22 @@
+import type { Ref } from 'vue';
 import type { ConsentScriptTriggerOptions } from '../types.js';
 interface UseConsentScriptTriggerApi extends Promise<void> {
     /**
      * A function that can be called to accept the consent and load the script.
      */
     accept: () => void;
+    /**
+     * A function that can be called to revoke consent and signal the script should be unloaded.
+     */
+    revoke: () => void;
+    /**
+     * Reactive reference to the consent state
+     */
+    consented: Ref<boolean>;
 }
 /**
  * Load a script once consent has been provided either through a resolvable `consent` or calling the `accept` method.
+ * Supports revoking consent via the reactive `consented` ref. Consumers should watch `consented` to react to revocation.
  * @param options
  */
 export declare function useScriptTriggerConsent(options?: ConsentScriptTriggerOptions): UseConsentScriptTriggerApi;

package/dist/runtime/composables/useScriptTriggerConsent.js

@@ -1,14 +1,37 @@
 import { onNuxtReady, requestIdleCallback, tryUseNuxtApp } from "nuxt/app";
 import { isRef, ref, toValue, watch } from "vue";
 export function useScriptTriggerConsent(options) {
-  if (import.meta.server)
-    return new Promise(() => {
+  if (import.meta.server) {
+    const p = new Promise(() => {
     });
+    p.accept = () => {
+    };
+    p.revoke = () => {
+    };
+    p.consented = ref(false);
+    return p;
+  }
   const consented = ref(false);
   const nuxtApp = tryUseNuxtApp();
+  if (options?.consent) {
+    if (isRef(options?.consent)) {
+      watch(options.consent, (_val) => {
+        const val = toValue(_val);
+        consented.value = Boolean(val);
+      }, { immediate: true });
+    } else if (typeof options?.consent === "boolean") {
+      consented.value = options?.consent;
+    } else if (options?.consent instanceof Promise) {
+      options.consent.then((res) => {
+        consented.value = typeof res === "boolean" ? res : true;
+      }).catch(() => {
+        consented.value = false;
+      });
+    }
+  }
   const promise = new Promise((resolve) => {
-    watch(consented, (ready) => {
-      if (ready) {
+    watch(consented, (newValue, oldValue) => {
+      if (newValue && !oldValue) {
         const runner = nuxtApp?.runWithContext || ((cb) => cb());
         if (options?.postConsentTrigger instanceof Promise) {
           options.postConsentTrigger.then(() => runner(resolve));
@@ -32,24 +55,14 @@ export function useScriptTriggerConsent(options) {
         }
         runner(resolve);
       }
-    });
-    if (options?.consent) {
-      if (isRef(options?.consent)) {
-        watch(options.consent, (_val) => {
-          const val = toValue(_val);
-          consented.value = Boolean(val);
-        }, { immediate: true });
-      } else if (typeof options?.consent === "boolean") {
-        consented.value = options?.consent;
-      } else if (options?.consent instanceof Promise) {
-        options?.consent.then((res) => {
-          consented.value = typeof res === "boolean" ? res : true;
-        });
-      }
-    }
+    }, { immediate: true });
   });
   promise.accept = () => {
     consented.value = true;
   };
+  promise.revoke = () => {
+    consented.value = false;
+  };
+  promise.consented = consented;
   return promise;
 }

package/dist/runtime/registry/bing-uet.d.ts

@@ -0,0 +1,20 @@
+import type { RegistryScriptInput } from '#nuxt-scripts/types';
+import { BingUetOptions } from './schemas.js';
+export { BingUetOptions };
+export type BingUetInput = RegistryScriptInput<typeof BingUetOptions, true, false>;
+export interface BingUetApi {
+    uetq: {
+        push: (event: string | Record<string, any>) => void;
+    };
+}
+declare global {
+    interface Window {
+        UET: new (options: {
+            ti: string;
+            enableAutoSpaTracking?: boolean;
+            q?: any[];
+        }) => BingUetApi['uetq'];
+        uetq: any[] | BingUetApi['uetq'];
+    }
+}
+export declare function useScriptBingUet<T extends BingUetApi>(_options?: BingUetInput): import("#nuxt-scripts/types").UseScriptContext<T>;

package/dist/runtime/registry/bing-uet.js

@@ -0,0 +1,29 @@
+import { useRegistryScript } from "../utils.js";
+import { BingUetOptions } from "./schemas.js";
+export { BingUetOptions };
+export function useScriptBingUet(_options) {
+  return useRegistryScript("bingUet", (options) => ({
+    scriptInput: {
+      src: "https://bat.bing.com/bat.js",
+      crossorigin: false
+    },
+    schema: import.meta.dev ? BingUetOptions : void 0,
+    scriptOptions: {
+      use() {
+        if (options?.id && typeof window.UET === "function" && Array.isArray(window.uetq)) {
+          const uetOptions = {
+            ti: options.id,
+            enableAutoSpaTracking: options.enableAutoSpaTracking ?? true,
+            q: window.uetq
+          };
+          window.uetq = new window.UET(uetOptions);
+          window.uetq.push("pageLoad");
+        }
+        return { uetq: window.uetq };
+      }
+    },
+    clientInit: import.meta.server ? void 0 : () => {
+      window.uetq = window.uetq || [];
+    }
+  }), _options);
+}

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

@@ -90,7 +90,7 @@ export interface BlueskyEmbedPostData {
         val: string;
     }>;
 }
-export type BlueskyEmbedInput = RegistryScriptInput<typeof BlueskyEmbedOptions, false, false, false>;
+export type BlueskyEmbedInput = RegistryScriptInput<typeof BlueskyEmbedOptions, false, false>;
 /**
  * Extract the handle/DID and post rkey from a Bluesky post URL
  */

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

@@ -1,7 +1,7 @@
 import type { RegistryScriptInput } from '#nuxt-scripts/types';
 import { CrispOptions } from './schemas.js';
 export { CrispOptions };
-export type CrispInput = RegistryScriptInput<typeof CrispOptions, false, false, false>;
+export type CrispInput = RegistryScriptInput<typeof CrispOptions, false, false>;
 export interface CrispApi {
     push: (...args: any[]) => void;
     is: (name: 'chat:opened' | 'chat:closed' | 'chat:visible' | 'chat:hidden' | 'chat:small' | 'chat:large' | 'session:ongoing' | 'website:available' | 'overlay:opened' | 'overlay:closed' | (string & {})) => boolean;

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

@@ -1,7 +1,7 @@
 import type { RegistryScriptInput } from '#nuxt-scripts/types';
 import { FathomAnalyticsOptions } from './schemas.js';
 export { FathomAnalyticsOptions };
-export type FathomAnalyticsInput = RegistryScriptInput<typeof FathomAnalyticsOptions, false, false, false>;
+export type FathomAnalyticsInput = RegistryScriptInput<typeof FathomAnalyticsOptions, false, false>;
 export interface FathomAnalyticsApi {
     beacon: (ctx: {
         url: string;

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

@@ -1,7 +1,7 @@
 import type { RegistryScriptInput } from '#nuxt-scripts/types';
 import { GoogleAdsenseOptions } from './schemas.js';
 export { GoogleAdsenseOptions };
-export type GoogleAdsenseInput = RegistryScriptInput<typeof GoogleAdsenseOptions, true, false, false>;
+export type GoogleAdsenseInput = RegistryScriptInput<typeof GoogleAdsenseOptions, true, false>;
 export interface GoogleAdsenseApi {
     /**
      * The Google Adsense API.

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

@@ -14,5 +14,5 @@ declare global {
         };
     }
 }
-export type HotjarInput = RegistryScriptInput<typeof HotjarOptions, true, false, false>;
+export type HotjarInput = RegistryScriptInput<typeof HotjarOptions, true, false>;
 export declare function useScriptHotjar<T extends HotjarApi>(_options?: HotjarInput): import("#nuxt-scripts/types").UseScriptContext<T>;

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

@@ -1,7 +1,7 @@
 import type { RegistryScriptInput } from '#nuxt-scripts/types';
 import { InstagramEmbedOptions } from './schemas.js';
 export { InstagramEmbedOptions };
-export type InstagramEmbedInput = RegistryScriptInput<typeof InstagramEmbedOptions, false, false, false>;
+export type InstagramEmbedInput = RegistryScriptInput<typeof InstagramEmbedOptions, false, false>;
 /**
  * Extract the post shortcode from an Instagram URL
  */

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

@@ -2,7 +2,7 @@ import type { InferInput } from '#nuxt-scripts-validator';
 import type { RegistryScriptInput } from '#nuxt-scripts/types';
 import { IntercomOptions } from './schemas.js';
 export { IntercomOptions };
-export type IntercomInput = RegistryScriptInput<typeof IntercomOptions, true, false, false>;
+export type IntercomInput = RegistryScriptInput<typeof IntercomOptions, true, false>;
 export interface IntercomApi {
     Intercom: ((event: 'boot', data?: InferInput<typeof IntercomOptions>) => void) & ((event: 'shutdown') => void) & ((event: 'update', options?: InferInput<typeof IntercomOptions>) => void) & ((event: 'hide') => void) & ((event: 'show') => void) & ((event: 'showSpace', spaceName: 'home' | 'messages' | 'help' | 'news' | 'tasks' | 'tickets' | (string & {})) => void) & ((event: 'showMessages') => void) & ((event: 'showNewMessage', content?: string) => void) & ((event: 'onHide', fn: () => void) => void) & ((event: 'onShow', fn: () => void) => void) & ((event: 'onUnreadCountChange', fn: () => void) => void) & ((event: 'trackEvent', eventName: string, metadata?: Record<string, any>) => void) & ((event: 'getVisitorId') => Promise<string>) & ((event: 'startTour', tourId: string | number) => void) & ((event: 'showArticle', articleId: string | number) => void) & ((event: 'showNews', newsItemId: string | number) => void) & ((event: 'startSurvey', surveyId: string | number) => void) & ((event: 'startChecklist', checklistId: string | number) => void) & ((event: 'showTicket', ticketId: string | number) => void) & ((event: 'showConversation', conversationId: string | number) => void) & ((event: 'onUserEmailSupplied', fn: () => void) => void) & ((event: (string & {}), ...params: any[]) => void);
 }

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

@@ -1,7 +1,7 @@
 import type { RegistryScriptInput } from '#nuxt-scripts/types';
 import { MatomoAnalyticsOptions } from './schemas.js';
 export { MatomoAnalyticsOptions };
-export type MatomoAnalyticsInput = RegistryScriptInput<typeof MatomoAnalyticsOptions, false, false, false>;
+export type MatomoAnalyticsInput = RegistryScriptInput<typeof MatomoAnalyticsOptions, false, false>;
 interface MatomoAnalyticsApi {
     _paq: unknown[];
 }

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

@@ -37,5 +37,5 @@ declare global {
     }
 }
 export { MetaPixelOptions };
-export type MetaPixelInput = RegistryScriptInput<typeof MetaPixelOptions, true, false, false>;
+export type MetaPixelInput = RegistryScriptInput<typeof MetaPixelOptions, true, false>;
 export declare function useScriptMetaPixel<T extends MetaPixelApi>(_options?: MetaPixelInput): import("#nuxt-scripts/types").UseScriptContext<T>;

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

@@ -0,0 +1,22 @@
+import type { RegistryScriptInput } from '#nuxt-scripts/types';
+import { MixpanelAnalyticsOptions } from './schemas.js';
+export { MixpanelAnalyticsOptions };
+export type MixpanelAnalyticsInput = RegistryScriptInput<typeof MixpanelAnalyticsOptions>;
+export interface MixpanelAnalyticsApi {
+    mixpanel: {
+        track: (event: string, properties?: Record<string, any>) => void;
+        identify: (distinctId: string) => void;
+        reset: () => void;
+        people: {
+            set: (properties: Record<string, any>) => void;
+        };
+        register: (properties: Record<string, any>) => void;
+        init: (token: string, config?: Record<string, any>) => void;
+    };
+}
+declare global {
+    interface Window {
+        mixpanel: MixpanelAnalyticsApi['mixpanel'];
+    }
+}
+export declare function useScriptMixpanelAnalytics<T extends MixpanelAnalyticsApi>(_options?: MixpanelAnalyticsInput): import("#nuxt-scripts/types").UseScriptContext<T>;

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

@@ -0,0 +1,46 @@
+import { useRegistryScript } from "../utils.js";
+import { MixpanelAnalyticsOptions } from "./schemas.js";
+export { MixpanelAnalyticsOptions };
+const methods = ["track", "identify", "reset", "register"];
+const peopleMethods = ["set"];
+export function useScriptMixpanelAnalytics(_options) {
+  return useRegistryScript("mixpanelAnalytics", (options) => {
+    return {
+      scriptInput: {
+        src: "https://cdn.mxpnl.com/libs/mixpanel-2-latest.min.js"
+      },
+      schema: import.meta.dev ? MixpanelAnalyticsOptions : void 0,
+      scriptOptions: {
+        use() {
+          return {
+            mixpanel: window.mixpanel
+          };
+        }
+      },
+      clientInit: import.meta.server ? void 0 : () => {
+        const mp = window.mixpanel = window.mixpanel || [];
+        if (!mp.__SV) {
+          mp.__SV = 1.2;
+          mp._i = mp._i || [];
+          mp.init = (token, config, name = "mixpanel") => {
+            const target = name === "mixpanel" ? mp : mp[name] = [];
+            target.people = target.people || [];
+            for (const method of methods) {
+              target[method] = (...args) => {
+                target.push([method, ...args]);
+              };
+            }
+            for (const method of peopleMethods) {
+              target.people[method] = (...args) => {
+                target.push([`people.${method}`, ...args]);
+              };
+            }
+            mp._i.push([token, config, name]);
+          };
+        }
+        if (options?.token)
+          mp.init(options.token);
+      }
+    };
+  }, _options);
+}

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

@@ -1,5 +1,5 @@
 import type { RegistryScriptInput } from '#nuxt-scripts/types';
 import { NpmOptions } from './schemas.js';
 export { NpmOptions };
-export type NpmInput = RegistryScriptInput<typeof NpmOptions, true, true, false>;
+export type NpmInput = RegistryScriptInput<typeof NpmOptions, true, true>;
 export declare function useScriptNpm<T extends Record<string | symbol, any>>(_options: NpmInput): import("#nuxt-scripts/types").UseScriptContext<T>;

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

@@ -13,5 +13,5 @@ declare global {
     }
 }
 export { RedditPixelOptions };
-export type RedditPixelInput = RegistryScriptInput<typeof RedditPixelOptions, true, false, false>;
+export type RedditPixelInput = RegistryScriptInput<typeof RedditPixelOptions, true, false>;
 export declare function useScriptRedditPixel<T extends RedditPixelApi>(_options?: RedditPixelInput): import("#nuxt-scripts/types").UseScriptContext<T>;

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

@@ -697,6 +697,25 @@ export declare const RybbitAnalyticsOptions: import("valibot").ObjectSchema<{
      */
     readonly analyticsHost: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
 }, undefined>;
+export declare const MixpanelAnalyticsOptions: import("valibot").ObjectSchema<{
+    /**
+     * Your Mixpanel project token.
+     * @see https://docs.mixpanel.com/docs/tracking-methods/sdks/javascript#1-initialize-the-library
+     */
+    readonly token: import("valibot").StringSchema<undefined>;
+}, undefined>;
+export declare const BingUetOptions: import("valibot").ObjectSchema<{
+    /**
+     * Your Bing UET tag ID.
+     * @see https://help.ads.microsoft.com/#apex/ads/en/56682/2-500
+     */
+    readonly id: import("valibot").StringSchema<undefined>;
+    /**
+     * Enable automatic SPA page tracking.
+     * @default true
+     */
+    readonly enableAutoSpaTracking: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+}, undefined>;
 export declare const SegmentOptions: import("valibot").ObjectSchema<{
     /**
      * Your Segment write key.

package/dist/runtime/registry/schemas.js

@@ -695,6 +695,25 @@ export const RybbitAnalyticsOptions = object({
    */
   analyticsHost: optional(string())
 });
+export const MixpanelAnalyticsOptions = object({
+  /**
+   * Your Mixpanel project token.
+   * @see https://docs.mixpanel.com/docs/tracking-methods/sdks/javascript#1-initialize-the-library
+   */
+  token: string()
+});
+export const BingUetOptions = object({
+  /**
+   * Your Bing UET tag ID.
+   * @see https://help.ads.microsoft.com/#apex/ads/en/56682/2-500
+   */
+  id: string(),
+  /**
+   * Enable automatic SPA page tracking.
+   * @default true
+   */
+  enableAutoSpaTracking: optional(boolean())
+});
 export const SegmentOptions = object({
   /**
    * Your Segment write key.