@weasel-js/core 1.7.0 → 1.7.1

package/dist/features/meshPaint/lazyKind.js

@@ -0,0 +1,1298 @@
+//#region ../paint/dist/index.js
+var SRGB_TO_LINEAR = (() => {
+	const lut = /* @__PURE__ */ new Float64Array(256);
+	for (let i = 0; i < 256; i++) {
+		const c = i / 255;
+		lut[i] = c <= .04045 ? c / 12.92 : Math.pow((c + .055) / 1.055, 2.4);
+	}
+	return lut;
+})();
+function linearToSrgbByte(c) {
+	if (c <= 0) return 0;
+	if (c >= 1) return 255;
+	const v = c <= .0031308 ? c * 12.92 : 1.055 * Math.pow(c, 1 / 2.4) - .055;
+	return Math.round(v * 255);
+}
+var f2u = (v) => Math.max(0, Math.min(255, Math.round(v * 255)));
+function srgbFloatToOklab(r, g, b) {
+	return srgbU8ToOklab(f2u(r), f2u(g), f2u(b));
+}
+function srgbU8ToOklab(r, g, b) {
+	return linearSrgbToOklab(SRGB_TO_LINEAR[r & 255], SRGB_TO_LINEAR[g & 255], SRGB_TO_LINEAR[b & 255]);
+}
+function linearSrgbToOklab(rl, gl, bl) {
+	const l = .4122214708 * rl + .5363325363 * gl + .0514459929 * bl;
+	const m = .2119034982 * rl + .6806995451 * gl + .1073969566 * bl;
+	const s = .0883024619 * rl + .2817188376 * gl + .6299787005 * bl;
+	const lp = Math.cbrt(l);
+	const mp = Math.cbrt(m);
+	const sp = Math.cbrt(s);
+	return [
+		.2104542553 * lp + .793617785 * mp - .0040720468 * sp,
+		1.9779984951 * lp - 2.428592205 * mp + .4505937099 * sp,
+		.0259040371 * lp + .7827717662 * mp - .808675766 * sp
+	];
+}
+function oklabToLinearSrgb(L, A, B) {
+	const lp = L + .3963377774 * A + .2158037573 * B;
+	const mp = L - .1055613458 * A - .0638541728 * B;
+	const sp = L - .0894841775 * A - 1.291485548 * B;
+	const l = lp * lp * lp;
+	const m = mp * mp * mp;
+	const s = sp * sp * sp;
+	return [
+		4.0767416621 * l - 3.3077115913 * m + .2309699292 * s,
+		-1.2684380046 * l + 2.6097574011 * m - .3413193965 * s,
+		-.0041960863 * l - .7034186147 * m + 1.707614701 * s
+	];
+}
+function inGamut(rl, gl, bl) {
+	return rl >= -1e-6 && rl <= 1.000001 && gl >= -1e-6 && gl <= 1.000001 && bl >= -1e-6 && bl <= 1.000001;
+}
+function clipToGamut(L, A, B) {
+	let [rl, gl, bl] = oklabToLinearSrgb(L, A, B);
+	if (inGamut(rl, gl, bl)) return [
+		rl,
+		gl,
+		bl
+	];
+	let lo = 0;
+	let hi = 1;
+	for (let i = 0; i < 5; i++) {
+		const t = (lo + hi) / 2;
+		[rl, gl, bl] = oklabToLinearSrgb(L, A * t, B * t);
+		if (inGamut(rl, gl, bl)) lo = t;
+		else hi = t;
+	}
+	[rl, gl, bl] = oklabToLinearSrgb(L, A * lo, B * lo);
+	return [
+		rl,
+		gl,
+		bl
+	];
+}
+function oklabToSrgbU8(L, A, B) {
+	const [rl, gl, bl] = clipToGamut(L, A, B);
+	return [
+		linearToSrgbByte(rl),
+		linearToSrgbByte(gl),
+		linearToSrgbByte(bl)
+	];
+}
+function lerpOklab(from, to, t) {
+	return [
+		from[0] + (to[0] - from[0]) * t,
+		from[1] + (to[1] - from[1]) * t,
+		from[2] + (to[2] - from[2]) * t
+	];
+}
+function oklabToOklch(L, A, B) {
+	return [
+		L,
+		Math.hypot(A, B),
+		Math.atan2(B, A)
+	];
+}
+function oklchToOklab(L, C, h) {
+	return [
+		L,
+		C * Math.cos(h),
+		C * Math.sin(h)
+	];
+}
+function lerpOklch(from, to, t) {
+	const [L1, C1, h1Raw] = from;
+	const [L2, C2, h2Raw] = to;
+	const C_EPS = 1e-4;
+	const h1 = C1 < C_EPS ? h2Raw : h1Raw;
+	const h2 = C2 < C_EPS ? h1Raw : h2Raw;
+	const TWO_PI = Math.PI * 2;
+	let dh = h2 - h1;
+	while (dh > Math.PI) dh -= TWO_PI;
+	while (dh < -Math.PI) dh += TWO_PI;
+	return [
+		L1 + (L2 - L1) * t,
+		C1 + (C2 - C1) * t,
+		h1 + dh * t
+	];
+}
+var u2f = (v) => v / 255;
+function lerpColorArray(from, to, t, space = "rgb") {
+	if (from.length !== to.length) throw new Error(`lerpColorArray: length mismatch (from=${from.length}, to=${to.length})`);
+	if (from.length % 4 !== 0) throw new Error(`lerpColorArray: length ${from.length} not divisible by 4`);
+	const out = new Array(from.length);
+	const n = from.length / 4;
+	if (space === "rgb") {
+		for (let i = 0; i < from.length; i++) out[i] = from[i] + (to[i] - from[i]) * t;
+		return out;
+	}
+	if (space === "oklch") {
+		for (let i = 0; i < n; i++) {
+			const k = i * 4;
+			const fLab = srgbU8ToOklab(f2u(from[k]), f2u(from[k + 1]), f2u(from[k + 2]));
+			const tLab = srgbU8ToOklab(f2u(to[k]), f2u(to[k + 1]), f2u(to[k + 2]));
+			const midLch = lerpOklch(oklabToOklch(fLab[0], fLab[1], fLab[2]), oklabToOklch(tLab[0], tLab[1], tLab[2]), t);
+			const midLab = oklchToOklab(midLch[0], midLch[1], midLch[2]);
+			const [r, g, b] = oklabToSrgbU8(midLab[0], midLab[1], midLab[2]);
+			out[k] = u2f(r);
+			out[k + 1] = u2f(g);
+			out[k + 2] = u2f(b);
+			out[k + 3] = from[k + 3] + (to[k + 3] - from[k + 3]) * t;
+		}
+		return out;
+	}
+	for (let i = 0; i < n; i++) {
+		const k = i * 4;
+		const mid = lerpOklab(srgbU8ToOklab(f2u(from[k]), f2u(from[k + 1]), f2u(from[k + 2])), srgbU8ToOklab(f2u(to[k]), f2u(to[k + 1]), f2u(to[k + 2])), t);
+		const [r, g, b] = oklabToSrgbU8(mid[0], mid[1], mid[2]);
+		out[k] = u2f(r);
+		out[k + 1] = u2f(g);
+		out[k + 2] = u2f(b);
+		out[k + 3] = from[k + 3] + (to[k + 3] - from[k + 3]) * t;
+	}
+	return out;
+}
+function hslToSrgb(h, s, l) {
+	if (s === 0) return [
+		l,
+		l,
+		l
+	];
+	const q = l < .5 ? l * (1 + s) : l + s - l * s;
+	const p = 2 * l - q;
+	const hk = h / 360;
+	return [
+		hueToChannel(p, q, hk + 1 / 3),
+		hueToChannel(p, q, hk),
+		hueToChannel(p, q, hk - 1 / 3)
+	];
+}
+function hueToChannel(p, q, t) {
+	if (t < 0) t += 1;
+	if (t > 1) t -= 1;
+	if (t < 1 / 6) return p + (q - p) * 6 * t;
+	if (t < 1 / 2) return q;
+	if (t < 2 / 3) return p + (q - p) * (2 / 3 - t) * 6;
+	return p;
+}
+//#endregion
+//#region src/renderer/math/color.ts
+/**
+* Parse a CSS color string into [r, g, b, a] with 0..1 components.
+*
+* Supported forms:
+*   - Hex: `#rgb`, `#rgba`, `#rrggbb`, `#rrggbbaa` (any case)
+*   - `rgb()` / `rgba()` with integer, float, or percent R/G/B; number or
+*     percent alpha; commas or modern space-separated `R G B / A` syntax
+*   - `hsl()` / `hsla()` with hue as a unitless number (deg) or with `deg`,
+*     `rad`, `grad`, `turn` units; saturation/lightness as percent (or
+*     unitless in the modern syntax); same alpha rules and separator rules
+*     as `rgb()`
+*   - The 148 CSS named colors plus `transparent`
+*
+* Not supported: `oklch()`, `lab()`, `color()`, `currentColor`, system
+* colors. Throws on anything unrecognized.
+*
+* Results are cached by input-string identity. Callers MUST treat the
+* returned tuple as read-only — mutation would corrupt the cache.
+*/
+function parseColor(input) {
+	const cached = CACHE.get(input);
+	if (cached !== void 0) return cached;
+	const result = parseColorUncached(input);
+	if (CACHE.size >= CACHE_MAX) CACHE.clear();
+	CACHE.set(input, result);
+	return result;
+}
+const CACHE = /* @__PURE__ */ new Map();
+const CACHE_MAX = 1024;
+function parseColorUncached(input) {
+	const s = input.trim();
+	if (s.startsWith("#")) return parseHex(s);
+	const lower = s.toLowerCase();
+	const named = NAMED_COLORS[lower];
+	if (named !== void 0) return named;
+	if (lower.startsWith("rgb")) {
+		const parsed = parseRgbFunction(lower);
+		if (parsed) return parsed;
+	}
+	if (lower.startsWith("hsl")) {
+		const parsed = parseHslFunction(lower);
+		if (parsed) return parsed;
+	}
+	throw new Error(`parseColor: unrecognized color "${input}"`);
+}
+const RESOLVE_COLOR_CACHE_CAP = 1024;
+const resolveColorCache = /* @__PURE__ */ new Map();
+/** Cached `parseColor`. Use this from renderer hot paths (per-frame draw
+*  callbacks, gradient ramp builds) so repeated color strings — which are
+*  common when many objects share a fill — don't re-tokenize each frame.
+*
+*  Cache is keyed by input-string identity, capped at ~1024 entries, and
+*  cleared wholesale on overflow (no LRU tracking — simple is fine since
+*  the working set in any one app is typically much smaller than the cap). */
+function resolveColor(input) {
+	const hit = resolveColorCache.get(input);
+	if (hit) return hit;
+	if (resolveColorCache.size >= RESOLVE_COLOR_CACHE_CAP) resolveColorCache.clear();
+	const frozen = parseColor(input);
+	resolveColorCache.set(input, frozen);
+	return frozen;
+}
+/**
+* Format [r, g, b, a] (0..1 components) as a hex string. Emits `#rrggbb` when
+* alpha is exactly 1 (or omitted), otherwise `#rrggbbaa`.
+*/
+function rgbaToHex(rgba) {
+	const [r, g, b] = rgba;
+	const a = rgba.length === 4 ? rgba[3] : 1;
+	const f = (n) => Math.max(0, Math.min(255, Math.round(n * 255))).toString(16).padStart(2, "0");
+	const base = `#${f(r)}${f(g)}${f(b)}`;
+	return a >= 1 ? base : `${base}${f(a)}`;
+}
+function parseHex(s) {
+	const hex = s.slice(1);
+	if (hex.length === 3) return [
+		parseInt(hex[0] + hex[0], 16) / 255,
+		parseInt(hex[1] + hex[1], 16) / 255,
+		parseInt(hex[2] + hex[2], 16) / 255,
+		1
+	];
+	if (hex.length === 4) return [
+		parseInt(hex[0] + hex[0], 16) / 255,
+		parseInt(hex[1] + hex[1], 16) / 255,
+		parseInt(hex[2] + hex[2], 16) / 255,
+		parseInt(hex[3] + hex[3], 16) / 255
+	];
+	if (hex.length === 6) return [
+		parseInt(hex.slice(0, 2), 16) / 255,
+		parseInt(hex.slice(2, 4), 16) / 255,
+		parseInt(hex.slice(4, 6), 16) / 255,
+		1
+	];
+	if (hex.length === 8) return [
+		parseInt(hex.slice(0, 2), 16) / 255,
+		parseInt(hex.slice(2, 4), 16) / 255,
+		parseInt(hex.slice(4, 6), 16) / 255,
+		parseInt(hex.slice(6, 8), 16) / 255
+	];
+	throw new Error(`parseColor: invalid hex "${s}"`);
+}
+/** Match `name( body )` and return the trimmed body, or null. */
+function unwrapFn(s, name) {
+	if (!s.startsWith(name + "(") || !s.endsWith(")")) return null;
+	return s.slice(name.length + 1, -1).trim();
+}
+/**
+* Split a function body into the value tokens (3 channels + optional alpha).
+* Supports both legacy `r, g, b[, a]` and modern `r g b[ / a]` separators.
+* Returns null if the token count is wrong.
+*/
+function splitChannels(body) {
+	if (body.includes(",")) {
+		const parts = body.split(",").map((p) => p.trim());
+		if (parts.length !== 3 && parts.length !== 4) return null;
+		return {
+			rgb: [
+				parts[0],
+				parts[1],
+				parts[2]
+			],
+			alpha: parts.length === 4 ? parts[3] : null
+		};
+	}
+	const slash = body.indexOf("/");
+	const head = (slash === -1 ? body : body.slice(0, slash)).trim();
+	const alpha = slash === -1 ? null : body.slice(slash + 1).trim();
+	const parts = head.split(/\s+/);
+	if (parts.length !== 3) return null;
+	if (alpha !== null && alpha === "") return null;
+	return {
+		rgb: [
+			parts[0],
+			parts[1],
+			parts[2]
+		],
+		alpha
+	};
+}
+/** Parse a channel value: integer, float, or percent. Returns 0..1 (with `max` as the integer scale). */
+function parseChannel(tok, max) {
+	if (tok.endsWith("%")) {
+		const n = Number(tok.slice(0, -1));
+		if (!Number.isFinite(n)) return null;
+		return clamp01(n / 100);
+	}
+	const n = Number(tok);
+	if (!Number.isFinite(n)) return null;
+	return clamp01(n / max);
+}
+/** Alpha may be a number 0..1 or a percent. */
+function parseAlpha(tok) {
+	if (tok === null) return 1;
+	if (tok.endsWith("%")) {
+		const n = Number(tok.slice(0, -1));
+		return Number.isFinite(n) ? clamp01(n / 100) : 1;
+	}
+	const n = Number(tok);
+	return Number.isFinite(n) ? clamp01(n) : 1;
+}
+function parseRgbFunction(s) {
+	const body = unwrapFn(s, "rgba") ?? unwrapFn(s, "rgb");
+	if (body === null) return null;
+	const channels = splitChannels(body);
+	if (!channels) return null;
+	const r = parseChannel(channels.rgb[0], 255);
+	const g = parseChannel(channels.rgb[1], 255);
+	const b = parseChannel(channels.rgb[2], 255);
+	if (r === null || g === null || b === null) return null;
+	return [
+		r,
+		g,
+		b,
+		parseAlpha(channels.alpha)
+	];
+}
+function parseHslFunction(s) {
+	const body = unwrapFn(s, "hsla") ?? unwrapFn(s, "hsl");
+	if (body === null) return null;
+	const channels = splitChannels(body);
+	if (!channels) return null;
+	const h = parseHue(channels.rgb[0]);
+	const sat = parsePercentOrNumber(channels.rgb[1]);
+	const lit = parsePercentOrNumber(channels.rgb[2]);
+	if (h === null || sat === null || lit === null) return null;
+	const [r, g, b] = hslToRgb(h, sat, lit);
+	return [
+		r,
+		g,
+		b,
+		parseAlpha(channels.alpha)
+	];
+}
+/** Parse a hue token: `<number>`, `<number>deg`, `<number>rad`, `<number>grad`, `<number>turn`. Returns degrees 0..360 (modulo). */
+function parseHue(tok) {
+	let n;
+	if (tok.endsWith("deg")) n = Number(tok.slice(0, -3));
+	else if (tok.endsWith("grad")) n = Number(tok.slice(0, -4)) * .9;
+	else if (tok.endsWith("rad")) n = Number(tok.slice(0, -3)) * (180 / Math.PI);
+	else if (tok.endsWith("turn")) n = Number(tok.slice(0, -4)) * 360;
+	else n = Number(tok);
+	if (!Number.isFinite(n)) return null;
+	return (n % 360 + 360) % 360;
+}
+/** Saturation/lightness may be percent (CSS Color 3) or unitless number 0..1 (modern). */
+function parsePercentOrNumber(tok) {
+	if (tok.endsWith("%")) {
+		const n = Number(tok.slice(0, -1));
+		return Number.isFinite(n) ? clamp01(n / 100) : null;
+	}
+	const n = Number(tok);
+	return Number.isFinite(n) ? clamp01(n) : null;
+}
+/**
+* HSL → RGB, all components 0..1 except hue in degrees (0..360). paint's
+* `hslToSrgb` under the name this file's callers use.
+*
+* @internal Not part of the public API; not re-exported from the barrel.
+*/
+const hslToRgb = hslToSrgb;
+function clamp01(n) {
+	return n < 0 ? 0 : n > 1 ? 1 : n;
+}
+const NAMED_COLORS = (() => {
+	const hex = {
+		aliceblue: 15792383,
+		antiquewhite: 16444375,
+		aqua: 65535,
+		aquamarine: 8388564,
+		azure: 15794175,
+		beige: 16119260,
+		bisque: 16770244,
+		black: 0,
+		blanchedalmond: 16772045,
+		blue: 255,
+		blueviolet: 9055202,
+		brown: 10824234,
+		burlywood: 14596231,
+		cadetblue: 6266528,
+		chartreuse: 8388352,
+		chocolate: 13789470,
+		coral: 16744272,
+		cornflowerblue: 6591981,
+		cornsilk: 16775388,
+		crimson: 14423100,
+		cyan: 65535,
+		darkblue: 139,
+		darkcyan: 35723,
+		darkgoldenrod: 12092939,
+		darkgray: 11119017,
+		darkgreen: 25600,
+		darkgrey: 11119017,
+		darkkhaki: 12433259,
+		darkmagenta: 9109643,
+		darkolivegreen: 5597999,
+		darkorange: 16747520,
+		darkorchid: 10040012,
+		darkred: 9109504,
+		darksalmon: 15308410,
+		darkseagreen: 9419919,
+		darkslateblue: 4734347,
+		darkslategray: 3100495,
+		darkslategrey: 3100495,
+		darkturquoise: 52945,
+		darkviolet: 9699539,
+		deeppink: 16716947,
+		deepskyblue: 49151,
+		dimgray: 6908265,
+		dimgrey: 6908265,
+		dodgerblue: 2003199,
+		firebrick: 11674146,
+		floralwhite: 16775920,
+		forestgreen: 2263842,
+		fuchsia: 16711935,
+		gainsboro: 14474460,
+		ghostwhite: 16316671,
+		gold: 16766720,
+		goldenrod: 14329120,
+		gray: 8421504,
+		green: 32768,
+		greenyellow: 11403055,
+		grey: 8421504,
+		honeydew: 15794160,
+		hotpink: 16738740,
+		indianred: 13458524,
+		indigo: 4915330,
+		ivory: 16777200,
+		khaki: 15787660,
+		lavender: 15132410,
+		lavenderblush: 16773365,
+		lawngreen: 8190976,
+		lemonchiffon: 16775885,
+		lightblue: 11393254,
+		lightcoral: 15761536,
+		lightcyan: 14745599,
+		lightgoldenrodyellow: 16448210,
+		lightgray: 13882323,
+		lightgreen: 9498256,
+		lightgrey: 13882323,
+		lightpink: 16758465,
+		lightsalmon: 16752762,
+		lightseagreen: 2142890,
+		lightskyblue: 8900346,
+		lightslategray: 7833753,
+		lightslategrey: 7833753,
+		lightsteelblue: 11584734,
+		lightyellow: 16777184,
+		lime: 65280,
+		limegreen: 3329330,
+		linen: 16445670,
+		magenta: 16711935,
+		maroon: 8388608,
+		mediumaquamarine: 6737322,
+		mediumblue: 205,
+		mediumorchid: 12211667,
+		mediumpurple: 9662683,
+		mediumseagreen: 3978097,
+		mediumslateblue: 8087790,
+		mediumspringgreen: 64154,
+		mediumturquoise: 4772300,
+		mediumvioletred: 13047173,
+		midnightblue: 1644912,
+		mintcream: 16121850,
+		mistyrose: 16770273,
+		moccasin: 16770229,
+		navajowhite: 16768685,
+		navy: 128,
+		oldlace: 16643558,
+		olive: 8421376,
+		olivedrab: 7048739,
+		orange: 16753920,
+		orangered: 16729344,
+		orchid: 14315734,
+		palegoldenrod: 15657130,
+		palegreen: 10025880,
+		paleturquoise: 11529966,
+		palevioletred: 14381203,
+		papayawhip: 16773077,
+		peachpuff: 16767673,
+		peru: 13468991,
+		pink: 16761035,
+		plum: 14524637,
+		powderblue: 11591910,
+		purple: 8388736,
+		rebeccapurple: 6697881,
+		red: 16711680,
+		rosybrown: 12357519,
+		royalblue: 4286945,
+		saddlebrown: 9127187,
+		salmon: 16416882,
+		sandybrown: 16032864,
+		seagreen: 3050327,
+		seashell: 16774638,
+		sienna: 10506797,
+		silver: 12632256,
+		skyblue: 8900331,
+		slateblue: 6970061,
+		slategray: 7372944,
+		slategrey: 7372944,
+		snow: 16775930,
+		springgreen: 65407,
+		steelblue: 4620980,
+		tan: 13808780,
+		teal: 32896,
+		thistle: 14204888,
+		tomato: 16737095,
+		turquoise: 4251856,
+		violet: 15631086,
+		wheat: 16113331,
+		white: 16777215,
+		whitesmoke: 16119285,
+		yellow: 16776960,
+		yellowgreen: 10145074
+	};
+	const out = { transparent: [
+		0,
+		0,
+		0,
+		0
+	] };
+	for (const name in hex) {
+		const n = hex[name];
+		out[name] = [
+			(n >> 16 & 255) / 255,
+			(n >> 8 & 255) / 255,
+			(n & 255) / 255,
+			1
+		];
+	}
+	return out;
+})();
+//#endregion
+//#region src/features/meshPaint/surface.ts
+/** Corner `i` of the boundary walk. */
+function patchCorner(patch, i) {
+	return patch.points[(i & 3) * 3];
+}
+/** `true` when the patch carries the four interior points a tensor patch adds. */
+function isTensorPatch(patch) {
+	return patch.points.length >= 16;
+}
+/** A patch is twelve boundary points, or sixteen with the interior. Anything
+*  else cannot be evaluated, and saying so here beats painting nonsense. */
+function isValidPatch(patch) {
+	return patch.points.length === 12 || patch.points.length === 16;
+}
+function bezier(p0, p1, p2, p3, t) {
+	const s = 1 - t;
+	const a = s * s * s;
+	const b = 3 * s * s * t;
+	const c = 3 * s * t * t;
+	const d = t * t * t;
+	return {
+		x: a * p0.x + b * p1.x + c * p2.x + d * p3.x,
+		y: a * p0.y + b * p1.y + c * p2.y + d * p3.y
+	};
+}
+/** The edge leaving corner `i`, as its four control points. */
+function edge(patch, i) {
+	const p = patch.points;
+	const a = (i & 3) * 3;
+	return [
+		p[a],
+		p[a + 1],
+		p[a + 2],
+		p[(i + 1 & 3) * 3]
+	];
+}
+/**
+* The patch surface at `(u, v)`, both in `0..1`.
+*
+* `u` runs along the edge leaving corner 0 and `v` along the edge leaving
+* corner 1, so `(0,0)` is corner 0, `(1,0)` corner 1, `(1,1)` corner 2 and
+* `(0,1)` corner 3 — the same walk `colors` is in.
+*/
+function evalPatch(patch, u, v) {
+	return isTensorPatch(patch) ? evalTensor(patch, u, v) : evalCoons(patch, u, v);
+}
+function evalCoons(patch, u, v) {
+	const [b0, b1, b2, b3] = edge(patch, 0);
+	const [r0, r1, r2, r3] = edge(patch, 1);
+	const [t0, t1, t2, t3] = edge(patch, 2);
+	const [l0, l1, l2, l3] = edge(patch, 3);
+	const bottom = bezier(b0, b1, b2, b3, u);
+	const top = bezier(t0, t1, t2, t3, 1 - u);
+	const right = bezier(r0, r1, r2, r3, v);
+	const left = bezier(l0, l1, l2, l3, 1 - v);
+	const c0 = patchCorner(patch, 0);
+	const c1 = patchCorner(patch, 1);
+	const c2 = patchCorner(patch, 2);
+	const c3 = patchCorner(patch, 3);
+	const ruledU = (a, b) => (1 - v) * a + v * b;
+	const ruledV = (a, b) => (1 - u) * a + u * b;
+	const corner = (k0, k1, k2, k3) => (1 - u) * (1 - v) * k0 + u * (1 - v) * k1 + u * v * k2 + (1 - u) * v * k3;
+	return {
+		x: ruledU(bottom.x, top.x) + ruledV(left.x, right.x) - corner(c0.x, c1.x, c2.x, c3.x),
+		y: ruledU(bottom.y, top.y) + ruledV(left.y, right.y) - corner(c0.y, c1.y, c2.y, c3.y)
+	};
+}
+/** The bicubic control net a tensor patch's sixteen points make, as
+*  `net[i][j]` with `i` along `u` and `j` along `v`. */
+function tensorNet(patch) {
+	const p = patch.points;
+	return [
+		[
+			p[0],
+			p[11],
+			p[10],
+			p[9]
+		],
+		[
+			p[1],
+			p[12],
+			p[13],
+			p[8]
+		],
+		[
+			p[2],
+			p[15],
+			p[14],
+			p[7]
+		],
+		[
+			p[3],
+			p[4],
+			p[5],
+			p[6]
+		]
+	];
+}
+const BERNSTEIN = (t) => {
+	const s = 1 - t;
+	return [
+		s * s * s,
+		3 * s * s * t,
+		3 * s * t * t,
+		t * t * t
+	];
+};
+function evalTensor(patch, u, v) {
+	const net = tensorNet(patch);
+	const bu = BERNSTEIN(u);
+	const bv = BERNSTEIN(v);
+	let x = 0;
+	let y = 0;
+	for (let i = 0; i < 4; i++) for (let j = 0; j < 4; j++) {
+		const w = bu[i] * bv[j];
+		x += w * net[i][j].x;
+		y += w * net[i][j].y;
+	}
+	return {
+		x,
+		y
+	};
+}
+/** Axis-aligned bounds of a patch, sampled on a grid. Control points alone
+*  bound a Bézier but not tightly, and a mesh paint is baked into a texture
+*  sized from this — a loose box wastes texels on every side. */
+function patchBounds(patch, steps = 8) {
+	let minX = Infinity;
+	let minY = Infinity;
+	let maxX = -Infinity;
+	let maxY = -Infinity;
+	for (let i = 0; i <= steps; i++) for (let j = 0; j <= steps; j++) {
+		const p = evalPatch(patch, i / steps, j / steps);
+		if (p.x < minX) minX = p.x;
+		if (p.y < minY) minY = p.y;
+		if (p.x > maxX) maxX = p.x;
+		if (p.y > maxY) maxY = p.y;
+	}
+	return {
+		x: minX,
+		y: minY,
+		width: maxX - minX,
+		height: maxY - minY
+	};
+}
+/** Texels a rasterized cell spans at most. The rasterizer interpolates color
+*  linearly inside a cell and draws a curved edge as its chord, so this is
+*  what keeps a perceptual blend perceptual and an edge curved at any size. */
+const TEXELS_PER_CELL = 10;
+/** Quads per patch on a side, never fewer than 24. */
+function gridFor(size) {
+	return Math.max(24, Math.ceil(size / TEXELS_PER_CELL));
+}
+/** The union of every patch's bounds, or `null` when nothing is drawable. */
+function meshBounds(patches) {
+	let minX = Infinity;
+	let minY = Infinity;
+	let maxX = -Infinity;
+	let maxY = -Infinity;
+	for (const patch of patches) {
+		if (!isValidPatch(patch)) continue;
+		const b = patchBounds(patch);
+		minX = Math.min(minX, b.x);
+		minY = Math.min(minY, b.y);
+		maxX = Math.max(maxX, b.x + b.width);
+		maxY = Math.max(maxY, b.y + b.height);
+	}
+	if (!Number.isFinite(minX) || maxX <= minX || maxY <= minY) return null;
+	return {
+		x: minX,
+		y: minY,
+		width: maxX - minX,
+		height: maxY - minY
+	};
+}
+/**
+* Corner colors blended at `(u, v)` in `space`.
+*
+* Bilinear as three lerps rather than four weights, because a perceptual space
+* has a midpoint between two colors and no meaningful four-way mix — OKLCh's
+* hue in particular is an arc, which only two endpoints define.
+*/
+function colorAt(corners, u, v, space) {
+	return lerpColorArray(lerpColorArray(corners[0], corners[1], u, space), lerpColorArray(corners[3], corners[2], u, space), v, space);
+}
+/**
+* Rasterize `patches` into a square bitmap covering their union.
+*
+* Returns `null` when no patch is drawable, which is the caller's cue to paint
+* nothing rather than a blank square.
+*/
+function bakeMesh(patches, space = "rgb", size = 256) {
+	const box = meshBounds(patches);
+	if (!box) return null;
+	const pixels = new Uint8ClampedArray(size * size * 4);
+	const grid = gridFor(size);
+	const toTexel = (p) => ({
+		x: (p.x - box.x) / box.width * (size - 1) + .5,
+		y: (p.y - box.y) / box.height * (size - 1) + .5
+	});
+	for (const patch of patches) {
+		if (!isValidPatch(patch)) continue;
+		const corners = patch.colors.map((c) => resolveColor(c));
+		for (let i = 0; i < grid; i++) for (let j = 0; j < grid; j++) {
+			const u0 = i / grid;
+			const u1 = (i + 1) / grid;
+			const v0 = j / grid;
+			const v1 = (j + 1) / grid;
+			const quad = [
+				{
+					at: toTexel(evalPatch(patch, u0, v0)),
+					color: colorAt(corners, u0, v0, space)
+				},
+				{
+					at: toTexel(evalPatch(patch, u1, v0)),
+					color: colorAt(corners, u1, v0, space)
+				},
+				{
+					at: toTexel(evalPatch(patch, u1, v1)),
+					color: colorAt(corners, u1, v1, space)
+				},
+				{
+					at: toTexel(evalPatch(patch, u0, v1)),
+					color: colorAt(corners, u0, v1, space)
+				}
+			];
+			fillTriangle(pixels, size, quad[0], quad[1], quad[2]);
+			fillTriangle(pixels, size, quad[0], quad[2], quad[3]);
+		}
+	}
+	return {
+		pixels,
+		size,
+		box
+	};
+}
+/**
+* One triangle, barycentric, colors interpolated across it.
+*
+* Neighboring cells share an edge, so a pixel exactly on one is claimed by
+* both — harmless here because both carry the same color there, and cheaper
+* than a fill rule.
+*/
+function fillTriangle(pixels, size, a, b, c) {
+	const minX = Math.max(0, Math.floor(Math.min(a.at.x, b.at.x, c.at.x)));
+	const maxX = Math.min(size - 1, Math.ceil(Math.max(a.at.x, b.at.x, c.at.x)));
+	const minY = Math.max(0, Math.floor(Math.min(a.at.y, b.at.y, c.at.y)));
+	const maxY = Math.min(size - 1, Math.ceil(Math.max(a.at.y, b.at.y, c.at.y)));
+	if (maxX < minX || maxY < minY) return;
+	const area = (b.at.x - a.at.x) * (c.at.y - a.at.y) - (c.at.x - a.at.x) * (b.at.y - a.at.y);
+	if (Math.abs(area) < 1e-9) return;
+	for (let y = minY; y <= maxY; y++) for (let x = minX; x <= maxX; x++) {
+		const px = x + .5;
+		const py = y + .5;
+		const w0 = ((b.at.x - px) * (c.at.y - py) - (c.at.x - px) * (b.at.y - py)) / area;
+		const w1 = ((c.at.x - px) * (a.at.y - py) - (a.at.x - px) * (c.at.y - py)) / area;
+		const w2 = 1 - w0 - w1;
+		if (w0 < -1e-6 || w1 < -1e-6 || w2 < -1e-6) continue;
+		const k = (y * size + x) * 4;
+		for (let ch = 0; ch < 4; ch++) pixels[k + ch] = (w0 * a.color[ch] + w1 * b.color[ch] + w2 * c.color[ch]) * 255;
+	}
+}
+/** The largest bake, whatever the context allows: 16 MiB of RGBA, and a bake
+*  that already takes a noticeable moment on the CPU. */
+const MESH_BAKE_MAX = 2048;
+/** Bytes of baked texture one renderer keeps before evicting the least
+*  recently drawn. */
+const MESH_BAKE_CACHE_BYTES = 67108864;
+/**
+* The bake side for a paint drawn `devicePx` device pixels across, on a
+* context accepting `maxTextureSize`: the next power of two at or above it,
+* clamped to `[MESH_BAKE_MIN, MESH_BAKE_MAX]` and to the context. A size that
+* cannot be measured gets `MESH_BAKE_SIZE`.
+*/
+function meshBakeSize(devicePx, maxTextureSize) {
+	const ceiling = Math.min(MESH_BAKE_MAX, floorPow2(maxTextureSize));
+	if (Number.isNaN(devicePx)) return Math.min(256, ceiling);
+	if (devicePx <= 32) return Math.min(32, ceiling);
+	if (devicePx >= ceiling) return ceiling;
+	return Math.min(ceiling, 2 ** Math.ceil(Math.log2(devicePx)));
+}
+function floorPow2(n) {
+	if (!(n >= 1)) return 32;
+	if (!Number.isFinite(n)) return MESH_BAKE_MAX;
+	return 2 ** Math.floor(Math.log2(n));
+}
+/**
+* Bakes keyed by paint and bake size, least recently used first out.
+*
+* The paint is held weakly, so a paint nobody draws any more does not pin its
+* key; its texture stays until eviction reaches it, which the bounds keep
+* finite. `free` runs for every value that leaves, by eviction, replacement or
+* `clear`.
+*/
+var MeshBakeCache = class {
+	free;
+	budgetBytes;
+	maxEntries;
+	byPaint = /* @__PURE__ */ new WeakMap();
+	/** Insertion order is recency: a hit is deleted and re-added. */
+	order = /* @__PURE__ */ new Set();
+	held = 0;
+	constructor(free, budgetBytes = MESH_BAKE_CACHE_BYTES, maxEntries = 256) {
+		this.free = free;
+		this.budgetBytes = budgetBytes;
+		this.maxEntries = maxEntries;
+	}
+	/** Bytes the held bakes occupy, as RGBA8. */
+	get bytes() {
+		return this.held;
+	}
+	/** Bakes held. */
+	get size() {
+		return this.order.size;
+	}
+	get(paint, size) {
+		const entry = this.byPaint.get(paint)?.get(size);
+		if (!entry) return void 0;
+		this.order.delete(entry);
+		this.order.add(entry);
+		return entry.value;
+	}
+	set(paint, size, value) {
+		let bySize = this.byPaint.get(paint);
+		if (!bySize) {
+			bySize = /* @__PURE__ */ new Map();
+			this.byPaint.set(paint, bySize);
+		}
+		const old = bySize.get(size);
+		if (old) this.drop(old);
+		const entry = {
+			value,
+			size,
+			bySize
+		};
+		bySize.set(size, entry);
+		this.order.add(entry);
+		this.held += size * size * 4;
+		this.evict(entry);
+	}
+	/** Free every bake. The cache stays usable. */
+	clear() {
+		for (const entry of [...this.order]) this.drop(entry);
+	}
+	/** Oldest first until both bounds hold, never evicting `keep` — the bake
+	*  the caller is about to draw. */
+	evict(keep) {
+		for (const entry of this.order) {
+			if (this.held <= this.budgetBytes && this.order.size <= this.maxEntries) return;
+			if (entry !== keep) this.drop(entry);
+		}
+	}
+	drop(entry) {
+		if (!this.order.delete(entry)) return;
+		entry.bySize.delete(entry.size);
+		this.held -= entry.size * entry.size * 4;
+		this.free(entry.value);
+	}
+};
+//#endregion
+//#region src/features/meshPaint/meshShader.ts
+/**
+* GLSL ES 3.0 sources for the mesh-gradient paint.
+*
+* The vertex stage is the pattern/gradient one: a path fill mesh carries
+* `a_position` only, so paint-space coordinates come back per fragment from
+* the screen position through `u_worldInv`. The fragment stage is a clamped
+* texture read of the baked mesh, with everything outside the bake's box
+* transparent — a mesh covers the area its patches cover, not the whole shape
+* it is filling, and a clamped read would otherwise smear its border colors
+* across the rest.
+*
+* `u_meshOrigin` / `u_meshSize` are the bake's box in paint space, and the
+* bake maps that box onto texel *centers*, which is the half-texel the uv
+* rescale accounts for.
+*
+* Output convention §2: PREMULTIPLIED alpha.
+*/
+/** The id this program is registered under. */
+const MESH_PROGRAM_ID = "kit:mesh-gradient";
+const MESH_VERT_SRC = `#version 300 es
+in vec2 a_position;
+uniform mat3 u_proj;
+uniform mat3 u_model;
+uniform mat3 u_worldInv;
+out vec2 v_world;
+void main() {
+  vec3 screen = u_model * vec3(a_position, 1.0);
+  vec3 clip   = u_proj  * vec3(screen.xy, 1.0);
+  gl_Position = vec4(clip.xy, 0.0, 1.0);
+  vec3 world = u_worldInv * vec3(screen.xy, 1.0);
+  v_world = world.xy;
+}
+`;
+const MESH_FRAG_SRC = `#version 300 es
+precision highp float;
+in vec2 v_world;
+uniform sampler2D u_sampler;
+uniform vec2  u_meshOrigin;
+uniform vec2  u_meshSize;
+uniform float u_opacity;
+uniform float u_alpha;
+out vec4 outColor;
+void main() {
+  vec2 t =(v_world - u_meshOrigin) / max(u_meshSize, vec2(0.0001));
+  if (t.x < 0.0 || t.x > 1.0 || t.y < 0.0 || t.y > 1.0) {
+    outColor = vec4(0.0);
+    return;
+  }
+  vec2 texels = vec2(textureSize(u_sampler, 0));
+  vec2 uv = (t * (texels - 1.0) + 0.5) / texels;
+  vec4 texel = texture(u_sampler, uv);
+  float a = texel.a * u_opacity * u_alpha;
+  outColor = vec4(texel.rgb * a, a);
+}
+`;
+//#endregion
+//#region src/features/meshPaint/meshPaint.ts
+/** The kind's id, as `FillStyle['fill']` carries it. */
+const MESH_GRADIENT_KIND = "mesh-gradient";
+function asMesh(fill) {
+	return fill;
+}
+function asFill(mesh) {
+	return mesh;
+}
+/**
+* `color` moved in OKLCh — lightness, chroma and hue by the given deltas, with
+* its alpha kept. The seed's corners come from one color, and they have to
+* differ enough to read as a mesh rather than as a flat fill.
+*/
+function shifted(color, dL, cScale, dHueDeg) {
+	const [r, g, b, a] = resolveColor(color);
+	const [L, A, B] = srgbFloatToOklab(r, g, b);
+	const [, C, h] = oklabToOklch(L, A, B);
+	const [nL, nA, nB] = oklchToOklab(Math.min(1, Math.max(0, L + dL)), Math.max(0, C * cScale), h + dHueDeg * Math.PI / 180);
+	const [nr, ng, nb] = oklabToSrgbU8(nL, nA, nB);
+	return rgbaToHex([
+		nr / 255,
+		ng / 255,
+		nb / 255,
+		a
+	]);
+}
+/** A one-patch square covering the unit box, its four corners four readings of
+*  `color` — a mesh seeded from a solid has to show *something* curved, or
+*  switching kind looks like nothing happened. */
+function seedMeshPatch(color) {
+	const corners = [
+		{
+			x: 0,
+			y: 0
+		},
+		{
+			x: 1,
+			y: 0
+		},
+		{
+			x: 1,
+			y: 1
+		},
+		{
+			x: 0,
+			y: 1
+		}
+	];
+	const points = [];
+	for (let i = 0; i < 4; i++) {
+		const a = corners[i];
+		const b = corners[(i + 1) % 4];
+		const nx = (b.y - a.y) * .125;
+		const ny = -(b.x - a.x) * .125;
+		points.push(a, {
+			x: a.x + (b.x - a.x) / 3 + nx,
+			y: a.y + (b.y - a.y) / 3 + ny
+		}, {
+			x: a.x + 2 * (b.x - a.x) / 3 + nx,
+			y: a.y + 2 * (b.y - a.y) / 3 + ny
+		});
+	}
+	return {
+		fill: MESH_GRADIENT_KIND,
+		patches: [{
+			points,
+			colors: [
+				color,
+				shifted(color, .14, .85, 0),
+				shifted(color, -.06, 1.1, 38),
+				shifted(color, -.16, 1, -22)
+			]
+		}],
+		units: "bounds"
+	};
+}
+/** The straight-edged patch covering `[x0, x1] × [0, 1]`, in walk order. */
+function bandPatch(x0, x1, left, right) {
+	const corners = [
+		{
+			x: x0,
+			y: 0
+		},
+		{
+			x: x1,
+			y: 0
+		},
+		{
+			x: x1,
+			y: 1
+		},
+		{
+			x: x0,
+			y: 1
+		}
+	];
+	const points = [];
+	for (let i = 0; i < 4; i++) {
+		const a = corners[i];
+		const b = corners[(i + 1) % 4];
+		points.push(a, {
+			x: a.x + (b.x - a.x) / 3,
+			y: a.y + (b.y - a.y) / 3
+		}, {
+			x: a.x + 2 * (b.x - a.x) / 3,
+			y: a.y + 2 * (b.y - a.y) / 3
+		});
+	}
+	return {
+		points,
+		colors: [
+			left,
+			right,
+			right,
+			left
+		]
+	};
+}
+/**
+* A stop list as a mesh: one full-height band per gap between neighboring
+* stops, colored left to right. The bands blend exactly the way the ramp
+* does, so a horizontal gradient survives the switch unchanged. A zero-width
+* gap is a hard break and gets no band.
+*/
+function meshFromStops(stops) {
+	const sorted = [...stops].sort((a, b) => a.offset - b.offset);
+	if (sorted.length === 1) sorted.push({
+		offset: 1,
+		color: sorted[0].color
+	});
+	if (sorted.length === 0) return seedMeshPatch("#000000ff");
+	const patches = [];
+	for (let i = 0; i < sorted.length - 1; i++) {
+		const a = sorted[i];
+		const b = sorted[i + 1];
+		if (b.offset > a.offset) patches.push(bandPatch(a.offset, b.offset, a.color, b.color));
+	}
+	return {
+		fill: MESH_GRADIENT_KIND,
+		patches,
+		units: "bounds"
+	};
+}
+/**
+* A mesh read as a stop list: every patch's top edge — corner 0 to corner 1 —
+* placed by its `x` across the mesh's horizontal extent. The inverse of
+* `meshFromStops`, and for any other mesh the ramp across its top.
+*/
+function meshStops(mesh) {
+	const valid = mesh.patches.filter(isValidPatch);
+	if (valid.length === 0) return [];
+	const xs = valid.flatMap((p) => [p.points[0].x, p.points[3].x]);
+	const lo = Math.min(...xs);
+	const span = Math.max(...xs) - lo;
+	const offsetOf = (x) => span > 0 ? (x - lo) / span : 0;
+	const stops = [];
+	for (const patch of valid) for (const [point, color] of [[patch.points[0], patch.colors[0]], [patch.points[3], patch.colors[1]]]) {
+		const offset = offsetOf(point.x);
+		if (!stops.some((s) => s.offset === offset && s.color === color)) stops.push({
+			offset,
+			color
+		});
+	}
+	return stops.sort((a, b) => a.offset - b.offset);
+}
+/** Every patch mapped through `move`. */
+function mapPatches(mesh, move) {
+	return mesh.patches.map((patch) => ({
+		...patch,
+		points: patch.points.map(move)
+	}));
+}
+const CACHES = /* @__PURE__ */ new WeakMap();
+function cacheFor(ctx) {
+	let cache = CACHES.get(ctx.resources);
+	if (!cache) {
+		const gl = ctx.gl;
+		const made = new MeshBakeCache((entry) => gl.deleteTexture(entry.texture));
+		ctx.resources.onRelease(() => {
+			made.clear();
+			CACHES.delete(ctx.resources);
+		});
+		CACHES.set(ctx.resources, made);
+		cache = made;
+	}
+	return cache;
+}
+/** Device pixels the larger side of `box` covers when drawn in `units`. */
+function devicePixelsOf(ctx, mesh, box) {
+	const m = ctx.spaceToDevice(mesh.units);
+	if (!m) return NaN;
+	return Math.max(box.width * Math.hypot(m[0], m[1]), box.height * Math.hypot(m[3], m[4]));
+}
+function bakeFor(ctx, mesh) {
+	const box = meshBounds(mesh.patches);
+	if (!box) return null;
+	const size = meshBakeSize(devicePixelsOf(ctx, mesh, box), ctx.maxTextureSize);
+	const cache = cacheFor(ctx);
+	const hit = cache.get(mesh, size);
+	if (hit) return hit;
+	const baked = bakeMesh(mesh.patches, mesh.interpolate ?? "rgb", size);
+	if (!baked) return null;
+	const gl = ctx.gl;
+	const texture = gl.createTexture();
+	if (!texture) return null;
+	gl.bindTexture(gl.TEXTURE_2D, texture);
+	gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+	gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+	gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+	gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+	gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, baked.size, baked.size, 0, gl.RGBA, gl.UNSIGNED_BYTE, baked.pixels);
+	gl.bindTexture(gl.TEXTURE_2D, null);
+	const entry = {
+		texture,
+		baked
+	};
+	cache.set(mesh, size, entry);
+	return entry;
+}
+function bindMesh(ctx, fill) {
+	const mesh = asMesh(fill);
+	if (!mesh.patches.some(isValidPatch)) return null;
+	const inverse = ctx.spaceInverse(mesh.units);
+	if (!inverse) return null;
+	const program = ctx.program(MESH_PROGRAM_ID);
+	if (!program) return null;
+	const entry = bakeFor(ctx, mesh);
+	if (!entry) return null;
+	const gl = ctx.gl;
+	gl.useProgram(program.handle);
+	ctx.setProjAndModel(program);
+	gl.uniformMatrix3fv(program.uniform("u_worldInv"), false, inverse);
+	gl.activeTexture(gl.TEXTURE0);
+	gl.bindTexture(gl.TEXTURE_2D, entry.texture);
+	gl.uniform1i(program.uniform("u_sampler"), 0);
+	const { box } = entry.baked;
+	gl.uniform2f(program.uniform("u_meshOrigin"), box.x, box.y);
+	gl.uniform2f(program.uniform("u_meshSize"), box.width, box.height);
+	gl.uniform1f(program.uniform("u_opacity"), mesh.opacity ?? 1);
+	gl.uniform1f(program.uniform("u_alpha"), ctx.alpha);
+	return program;
+}
+/** The kind's registry entry, shader program included. `./register` registers
+*  it; core's paint-kind registry loads it on demand otherwise. */
+const meshGradientKind = {
+	id: MESH_GRADIENT_KIND,
+	programs: { [MESH_PROGRAM_ID]: {
+		vert: MESH_VERT_SRC,
+		frag: MESH_FRAG_SRC
+	} },
+	label: "Mesh",
+	icon: "paintMesh",
+	seed: (color) => asFill(seedMeshPatch(color)),
+	colorOf: (paint) => asMesh(paint).patches?.[0]?.colors?.[0],
+	stopsOf: (paint) => meshStops(asMesh(paint)),
+	fromStops: (stops) => asFill(meshFromStops(stops)),
+	bind: bindMesh,
+	inPoseFrame: (fill, box) => {
+		const mesh = asMesh(fill);
+		if (mesh.units !== "bounds") return fill;
+		return asFill({
+			...mesh,
+			patches: mapPatches(mesh, (p) => ({
+				x: box.x + p.x * box.width,
+				y: box.y + p.y * box.height
+			})),
+			units: "local"
+		});
+	},
+	toBoundsFrame: (fill, box) => {
+		const mesh = asMesh(fill);
+		if (mesh.units === "bounds" || box.width === 0 || box.height === 0) return fill;
+		return asFill({
+			...mesh,
+			patches: mapPatches(mesh, (p) => ({
+				x: (p.x - box.x) / box.width,
+				y: (p.y - box.y) / box.height
+			})),
+			units: "bounds"
+		});
+	},
+	toSvg: (id, fill) => meshGradientXml(id, asMesh(fill))
+};
+/**
+* The `<defs>` entry for a mesh paint, in weasel's own namespace.
+*
+* Not SVG's abandoned `<meshgradient>`: that vocabulary only reaches Coons
+* patches, shares patch edges implicitly — a reader that gets the sharing
+* wrong tears the surface rather than failing outright — and has exactly one
+* implementation in the world. Ours writes every patch's points in full.
+* `@weasel-js/svg` puts the paint fallback color beside the reference, so a
+* foreign renderer paints flat instead of nothing.
+*/
+function meshGradientXml(id, mesh) {
+	const P = "wzl";
+	return `<${P}:meshGradient id="${id}" gradientUnits="${mesh.units === "bounds" ? "objectBoundingBox" : "userSpaceOnUse"}"${mesh.interpolate && mesh.interpolate !== "rgb" ? ` interpolate="${mesh.interpolate}"` : ""}>${mesh.patches.map((patch) => {
+		const points = patch.points.map((p) => `${trim(p.x)},${trim(p.y)}`).join(" ");
+		const colors = patch.colors.join(" ");
+		return `<${P}:patch points="${points}" colors="${colors}"/>`;
+	}).join("")}</${P}:meshGradient>`;
+}
+/** Short decimals, matching what `@weasel-js/svg` writes elsewhere. */
+function trim(n) {
+	return Number.isInteger(n) ? String(n) : String(Number(n.toFixed(4)));
+}
+//#endregion
+export { meshGradientKind };
+
+//# sourceMappingURL=lazyKind.js.map