@nuxt/scripts 1.0.0-beta.25 → 1.0.0-beta.27

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

@@ -1,9 +1,7 @@
 <script setup>
-import { whenever } from "@vueuse/core";
-import { inject, onUnmounted, useTemplateRef } from "vue";
-import { MAP_INJECTION_KEY } from "./ScriptGoogleMaps.vue";
-import { ADVANCED_MARKER_ELEMENT_INJECTION_KEY } from "./ScriptGoogleMapsAdvancedMarkerElement.vue";
-import { MARKER_INJECTION_KEY } from "./ScriptGoogleMapsMarker.vue";
+import { inject, useTemplateRef, watch } from "vue";
+import { ADVANCED_MARKER_ELEMENT_INJECTION_KEY, MARKER_INJECTION_KEY } from "./injectionKeys";
+import { useGoogleMapsResource } from "./useGoogleMapsResource";
 const props = defineProps({
   options: { type: null, required: false }
 });
@@ -19,58 +17,53 @@ const infoWindowEvents = [
   "visible",
   "zindex_changed"
 ];
-const mapContext = inject(MAP_INJECTION_KEY, void 0);
 const markerContext = inject(MARKER_INJECTION_KEY, void 0);
 const advancedMarkerElementContext = inject(ADVANCED_MARKER_ELEMENT_INJECTION_KEY, void 0);
 const infoWindowContainer = useTemplateRef("info-window-container");
