@ubean/image 0.1.2 → 0.1.3

package/dist/runtime-3aSOG0e9.js

@@ -0,0 +1,417 @@
+import { hash } from "ohash";
+import { hasProtocol, joinURL } from "ufo";
+//#region src/core.ts
+const formatMap = {
+	webp: "image/webp",
+	avif: "image/avif",
+	jpeg: "image/jpeg",
+	jpg: "image/jpeg",
+	png: "image/png",
+	gif: "image/gif",
+	svg: "image/svg+xml"
+};
+function detectFormat(src) {
+	const ext = src.split("?")[0].split(".").pop()?.toLowerCase();
+	if (ext && ext in formatMap) return ext;
+}
+function isRemoteUrl(src) {
+	if (src.startsWith("//")) return true;
+	return hasProtocol(src, { acceptRelative: false });
+}
+function isDataUrl(src) {
+	return src.startsWith("data:");
+}
+function resolveAlias(src, alias) {
+	for (const [prefix, target] of Object.entries(alias)) if (src.startsWith(prefix)) return joinURL(target, src.slice(prefix.length));
+	return src;
+}
+function validateDomain(src, domains) {
+	if (!domains.length) return true;
+	if (!isRemoteUrl(src)) return true;
+	try {
+		const url = new URL(src);
+		return domains.some((domain) => url.hostname === domain || url.hostname.endsWith(`.${domain}`));
+	} catch {
+		return false;
+	}
+}
+function createIPXUrl(baseURL, src, modifiers = {}, defaultModifiers = {}) {
+	const mods = {
+		...defaultModifiers,
+		...modifiers
+	};
+	const segments = [];
+	if (mods.width) segments.push(`w_${mods.width}`);
+	if (mods.height) segments.push(`h_${mods.height}`);
+	if (mods.fit) segments.push(`f_${mods.fit}`);
+	if (mods.position) segments.push(`p_${encodeURIComponent(mods.position)}`);
+	if (mods.format) segments.push(`fm_${mods.format}`);
+	if (mods.quality) segments.push(`q_${mods.quality}`);
+	if (mods.blur) segments.push(`blur_${mods.blur}`);
+	if (mods.sharpen) segments.push(`sharpen_${mods.sharpen}`);
+	if (mods.rotate) segments.push(`rot_${mods.rotate}`);
+	if (mods.background) segments.push(`bg_${encodeURIComponent(mods.background)}`);
+	if (mods.grayscale) segments.push("grayscale");
+	if (mods.negate) segments.push("negate");
+	if (mods.trim) segments.push("trim");
+	if (mods.enlarge) segments.push("enlarge");
+	if (mods.flip === "h") segments.push("fh");
+	if (mods.flip === "v") segments.push("fv");
+	if (mods.flip === "hv") segments.push("fh", "fv");
+	if (mods.brightness !== void 0) segments.push(`br_${mods.brightness}`);
+	if (mods.contrast !== void 0) segments.push(`con_${mods.contrast}`);
+	if (mods.saturation !== void 0) segments.push(`sat_${mods.saturation}`);
+	return joinURL(baseURL, segments.length > 0 ? segments.join(",") : "_", src);
+}
+function createStaticUrl(baseURL, src, modifiers = {}, defaultModifiers = {}, dir = "") {
+	const mods = {
+		...defaultModifiers,
+		...modifiers
+	};
+	const ext = detectFormat(src) || "webp";
+	const format = mods.format || ext;
+	const suffixParts = [];
+	if (mods.width) suffixParts.push(`w${mods.width}`);
+	if (mods.height) suffixParts.push(`h${mods.height}`);
+	if (mods.quality) suffixParts.push(`q${mods.quality}`);
+	if (mods.blur) suffixParts.push(`blur${mods.blur}`);
+	const suffix = suffixParts.length > 0 ? `_${suffixParts.join("_")}` : "";
+	return joinURL(baseURL, dir, `${src.replace(/\.[^.]+$/, "")}${suffix}.${format}`);
+}
+const ipxProvider = {
+	name: "ipx",
+	getImage(src, mods, ctx) {
+		return { url: createIPXUrl(ctx?.options.ipx.baseURL || "/_ipx", src, mods, ctx?.options.ipx.modifiers || {}) };
+	}
+};
+const staticProvider = {
+	name: "static",
+	getImage(src, mods, ctx) {
+		const baseURL = ctx?.options.static.baseURL || "/_image";
+		const dir = ctx?.options.static.dir || "";
+		return { url: createStaticUrl(baseURL, src, mods, ctx?.options.static.modifiers || {}, dir) };
+	}
+};
+const cloudinaryProvider = {
+	name: "cloudinary",
+	getImage(src, mods = {}, ctx) {
+		const baseURL = ctx?.options.cloudinary?.baseURL || "";
+		const transforms = [];
+		if (mods.width || mods.height) {
+			transforms.push(`c_${mods.fit || "fill"}`);
+			if (mods.width) transforms.push(`w_${mods.width}`);
+			if (mods.height) transforms.push(`h_${mods.height}`);
+			if (mods.position) transforms.push(`g_${mods.position.replace(" ", "_")}`);
+		}
+		if (mods.quality) transforms.push(`q_${mods.quality}`);
+		if (mods.format) transforms.push(`f_${mods.format}`);
+		if (mods.rotate) transforms.push(`a_${mods.rotate}`);
+		if (mods.blur) transforms.push(`e_blur:${Math.round(mods.blur * 20)}`);
+		if (mods.grayscale) transforms.push("e_grayscale");
+		if (mods.negate) transforms.push("e_negate");
+		return { url: joinURL(baseURL, "image/upload", transforms.length > 0 ? `${transforms.join(",")}/` : "", src) };
+	}
+};
+const imgixProvider = {
+	name: "imgix",
+	getImage(src, mods = {}, ctx) {
+		const baseURL = ctx?.options.imgix?.baseURL || "";
+		const params = new URLSearchParams();
+		if (mods.width) params.set("w", String(mods.width));
+		if (mods.height) params.set("h", String(mods.height));
+		if (mods.fit) params.set("fit", mods.fit === "cover" ? "crop" : mods.fit);
+		if (mods.position) params.set("crop", {
+			center: "center",
+			top: "top",
+			bottom: "bottom",
+			left: "left",
+			right: "right",
+			"left top": "top,left",
+			"right top": "top,right",
+			"left bottom": "bottom,left",
+			"right bottom": "bottom,right"
+		}[mods.position] || "center");
+		if (mods.format) params.set("fm", mods.format);
+		if (mods.quality) params.set("q", String(mods.quality));
+		if (mods.blur) params.set("blur", String(Math.round(mods.blur * 20)));
+		if (mods.rotate) params.set("rot", String(mods.rotate));
+		if (mods.grayscale) params.set("sat", "-100");
+		const query = params.toString();
+		return { url: joinURL(baseURL, src) + (query ? `?${query}` : "") };
+	}
+};
+const builtinProviders = {
+	ipx: ipxProvider,
+	static: staticProvider,
+	cloudinary: cloudinaryProvider,
+	imgix: imgixProvider,
+	none: {
+		name: "none",
+		getImage(src) {
+			return { url: src };
+		}
+	}
+};
+const defaultScreens = {
+	xs: 320,
+	sm: 640,
+	md: 768,
+	lg: 1024,
+	xl: 1280,
+	xxl: 1536
+};
+function createImageContext(userOptions = {}) {
+	const options = {
+		provider: userOptions.provider || "ipx",
+		providers: {
+			...builtinProviders,
+			...userOptions.providers
+		},
+		presets: userOptions.presets || {},
+		screens: {
+			...defaultScreens,
+			...userOptions.screens
+		},
+		densities: userOptions.densities || [1, 2],
+		format: userOptions.format || [
+			"webp",
+			"avif",
+			"jpeg"
+		],
+		quality: userOptions.quality || 80,
+		placeholder: userOptions.quality ?? 10,
+		responsiveSizes: userOptions.responsiveSizes || [
+			320,
+			640,
+			768,
+			1024,
+			1280
+		],
+		domains: userOptions.domains || [],
+		alias: userOptions.alias || {},
+		dir: userOptions.dir || "",
+		ipx: {
+			baseURL: "/_ipx",
+			modifiers: {},
+			...userOptions.ipx
+		},
+		static: {
+			baseURL: "/_image",
+			modifiers: {},
+			dir: "",
+			...userOptions.static
+		},
+		cloudinary: {
+			baseURL: "",
+			modifiers: {},
+			...userOptions.cloudinary
+		},
+		imgix: {
+			baseURL: "",
+			modifiers: {},
+			...userOptions.imgix
+		},
+		twicpics: {
+			baseURL: "",
+			modifiers: {}
+		},
+		fastly: {
+			baseURL: "",
+			modifiers: {}
+		},
+		vercel: {
+			baseURL: "/_vercel/image",
+			modifiers: {}
+		},
+		netlify: {
+			baseURL: "/.netlify/images",
+			modifiers: {}
+		},
+		imagekit: {
+			baseURL: "",
+			modifiers: {}
+		},
+		uploadcare: {
+			baseURL: "",
+			modifiers: {}
+		},
+		preload: true,
+		intersectOptions: { rootMargin: "200px" }
+	};
+	const providers = {};
+	for (const [name, provider] of Object.entries(options.providers)) providers[name] = {
+		name,
+		getImage: provider.getImage || builtinProviders[name]?.getImage || ((src) => ({ url: src })),
+		validateDomains: provider.validateDomains ?? builtinProviders[name]?.validateDomains,
+		supportsAlias: provider.supportsAlias ?? builtinProviders[name]?.supportsAlias
+	};
+	return {
+		options,
+		providers,
+		presets: options.presets
+	};
+}
+function getProvider(name, ctx) {
+	return ctx.providers[name] || ctx.providers[ctx.options.provider] || builtinProviders.none;
+}
+function resolvePreset(preset, ctx) {
+	if (!preset) return {};
+	return ctx.presets[preset] || {};
+}
+function resolveImage$1(source, overrides = {}, ctx) {
+	const input = typeof source === "string" ? {
+		src: source,
+		...overrides
+	} : {
+		...source,
+		...overrides
+	};
+	if (input.preset) {
+		const preset = resolvePreset(input.preset, ctx);
+		Object.assign(input, preset, input);
+	}
+	let { src } = input;
+	const provider = getProvider(input.provider || ctx.options.provider, ctx);
+	src = resolveAlias(src, ctx.options.alias);
+	if (isDataUrl(src)) return { url: src };
+	if (isRemoteUrl(src)) {
+		if (!validateDomain(src, ctx.options.domains)) console.warn(`[ubean-image] Domain not allowed: ${new URL(src).hostname}`);
+	}
+	const modifiers = {
+		quality: input.quality ?? ctx.options.quality,
+		width: input.width,
+		height: input.height,
+		fit: input.fit,
+		position: input.position,
+		format: input.format,
+		background: input.background,
+		blur: input.blur,
+		sharpen: input.sharpen,
+		rotate: input.rotate,
+		flip: input.flip,
+		trim: input.trim,
+		enlarge: input.enlarge,
+		grayscale: input.grayscale,
+		negate: input.negate,
+		brightness: input.brightness,
+		contrast: input.contrast,
+		saturation: input.saturation
+	};
+	return {
+		...provider.getImage(src, modifiers, ctx),
+		width: modifiers.width,
+		height: modifiers.height,
+		format: modifiers.format
+	};
+}
+function createSrcSet(src, sizes, modifiers, ctx, formats = []) {
+	const items = [];
+	const targetFormats = formats.length > 0 ? formats : [modifiers.format || detectFormat(src) || "jpeg"];
+	for (const format of targetFormats) for (const width of sizes) {
+		if (modifiers.width && width > modifiers.width) continue;
+		const resolved = resolveImage$1(src, {
+			...modifiers,
+			width,
+			format
+		}, ctx);
+		items.push({
+			url: resolved.url,
+			width,
+			format
+		});
+	}
+	return items;
+}
+function createDensitySrcSet(src, densities, modifiers, ctx, formats = []) {
+	const items = [];
+	const targetFormats = formats.length > 0 ? formats : [modifiers.format || detectFormat(src) || "jpeg"];
+	const baseWidth = modifiers.width || 0;
+	for (const format of targetFormats) for (const density of densities) {
+		const width = baseWidth ? Math.round(baseWidth * density) : void 0;
+		const resolved = resolveImage$1(src, {
+			...modifiers,
+			width,
+			format
+		}, ctx);
+		items.push({
+			url: resolved.url,
+			density,
+			format
+		});
+	}
+	return items;
+}
+function srcSetToString(items) {
+	return items.map((item) => {
+		if (item.width) return `${item.url} ${item.width}w`;
+		if (item.density) return `${item.url} ${item.density}x`;
+		return item.url;
+	}).join(", ");
+}
+function getPlaceholder(src, modifiers, ctx, size = 10) {
+	return resolveImage$1(src, {
+		...modifiers,
+		width: size,
+		quality: 30,
+		format: "webp",
+		blur: 3
+	}, ctx).url;
+}
+function buildImgAttributes(src, options, ctx) {
+	const attrs = {
+		src: resolveImage$1(src, options, ctx).url,
+		alt: options.alt || "",
+		loading: options.loading || "lazy",
+		decoding: "async"
+	};
+	if (options.title) attrs.title = options.title;
+	if (options.crossorigin) attrs.crossorigin = options.crossorigin;
+	if (options.referrerpolicy) attrs.referrerpolicy = options.referrerpolicy;
+	if (options.sizes) attrs.sizes = options.sizes;
+	if (options.width) attrs.width = options.width;
+	if (options.height) attrs.height = options.height;
+	return attrs;
+}
+function createImageHash(url, modifiers) {
+	return hash({
+		url,
+		modifiers
+	}).slice(0, 10);
+}
+//#endregion
+//#region src/runtime.ts
+let imageCTX = null;
+function configureImageRuntime(options = {}) {
+	imageCTX = createImageContext(options);
+	return imageCTX;
+}
+function getImageContext() {
+	if (!imageCTX) imageCTX = createImageContext();
+	return imageCTX;
+}
+function resolveImage(source, overrides = {}) {
+	return resolveImage$1(source, overrides, getImageContext());
+}
+function defineImagePreset(name, options) {
+	const ctx = getImageContext();
+	ctx.presets[name] = options;
+}
+function useImage() {
+	const ctx = getImageContext();
+	return {
+		resolveImage: (src, options) => resolveImage$1(src, options, ctx),
+		getImage: (src, mods) => resolveImage$1(src, mods || {}, ctx),
+		srcset: (src, sizes, mods, formats) => createSrcSet(src, sizes, mods || {}, ctx, formats),
+		densitySrcset: (src, densities, mods, formats) => createDensitySrcSet(src, densities, mods || {}, ctx, formats),
+		srcsetToString: srcSetToString,
+		getPlaceholder: (src, mods, size) => getPlaceholder(src, mods || {}, ctx, size),
+		getImgAttributes: (src, options) => buildImgAttributes(src, options, ctx),
+		detectFormat,
+		isRemote: isRemoteUrl,
+		isDataUrl,
+		validateDomain: (src) => validateDomain(src, ctx.options.domains),
+		resolveAlias: (src) => resolveAlias(src, ctx.options.alias)
+	};
+}
+//#endregion
+export { resolveAlias as C, staticProvider as D, srcSetToString as E, validateDomain as O, isRemoteUrl as S, resolvePreset as T, getPlaceholder as _, useImage as a, ipxProvider as b, cloudinaryProvider as c, createImageContext as d, createImageHash as f, detectFormat as g, defaultScreens as h, resolveImage as i, createDensitySrcSet as l, createStaticUrl as m, defineImagePreset as n, buildImgAttributes as o, createSrcSet as p, getImageContext as r, builtinProviders as s, configureImageRuntime as t, createIPXUrl as u, getProvider as v, resolveImage$1 as w, isDataUrl as x, imgixProvider as y };

