ipx 4.0.0-alpha.2 → 4.0.0-beta.1

package/dist/_chunks/node-fs.mjs

@@ -1,10 +1,9 @@
 import { __exportAll, __toESM } from "./rolldown-runtime.mjs";
-import { decode, hasProtocol, joinURL, withLeadingSlash } from "./libs/ufo.mjs";
+import { hasProtocol, joinURL, withLeadingSlash } from "./libs/ufo.mjs";
 import { HTTPError, defineEventHandler } from "./libs/h3.mjs";
 import { imageMeta } from "./libs/image-meta.mjs";
 import { require_etag } from "./libs/etag.mjs";
 import { require_accept_negotiator } from "./libs/@fastify/accept-negotiator.mjs";
-import { join, parse, resolve } from "pathe";
 function VArg(argument) {
 	if (argument === "Infinity") return Infinity;
 	if (argument === "undefined") return;
@@ -15,6 +14,78 @@ function VArg(argument) {
 	} catch {}
 	return argument;
 }
+function invalidArg(name, argument, expected) {
+	throw new HTTPError({
+		statusCode: 400,
+		statusText: "IPX_INVALID_MODIFIER_ARG",
+		message: `Invalid \`${name}\` modifier argument: \`${argument}\` (expected ${expected})`
+	});
+}
+function isOmitted(argument) {
+	return argument === void 0 || argument === "" || argument === "undefined";
+}
+function VNumber(name, options = {}) {
+	const { min, max, integer } = options;
+	const expected = [integer ? "an integer" : "a number", min !== void 0 && max !== void 0 ? `between ${min} and ${max}` : min !== void 0 && `greater than or equal to ${min}` || max !== void 0 && `less than or equal to ${max}` || ""].filter(Boolean).join(" ");
+	return (argument) => {
+		if (isOmitted(argument)) return;
+		const value = VArg(argument);
+		if (typeof value === "number" && Number.isFinite(value) && (!integer || Number.isInteger(value)) && (min === void 0 || value >= min) && (max === void 0 || value <= max)) return value;
+		invalidArg(name, argument, expected);
+	};
+}
+function VEnum(name, values) {
+	const expected = `one of: ${values.join(", ")}`;
+	return (argument) => {
+		if (isOmitted(argument)) return;
+		if (values.includes(argument)) return argument;
+		invalidArg(name, argument, expected);
+	};
+}
+function VBoolean(name) {
+	return (argument) => {
+		if (isOmitted(argument)) return;
+		if (argument === "true" || argument === "1") return true;
+		if (argument === "false" || argument === "0") return false;
+		invalidArg(name, argument, "`true` or `false`");
+	};
+}
+const HEX_COLOR_RE = /^#?(?:[\da-f]{3,4}|[\da-f]{6}|[\da-f]{8})$/i;
+const FN_COLOR_RE = /^(?:rgba?|hsla?|hwb)\([\d\s%,./-]+\)$/i;
+const NAMED_COLOR_RE = /^[a-z]{3,20}$/i;
+function VColor(name) {
+	return (argument) => {
+		if (isOmitted(argument)) return;
+		if (HEX_COLOR_RE.test(argument)) return argument.startsWith("#") ? argument : `#${argument}`;
+		if (FN_COLOR_RE.test(argument) || NAMED_COLOR_RE.test(argument)) return argument;
+		invalidArg(name, argument, "a hex (`f00`, `ff0000`) or named (`red`) colour");
+	};
+}
+const SIZE_RE = /^(\d+)(?:x(\d+))?$/;
+function VSize(name) {
+	return (argument) => {
+		if (isOmitted(argument)) return;
+		const match = SIZE_RE.exec(argument);
+		const width = Number(match?.[1]);
+		const height = match?.[2] === void 0 ? width : Number(match[2]);
+		if (match && width > 0 && height > 0) return {
+			width,
+			height
+		};
+		invalidArg(name, argument, "`{width}x{height}` of positive integers");
+	};
+}
+function VRequired(name, mapper) {
+	return (argument) => {
+		const value = mapper(argument);
+		if (value === void 0) throw new HTTPError({
+			statusCode: 400,
+			statusText: "IPX_MISSING_MODIFIER_ARG",
+			message: `Missing \`${name}\` modifier argument`
+		});
+		return value;
+	};
+}
 function parseArgs(arguments_, mappers) {
 	const vargs = arguments_.split("_");
 	return mappers.map((v, index) => v(vargs[index]));
@@ -24,7 +95,97 @@ function getHandler(key) {
 }
 function applyHandler(context, pipe, handler, argumentsString) {
 	const arguments_ = handler.args ? parseArgs(argumentsString, handler.args) : [];
-	return handler.apply(context, pipe, ...arguments_);
+	try {
+		return handler.apply(context, pipe, ...arguments_);
+	} catch (error) {
+		throw asModifierError(error);
+	}
+}
+function asModifierError(error) {
+	if (HTTPError.isError(error)) return error;
+	return new HTTPError({
+		statusCode: 400,
+		statusText: "IPX_INVALID_MODIFIER",
+		message: `Cannot apply modifier: ${error?.message || error}`,
+		cause: error
+	});
+}
+const SVG_NS = "http://www.w3.org/2000/svg";
+function opacityOverlay(opacity, background) {
+	return background ? {
+		input: Buffer.from(`<svg xmlns="${SVG_NS}" width="1" height="1"><rect width="1" height="1" fill="${background}" fill-opacity="${1 - opacity}"/></svg>`),
+		tile: true,
+		blend: "over"
+	} : {
+		input: { create: {
+			width: 1,
+			height: 1,
+			channels: 4,
+			background: {
+				r: 0,
+				g: 0,
+				b: 0,
+				alpha: opacity
+			}
+		} },
+		tile: true,
+		blend: "dest-in"
+	};
+}
+function clampToMaxDimension(max, desired, source) {
+	const { width, height } = desired;
+	if (!max || width === void 0 && height === void 0) return desired;
+	const ratio = source?.width && source?.height ? source.width / source.height : void 0;
+	const effectiveWidth = width ?? (ratio && height ? height * ratio : void 0);
+	const effectiveHeight = height ?? (ratio && width ? width / ratio : void 0);
+	const scale = Math.min(effectiveWidth ? max / effectiveWidth : 1, effectiveHeight ? max / effectiveHeight : 1);
+	if (scale >= 1) return desired;
+	const clamp = (value) => value === void 0 ? void 0 : Math.max(1, Math.min(max, Math.round(value * scale)));
+	return {
+		width: clamp(width),
+		height: clamp(height)
+	};
+}
+function resizeOutputDimensions(desired, source, options = {}) {
+	const { width, height } = desired;
+	if (width === void 0 && height === void 0) return;
+	const sourceWidth = source?.width;
+	const sourceHeight = source?.height;
+	if (!sourceWidth || !sourceHeight) return desired;
+	const derive = (value) => Math.max(1, Math.round(value));
+	let out = {
+		width: width ?? derive(height * sourceWidth / sourceHeight),
+		height: height ?? derive(width * sourceHeight / sourceWidth)
+	};
+	if (options.fit === "outside" && width !== void 0 && height !== void 0) {
+		const scale = Math.max(width / sourceWidth, height / sourceHeight);
+		out = {
+			width: derive(sourceWidth * scale),
+			height: derive(sourceHeight * scale)
+		};
+	}
+	return options.withoutEnlargement ? {
+		width: Math.min(out.width, sourceWidth),
+		height: Math.min(out.height, sourceHeight)
+	} : out;
+}
+function clampExtendEdges(max, edges, source) {
+	if (!max) return edges;
+	const [top, bottom] = clampEdges(max - (source?.height || 0), edges.top, edges.bottom);
+	const [left, right] = clampEdges(max - (source?.width || 0), edges.left, edges.right);
+	return {
+		top,
+		right,
+		bottom,
+		left
+	};
+}
+function clampEdges(available, a, b) {
+	const total = (a || 0) + (b || 0);
+	if (total === 0 || total <= available) return [a, b];
+	const scale = Math.max(0, available) / total;
+	const clamp = (value) => value === void 0 ? void 0 : Math.floor(value * scale);
+	return [clamp(a), clamp(b)];
 }
 function clampDimensionsPreservingAspectRatio(sourceDimensions, desiredDimensions) {
 	const desiredAspectRatio = desiredDimensions.width / desiredDimensions.height;
@@ -43,11 +204,16 @@ function clampDimensionsPreservingAspectRatio(sourceDimensions, desiredDimension
 	};
 }
 var handlers_exports = /* @__PURE__ */ __exportAll({
+	autoorient: () => autoorient,
 	b: () => b,
 	background: () => background,
 	blur: () => blur,
+	brightness: () => brightness,
+	clahe: () => clahe,
 	crop: () => crop,
+	dilate: () => dilate,
 	enlarge: () => enlarge,
+	erode: () => erode,
 	extend: () => extend,
 	extract: () => extract,
 	fit: () => fit,
@@ -58,11 +224,15 @@ var handlers_exports = /* @__PURE__ */ __exportAll({
 	grayscale: () => grayscale,
 	h: () => h,
 	height: () => height,
+	hue: () => hue,
 	kernel: () => kernel,
+	lightness: () => lightness,
+	linear: () => linear,
 	median: () => median,
 	modulate: () => modulate,
 	negate: () => negate,
 	normalize: () => normalize,
+	opacity: () => opacity,
 	pos: () => pos,
 	position: () => position,
 	q: () => q,
@@ -70,42 +240,92 @@ var handlers_exports = /* @__PURE__ */ __exportAll({
 	resize: () => resize,
 	rotate: () => rotate,
 	s: () => s,
+	saturation: () => saturation,
 	sharpen: () => sharpen,
 	threshold: () => threshold,
 	tint: () => tint,
 	trim: () => trim,
+	unflatten: () => unflatten,
 	w: () => w,
 	width: () => width
 });
 const quality = {
-	args: [VArg],
+	args: [VNumber("quality", {
+		min: 1,
+		max: 100,
+		integer: true
+	})],
 	order: -1,
 	apply: (context, _pipe, quality) => {
 		context.quality = quality;
 	}
 };
 const fit = {
-	args: [VArg],
+	args: [VEnum("fit", [
+		"contain",
+		"cover",
+		"fill",
+		"inside",
+		"outside"
+	])],
 	order: -1,
 	apply: (context, _pipe, fit) => {
 		context.fit = fit;
 	}
 };
+const POSITIONS = [
+	"top",
+	"right top",
+	"right",
+	"right bottom",
+	"bottom",
+	"left bottom",
+	"left",
+	"left top",
+	"north",
+	"northeast",
+	"east",
+	"southeast",
+	"south",
+	"southwest",
+	"west",
+	"northwest",
+	"center",
+	"centre",
+	"entropy",
+	"attention"
+];
+const GRAVITIES = /* @__PURE__ */ new Set([
+	0,
+	1,
+	2,
+	3,
+	4,
+	5,
+	6,
+	7,
+	8,
+	16,
+	17
+]);
+const VPosition = (name) => {
+	const vEnum = VEnum(name, POSITIONS);
+	return (argument) => {
+		if (/^\d+$/.test(argument) && GRAVITIES.has(Number(argument))) return Number(argument);
+		return vEnum(argument?.replace("-", " "));
+	};
+};
 const position = {
-	args: [VArg],
+	args: [VPosition("position")],
 	order: -1,
 	apply: (context, _pipe, position) => {
 		context.position = position;
 	}
 };
-const HEX_RE = /^([\da-f]{2})([\da-f]{2})([\da-f]{2})$/i;
-const SHORTHEX_RE = /^([\da-f])([\da-f])([\da-f])$/i;
 const background = {
-	args: [VArg],
+	args: [VColor("background")],
 	order: -1,
 	apply: (context, _pipe, background) => {
-		background = String(background);
-		if (!background.startsWith("#") && (HEX_RE.test(background) || SHORTHEX_RE.test(background))) background = "#" + background;
 		context.background = background;
 	}
 };
@@ -116,33 +336,49 @@ const enlarge = {
 	}
 };
 const kernel = {
-	args: [VArg],
+	args: [VEnum("kernel", [
+		"nearest",
+		"linear",
+		"cubic",
+		"mitchell",
+		"lanczos2",
+		"lanczos3",
+		"mks2013",
+		"mks2021"
+	])],
 	apply: (context, _pipe, kernel) => {
 		context.kernel = kernel;
 	}
 };
 const width = {
-	args: [VArg],
+	args: [VNumber("width", {
+		min: 1,
+		integer: true
+	})],
 	apply: (context, pipe, width) => {
-		return pipe.resize(width, void 0, { withoutEnlargement: !context.enlarge });
+		const clamped = clampToMaxDimension(context.maxOutputDimension, { width }, context.meta);
+		const withoutEnlargement = !context.enlarge;
+		context.outputDimensions = resizeOutputDimensions(clamped, context.meta, { withoutEnlargement });
+		return pipe.resize(clamped.width, void 0, { withoutEnlargement });
 	}
 };
 const height = {
-	args: [VArg],
+	args: [VNumber("height", {
+		min: 1,
+		integer: true
+	})],
 	apply: (context, pipe, height) => {
-		return pipe.resize(void 0, height, { withoutEnlargement: !context.enlarge });
+		const clamped = clampToMaxDimension(context.maxOutputDimension, { height }, context.meta);
+		const withoutEnlargement = !context.enlarge;
+		context.outputDimensions = resizeOutputDimensions(clamped, context.meta, { withoutEnlargement });
+		return pipe.resize(void 0, clamped.height, { withoutEnlargement });
 	}
 };
 const resize = {
-	args: [
-		VArg,
-		VArg,
-		VArg
-	],
+	args: [VSize("resize")],
 	apply: (context, pipe, size) => {
-		let [width, height] = String(size).split("x").map(Number);
-		if (!width) return;
-		if (!height) height = width;
+		if (!size) return;
+		let { width, height } = size;
 		if (!context.enlarge) {
 			const clamped = clampDimensionsPreservingAspectRatio(context.meta, {
 				width,
@@ -151,7 +387,12 @@ const resize = {
 			width = clamped.width;
 			height = clamped.height;
 		}
-		return pipe.resize(width, height, {
+		const capped = clampToMaxDimension(context.maxOutputDimension, {
+			width,
+			height
+		});
+		context.outputDimensions = resizeOutputDimensions(capped, context.meta, { fit: context.fit });
+		return pipe.resize(capped.width, capped.height, {
 			fit: context.fit,
 			position: context.position,
 			background: context.background,
@@ -160,34 +401,71 @@ const resize = {
 	}
 };
 const trim = {
-	args: [VArg],
+	args: [VNumber("trim", { min: 0 })],
 	apply: (_context, pipe, threshold) => {
-		return pipe.trim(threshold);
+		return pipe.trim({ threshold });
 	}
 };
+const EXTEND_WITH = [
+	"background",
+	"copy",
+	"repeat",
+	"mirror"
+];
+const VExtendEdge = (name) => VNumber(name, {
+	min: 0,
+	max: 1e4,
+	integer: true
+});
 const extend = {
 	args: [
-		VArg,
-		VArg,
-		VArg,
-		VArg
+		VExtendEdge("extend.top"),
+		VExtendEdge("extend.right"),
+		VExtendEdge("extend.bottom"),
+		VExtendEdge("extend.left"),
+		VEnum("extend.extendWith", EXTEND_WITH)
 	],
-	apply: (context, pipe, top, right, bottom, left) => {
-		return pipe.extend({
+	order: 1,
+	apply: (context, pipe, top, right, bottom, left, extendWith) => {
+		const edges = clampExtendEdges(context.maxOutputDimension, {
 			top,
-			left,
-			bottom,
 			right,
-			background: context.background
+			bottom,
+			left
+		}, context.outputDimensions ?? context.meta);
+		return pipe.extend({
+			top: edges.top,
+			left: edges.left,
+			bottom: edges.bottom,
+			right: edges.right,
+			background: context.background,
+			extendWith
 		});
 	}
 };
+const MAX_EXTRACT = 1e8;
 const extract = {
 	args: [
-		VArg,
-		VArg,
-		VArg,
-		VArg
+		VRequired("extract.left", VNumber("extract.left", {
+			min: 0,
+			max: MAX_EXTRACT,
+			integer: true
+		})),
+		VRequired("extract.top", VNumber("extract.top", {
+			min: 0,
+			max: MAX_EXTRACT,
+			integer: true
+		})),
+		VRequired("extract.width", VNumber("extract.width", {
+			min: 1,
+			max: MAX_EXTRACT,
+			integer: true
+		})),
+		VRequired("extract.height", VNumber("extract.height", {
+			min: 1,
+			max: MAX_EXTRACT,
+			integer: true
+		}))
 	],
 	apply: (_context, pipe, left, top, width, height) => {
 		return pipe.extract({
@@ -199,9 +477,18 @@ const extract = {
 	}
 };
 const rotate = {
-	args: [VArg],
-	apply: (context, pipe, angel) => {
-		return pipe.rotate(angel, { background: context.background });
+	args: [VNumber("rotate", {
+		min: -3600,
+		max: 3600
+	})],
+	apply: (context, pipe, angle) => {
+		return pipe.rotate(angle, { background: context.background });
+	}
+};
+const autoorient = {
+	args: [],
+	apply: (_context, pipe) => {
+		return pipe.autoOrient();
 	}
 };
 const flip = {
@@ -218,102 +505,243 @@ const flop = {
 };
 const sharpen = {
 	args: [
-		VArg,
-		VArg,
-		VArg
+		VNumber("sharpen.sigma", {
+			min: 1e-6,
+			max: 10
+		}),
+		VNumber("sharpen.flat", {
+			min: 0,
+			max: 1e6
+		}),
+		VNumber("sharpen.jagged", {
+			min: 0,
+			max: 1e6
+		}),
+		VNumber("sharpen.x1", {
+			min: 0,
+			max: 1e6
+		}),
+		VNumber("sharpen.y2", {
+			min: 0,
+			max: 1e6
+		}),
+		VNumber("sharpen.y3", {
+			min: 0,
+			max: 1e6
+		})
 	],
-	apply: (_context, pipe, sigma, flat, jagged) => {
-		return pipe.sharpen({
+	apply: (_context, pipe, sigma, flat, jagged, x1, y2, y3) => {
+		return sigma === void 0 ? pipe.sharpen() : pipe.sharpen({
 			sigma,
 			m1: flat,
-			m2: jagged
+			m2: jagged,
+			x1,
+			y2,
+			y3
 		});
 	}
 };
 const median = {
-	args: [
-		VArg,
-		VArg,
-		VArg
-	],
+	args: [VNumber("median", {
+		min: 1,
+		max: 1e3,
+		integer: true
+	})],
 	apply: (_context, pipe, size) => {
 		return pipe.median(size);
 	}
 };
 const blur = {
 	args: [
-		VArg,
-		VArg,
-		VArg
+		VNumber("blur.sigma", {
+			min: .3,
+			max: 1e3
+		}),
+		VEnum("blur.precision", [
+			"integer",
+			"float",
+			"approximate"
+		]),
+		VNumber("blur.minAmplitude", {
+			min: .001,
+			max: 1
+		})
 	],
-	apply: (_context, pipe, sigma) => {
-		return pipe.blur(sigma);
+	apply: (_context, pipe, sigma, precision, minAmplitude) => {
+		return sigma === void 0 ? pipe.blur() : pipe.blur({
+			sigma,
+			...precision === void 0 ? {} : { precision },
+			...minAmplitude === void 0 ? {} : { minAmplitude }
+		});
 	}
 };
-const flatten = {
+const MAX_MORPHOLOGY = 100;
+const dilate = {
+	args: [VNumber("dilate", {
+		min: 1,
+		max: MAX_MORPHOLOGY,
+		integer: true
+	})],
+	apply: (_context, pipe, width) => {
+		return pipe.dilate(width);
+	}
+};
+const erode = {
+	args: [VNumber("erode", {
+		min: 1,
+		max: MAX_MORPHOLOGY,
+		integer: true
+	})],
+	apply: (_context, pipe, width) => {
+		return pipe.erode(width);
+	}
+};
+const MAX_CLAHE = 100;
+const clahe = {
 	args: [
-		VArg,
-		VArg,
-		VArg
+		VRequired("clahe.width", VNumber("clahe.width", {
+			min: 1,
+			max: MAX_CLAHE,
+			integer: true
+		})),
+		VNumber("clahe.height", {
+			min: 1,
+			max: MAX_CLAHE,
+			integer: true
+		}),
+		VNumber("clahe.maxSlope", {
+			min: 0,
+			max: 100,
+			integer: true
+		})
 	],
+	apply: (context, pipe, width, height, maxSlope) => {
+		return pipe.clahe({
+			width: Math.min(width, context.meta.width || width),
+			height: Math.min(height ?? width, (context.meta.height || height) ?? width),
+			...maxSlope === void 0 ? {} : { maxSlope }
+		});
+	}
+};
+const flatten = {
+	args: [],
 	apply: (context, pipe) => {
 		return pipe.flatten({ background: context.background });
 	}
 };
+const unflatten = {
+	args: [],
+	apply: (_context, pipe) => {
+		return pipe.unflatten();
+	}
+};
 const gamma = {
-	args: [
-		VArg,
-		VArg,
-		VArg
-	],
+	args: [VNumber("gamma", {
+		min: 1,
+		max: 3
+	}), VNumber("gamma.gammaOut", {
+		min: 1,
+		max: 3
+	})],
 	apply: (_context, pipe, gamma, gammaOut) => {
 		return pipe.gamma(gamma, gammaOut);
 	}
 };
 const negate = {
-	args: [
-		VArg,
-		VArg,
-		VArg
-	],
-	apply: (_context, pipe) => {
-		return pipe.negate();
+	args: [VBoolean("negate.alpha")],
+	apply: (_context, pipe, alpha) => {
+		return alpha === void 0 ? pipe.negate() : pipe.negate({ alpha });
 	}
 };
 const normalize = {
-	args: [
-		VArg,
-		VArg,
-		VArg
-	],
-	apply: (_context, pipe) => {
-		return pipe.normalize();
+	args: [VNumber("normalize.lower", {
+		min: 0,
+		max: 99
+	}), VNumber("normalize.upper", {
+		min: 1,
+		max: 100
+	})],
+	apply: (_context, pipe, lower, upper) => {
+		return pipe.normalize({
+			lower,
+			upper
+		});
 	}
 };
 const threshold = {
-	args: [VArg],
-	apply: (_context, pipe, threshold) => {
-		return pipe.threshold(threshold);
+	args: [VNumber("threshold", {
+		min: 0,
+		max: 255,
+		integer: true
+	}), VBoolean("threshold.grayscale")],
+	apply: (_context, pipe, threshold, grayscale) => {
+		return grayscale === void 0 ? pipe.threshold(threshold) : pipe.threshold(threshold, { grayscale });
+	}
+};
+const linear = {
+	args: [VNumber("linear.a"), VNumber("linear.b")],
+	apply: (_context, pipe, a, b) => {
+		return pipe.linear(a, b);
 	}
 };
 const modulate = {
-	args: [VArg],
-	apply: (_context, pipe, brightness, saturation, hue) => {
+	args: [
+		VNumber("modulate.brightness", { min: 0 }),
+		VNumber("modulate.saturation", { min: 0 }),
+		VNumber("modulate.hue", { integer: true }),
+		VNumber("modulate.lightness")
+	],
+	apply: (_context, pipe, brightness, saturation, hue, lightness) => {
 		return pipe.modulate({
-			brightness,
-			saturation,
-			hue
+			...brightness === void 0 ? {} : { brightness },
+			...saturation === void 0 ? {} : { saturation },
+			...hue === void 0 ? {} : { hue },
+			...lightness === void 0 ? {} : { lightness }
 		});
 	}
 };
+const brightness = {
+	args: [VRequired("brightness", VNumber("brightness", { min: 0 }))],
+	apply: (_context, pipe, brightness) => {
+		return pipe.modulate({ brightness });
+	}
+};
+const saturation = {
+	args: [VRequired("saturation", VNumber("saturation", { min: 0 }))],
+	apply: (_context, pipe, saturation) => {
+		return pipe.modulate({ saturation });
+	}
+};
+const hue = {
+	args: [VRequired("hue", VNumber("hue", { integer: true }))],
+	apply: (_context, pipe, hue) => {
+		return pipe.modulate({ hue });
+	}
+};
+const lightness = {
+	args: [VRequired("lightness", VNumber("lightness"))],
+	apply: (_context, pipe, lightness) => {
+		return pipe.modulate({ lightness });
+	}
+};
+const opacity = {
+	args: [VRequired("opacity", VNumber("opacity", {
+		min: 0,
+		max: 1
+	}))],
+	apply: (context, pipe, opacity) => {
+		const overlay = opacityOverlay(opacity, context.background);
+		return (context.background ? pipe : pipe.ensureAlpha()).composite([overlay]);
+	}
+};
 const tint = {
-	args: [VArg],
+	args: [VColor("tint")],
 	apply: (_context, pipe, rgb) => {
 		return pipe.tint(rgb);
 	}
 };
 const grayscale = {
-	args: [VArg],
+	args: [],
 	apply: (_context, pipe) => {
 		return pipe.grayscale();
 	}
@@ -325,9 +753,94 @@ const w = width;
 const h = height;
 const s = resize;
 const pos = position;
+const UNSAFE_ELEMENTS = /* @__PURE__ */ new Set([
+	"script",
+	"foreignobject",
+	"iframe",
+	"embed",
+	"object",
+	"handler",
+	"listener",
+	"base",
+	"link",
+	"meta"
+]);
+const ANIMATION_ELEMENTS = /* @__PURE__ */ new Set([
+	"animate",
+	"animatemotion",
+	"animatetransform",
+	"set"
+]);
+const ANIMATION_VALUE_ATTRS = [
+	"from",
+	"to",
+	"by",
+	"values"
+];
+const URI_ATTRS = /* @__PURE__ */ new Set(["href", "src"]);
+const SAFE_URI_SCHEMES = /* @__PURE__ */ new Set([
+	"http",
+	"https",
+	"mailto",
+	"tel",
+	"ftp"
+]);
+const SAFE_DATA_URI_RE = /^data:image\/(?!svg\+xml)[\w.+-]+[,;]/;
+const URI_SCHEME_RE = /^([a-z][\d+.a-z-]*):/;
+const URI_IGNORED_CHARS_RE = /[\u0000-\u0020]/g;
+function localName(name) {
+	const colonIndex = name.indexOf(":");
+	return (colonIndex === -1 ? name : name.slice(colonIndex + 1)).toLowerCase();
+}
+function isUnsafeURI(value) {
+	const uri = value.replace(URI_IGNORED_CHARS_RE, "").toLowerCase();
+	const scheme = URI_SCHEME_RE.exec(uri)?.[1];
+	if (!scheme) return false;
+	if (scheme === "data") return !SAFE_DATA_URI_RE.test(uri);
+	return !SAFE_URI_SCHEMES.has(scheme);
+}
+function isUnsafeAnimation(attributes) {
+	const attrs = {};
+	for (const [name, value] of Object.entries(attributes)) attrs[localName(name)] = value;
+	if (localName(attrs.attributename?.trim() || "").startsWith("on")) return true;
+	return ANIMATION_VALUE_ATTRS.some((attr) => (attrs[attr] || "").split(";").some((value) => isUnsafeURI(value)));
+}
+function detach(node, parent) {
+	parent.children = parent.children.filter((child) => child !== node);
+}
+const sanitizeSVGPlugin = {
+	name: "ipx-sanitize",
+	fn: () => ({
+		doctype: { enter: (node, parentNode) => detach(node, parentNode) },
+		instruction: { enter: (node, parentNode) => detach(node, parentNode) },
+		element: { enter: (node, parentNode) => {
+			const name = localName(node.name);
+			if (UNSAFE_ELEMENTS.has(name)) {
+				detach(node, parentNode);
+				return;
+			}
+			if (ANIMATION_ELEMENTS.has(name) && isUnsafeAnimation(node.attributes)) {
+				detach(node, parentNode);
+				return;
+			}
+			for (const [attr, value] of Object.entries(node.attributes)) {
+				const attrName = localName(attr);
+				if (attrName.startsWith("on") || URI_ATTRS.has(attrName) && isUnsafeURI(value)) delete node.attributes[attr];
+			}
+		} }
+	})
+};
 function getEnv(name) {
 	const value = globalThis.process?.env?.[name];
-	if (value !== void 0) return JSON.parse(value);
+	if (value === void 0) return;
+	try {
+		return JSON.parse(value);
+	} catch {
+		return value;
+	}
+}
+function getBuiltinModule(id) {
+	return globalThis.process?.getBuiltinModule?.(id);
 }
 function requireModule(id) {
 	const { createRequire } = globalThis.process.getBuiltinModule("node:module");
@@ -341,6 +854,7 @@ function cachedPromise(function_) {
 		return p;
 	};
 }
+const DEFAULT_MAX_OUTPUT_DIMENSION = 8192;
 const SUPPORTED_FORMATS = /* @__PURE__ */ new Set([
 	"jpeg",
 	"png",
@@ -356,6 +870,7 @@ function createIPX(userOptions) {
 		...userOptions,
 		alias: userOptions.alias || getEnv("IPX_ALIAS") || {},
 		maxAge: userOptions.maxAge ?? getEnv("IPX_MAX_AGE") ?? 60,
+		maxOutputDimension: userOptions.maxOutputDimension ?? getEnv("IPX_MAX_OUTPUT_DIMENSION") ?? DEFAULT_MAX_OUTPUT_DIMENSION,
 		sharpOptions: {
 			jpegProgressive: true,
 			...userOptions.sharpOptions
@@ -421,25 +936,43 @@ function createIPX(userOptions) {
 				}
 				let mFormat = modifiers.f || modifiers.format;
 				if (mFormat === "jpg") mFormat = "jpeg";
-				const format = mFormat && SUPPORTED_FORMATS.has(mFormat) ? mFormat : SUPPORTED_FORMATS.has(imageMeta$1.type || "") ? imageMeta$1.type : "jpeg";
-				if (imageMeta$1.type === "svg" && !mFormat) if (options.svgo === false) return {
-					data: sourceData,
-					format: "svg+xml",
-					meta: imageMeta$1
-				};
-				else {
+				if (imageMeta$1.type === "svg" && (!mFormat || mFormat === "svg")) {
+					const sanitize = !options.svg?.unsafeSkipSanitize;
+					const shouldOptimize = options.svg?.optimize !== false;
+					const svgoConfig = options.svg?.optimize === false ? void 0 : options.svg?.optimize;
+					if (!sanitize && !shouldOptimize) return {
+						data: sourceData,
+						format: "svg+xml",
+						meta: imageMeta$1
+					};
+					const plugins = sanitize ? ["removeScripts", sanitizeSVGPlugin] : [];
+					if (svgoConfig?.plugins) plugins.push(...svgoConfig.plugins);
+					else if (shouldOptimize) plugins.push("preset-default");
 					const { optimize } = await getSVGO();
+					let svg;
+					try {
+						svg = optimize(sourceData.toString("utf8"), {
+							...svgoConfig,
+							plugins
+						}).data;
+					} catch (error) {
+						throw new HTTPError({
+							statusCode: 400,
+							statusText: `IPX_INVALID_SVG`,
+							message: `Cannot parse SVG: ${id}`,
+							cause: error
+						});
+					}
 					return {
-						data: optimize(sourceData.toString("utf8"), {
-							...options.svgo,
-							plugins: ["removeScripts", ...options.svgo?.plugins || []]
-						}).data,
+						data: svg,
 						format: "svg+xml",
 						meta: imageMeta$1
 					};
 				}
+				const format = mFormat && SUPPORTED_FORMATS.has(mFormat) ? mFormat : SUPPORTED_FORMATS.has(imageMeta$1.type || "") ? imageMeta$1.type : "jpeg";
 				const animated = modifiers.animated !== void 0 || modifiers.a !== void 0 || format === "gif";
-				let sharp = (await getSharp())(sourceData, {
+				const Sharp = await getSharp();
+				let sharp = Sharp(sourceData, {
 					animated,
 					...options.sharpOptions
 				});
@@ -449,15 +982,34 @@ function createIPX(userOptions) {
 					name,
 					args: arguments_
 				})).filter((h) => h.handler).sort((a, b) => {
-					const aKey = (a.handler.order || a.name || "").toString();
-					const bKey = (b.handler.order || b.name || "").toString();
-					return aKey.localeCompare(bKey);
+					const aOrder = a.handler.order || 0;
+					const bOrder = b.handler.order || 0;
+					return aOrder === bOrder ? (a.name || "").localeCompare(b.name || "") : aOrder - bOrder;
 				});
-				const handlerContext = { meta: imageMeta$1 };
+				const handlerContext = {
+					meta: imageMeta$1,
+					maxOutputDimension: options.maxOutputDimension
+				};
 				for (const h of handlers) sharp = applyHandler(handlerContext, sharp, h.handler, h.args.toString()) || sharp;
+				if (handlerContext.background) try {
+					Sharp({ create: {
+						width: 1,
+						height: 1,
+						channels: 4,
+						background: handlerContext.background
+					} });
+				} catch (error) {
+					throw asModifierError(error);
+				}
 				if (SUPPORTED_FORMATS.has(format || "")) sharp = sharp.toFormat(format, { quality: handlerContext.quality });
+				let processedImage;
+				try {
+					processedImage = await sharp.toBuffer();
+				} catch (error) {
+					throw asModifierError(error);
+				}
 				return {
-					data: await sharp.toBuffer(),
+					data: processedImage,
 					format,
 					meta: imageMeta$1
 				};
@@ -467,42 +1019,54 @@ function createIPX(userOptions) {
 }
 var import_etag = /* @__PURE__ */ __toESM(require_etag(), 1);
 var import_accept_negotiator = require_accept_negotiator();
-function createIPXFetchHandler(ipx) {
-	return createIPXHandler(ipx).fetch;
+function createIPXFetchHandler(ipx, opts) {
+	return createIPXHandler(ipx, opts).fetch;
 }
-function createIPXNodeHandler(ipx) {
+function createIPXNodeHandler(ipx, opts) {
 	const { toNodeHandler } = requireModule("srvx/node");
-	return toNodeHandler(createIPXFetchHandler(ipx));
+	return toNodeHandler(createIPXFetchHandler(ipx, opts));
 }
 function serveIPX(ipx, opts) {
 	const { serve } = requireModule("srvx");
-	const fetch = createIPXFetchHandler(ipx);
+	const { parseURL, ...serverOptions } = opts || {};
+	const fetch = createIPXFetchHandler(ipx, { parseURL });
 	return serve({
-		...opts,
+		...serverOptions,
 		fetch
 	});
 }
 const MODIFIER_SEP = /[&,]/g;
 const MODIFIER_VAL_SEP = /[:=_]/;
-function createIPXHandler(ipx) {
+function parseIPXURL(url) {
+	const [modifiersString = "", ...idSegments] = new URL(url).pathname.slice(1).split("/");
+	const id = decode$1(idSegments.join("/"));
+	if (!modifiersString) throw new HTTPError({
+		statusCode: 400,
+		statusText: "IPX_MISSING_MODIFIERS",
+		message: `Modifiers are missing: ${safeString(id)}`
+	});
+	const modifiers = Object.create(null);
+	if (modifiersString !== "_") for (const p of modifiersString.split(MODIFIER_SEP)) {
+		const [key = "", ...values] = p.split(MODIFIER_VAL_SEP);
+		modifiers[key] = values.map((v) => decode$1(v)).join("_");
+	}
+	return {
+		id,
+		modifiers
+	};
+}
+function createIPXHandler(ipx, opts = {}) {
+	const parseURL = opts.parseURL || parseIPXURL;
 	return defineEventHandler(async (event) => {
-		const [modifiersString = "", ...idSegments] = event.url.pathname.slice(1).split("/");
-		const id = safeString(decode(idSegments.join("/")));
-		if (!modifiersString) throw new HTTPError({
-			statusCode: 400,
-			statusText: "IPX_MISSING_MODIFIERS",
-			message: `Modifiers are missing: ${id}`
-		});
+		const parsed = await parseURL(event.req.url) || {};
+		const id = safeString(parsed.id);
 		if (!id || id === "/") throw new HTTPError({
 			statusCode: 400,
 			statusText: "IPX_MISSING_ID",
 			message: `Resource id is missing: ${event.path}`
 		});
 		const modifiers = Object.create(null);
-		if (modifiersString !== "_") for (const p of modifiersString.split(MODIFIER_SEP)) {
-			const [key, ...values] = p.split(MODIFIER_VAL_SEP);
-			modifiers[safeString(key)] = values.map((v) => safeString(decode(v))).join("_");
-		}
+		for (const [key, value] of Object.entries(parsed.modifiers || {})) modifiers[safeString(key)] = safeString(value);
 		if ((modifiers.f || modifiers.format) === "auto") {
 			const acceptHeader = event.req.headers.get("accept") || "";
 			const animated = modifiers.animated ?? modifiers.a;
@@ -517,6 +1081,9 @@ function createIPXHandler(ipx) {
 		const img = ipx(id, modifiers);
 		const sourceMeta = await img.getSourceMeta();
 		sendResponseHeaderIfNotSet(event, "content-security-policy", "default-src 'none'");
+		sendResponseHeaderIfNotSet(event, "x-content-type-options", "nosniff");
+		if (typeof sourceMeta.maxAge === "number") sendResponseHeaderIfNotSet(event, "cache-control", `max-age=${+sourceMeta.maxAge}, public, s-maxage=${+sourceMeta.maxAge}`);
+		const ifNoneMatch = event.req.headers.get("if-none-match");
 		if (sourceMeta.mtime) {
 			sendResponseHeaderIfNotSet(event, "last-modified", sourceMeta.mtime.toUTCString());
 			const _ifModifiedSince = event.req.headers.get("if-modified-since");
@@ -525,13 +1092,22 @@ function createIPXHandler(ipx) {
 				return;
 			}
 		}
+		const weakEtag = sourceMeta.mtime ? getWeakEtag(id, modifiers, sourceMeta.mtime) : void 0;
+		if (weakEtag) {
+			sendResponseHeaderIfNotSet(event, "etag", weakEtag);
+			if (etagMatches(ifNoneMatch, weakEtag)) {
+				event.res.status = 304;
+				return;
+			}
+		}
 		const { data, format } = await img.process();
-		if (typeof sourceMeta.maxAge === "number") sendResponseHeaderIfNotSet(event, "cache-control", `max-age=${+sourceMeta.maxAge}, public, s-maxage=${+sourceMeta.maxAge}`);
-		const etag = (0, import_etag.default)(data);
-		sendResponseHeaderIfNotSet(event, "etag", etag);
-		if (etag && event.req.headers.get("if-none-match") === etag) {
-			event.res.status = 304;
-			return;
+		if (!weakEtag) {
+			const etag = (0, import_etag.default)(data);
+			sendResponseHeaderIfNotSet(event, "etag", etag);
+			if (etagMatches(ifNoneMatch, etag)) {
+				event.res.status = 304;
+				return;
+			}
 		}
 		if (format) sendResponseHeaderIfNotSet(event, "content-type", `image/${format}`);
 		return data;
@@ -540,6 +1116,25 @@ function createIPXHandler(ipx) {
 function sendResponseHeaderIfNotSet(event, name, value) {
 	if (!event.res.headers.has(name)) event.res.headers.set(name, value);
 }
+function getWeakEtag(id, modifiers, mtime) {
+	const crypto = getBuiltinModule("node:crypto");
+	if (!crypto?.createHash) return;
+	const key = JSON.stringify([
+		mtime.getTime(),
+		id,
+		Object.keys(modifiers).sort().map((key) => [key, modifiers[key]])
+	]);
+	return `W/"${crypto.createHash("sha256").update(key).digest("base64url").slice(0, 27)}"`;
+}
+function etagMatches(ifNoneMatch, etag) {
+	if (!ifNoneMatch || !etag) return false;
+	if (ifNoneMatch === "*") return true;
+	const opaque = opaqueTag(etag);
+	return ifNoneMatch.split(",").some((tag) => opaqueTag(tag.trim()) === opaque);
+}
+function opaqueTag(tag) {
+	return tag.startsWith("W/") ? tag.slice(2) : tag;
+}
 function autoDetectFormat(acceptHeader, animated) {
 	if (animated) return (0, import_accept_negotiator.negotiate)(acceptHeader, ["image/webp", "image/gif"])?.split("/")[1] || "gif";
 	return (0, import_accept_negotiator.negotiate)(acceptHeader, [
@@ -552,33 +1147,225 @@ function autoDetectFormat(acceptHeader, animated) {
 		"image/gif"
 	])?.split("/")[1] || "jpeg";
 }
+function decode$1(input) {
+	try {
+		return decodeURIComponent(input);
+	} catch {
+		return input;
+	}
+}
 function safeString(input) {
-	return JSON.stringify(input).replace(/^"|"$/g, "").replace(/\\+/g, "\\").replace(/\\"/g, "\"");
+	return JSON.stringify(input ?? "").replace(/^"|"$/g, "").replace(/\\+/g, "\\").replace(/\\"/g, "\"");
 }
 const HTTP_RE = /^https?:\/\//;
+const REDIRECT_STATUS = /* @__PURE__ */ new Set([
+	301,
+	302,
+	303,
+	307,
+	308
+]);
+const MAX_REDIRECTS = 3;
+function parseIPv4(input) {
+	const parts = input.split(".");
+	if (parts.length !== 4) return;
+	const octets = [];
+	for (const part of parts) {
+		if (!/^\d{1,3}$/.test(part)) return;
+		const octet = Number(part);
+		if (octet > 255) return;
+		octets.push(octet);
+	}
+	return octets;
+}
+function parseIPv6(input) {
+	const zoneIndex = input.indexOf("%");
+	const halves = (zoneIndex === -1 ? input : input.slice(0, zoneIndex)).split("::");
+	if (halves.length > 2) return;
+	const expand = (part) => {
+		if (part === "") return [];
+		const bytes = [];
+		const groups = part.split(":");
+		for (const [index, group] of groups.entries()) {
+			if (group.includes(".")) {
+				if (index !== groups.length - 1) return;
+				const octets = parseIPv4(group);
+				if (!octets) return;
+				bytes.push(...octets);
+				continue;
+			}
+			if (!/^[\da-f]{1,4}$/i.test(group)) return;
+			const value = Number.parseInt(group, 16);
+			bytes.push(value >> 8, value & 255);
+		}
+		return bytes;
+	};
+	const head = expand(halves[0]);
+	const tail = halves.length === 2 ? expand(halves[1]) : [];
+	if (!head || !tail) return;
+	if (halves.length === 1) return head.length === 16 ? head : void 0;
+	const fill = 16 - head.length - tail.length;
+	if (fill < 0) return;
+	return [
+		...head,
+		...Array.from({ length: fill }, () => 0),
+		...tail
+	];
+}
+function embeddedIPv4(bytes) {
+	if (bytes.slice(0, 10).every((byte) => byte === 0) && (bytes[10] === 255 && bytes[11] === 255 || bytes[10] === 0 && bytes[11] === 0)) return bytes.slice(12);
+	if (bytes.slice(0, 8).every((byte) => byte === 0) && bytes[8] === 255 && bytes[9] === 255 && bytes[10] === 0 && bytes[11] === 0) return bytes.slice(12);
+	if (bytes[0] === 0 && bytes[1] === 100 && bytes[2] === 255 && bytes[3] === 155 && bytes.slice(4, 12).every((byte) => byte === 0)) return bytes.slice(12);
+	if (bytes[0] === 32 && bytes[1] === 2) return bytes.slice(2, 6);
+}
+function isPublicIPv4(octets) {
+	const [a, b, c] = octets;
+	return !(a === 0 || a === 10 || a === 127 || a === 100 && b >= 64 && b <= 127 || a === 169 && b === 254 || a === 172 && b >= 16 && b <= 31 || a === 192 && b === 0 && c === 0 || a === 192 && b === 0 && c === 2 || a === 192 && b === 88 && c === 99 || a === 192 && b === 168 || a === 198 && (b === 18 || b === 19) || a === 198 && b === 51 && c === 100 || a === 203 && b === 0 && c === 113 || a >= 224);
+}
+function isPublicIPv6(bytes) {
+	const embedded = embeddedIPv4(bytes);
+	if (embedded) return isPublicIPv4(embedded);
+	const [a, b] = bytes;
+	return !(a === 255 || a === 254 && (b & 192) === 128 || a === 254 && (b & 192) === 192 || (a & 254) === 252 || a === 0 && b === 100 && bytes[2] === 255 && bytes[3] === 155 || a === 1 && b === 0 && bytes.slice(2, 8).every((x) => x === 0) || a === 32 && b === 1 && bytes[2] === 13 && bytes[3] === 184 || a === 32 && b === 1 && bytes[2] === 0 && bytes[3] === 0);
+}
+function isPublicIP(address, family) {
+	if (family === 4) {
+		const octets = parseIPv4(address);
+		return octets ? isPublicIPv4(octets) : false;
+	}
+	if (family === 6) {
+		const bytes = parseIPv6(address);
+		return bytes ? isPublicIPv6(bytes) : false;
+	}
+	return false;
+}
+function decode(input) {
+	try {
+		return decodeURIComponent(input);
+	} catch {
+		return input;
+	}
+}
 function ipxHttpStorage(_options = {}) {
 	const allowAllDomains = _options.allowAllDomains ?? getEnv("IPX_HTTP_ALLOW_ALL_DOMAINS") ?? false;
 	let _domains = _options.domains || getEnv("IPX_HTTP_DOMAINS") || [];
 	const defaultMaxAge = _options.maxAge || getEnv("IPX_HTTP_MAX_AGE") || 300;
 	const fetchOptions = _options.fetchOptions || getEnv("IPX_HTTP_FETCH_OPTIONS") || {};
+	const blockPrivateIPs = _options.blockPrivateIPs ?? getEnv("IPX_HTTP_BLOCK_PRIVATE_IPS") ?? false;
 	if (typeof _domains === "string") _domains = _domains.split(",").map((s) => s.trim());
 	const domains = new Set(_domains.map((d) => {
 		if (!HTTP_RE.test(d)) d = "http://" + d;
 		return new URL(d).hostname;
 	}).filter(Boolean));
-	function validateId(id) {
-		const url = new URL(decodeURIComponent(id));
+	async function validateId(id) {
+		let url;
+		try {
+			url = new URL(decode(id));
+		} catch {
+			throw new HTTPError({
+				statusCode: 400,
+				statusText: `IPX_INVALID_URL`,
+				message: `Invalid URL: ${id}`
+			});
+		}
+		await validateURL(url, id);
+		return url.toString();
+	}
+	async function validateURL(url, id = url.toString()) {
 		if (!url.hostname) throw new HTTPError({
 			statusCode: 403,
 			statusText: `IPX_MISSING_HOSTNAME`,
 			message: `Hostname is missing: ${id}`
 		});
+		if (url.protocol !== "http:" && url.protocol !== "https:") throw new HTTPError({
+			statusCode: 403,
+			statusText: `IPX_FORBIDDEN_PROTOCOL`,
+			message: `Forbidden protocol: ${url.protocol}`
+		});
 		if (!allowAllDomains && !domains.has(url.hostname)) throw new HTTPError({
 			statusCode: 403,
 			statusText: `IPX_FORBIDDEN_HOST`,
 			message: `Forbidden host: ${url.hostname}`
 		});
-		return url.toString();
+		if (blockPrivateIPs) await validatePublicIP(url, id);
+	}
+	async function validatePublicIP(url, id) {
+		const hostname = url.hostname.replace(/^\[|]$/g, "");
+		const net = getBuiltinModule("node:net");
+		const dns = getBuiltinModule("node:dns");
+		if (!net?.isIP || !dns?.promises?.lookup) throw new HTTPError({
+			statusCode: 500,
+			statusText: `IPX_IP_CHECK_UNAVAILABLE`,
+			message: `Cannot verify the address of ${hostname}: \`blockPrivateIPs\` requires \`node:net\` and \`node:dns\`.`
+		});
+		const assertPublic = (address, family) => {
+			if (!isPublicIP(address, family)) throw new HTTPError({
+				statusCode: 403,
+				statusText: `IPX_FORBIDDEN_IP`,
+				message: `Forbidden IP address: ${address} (${id})`
+			});
+		};
+		const family = net.isIP(hostname);
+		if (family) {
+			assertPublic(hostname, family);
+			return;
+		}
+		let addresses;
+		try {
+			addresses = await dns.promises.lookup(hostname, {
+				all: true,
+				verbatim: true
+			});
+		} catch {
+			throw new HTTPError({
+				statusCode: 502,
+				statusText: `IPX_DNS_LOOKUP_FAILED`,
+				message: `Cannot resolve host: ${hostname}`
+			});
+		}
+		if (addresses.length === 0) throw new HTTPError({
+			statusCode: 502,
+			statusText: `IPX_DNS_LOOKUP_FAILED`,
+			message: `Cannot resolve host: ${hostname}`
+		});
+		for (const { address, family } of addresses) assertPublic(address, family || net.isIP(address));
+	}
+	async function fetchURL(url, init) {
+		const _init = {
+			...fetchOptions,
+			...init
+		};
+		if (allowAllDomains && !blockPrivateIPs || _init.redirect) return fetch(url, _init);
+		let currentURL = url;
+		let method = _init.method || "GET";
+		for (let i = 0; i <= MAX_REDIRECTS; i++) {
+			const response = await fetch(currentURL, {
+				..._init,
+				method,
+				redirect: "manual"
+			});
+			if (!REDIRECT_STATUS.has(response.status)) return response;
+			const location = response.headers.get("location");
+			if (!location) return response;
+			let nextURL;
+			try {
+				nextURL = new URL(location, currentURL);
+			} catch {
+				throw new HTTPError({
+					statusCode: 502,
+					statusText: `IPX_INVALID_REDIRECT`,
+					message: `Invalid redirect location: ${location}`
+				});
+			}
+			await validateURL(nextURL, location);
+			if (response.status === 303 && method !== "HEAD") method = "GET";
+			currentURL = nextURL.toString();
+		}
+		throw new HTTPError({
+			statusCode: 502,
+			statusText: `IPX_TOO_MANY_REDIRECTS`,
+			message: `Too many redirects (max ${MAX_REDIRECTS}): ${url}`
+		});
 	}
 	function parseResponse(response) {
 		let maxAge = defaultMaxAge;
@@ -600,12 +1387,9 @@ function ipxHttpStorage(_options = {}) {
 	return {
 		name: "ipx:http",
 		async getMeta(id) {
-			const url = validateId(id);
+			const url = await validateId(id);
 			try {
-				const response = await fetch(url, {
-					...fetchOptions,
-					method: "HEAD"
-				});
+				const response = await fetchURL(url, { method: "HEAD" });
 				if (!response.ok) return {};
 				const { maxAge, mtime } = parseResponse(response);
 				return {
@@ -617,8 +1401,7 @@ function ipxHttpStorage(_options = {}) {
 			}
 		},
 		async getData(id) {
-			const url = validateId(id);
-			const response = await fetch(url, fetchOptions);
+			const response = await fetchURL(await validateId(id));
 			if (!response.ok) throw new HTTPError({
 				statusCode: response.status,
 				statusText: response.statusText,
@@ -628,33 +1411,66 @@ function ipxHttpStorage(_options = {}) {
 		}
 	};
 }
+const { join, parse, resolve, relative, isAbsolute, sep } = /* #__PURE__ */ getBuiltinModule("node:path") || {};
+const NOT_IN_THIS_DIR = /* @__PURE__ */ new Set([
+	"ENOENT",
+	"ENOTDIR",
+	"ELOOP",
+	"ENAMETOOLONG"
+]);
 function ipxFSStorage(_options = {}) {
+	const fs = getBuiltinModule("node:fs/promises");
+	if (!fs) throw new Error("ipxFSStorage requires the `node:fs/promises` builtin, which this runtime does not provide");
 	const dirs = resolveDirs(_options.dir);
-	const maxAge = _options.maxAge || getEnv("IPX_FS_MAX_AGE");
-	const fs = globalThis.process.getBuiltinModule("node:fs/promises");
+	const maxAge = _options.maxAge ?? getEnv("IPX_FS_MAX_AGE");
+	const allowSymlinksOutsideDir = _options.allowSymlinksOutsideDir ?? getEnv("IPX_FS_ALLOW_SYMLINKS_OUTSIDE_DIR") ?? false;
+	const realDirCache = [];
+	const getRealDir = (index, dir) => {
+		let realDir = realDirCache[index];
+		if (!realDir) {
+			realDir = fs.realpath(dir).catch(() => dir);
+			realDirCache[index] = realDir;
+		}
+		return realDir;
+	};
 	const resolveFile = async (id) => {
-		for (const dir of dirs) {
+		for (const [index, dir] of dirs.entries()) {
 			const filePath = join(dir, id);
-			if (!isValidPath(filePath) || !filePath.startsWith(dir + "/")) throw new HTTPError({
+			if (!isValidPath(filePath) || !isInsideDir(filePath, dir)) throw new HTTPError({
 				statusCode: 403,
 				statusText: `IPX_FORBIDDEN_PATH`,
 				message: `Forbidden path: ${id}`
 			});
+			let stats;
+			let realPath;
 			try {
-				const stats = await fs.stat(filePath);
-				if (!stats.isFile()) continue;
-				return {
-					stats,
-					read: () => fs.readFile(filePath)
-				};
+				stats = await fs.stat(filePath);
+				if (stats.isFile() && !allowSymlinksOutsideDir) realPath = await fs.realpath(filePath);
 			} catch (error) {
-				if (error.code === "ENOENT") continue;
+				if (NOT_IN_THIS_DIR.has(error.code)) continue;
 				throw new HTTPError({
 					statusCode: 403,
 					statusText: `IPX_FORBIDDEN_FILE`,
 					message: `Cannot access file: ${id}`
 				});
 			}
+			if (!stats.isFile()) continue;
+			if (realPath !== void 0) {
+				let realDir = await getRealDir(index, dir);
+				if (!isInsideDir(realPath, realDir)) {
+					realDirCache[index] = void 0;
+					realDir = await getRealDir(index, dir);
+				}
+				if (!isInsideDir(realPath, realDir)) throw new HTTPError({
+					statusCode: 403,
+					statusText: `IPX_FORBIDDEN_SYMLINK`,
+					message: `Forbidden symlink: ${id}`
+				});
+			}
+			return {
+				stats,
+				read: () => fs.readFile(realPath ?? filePath)
+			};
 		}
 		throw new HTTPError({
 			statusCode: 404,
@@ -677,14 +1493,22 @@ function ipxFSStorage(_options = {}) {
 		}
 	};
 }
-const isWindows = process.platform === "win32";
+const isWindows = globalThis.process?.platform === "win32";
 function isValidPath(fp) {
 	if (isWindows) fp = fp.slice(parse(fp).root.length);
 	if (/["*:<>?|]/.test(fp)) return false;
 	return true;
 }
+function isInsideDir(filePath, dir) {
+	if (isWindows) {
+		filePath = filePath.toLowerCase();
+		dir = dir.toLowerCase();
+	}
+	const rel = relative(dir, filePath);
+	return rel !== "" && rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel);
+}
 function resolveDirs(dirs) {
 	if (!dirs || !Array.isArray(dirs)) return [resolve(dirs || getEnv("IPX_FS_DIR") || ".")];
 	return dirs.map((dirs) => resolve(dirs));
 }
-export { createIPX, createIPXFetchHandler, createIPXNodeHandler, ipxFSStorage, ipxHttpStorage, serveIPX };
+export { createIPX, createIPXFetchHandler, createIPXNodeHandler, ipxFSStorage, ipxHttpStorage, parseIPXURL, serveIPX };