@teamnovu/nuxt-image 0.5.5 → 1.0.0-beta.1

package/dist/runtime/providers/imgproxy.js

@@ -0,0 +1,161 @@
+import { joinURL } from "ufo";
+import { hmac } from "@noble/hashes/hmac.js";
+import { sha256 } from "@noble/hashes/sha2.js";
+import { defu } from "defu";
+const KEY_MAP = {
+  resize: "rs",
+  size: "s",
+  resizingType: "rt",
+  width: "w",
+  height: "h",
+  minWidth: "mw",
+  minHeight: "mh",
+  zoom: "z",
+  dpr: "dpr",
+  enlarge: "el",
+  extend: "ex",
+  extendAspectRatio: "exar",
+  gravity: "g",
+  crop: "c",
+  autoRotate: "ar",
+  rotate: "rot",
+  background: "bg",
+  blur: "bl",
+  sharpen: "sh",
+  pixelate: "pix",
+  stripMetadata: "sm",
+  keepCopyright: "kcr",
+  stripColorProfile: "scp",
+  enforceThumbnail: "eth",
+  quality: "q",
+  maxBytes: "mb",
+  format: "f",
+  raw: "raw",
+  cachebuster: "cb",
+  expires: "exp",
+  filename: "fn",
+  returnAttachment: "att",
+  preset: "pr",
+  maxSrcResolution: "msr",
+  maxSrcFileSize: "msfs",
+  maxAnimationFrames: "maf",
+  maxAnimationFrameResolution: "mafr",
+  maxResultDimension: "mrd"
+};
+function booleanMap(value) {
+  if (typeof value === "boolean") return value ? 1 : 0;
+  if (value === 1 || value === "true" || value === "t") return 1;
+  return 0;
+}
+function cropMap(value) {
+  if (typeof value === "string") return value;
+  if (value && typeof value === "object") {
+    return `${value.width}:${value.height}${value.gravity ? `:${value.gravity}` : ""}`;
+  }
+  throw new TypeError("Wrong crop format");
+}
+function rotateMap(value) {
+  if (typeof value !== "number" || value < 0 || value > 359) {
+    throw new TypeError("Wrong rotate format - must be a number between 0 and 359");
+  }
+  return value - value % 90;
+}
+const VALUE_MAP = {
+  crop: (v) => cropMap(v),
+  enlarge: booleanMap,
+  extend: booleanMap,
+  autoRotate: booleanMap,
+  stripMetadata: booleanMap,
+  keepCopyright: booleanMap,
+  stripColorProfile: booleanMap,
+  enforceThumbnail: booleanMap,
+  raw: booleanMap,
+  returnAttachment: booleanMap,
+  rotate: (v) => rotateMap(v)
+};
+function generateOperations(modifiers) {
+  const ops = [];
+  for (const key in modifiers) {
+    const value = modifiers[key];
+    if (value === void 0 || value === null || value === "") continue;
+    const mappedKey = KEY_MAP[key] ?? key;
+    const mappedValue = VALUE_MAP[key] ? VALUE_MAP[key](value) : value;
+    ops.push(`${mappedKey}:${mappedValue}`);
+  }
+  return ops.join("/");
+}
+function hexToBytes(hex, label = "signing key/salt") {
+  if (hex.length === 0 || hex.length % 2 !== 0 || !/^[0-9a-f]+$/i.test(hex)) {
+    throw new Error(`Invalid hex string for ${label}: must be non-empty, even-length hex`);
+  }
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < hex.length; i += 2) {
+    bytes[i / 2] = Number.parseInt(hex.slice(i, i + 2), 16);
+  }
+  return bytes;
+}
+function urlSafeBase64(input) {
+  const bytes = typeof input === "string" ? new TextEncoder().encode(input) : input;
+  let binary = "";
+  for (let i = 0; i < bytes.length; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  return btoa(binary).replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
+}
+function sign(salt, target, secret) {
+  const mac = hmac.create(sha256, hexToBytes(secret, "signing key"));
+  mac.update(hexToBytes(salt, "signing salt"));
+  mac.update(new TextEncoder().encode(target));
+  return urlSafeBase64(mac.digest());
+}
+const defaultModifiers = {
+  resizingType: "auto",
+  gravity: "ce",
+  format: "webp"
+};
+function resolveModifiers(modifiers) {
+  const resolved = { ...modifiers };
+  if (resolved.fit) {
+    const hasW = typeof resolved.width === "number" && resolved.width > 0;
+    const hasH = typeof resolved.height === "number" && resolved.height > 0;
+    const hasBoth = hasW && hasH;
+    switch (resolved.fit) {
+      case "cover":
+        resolved.resizingType = hasBoth ? "fill" : "fit";
+        break;
+      case "contain":
+        resolved.resizingType = "fit";
+        resolved.extend = hasBoth;
+        break;
+      case "fill":
+        resolved.resizingType = hasBoth ? "force" : "fit";
+        break;
+      case "inside":
+        resolved.resizingType = "fit";
+        break;
+      case "outside":
+        resolved.resizingType = hasBoth ? "fill" : "fit";
+        break;
+    }
+    delete resolved.fit;
+  }
+  return resolved;
+}
+export const getImage = (src, ctx) => {
+  const baseURL = ctx?.baseURL ?? "";
+  const key = ctx?.key ?? "";
+  const salt = ctx?.salt ?? "";
+  const modifiers = ctx?.modifiers ?? {};
+  if (!key || !salt) {
+    throw new Error("[imgproxy] `key` and `salt` are required - configure them in `image.imgproxy`.");
+  }
+  const merged = resolveModifiers(defu(modifiers, defaultModifiers));
+  const encodedUrl = urlSafeBase64(src);
+  const operations = generateOperations(merged);
+  const path = joinURL("/", operations, encodedUrl);
+  const signature = sign(salt, path, key);
+  return {
+    url: joinURL(baseURL, signature, path)
+  };
+};
+export default () => ({ getImage });

package/dist/runtime/types.d.ts

@@ -0,0 +1,56 @@
+import type { FocalPoint } from './utils/focal.js';
+export type { FocalPoint };
+export interface StatamicPlaceholder {
+    uri?: string | null;
+    type?: string | null;
+    hash?: string | null;
+}
+/**
+ * Statamic asset shape used by `<NovuStatamicImage>` and `resolveStatamicAsset`.
+ *
+ * Maps to a Statamic image asset with focal-point and per-locale alt text fields.
+ * Per-locale alt fields are addressed as `alt_${locale}` (e.g. `alt_de`, `alt_fr`).
+ */
+export interface StatamicAsset {
+    permalink?: string;
+    url?: string;
+    alt?: string;
+    width?: number;
+    height?: number;
+    /** Statamic native focal-point format `"x-y"` where x and y are 0-100. */
+    focus?: string;
+    /** CSS-friendly focal-point format `"x% y%"` (Statamic's `focus_css` augmentation). */
+    focus_css?: string;
+    aspectRatio?: number;
+    placeholder?: string | StatamicPlaceholder | null;
+    lqip?: string | StatamicPlaceholder | null;
+    thumbhash?: string | StatamicPlaceholder | null;
+    /** Per-locale alt fields like `alt_de`, `alt_fr`. */
+    [key: `alt_${string}`]: string | undefined;
+    [key: string]: unknown;
+}
+export interface ResolvedStatamicAsset {
+    src: string | undefined;
+    placeholderSrc: string | undefined;
+    alt: string | undefined;
+    focal: FocalPoint | undefined;
+    width: number | undefined;
+    height: number | undefined;
+    sourceWidth: number | undefined;
+    sourceHeight: number | undefined;
+    aspectRatio: number | undefined;
+}
+export interface ResolveStatamicAssetProps {
+    alt?: string;
+    fallbackAlt?: string;
+    focal?: FocalPoint;
+    width?: number;
+    height?: number;
+    aspectRatio?: number;
+    placeholderField?: string | string[];
+}
+export interface ResolveStatamicAssetOptions {
+    locale?: string;
+    provider?: string;
+    statamicPlaceholderFields?: string[];
+}

package/dist/runtime/utils/focal.d.ts

@@ -0,0 +1,11 @@
+export type FocalPoint = 'auto' | readonly [number, number];
+export interface FocalContext {
+    /** Original (intrinsic) image width in pixels - required to normalize for imgproxy. */
+    width?: number;
+    /** Original (intrinsic) image height in pixels - required to normalize for imgproxy. */
+    height?: number;
+}
+export type FocalMapper = (focal: FocalPoint, ctx: FocalContext) => Record<string, unknown>;
+export declare const focalMappers: Record<string, FocalMapper>;
+export declare function defaultFocalForProvider(provider: string | undefined): FocalPoint | undefined;
+export declare function applyFocal(provider: string | undefined, focal: FocalPoint | undefined, ctx: FocalContext): Record<string, unknown>;

package/dist/runtime/utils/focal.js

@@ -0,0 +1,33 @@
+const cloudinary = (focal) => {
+  if (focal === "auto") return { gravity: "auto", fit: "fill" };
+  return { x: focal[0], y: focal[1], gravity: "xy_center", fit: "fill" };
+};
+const bunny = (focal) => {
+  if (focal === "auto") return {};
+  return {};
+};
+const imgproxy = (focal, ctx) => {
+  if (focal === "auto") return { gravity: "sm" };
+  if (!ctx.width || !ctx.height) return {};
+  const nx = clamp01(focal[0] / ctx.width);
+  const ny = clamp01(focal[1] / ctx.height);
+  return { gravity: `fp:${nx}:${ny}` };
+};
+function clamp01(value) {
+  return Math.max(0, Math.min(1, Number.isFinite(value) ? value : 0.5));
+}
+export const focalMappers = {
+  cloudinary,
+  bunny,
+  imgproxy
+};
+const AUTO_FOCAL_PROVIDERS = /* @__PURE__ */ new Set(["cloudinary", "imgproxy"]);
+export function defaultFocalForProvider(provider) {
+  return provider && AUTO_FOCAL_PROVIDERS.has(provider) ? "auto" : void 0;
+}
+export function applyFocal(provider, focal, ctx) {
+  if (!focal || !provider) return {};
+  const mapper = focalMappers[provider];
+  if (!mapper) return {};
+  return mapper(focal, ctx);
+}

package/dist/runtime/utils/i18n.d.ts

@@ -0,0 +1 @@
+export declare function getI18nLocale(nuxtApp: unknown): string | undefined;

package/dist/runtime/utils/i18n.js

@@ -0,0 +1,10 @@
+import { isRef, unref } from "vue";
+export function getI18nLocale(nuxtApp) {
+  const $i18n = nuxtApp.$i18n;
+  if (!$i18n) return void 0;
+  const value = $i18n.locale;
+  if (isRef(value)) return unref(value);
+  if (value && typeof value === "object" && "value" in value) return value.value;
+  if (typeof value === "string") return value;
+  return void 0;
+}

package/dist/runtime/utils/numbers.d.ts

@@ -0,0 +1 @@
+export declare function toFiniteNumber(value: unknown): number | undefined;

package/dist/runtime/utils/numbers.js

@@ -0,0 +1,6 @@
+export function toFiniteNumber(value) {
+  if (value === void 0 || value === null || value === "") return void 0;
+  if (typeof value !== "number" && typeof value !== "string") return void 0;
+  const parsed = typeof value === "number" ? value : Number.parseFloat(value);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : void 0;
+}

package/dist/runtime/utils/providerModifiers.d.ts

@@ -0,0 +1,4 @@
+type ModifierTransform = (modifiers: Record<string, unknown>) => Record<string, unknown>;
+export declare const providerModifierTransforms: Record<string, ModifierTransform>;
+export declare function transformProviderModifiers(provider: string | undefined, modifiers: Record<string, unknown>): Record<string, unknown>;
+export {};

package/dist/runtime/utils/providerModifiers.js

@@ -0,0 +1,36 @@
+import { toFiniteNumber } from "./numbers.js";
+const FILL_FITS = /* @__PURE__ */ new Set(["cover", "fill", "crop"]);
+const bunny = (m) => {
+  const wantsFaceCrop = m.faceCrop !== void 0 && m.faceCrop !== false;
+  const wantsCrop = m.cropGravity !== void 0 || typeof m.fit === "string" && FILL_FITS.has(m.fit);
+  if (!wantsFaceCrop && !wantsCrop) return m;
+  if (wantsFaceCrop && typeof m.faceCrop === "string") {
+    const { fit: _fit2, width: _w2, height: _h2, crop: _crop2, cropGravity: _cg, faceCrop: _fc2, ...rest2 } = m;
+    return { ...rest2, face_crop: m.faceCrop };
+  }
+  if (m.width === void 0 || m.height === void 0) {
+    if (wantsFaceCrop) {
+      const { fit: _fit2, crop: _crop2, cropGravity: _cg, faceCrop: _fc2, ...rest2 } = m;
+      return { ...rest2, face_crop: true };
+    }
+    return m;
+  }
+  const width = toFiniteNumber(m.width);
+  const height = toFiniteNumber(m.height);
+  if (width === void 0 || height === void 0) return m;
+  const { fit: _fit, width: _w, height: _h, crop: _crop, cropGravity, faceCrop: _fc, ...rest } = m;
+  if (wantsFaceCrop) return { ...rest, face_crop: `${width},${height}` };
+  return {
+    ...rest,
+    ...cropGravity !== void 0 ? { cropGravity } : {},
+    crop: `${width},${height}`
+  };
+};
+export const providerModifierTransforms = {
+  bunny
+};
+export function transformProviderModifiers(provider, modifiers) {
+  if (!provider) return modifiers;
+  const transform = providerModifierTransforms[provider];
+  return transform ? transform(modifiers) : modifiers;
+}

package/dist/runtime/utils/screens.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Parse a `screens` config into a sorted descending list of breakpoint widths
+ * in pixels. Accepts either plain numbers or strings with `px` suffix.
+ */
+export declare function parseScreens(screens: Record<string, number | string>): number[];

package/dist/runtime/utils/screens.js

@@ -0,0 +1,19 @@
+export function parseScreens(screens) {
+  const widths = [];
+  for (const value of Object.values(screens)) {
+    const px = parseScreenValue(value);
+    if (px !== void 0) widths.push(px);
+  }
+  return widths.sort((a, b) => b - a);
+}
+function parseScreenValue(value) {
+  if (typeof value === "number" && Number.isFinite(value) && value > 0) return value;
+  if (typeof value === "string") {
+    const match = value.trim().match(/^(\d+(?:\.\d+)?)\s*px?$/i) ?? value.trim().match(/^(\d+(?:\.\d+)?)$/);
+    if (match) {
+      const parsed = Number.parseFloat(match[1]);
+      if (Number.isFinite(parsed) && parsed > 0) return parsed;
+    }
+  }
+  return void 0;
+}

package/dist/runtime/utils/statamic.d.ts

@@ -0,0 +1,3 @@
+import type { ResolveStatamicAssetOptions, ResolveStatamicAssetProps, ResolvedStatamicAsset, StatamicAsset } from '../types.js';
+export declare const DEFAULT_STATAMIC_PLACEHOLDER_FIELDS: string[];
+export declare function resolveStatamicAsset(src: string | StatamicAsset | null | undefined, props?: ResolveStatamicAssetProps, options?: ResolveStatamicAssetOptions): ResolvedStatamicAsset;

package/dist/runtime/utils/statamic.js

@@ -0,0 +1,143 @@
+import { thumbHashToDataURL } from "thumbhash";
+import { toFiniteNumber } from "./numbers.js";
+export const DEFAULT_STATAMIC_PLACEHOLDER_FIELDS = ["placeholder", "lqip", "thumbhash"];
+export function resolveStatamicAsset(src, props = {}, options = {}) {
+  const asset = normalizeAsset(src);
+  const dims = resolveDimensions(asset, props);
+  return {
+    src: resolveSrc(asset, options.provider),
+    placeholderSrc: resolvePlaceholderSrc(asset, props, options),
+    alt: resolveAlt(asset, props, options.locale),
+    focal: props.focal ?? resolveFocal(asset),
+    width: dims.width,
+    height: dims.height,
+    sourceWidth: toFiniteNumber(asset?.width),
+    sourceHeight: toFiniteNumber(asset?.height),
+    aspectRatio: resolveAspectRatio(asset, props, dims)
+  };
+}
+function resolveDimensions(asset, props) {
+  const propW = toFiniteNumber(props.width);
+  const propH = toFiniteNumber(props.height);
+  if (propW !== void 0 && propH !== void 0) {
+    return { width: propW, height: propH };
+  }
+  const aspect = intrinsicAspectRatio(asset, props);
+  if (propW !== void 0) {
+    const derivedH = aspect ? Math.round(propW / aspect) : asset?.height;
+    return { width: propW, height: toFiniteNumber(derivedH) };
+  }
+  if (propH !== void 0) {
+    const derivedW = aspect ? Math.round(propH * aspect) : asset?.width;
+    return { width: toFiniteNumber(derivedW), height: propH };
+  }
+  return { width: toFiniteNumber(asset?.width), height: toFiniteNumber(asset?.height) };
+}
+function intrinsicAspectRatio(asset, props) {
+  if (props.aspectRatio && props.aspectRatio > 0) return props.aspectRatio;
+  if (asset?.aspectRatio && asset.aspectRatio > 0) return asset.aspectRatio;
+  if (asset?.width && asset?.height && asset.width > 0 && asset.height > 0) {
+    return asset.width / asset.height;
+  }
+  return void 0;
+}
+function normalizeAsset(src) {
+  if (src == null) return void 0;
+  if (typeof src === "string") return { permalink: src };
+  return src;
+}
+const CLOUDINARY_PATH_RE = /^\/[^/]+\/image\/(?:upload|fetch|private|authenticated)\/(?:s--[^/]+--\/)?/i;
+function resolveSrc(asset, provider) {
+  const permalink = asset?.permalink ?? asset?.url;
+  if (!permalink) return void 0;
+  if (provider === "imgproxy" && /^https?:\/\//i.test(permalink)) return permalink;
+  let path = permalink.replace(/^https?:\/\/[^/]+/i, "");
+  path = path.replace(CLOUDINARY_PATH_RE, "");
+  return path.replace(/^\//, "");
+}
+function resolvePlaceholderSrc(asset, props, options) {
+  if (!asset) return void 0;
+  for (const field of resolvePlaceholderFields(props.placeholderField, options.statamicPlaceholderFields)) {
+    const src = resolvePlaceholderValue(asset[field]);
+    if (src) return src;
+  }
+  return void 0;
+}
+function resolvePlaceholderFields(propFields, optionFields) {
+  const fields = [
+    ...toFieldList(propFields),
+    ...optionFields ?? DEFAULT_STATAMIC_PLACEHOLDER_FIELDS
+  ];
+  return [...new Set(fields.map((field) => field.trim()).filter(Boolean))];
+}
+function toFieldList(fields) {
+  if (fields === void 0) return [];
+  return Array.isArray(fields) ? fields : [fields];
+}
+function resolvePlaceholderValue(value) {
+  if (typeof value === "string") return value || void 0;
+  if (!isPlaceholderObject(value)) return void 0;
+  if (typeof value.uri === "string" && value.uri) return value.uri;
+  const type = typeof value.type === "string" ? value.type.toLowerCase() : void 0;
+  if (type !== void 0 && type !== "thumbhash") return void 0;
+  if (typeof value.hash !== "string" || !value.hash) return void 0;
+  return decodeThumbHash(value.hash);
+}
+function isPlaceholderObject(value) {
+  return typeof value === "object" && value !== null;
+}
+function decodeThumbHash(hash) {
+  try {
+    const bytes = decodeBase64Bytes(hash);
+    if (!bytes.length) return void 0;
+    return thumbHashToDataURL(bytes);
+  } catch {
+    return void 0;
+  }
+}
+function decodeBase64Bytes(value) {
+  const normalized = value.trim().replace(/-/g, "+").replace(/_/g, "/").padEnd(Math.ceil(value.trim().length / 4) * 4, "=");
+  const binary = globalThis.atob(normalized);
+  return Uint8Array.from(binary, (char) => char.charCodeAt(0));
+}
+function resolveAlt(asset, props, locale) {
+  if (props.alt) return props.alt;
+  if (asset && locale) {
+    const localized = asset[`alt_${locale}`];
+    if (localized) return localized;
+  }
+  if (asset?.alt) return asset.alt;
+  if (props.fallbackAlt) return props.fallbackAlt;
+  return void 0;
+}
+function resolveFocal(asset) {
+  if (!asset?.width || !asset?.height) return void 0;
+  let xRaw;
+  let yRaw;
+  if (asset.focus) {
+    const parts = asset.focus.split("-");
+    xRaw = parts[0];
+    yRaw = parts[1];
+  } else if (asset.focus_css) {
+    const parts = asset.focus_css.replace(/%/g, "").trim().split(/\s+/);
+    xRaw = parts[0];
+    yRaw = parts[1];
+  }
+  if (xRaw === void 0 || yRaw === void 0) return void 0;
+  const xPct = Number.parseFloat(xRaw);
+  const yPct = Number.parseFloat(yRaw);
+  if (!Number.isFinite(xPct) || !Number.isFinite(yPct)) return void 0;
+  if (xPct === 50 && yPct === 50) return void 0;
+  return [
+    Math.round(xPct * asset.width / 100),
+    Math.round(yPct * asset.height / 100)
+  ];
+}
+function resolveAspectRatio(asset, props, dims) {
+  if (props.aspectRatio && props.aspectRatio > 0) return props.aspectRatio;
+  if (asset?.aspectRatio && asset.aspectRatio > 0) return asset.aspectRatio;
+  const w = toFiniteNumber(dims.width);
+  const h = toFiniteNumber(dims.height);
+  if (w && h) return w / h;
+  return void 0;
+}

package/dist/types.d.mts

@@ -0,0 +1,3 @@
+export { default } from './module.mjs'
+
+export { type ModuleOptions } from './module.mjs'

package/package.json

@@ -1,80 +1,77 @@
 {
   "name": "@teamnovu/nuxt-image",
-  "version": "0.5.5",
-  "description": "Nuxt Image Module",
-  "repository": "nuxt/image",
+  "version": "1.0.0-beta.1",
+  "description": "Responsive image module for Nuxt 4 with provider-agnostic focal-point handling and a Statamic adapter built on @nuxt/image.",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/teamnovu/novu-nuxt-image.git"
+  },
   "license": "MIT",
-  "sideEffects": false,
-  "main": "dist/module.js",
-  "types": "dist/types.d.ts",
+  "type": "module",
+  "keywords": [
+    "nuxt",
+    "nuxt-module",
+    "image",
+    "responsive-images",
+    "cloudinary",
+    "bunny",
+    "imgproxy",
+    "statamic"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/types.d.mts",
+      "import": "./dist/module.mjs"
+    }
+  },
+  "main": "./dist/module.mjs",
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./dist/types.d.mts"
+      ]
+    }
+  },
   "files": [
-    "dist",
-    "vetur"
+    "dist"
   ],
   "scripts": {
-    "build": "siroc build && mkdist --src src/runtime --dist dist/runtime -d --ext js",
-    "dev": "yarn nuxt playground",
-    "docs:build": "cd docs && nuxt generate",
-    "docs:dev": "yarn nuxt dev docs",
-    "lint": "eslint --ext .ts --ext .vue .",
-    "prepublishOnly": "yarn build",
-    "release": "standard-version && git push --follow-tags && npm publish",
-    "test": "yarn lint && yarn jest --forceExit",
-    "test:e2e": "jest test/e2e --forceExit",
-    "test:unit": "jest test/unit --forceExit"
+    "prepack": "nuxt-module-build build",
+    "dev": "npm run dev:prepare && nuxt dev playground",
+    "dev:build": "nuxt build playground",
+    "dev:prepare": "nuxt-module-build build --stub && nuxt-module-build prepare && nuxt prepare playground",
+    "release": "npm run lint && npm run test && npm run prepack && changelogen --release && npm publish && git push --follow-tags",
+    "lint": "eslint .",
+    "test": "vitest run",
+    "test:watch": "vitest watch",
+    "test:types": "vue-tsc --noEmit && cd playground && vue-tsc --noEmit"
   },
   "dependencies": {
-    "consola": "^2.15.3",
-    "defu": "^5.0.0",
-    "fs-extra": "^10.0.0",
-    "hasha": "^5.2.2",
-    "image-meta": "^0.0.1",
-    "ipx": "^0.7.1",
-    "is-https": "^4.0.0",
-    "lru-cache": "^6.0.0",
-    "node-fetch": "^2.6.1",
-    "p-limit": "^3.1.0",
-    "rc9": "^1.2.0",
-    "requrl": "^3.0.2",
-    "semver": "^7.3.5",
-    "ufo": "^0.7.7",
-    "upath": "^2.0.1"
+    "@noble/hashes": "^2.2.0",
+    "@nuxt/image": "^2.0.0",
+    "@nuxt/kit": "^4.4.5",
+    "@vueuse/core": "^14.3.0",
+    "defu": "^6.1.4",
+    "thumbhash": "^0.1.1",
+    "ufo": "^1.6.4"
   },