package/dist/runtime-B5AxhRTR.d.ts

@@ -0,0 +1,47 @@
+import { a as ImageModifiers, c as ImageProvider, d as ResolvedImage, i as ImageFormat, n as ImageCTX, o as ImageOptions, t as CreateImageOptions, u as ImageSrcsetItem } from "./types-DosomQo8.js";
+//#region src/core.d.ts
+declare function detectFormat(src: string): ImageFormat | undefined;
+declare function isRemoteUrl(src: string): boolean;
+declare function isDataUrl(src: string): boolean;
+declare function resolveAlias(src: string, alias: Record<string, string>): string;
+declare function validateDomain(src: string, domains: string[]): boolean;
+declare function createIPXUrl(baseURL: string, src: string, modifiers?: ImageModifiers, defaultModifiers?: ImageModifiers): string;
+declare function createStaticUrl(baseURL: string, src: string, modifiers?: ImageModifiers, defaultModifiers?: ImageModifiers, dir?: string): string;
+declare const ipxProvider: ImageProvider;
+declare const staticProvider: ImageProvider;
+declare const cloudinaryProvider: ImageProvider;
+declare const imgixProvider: ImageProvider;
+declare const builtinProviders: Record<string, ImageProvider>;
+declare const defaultScreens: Record<string, number>;
+declare function createImageContext(userOptions?: CreateImageOptions): ImageCTX;
+declare function getProvider(name: string, ctx: ImageCTX): ImageProvider;
+declare function resolvePreset(preset: string | undefined, ctx: ImageCTX): Partial<ImageOptions>;
+declare function resolveImage$1(source: string | ImageOptions, overrides: Partial<ImageOptions> | undefined, ctx: ImageCTX): ResolvedImage;
+declare function createSrcSet(src: string, sizes: number[], modifiers: ImageModifiers, ctx: ImageCTX, formats?: ImageFormat[]): ImageSrcsetItem[];
+declare function createDensitySrcSet(src: string, densities: number[], modifiers: ImageModifiers, ctx: ImageCTX, formats?: ImageFormat[]): ImageSrcsetItem[];
+declare function srcSetToString(items: ImageSrcsetItem[]): string;
+declare function getPlaceholder(src: string, modifiers: ImageModifiers, ctx: ImageCTX, size?: number): string | null;
+declare function buildImgAttributes(src: string, options: ImageOptions, ctx: ImageCTX): Record<string, any>;
+declare function createImageHash(url: string, modifiers?: ImageModifiers): string;
+//#endregion
+//#region src/runtime.d.ts
+declare function configureImageRuntime(options?: CreateImageOptions): ImageCTX;
+declare function getImageContext(): ImageCTX;
+declare function resolveImage(source: string | ImageOptions, overrides?: Partial<ImageOptions>): ResolvedImage;
+declare function defineImagePreset(name: string, options: Partial<ImageOptions>): void;
+declare function useImage(): {
+  resolveImage: (src: string | ImageOptions, options?: Partial<ImageOptions>) => ResolvedImage;
+  getImage: (src: string, mods?: ImageModifiers) => ResolvedImage;
+  srcset: (src: string, sizes: number[], mods?: ImageModifiers, formats?: any[]) => ImageSrcsetItem[];
+  densitySrcset: (src: string, densities: number[], mods?: ImageModifiers, formats?: any[]) => ImageSrcsetItem[];
+  srcsetToString: typeof srcSetToString;
+  getPlaceholder: (src: string, mods?: ImageModifiers, size?: number) => string | null;
+  getImgAttributes: (src: string, options: ImageOptions) => Record<string, any>;
+  detectFormat: typeof detectFormat;
+  isRemote: typeof isRemoteUrl;
+  isDataUrl: typeof isDataUrl;
+  validateDomain: (src: string) => boolean;
+  resolveAlias: (src: string) => string;
+};
+//#endregion
+export { resolveAlias as C, staticProvider as D, srcSetToString as E, validateDomain as O, isRemoteUrl as S, resolvePreset as T, getPlaceholder as _, useImage as a, ipxProvider as b, cloudinaryProvider as c, createImageContext as d, createImageHash as f, detectFormat as g, defaultScreens as h, resolveImage as i, createDensitySrcSet as l, createStaticUrl as m, defineImagePreset as n, buildImgAttributes as o, createSrcSet as p, getImageContext as r, builtinProviders as s, configureImageRuntime as t, createIPXUrl as u, getProvider as v, resolveImage$1 as w, isDataUrl as x, imgixProvider as y };