-let infoWindow;
-whenever(
-  () => mapContext?.map.value && mapContext.mapsApi.value && infoWindowContainer.value,
-  () => {
-    infoWindow = new mapContext.mapsApi.value.InfoWindow({
+let markerClickListener;
+const infoWindow = useGoogleMapsResource({
+  ready: () => !!infoWindowContainer.value,
+  create({ mapsApi, map }) {
+    const iw = new mapsApi.InfoWindow({
       content: infoWindowContainer.value,
       ...props.options
     });
-    setupInfoWindowEventListeners(infoWindow);
+    setupEventListeners(iw);
     if (markerContext?.marker.value) {
-      markerContext.marker.value.addListener("click", () => {
-        infoWindow.open({
+      markerClickListener = markerContext.marker.value.addListener("click", () => {
+        iw.open({
           anchor: markerContext.marker.value,
-          map: mapContext.map.value
+          map
         });
       });
     } else if (advancedMarkerElementContext?.advancedMarkerElement.value) {
-      advancedMarkerElementContext.advancedMarkerElement.value.addListener("click", () => {
-        infoWindow.open({
+      markerClickListener = advancedMarkerElementContext.advancedMarkerElement.value.addListener("click", () => {
+        iw.open({
           anchor: advancedMarkerElementContext.advancedMarkerElement.value,
-          map: mapContext.map.value
+          map
         });
       });
     } else {
-      infoWindow.setPosition(props.options?.position);
-      infoWindow.open(mapContext.map.value);
+      iw.setPosition(props.options?.position);
+      iw.open(map);
     }
-    whenever(() => props.options, (options) => {
-      infoWindow?.setOptions(options);
-    }, {
-      deep: true
-    });
+    return iw;
   },
-  {
-    immediate: true,
-    once: true
-  }
-);
-onUnmounted(() => {
-  if (!infoWindow || !mapContext?.mapsApi.value) {
-    return;
+  cleanup(iw, { mapsApi }) {
+    markerClickListener?.remove();
+    markerClickListener = void 0;
+    mapsApi.event.clearInstanceListeners(iw);
+    iw.close();
   }
-  mapContext.mapsApi.value.event.clearInstanceListeners(infoWindow);
-  infoWindow.close();
 });
-function setupInfoWindowEventListeners(infoWindow2) {
+watch(() => props.options, (options) => {
+  if (infoWindow.value && options) {
+    infoWindow.value.setOptions(options);
+  }
+}, { deep: true });
+function setupEventListeners(iw) {
   infoWindowEvents.forEach((event) => {
-    infoWindow2.addListener(event, () => emit(event));
+    iw.addListener(event, () => emit(event));
   });
 }
 </script>

package/dist/runtime/components/GoogleMaps/ScriptGoogleMapsMarker.d.vue.ts

@@ -1,7 +1,4 @@
-import type { InjectionKey, ShallowRef } from 'vue';
-export declare const MARKER_INJECTION_KEY: InjectionKey<{
-    marker: ShallowRef<google.maps.Marker | undefined>;
-}>;
+export { MARKER_INJECTION_KEY } from './injectionKeys.js';
 declare const _default: typeof __VLS_export;
 export default _default;
 declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<{

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

@@ -1,9 +1,9 @@
 <script>
-import { whenever } from "@vueuse/core";
-import { inject, onUnmounted, provide, shallowRef } from "vue";
-import { MAP_INJECTION_KEY } from "./ScriptGoogleMaps.vue";
+import { inject, provide, watch } from "vue";
+import { MARKER_INJECTION_KEY } from "./injectionKeys";
 import { MARKER_CLUSTERER_INJECTION_KEY } from "./ScriptGoogleMapsMarkerClusterer.vue";
-export const MARKER_INJECTION_KEY = /* @__PURE__ */ Symbol("marker");
+import { useGoogleMapsResource } from "./useGoogleMapsResource";
+export { MARKER_INJECTION_KEY } from "./injectionKeys";
 </script>
 
 <script setup>
@@ -36,46 +36,41 @@ const eventsWithMapMouseEventPayload = [
   "mouseover",
   "mouseup"
 ];
-const mapContext = inject(MAP_INJECTION_KEY, void 0);
 const markerClustererContext = inject(MARKER_CLUSTERER_INJECTION_KEY, void 0);
-const marker = shallowRef(void 0);
-whenever(() => mapContext?.map.value && mapContext.mapsApi.value, () => {
-  marker.value = new mapContext.mapsApi.value.Marker(props.options);
-  setupMarkerEventListeners(marker.value);
-  if (markerClustererContext?.markerClusterer.value) {
-    markerClustererContext.markerClusterer.value.addMarker(marker.value, true);
-    markerClustererContext.requestRerender();
-  } else {
-    marker.value.setMap(mapContext.map.value);
+const marker = useGoogleMapsResource({
+  create({ mapsApi, map }) {
+    const m = new mapsApi.Marker(props.options);
+    setupEventListeners(m);
+    if (markerClustererContext?.markerClusterer.value) {
+      markerClustererContext.markerClusterer.value.addMarker(m, true);
+      markerClustererContext.requestRerender();
+    } else {
+      m.setMap(map);
+    }
+    return m;
+  },
+  cleanup(m, { mapsApi }) {
+    mapsApi.event.clearInstanceListeners(m);
+    if (markerClustererContext?.markerClusterer.value) {
+      markerClustererContext.markerClusterer.value.removeMarker(m, true);
+      markerClustererContext.requestRerender();
+    } else {
+      m.setMap(null);
+    }
   }
-  whenever(() => props.options, (options) => {
-    marker.value?.setOptions(options);
-  }, {
-    deep: true
-  });
-}, {
-  immediate: true,
-  once: true
 });
-onUnmounted(() => {
-  if (!marker.value || !mapContext?.mapsApi.value) {
-    return;
-  }
-  mapContext.mapsApi.value.event.clearInstanceListeners(marker.value);
-  if (markerClustererContext?.markerClusterer.value) {
-    markerClustererContext.markerClusterer.value.removeMarker(marker.value, true);
-    markerClustererContext.requestRerender();
-  } else {
-    marker.value.setMap(null);
+watch(() => props.options, (options) => {
+  if (marker.value && options) {
+    marker.value.setOptions(options);
   }
-});
+}, { deep: true });
 provide(MARKER_INJECTION_KEY, { marker });
-function setupMarkerEventListeners(marker2) {
+function setupEventListeners(m) {
   eventsWithoutPayload.forEach((event) => {
-    marker2.addListener(event, () => emit(event));
+    m.addListener(event, () => emit(event));
   });
   eventsWithMapMouseEventPayload.forEach((event) => {
-    marker2.addListener(event, (payload) => emit(event, payload));
+    m.addListener(event, (payload) => emit(event, payload));
   });
 }
 </script>

package/dist/runtime/components/GoogleMaps/ScriptGoogleMapsMarker.vue.d.ts

@@ -1,7 +1,4 @@
-import type { InjectionKey, ShallowRef } from 'vue';
-export declare const MARKER_INJECTION_KEY: InjectionKey<{
-    marker: ShallowRef<google.maps.Marker | undefined>;
-}>;
+export { MARKER_INJECTION_KEY } from './injectionKeys.js';
 declare const _default: typeof __VLS_export;
 export default _default;
 declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<{

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

@@ -1,7 +1,7 @@
 <script>
 import { whenever } from "@vueuse/core";
-import { inject, onUnmounted, provide, shallowRef } from "vue";
-import { MAP_INJECTION_KEY } from "./ScriptGoogleMaps.vue";
+import { provide, shallowRef } from "vue";
+import { useGoogleMapsResource } from "./useGoogleMapsResource";
 export const MARKER_CLUSTERER_INJECTION_KEY = /* @__PURE__ */ Symbol("marker-clusterer");
 </script>
 
@@ -15,18 +15,20 @@ const markerClustererEvents = [
   "clusteringbegin",
   "clusteringend"
 ];
-const mapContext = inject(MAP_INJECTION_KEY, void 0);
-const markerClusterer = shallowRef(void 0);
-whenever(() => mapContext?.map.value, async (map) => {
-  const { MarkerClusterer } = await import("@googlemaps/markerclusterer");
-  markerClusterer.value = new MarkerClusterer({
-    map,
-    ...props.options
-  });
-  setupMarkerClustererEventListeners(markerClusterer.value);
-}, {
-  immediate: true,
-  once: true
+const markerClusterer = useGoogleMapsResource({
+  async create({ map }) {
+    const { MarkerClusterer } = await import("@googlemaps/markerclusterer");
+    const clusterer = new MarkerClusterer({
+      map,
+      ...props.options
+    });
+    setupEventListeners(clusterer);
+    return clusterer;
+  },
+  cleanup(clusterer, { mapsApi }) {
+    mapsApi.event.clearInstanceListeners(clusterer);
+    clusterer.setMap(null);
+  }
 });
 const markerClustererNeedsRerender = shallowRef(false);
 function requestRerender() {
@@ -36,13 +38,6 @@ whenever(() => markerClustererNeedsRerender.value && markerClusterer.value, () =
   markerClusterer.value.render();
   markerClustererNeedsRerender.value = false;
 });
-onUnmounted(() => {
-  if (!markerClusterer.value || !mapContext?.mapsApi.value) {
-    return;
-  }
-  mapContext.mapsApi.value.event.clearInstanceListeners(markerClusterer.value);
-  markerClusterer.value.setMap(null);
-});
 provide(
   MARKER_CLUSTERER_INJECTION_KEY,
   {
@@ -50,7 +45,7 @@ provide(
     requestRerender
   }
 );
-function setupMarkerClustererEventListeners(clusterer) {
+function setupEventListeners(clusterer) {
   markerClustererEvents.forEach((event) => {
     clusterer.addListener(event, () => emit(event, clusterer));
   });

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

@@ -1,41 +1,32 @@
 <script setup>
-import { whenever } from "@vueuse/core";
-import { inject, onUnmounted, shallowRef } from "vue";
-import { MAP_INJECTION_KEY } from "./ScriptGoogleMaps.vue";
-import { ADVANCED_MARKER_ELEMENT_INJECTION_KEY } from "./ScriptGoogleMapsAdvancedMarkerElement.vue";
+import { inject, watch } from "vue";
+import { ADVANCED_MARKER_ELEMENT_INJECTION_KEY } from "./injectionKeys";
+import { useGoogleMapsResource } from "./useGoogleMapsResource";
 const props = defineProps({
   options: { type: Object, required: false }
 });
-const mapContext = inject(MAP_INJECTION_KEY, void 0);
 const advancedMarkerElementContext = inject(ADVANCED_MARKER_ELEMENT_INJECTION_KEY, void 0);
-const pinElement = shallowRef(void 0);
-whenever(
-  () => mapContext?.map.value && mapContext.mapsApi.value && advancedMarkerElementContext?.advancedMarkerElement.value,
-  async () => {
-    await mapContext.mapsApi.value.importLibrary("marker");
-    pinElement.value = new mapContext.mapsApi.value.marker.PinElement(props.options);
+const pinElement = useGoogleMapsResource({
+  ready: () => !!advancedMarkerElementContext?.advancedMarkerElement.value,
+  async create({ mapsApi }) {
+    await mapsApi.importLibrary("marker");
+    const pin = new mapsApi.marker.PinElement(props.options);
     if (advancedMarkerElementContext?.advancedMarkerElement.value) {
-      advancedMarkerElementContext.advancedMarkerElement.value.content = pinElement.value.element;
+      advancedMarkerElementContext.advancedMarkerElement.value.content = pin.element;
     }
-    whenever(() => props.options, (options) => {
-      if (pinElement.value && options) {
-        Object.assign(pinElement.value, options);
-      }
-    }, {
-      deep: true
-    });
+    return pin;
   },
-  {
-    immediate: true,
-    once: true
-  }
-);
-onUnmounted(() => {
-  if (advancedMarkerElementContext?.advancedMarkerElement.value && pinElement.value) {
-    advancedMarkerElementContext.advancedMarkerElement.value.content = null;
+  cleanup() {
+    if (advancedMarkerElementContext?.advancedMarkerElement.value) {
+      advancedMarkerElementContext.advancedMarkerElement.value.content = null;
+    }
   }
-  pinElement.value = void 0;
 });
+watch(() => props.options, (options) => {
+  if (pinElement.value && options) {
+    Object.assign(pinElement.value, options);
+  }
+}, { deep: true });
 </script>
 
 <template>

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/server/gravatar-proxy.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<ArrayBuffer | undefined>>;
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
 export default _default;

package/dist/runtime/server/gravatar-proxy.js

@@ -29,7 +29,6 @@ export default defineEventHandler(async (event) => {
     r: rating
   });
   const response = await $fetch.raw(gravatarUrl, {
-    responseType: "arrayBuffer",
     headers: {
       "User-Agent": "Nuxt Scripts Gravatar Proxy"
     }