-  "devDependencies": {
-    "@babel/preset-env": "latest",
-    "@babel/preset-typescript": "latest",
-    "@cyrilf/vue-dat-gui": "latest",
-    "@nuxt/test-utils": "latest",
-    "@nuxt/types": "latest",
-    "@nuxt/typescript-build": "latest",
-    "@nuxt/typescript-runtime": "latest",
-    "@nuxtjs/eslint-config-typescript": "latest",
-    "@types/fs-extra": "latest",
-    "@types/jest": "latest",
-    "@types/lru-cache": "latest",
-    "@types/node-fetch": "latest",
-    "@types/semver": "^7.3.6",
-    "@vue/test-utils": "latest",
-    "babel-core": "^7.0.0-bridge.0",
-    "babel-eslint": "latest",
-    "eslint": "latest",
-    "jest": "latest",
-    "jsdom": "latest",
-    "jsdom-global": "latest",
-    "mkdist": "latest",
-    "nuxt": "^2.15.7",
-    "playwright": "latest",
-    "siroc": "latest",
-    "standard-version": "latest",
-    "ts-loader": "^8",
-    "typescript": "latest",
-    "vue-jest": "latest"
-  },
-  "publishConfig": {
-    "access": "public"
+  "peerDependencies": {
+    "nuxt": ">=3.13.0"
   },
-  "vetur": {
-    "tags": "vetur/tags.json",
-    "attributes": "vetur/attributes.json"
+  "devDependencies": {
+    "@nuxt/devtools": "^3.2.4",
+    "@nuxt/eslint-config": "^1.15.2",
+    "@nuxt/module-builder": "^1.0.2",
+    "@nuxt/schema": "^4.4.5",
+    "@nuxt/test-utils": "^4.0.3",
+    "@types/node": "latest",
+    "@vue/test-utils": "^2.4.10",
+    "changelogen": "^0.6.2",
+    "eslint": "^10.3.0",
+    "happy-dom": "^20.0.0",
+    "nuxt": "^4.4.5",
+    "typescript": "~6.0.3",
+    "vitest": "^4.1.5",
+    "vue-tsc": "^3.2.8"
   }
 }