package/dist/runtime.d.ts

@@ -0,0 +1,3 @@
+import { a as ImageModifiers, d as ResolvedImage, n as ImageCTX, o as ImageOptions, t as CreateImageOptions, u as ImageSrcsetItem } from "./types-DosomQo8.js";
+import { C as resolveAlias, E as srcSetToString, O as validateDomain, S as isRemoteUrl, T as resolvePreset, _ as getPlaceholder, a as useImage, d as createImageContext, g as detectFormat, i as resolveImage$1, l as createDensitySrcSet, n as defineImagePreset, o as buildImgAttributes, p as createSrcSet, r as getImageContext, t as configureImageRuntime, v as getProvider, w as resolveImage, x as isDataUrl } from "./runtime-B5AxhRTR.js";
+export { type CreateImageOptions, type ImageCTX, type ImageModifiers, type ImageOptions, type ImageSrcsetItem, type ResolvedImage, resolveImage as baseResolveImage, buildImgAttributes, configureImageRuntime, createDensitySrcSet, createImageContext, createSrcSet, defineImagePreset, detectFormat, getImageContext, getPlaceholder, getProvider, isDataUrl, isRemoteUrl, resolveAlias, resolveImage$1 as resolveImage, resolvePreset, srcSetToString, useImage, validateDomain };

package/dist/runtime.js

@@ -0,0 +1,2 @@
+import { C as resolveAlias, E as srcSetToString, O as validateDomain, S as isRemoteUrl, T as resolvePreset, _ as getPlaceholder, a as useImage, d as createImageContext, g as detectFormat, i as resolveImage$1, l as createDensitySrcSet, n as defineImagePreset, o as buildImgAttributes, p as createSrcSet, r as getImageContext, t as configureImageRuntime, v as getProvider, w as resolveImage, x as isDataUrl } from "./runtime-3aSOG0e9.js";
+export { resolveImage as baseResolveImage, buildImgAttributes, configureImageRuntime, createDensitySrcSet, createImageContext, createSrcSet, defineImagePreset, detectFormat, getImageContext, getPlaceholder, getProvider, isDataUrl, isRemoteUrl, resolveAlias, resolveImage$1 as resolveImage, resolvePreset, srcSetToString, useImage, validateDomain };

package/dist/types-DosomQo8.d.ts

@@ -0,0 +1,155 @@
+//#region src/types.d.ts
+type ImageFormat = 'webp' | 'avif' | 'jpeg' | 'jpg' | 'png' | 'gif' | 'svg';
+type ImageFit = 'cover' | 'contain' | 'fill' | 'inside' | 'outside';
+type ImagePosition = 'top' | 'right top' | 'right' | 'right bottom' | 'bottom' | 'left bottom' | 'left' | 'left top' | 'center';
+interface ImageModifiers {
+  width?: number;
+  height?: number;
+  size?: string;
+  fit?: ImageFit;
+  position?: ImagePosition;
+  format?: ImageFormat;
+  quality?: number;
+  background?: string;
+  blur?: number;
+  sharpen?: number;
+  rotate?: number;
+  flip?: 'h' | 'v' | 'hv';
+  trim?: boolean | number;
+  enlarge?: boolean;
+  grayscale?: boolean;
+  negate?: boolean;
+  brightness?: number;
+  contrast?: number;
+  saturation?: number;
+}
+interface ImageOptions extends ImageModifiers {
+  src: string;
+  alt?: string;
+  title?: string;
+  loading?: 'lazy' | 'eager';
+  crossorigin?: 'anonymous' | 'use-credentials' | '';
+  referrerpolicy?: string;
+  placeholder?: string;
+  sizes?: string;
+  srcset?: string;
+  preset?: string;
+  provider?: string;
+  densities?: string;
+}
+interface ImageSize {
+  width?: number;
+  height?: number;
+  media?: string;
+  breakpoint?: number;
+  format?: ImageFormat;
+}
+interface ProviderGetImage {
+  (src: string, options?: ImageModifiers, ctx?: ImageCTX): ResolvedImage;
+}
+interface ResolvedImage {
+  url: string;
+  format?: ImageFormat;
+  width?: number;
+  height?: number;
+  sizes?: string;
+  srcset?: ImageSrcsetItem[];
+}
+interface ImageSrcsetItem {
+  url: string;
+  width?: number;
+  density?: number;
+  format?: ImageFormat;
+}
+interface ImageProvider {
+  name: string;
+  getImage: ProviderGetImage;
+  validateDomains?: boolean;
+  supportsAlias?: boolean;
+}
+interface ImageCTX {
+  options: Required<ImageModuleOptions>;
+  providers: Record<string, ImageProvider>;
+  presets: Record<string, Partial<ImageOptions>>;
+}
+interface ImageModuleOptions {
+  provider: string;
+  providers: Record<string, Partial<ImageProvider> & {
+    options?: any;
+  }>;
+  presets: Record<string, Partial<ImageOptions>>;
+  screens: Record<string, number>;
+  densities: number[];
+  format: ImageFormat[];
+  quality: number;
+  placeholder: number | false;
+  responsiveSizes: number[];
+  domains: string[];
+  alias: Record<string, string>;
+  dir: string;
+  ipx: {
+    baseURL: string;
+    modifiers?: Partial<ImageModifiers>;
+  };
+  static: {
+    baseURL: string;
+    modifiers?: Partial<ImageModifiers>;
+    dir?: string;
+  };
+  cloudinary?: {
+    baseURL: string;
+    modifiers?: Partial<ImageModifiers>;
+  };
+  imgix?: {
+    baseURL: string;
+    modifiers?: Partial<ImageModifiers>;
+  };
+  twicpics?: {
+    baseURL: string;
+    modifiers?: Partial<ImageModifiers>;
+  };
+  fastly?: {
+    baseURL: string;
+    modifiers?: Partial<ImageModifiers>;
+  };
+  vercel?: {
+    baseURL: string;
+    modifiers?: Partial<ImageModifiers>;
+  };
+  netlify?: {
+    baseURL: string;
+    modifiers?: Partial<ImageModifiers>;
+  };
+  imagekit?: {
+    baseURL: string;
+    modifiers?: Partial<ImageModifiers>;
+  };
+  uploadcare?: {
+    baseURL: string;
+    modifiers?: Partial<ImageModifiers>;
+  };
+  preload: boolean;
+  intersectOptions: IntersectionObserverInit;
+}
+interface CreateImageOptions {
+  providers?: Record<string, ImageProvider | Partial<ImageProvider>>;
+  presets?: Record<string, Partial<ImageOptions>>;
+  screens?: Record<string, number>;
+  densities?: number[];
+  format?: ImageFormat[];
+  quality?: number;
+  placeholder?: number | false;
+  responsiveSizes?: number[];
+  domains?: string[];
+  alias?: Record<string, string>;
+  provider?: string;
+  dir?: string;
+  ipx?: Partial<ImageModuleOptions['ipx']>;
+  static?: Partial<ImageModuleOptions['static']>;
+  cloudinary?: Partial<ImageModuleOptions['cloudinary']>;
+  imgix?: Partial<ImageModuleOptions['imgix']>;
+  preload?: boolean;
+  intersectOptions?: IntersectionObserverInit;
+}
+//#endregion
+export { ImageModifiers as a, ImageProvider as c, ResolvedImage as d, ImageFormat as i, ImageSize as l, ImageCTX as n, ImageOptions as o, ImageFit as r, ImagePosition as s, CreateImageOptions as t, ImageSrcsetItem as u };

package/dist/vite.d.ts

@@ -0,0 +1,12 @@
+import { t as CreateImageOptions } from "./types-DosomQo8.js";
+import { Plugin } from "vite";
+//#region src/vite.d.ts
+interface UbeanImageOptions extends CreateImageOptions {
+  injectScript?: boolean;
+  staticDir?: string;
+  ipxMiddleware?: boolean;
+  devtools?: boolean;
+}
+declare function ubeanImagePlugin(userOptions?: UbeanImageOptions): Plugin;
+//#endregion
+export { UbeanImageOptions, ubeanImagePlugin as default, ubeanImagePlugin };