@weasel-js/core 1.9.4 → 1.10.1

package/dist/{features/meshPaint/lazyKind.js → core/paint/meshKindLazy.js}

@@ -1,5 +1,10 @@
-//#region ../paint/dist/index.js
-var HEX = /^#(?:[0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})$/i;
+//#region ../paint/src/hex.ts
+const HEX = /^#(?:[0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})$/i;
+/**
+* The kit's one hex color reader: `#rgb`, `#rgba`, `#rrggbb`, or `#rrggbbaa`,
+* in any case, as four 0..255 channels with alpha last (255 when the color
+* names none). `null` for anything else, a missing `#` included.
+*/
 function parseHexBytes(input) {
 	if (!HEX.test(input)) return null;
 	const digits = input.slice(1);
@@ -12,7 +17,9 @@ function parseHexBytes(input) {
 		long.length === 8 ? byte(6) : 255
 	];
 }
-var SRGB_TO_LINEAR = (() => {
+//#endregion
+//#region ../paint/src/colorSpaces.ts
+const SRGB_TO_LINEAR = (() => {
 	const lut = /* @__PURE__ */ new Float64Array(256);
 	for (let i = 0; i < 256; i++) {
 		const c = i / 255;
@@ -26,13 +33,24 @@ function linearToSrgbByte(c) {
 	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)));
+/** 0..1 float channel to the 8-bit index the LUTs are cut for. Rounds and
+*  clamps; `& 0xff` would truncate, and wrap anything out of range. */
+const f2u = (v) => Math.max(0, Math.min(255, Math.round(v * 255)));
+/**
+* Convert a 0..1 float sRGB triple to OKLab — the renderer's own color space,
+* and what a caller holding a `resolveColor` result has. Rounds into the u8
+* grid the way every other float→u8 crossing in this file does, rather than
+* leaving each caller to pick a convention.
+*/
 function srgbFloatToOklab(r, g, b) {
 	return srgbU8ToOklab(f2u(r), f2u(g), f2u(b));
 }
+/** Convert an 8-bit sRGB triple to OKLab. Channels are indices into a 256-entry
+*  LUT: pass integers, or `srgbFloatToOklab` for 0..1 floats. */
 function srgbU8ToOklab(r, g, b) {
 	return linearSrgbToOklab(SRGB_TO_LINEAR[r & 255], SRGB_TO_LINEAR[g & 255], SRGB_TO_LINEAR[b & 255]);
 }
+/** Linear-light sRGB (0..1 floats, unclamped) to OKLab. */
 function linearSrgbToOklab(rl, gl, bl) {
 	const l = .4122214708 * rl + .5363325363 * gl + .0514459929 * bl;
 	const m = .2119034982 * rl + .6806995451 * gl + .1073969566 * bl;
@@ -46,6 +64,8 @@ function linearSrgbToOklab(rl, gl, bl) {
 		.0259040371 * lp + .7827717662 * mp - .808675766 * sp
 	];
 }
+/** OKLab to linear-light sRGB. Not gamut-clipped: out-of-gamut colors come
+*  back with channels outside 0..1. */
 function oklabToLinearSrgb(L, A, B) {
 	const lp = L + .3963377774 * A + .2158037573 * B;
 	const mp = L - .1055613458 * A - .0638541728 * B;
@@ -84,6 +104,7 @@ function clipToGamut(L, A, B) {
 		bl
 	];
 }
+/** Convert OKLab back to an 8-bit sRGB triple, clamped into gamut. */
 function oklabToSrgbU8(L, A, B) {
 	const [rl, gl, bl] = clipToGamut(L, A, B);
 	return [
@@ -92,6 +113,9 @@ function oklabToSrgbU8(L, A, B) {
 		linearToSrgbByte(bl)
 	];
 }
+/** Blend two 8-bit sRGB colors through OKLab. Perceptually even, and it does
+*  not pass through the muddy midpoints an sRGB blend produces between
+*  complementary hues. */
 function lerpOklab(from, to, t) {
 	return [
 		from[0] + (to[0] - from[0]) * t,
@@ -99,6 +123,7 @@ function lerpOklab(from, to, t) {
 		from[2] + (to[2] - from[2]) * t
 	];
 }
+/** Convert OKLab (L, a, b) to OKLCh (L, C, h). h is in radians, range [-π, π]. */
 function oklabToOklch(L, A, B) {
 	return [
 		L,
@@ -106,6 +131,7 @@ function oklabToOklch(L, A, B) {
 		Math.atan2(B, A)
 	];
 }
+/** Convert OKLCh (L, C, h) to OKLab (L, a, b). h is in radians. */
 function oklchToOklab(L, C, h) {
 	return [
 		L,
@@ -113,6 +139,10 @@ function oklchToOklab(L, C, h) {
 		C * Math.sin(h)
 	];
 }
+/** Lerp OKLCh values with shortest-arc hue interpolation. Lightness and
+*  chroma lerp linearly. When chroma is near zero on either endpoint, hue
+*  is taken from the other endpoint (avoids hue snap-from-undefined).
+*  h inputs are in radians. */
 function lerpOklch(from, to, t) {
 	const [L1, C1, h1Raw] = from;
 	const [L2, C2, h2Raw] = to;
@@ -129,7 +159,14 @@ function lerpOklch(from, to, t) {
 		h1 + dh * t
 	];
 }
-var u2f = (v) => v / 255;
+const u2f = (v) => v / 255;
+/** Lerp a flat RGBA color array `from` toward `to`. Inputs are 0..1
+*  floats (the renderer's color space); outputs are 0..1 floats too.
+*  Alpha is always linearly lerped; RGB channels are lerped in the
+*  requested color space. OKLab / OKLCh paths bounce through u8 because
+*  the gamma-correction LUT and gamut-clip routines are byte-keyed —
+*  the round-trip is lossy at <1% per channel, well under the visible
+*  threshold for these animations. */
 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`);
@@ -165,6 +202,7 @@ function lerpColorArray(from, to, t, space = "rgb") {
 	}
 	return out;
 }
+/** HSL to sRGB. Hue in degrees, saturation, lightness and output all 0..1. */
 function hslToSrgb(h, s, l) {
 	if (s === 0) return [
 		l,
@@ -189,7 +227,7 @@ function hueToChannel(p, q, t) {
 	return p;
 }
 //#endregion
-//#region src/renderer/math/color.ts
+//#region ../paint/src/color.ts
 /**
 * Parse a CSS color string into [r, g, b, a] with 0..1 components.
 *
@@ -238,12 +276,8 @@ function parseColorUncached(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). */
+*  callbacks, gradient ramp builds). The cache is capped at ~1024 entries and
+*  cleared wholesale on overflow. */
 function resolveColor(input) {
 	const hit = resolveColorCache.get(input);
 	if (hit) return hit;
@@ -357,7 +391,7 @@ function parseHslFunction(s) {
 	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);
+	const [r, g, b] = hslToSrgb(h, sat, lit);
 	return [
 		r,
 		g,
@@ -385,13 +419,6 @@ function parsePercentOrNumber(tok) {
 	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;
 }
@@ -564,21 +591,16 @@ const NAMED_COLORS = (() => {
 	return out;
 })();
 //#endregion
-//#region ../geom/src/mat3.ts
+//#region ../geom/src/affine.ts
 /**
 * 2D affine transforms in canvas/DOMMatrix order: [a, b, c, d, e, f].
 *   x' = a·x + c·y + e
 *   y' = b·x + d·y + f
 * Represented as a readonly 6-tuple (f64). The affine tier of the kernel.
 *
-* Convention alignment: the renderer already has a `Mat3` in
-* `src/renderer/math/mat3.ts`. That one is a 9-element column-major
-* array (a full 3×3) laid out for `uniformMatrix3fv` — a deliberately
-* different *representation* for the WebGL upload path. Its *logical element
-* order* is identical to ours: `create(a, b, c, d, tx, ty)` maps
-* `x' = a·x + c·y + tx`, `y' = b·x + d·y + ty` (canvas/DOMMatrix a,b,c,d,e,f).
-* We keep the pure 6-tuple form here (the kernel form); the 9-element form
-* stays a render-layer concern. No second logical convention is created.
+* `glMat3.ts` beside this file holds the renderer's matrix: a 9-element
+* column-major array (a full 3×3) laid out for `uniformMatrix3fv`. Its
+* *logical element order* is identical to ours.
 */
 /** Inverse, or null when the matrix is singular, non-finite, or too
 *  ill-conditioned to invert meaningfully at its own scale. */
@@ -601,7 +623,7 @@ function invert$1(m) {
 	];
 }
 //#endregion
-//#region src/renderer/math/mat3.ts
+//#region ../geom/src/glMat3.ts
 /**
 * 2D affine matrix utilities. Column-major 9 elements, matching
 * `WebGL2RenderingContext.uniformMatrix3fv` element order so an upload needs
@@ -611,9 +633,6 @@ function invert$1(m) {
 *   [m00, m10, 0,
 *    m01, m11, 0,
 *    tx,  ty,  1]
-*
-* `apply(m, x, y)` returns `[m * (x, y, 1)] = [m00*x + m01*y + tx,
-*                                              m10*x + m11*y + ty]`.
 */
 function create(a, b, c, d, tx, ty) {
 	return new Float64Array([
@@ -650,8 +669,7 @@ function scaled(m, sx, sy) {
 	return multiply(m, create(sx, 0, 0, sy, 0, 0));
 }
 /** This layout read as the kernel's 6-element affine. The two carry the same
-*  logical order, so the conversion is a repack and nothing else — it exists
-*  so the repack has a name instead of appearing inline at each crossing. */
+*  logical order, so the conversion is a repack and nothing else. */
 function toAffine(m) {
 	return [
 		m[0],
@@ -662,9 +680,7 @@ function toAffine(m) {
 		m[7]
 	];
 }
-/** The kernel's affine in this layout. The inverse of {@link toAffine}, and
-*  what an `SvgGroupNode.transform` (also a kernel affine) becomes on its way
-*  to a `GroupDrawCommand`. */
+/** The kernel's affine in this layout. The inverse of {@link toAffine}. */
 function fromAffine(a) {
 	return create(a[0], a[1], a[2], a[3], a[4], a[5]);
 }
@@ -709,9 +725,8 @@ function minScaleOf(m) {
 	return Math.sqrt(Math.max(0, (sum - Math.sqrt(Math.max(0, sum * sum - 4 * det * det))) / 2));
 }
 /** The renderer's 3x3 matrix operations, as one namespace. These work on the
-*  9-element form the GL uniform upload wants — distinct from
-*  `@weasel-js/geom`'s 6-element affine `GlMat3`, though the logical element
-*  order is the same. */
+*  9-element form the GL uniform upload wants — distinct from the 6-element
+*  `Affine`, though the logical element order is the same. */
 const mat3 = {
 	identity,
 	toAffine,
@@ -727,7 +742,7 @@ const mat3 = {
 	minScaleOf
 };
 //#endregion
-//#region src/features/meshPaint/surface.ts
+//#region ../renderer/src/meshPaint/surface.ts
 /** Corner `i` of the boundary walk. */
 function patchCorner(patch, i) {
 	return patch.points[(i & 3) * 3];
@@ -850,9 +865,8 @@ function evalTensor(patch, u, v) {
 		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. */
+/** Axis-aligned bounds of a patch, sampled on a grid: control points alone
+*  bound a Bézier but not tightly. */
 function patchBounds(patch, steps = 8) {
 	let minX = Infinity;
 	let minY = Infinity;
@@ -903,20 +917,16 @@ function meshBounds(patches) {
 	};
 }
 /**
-* 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.
+* Corner colors blended at `(u, v)` in `space`. Three lerps rather than four
+* weights, because a perceptual space has no meaningful four-way mix — OKLCh's
+* hue 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.
+* Rasterize `patches` into a square bitmap covering their union, or `null`
+* when no patch is drawable.
 */
 function bakeMesh(patches, space = "rgb", size = 256) {
 	const box = meshBounds(patches);
@@ -964,11 +974,9 @@ function bakeMesh(patches, space = "rgb", size = 256) {
 	};
 }
 /**
-* 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.
+* One triangle, barycentric, colors interpolated across it. A pixel exactly on
+* an edge two cells share is claimed by both — harmless, because both carry
+* the same color there.
 */
 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)));
@@ -1087,23 +1095,17 @@ var MeshBakeCache = class {
 	}
 };
 //#endregion
-//#region src/features/meshPaint/meshShader.ts
+//#region ../renderer/src/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.
+* Everything outside the bake's box is 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.
+* rescale accounts for. Output is PREMULTIPLIED alpha.
 */
 /** The id this program is registered under. */
 const MESH_PROGRAM_ID = "kit:mesh-gradient";
@@ -1144,13 +1146,13 @@ void main() {
 }
 `;
 //#endregion
-//#region src/features/meshPaint/meshPaint.ts
-/** The kind's id, as `FillStyle['fill']` carries it. */
+//#region ../renderer/src/meshPaint/meshPaint.ts
+/** The kind's id, as `Paint['fill']` carries it. */
 const MESH_GRADIENT_KIND = "mesh-gradient";
-function asMesh(fill) {
+function asMesh$1(fill) {
 	return fill;
 }
-function asFill(mesh) {
+function asFill$1(mesh) {
 	return mesh;
 }
 /**
@@ -1208,7 +1210,7 @@ function seedMeshPatch(color) {
 		});
 	}
 	return {
-		fill: MESH_GRADIENT_KIND,
+		kind: MESH_GRADIENT_KIND,
 		patches: [{
 			points,
 			colors: [
@@ -1283,7 +1285,7 @@ function meshFromStops(stops) {
 		if (b.offset > a.offset) patches.push(bandPatch(a.offset, b.offset, a.color, b.color));
 	}
 	return {
-		fill: MESH_GRADIENT_KIND,
+		kind: MESH_GRADIENT_KIND,
 		patches,
 		units: "bounds"
 	};
@@ -1371,7 +1373,7 @@ function bakeFor(ctx, mesh) {
 	};
 }
 function bindMesh(ctx, fill) {
-	const mesh = asMesh(fill);
+	const mesh = asMesh$1(fill);
 	if (!mesh.patches.some(isValidPatch)) return null;
 	const inverse = ctx.spaceInverse(mesh.units);
 	if (!inverse) return null;
@@ -1393,25 +1395,19 @@ function bindMesh(ctx, fill) {
 	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 = {
+/** The kind's draw half, shader program included. Core adds the editor's
+*  slots and registers the whole entry. */
+const meshDrawKind = {
 	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);
+		const mesh = asMesh$1(fill);
 		if (mesh.units !== "bounds") return fill;
-		const posed = asFill({
+		const posed = asFill$1({
 			...mesh,
 			patches: mapPatches(mesh, (p) => ({
 				x: box.x + p.x * box.width,
@@ -1423,9 +1419,9 @@ const meshGradientKind = {
 		return posed;
 	},
 	toBoundsFrame: (fill, box) => {
-		const mesh = asMesh(fill);
+		const mesh = asMesh$1(fill);
 		if (mesh.units === "bounds" || box.width === 0 || box.height === 0) return fill;
-		return asFill({
+		return asFill$1({
 			...mesh,
 			patches: mapPatches(mesh, (p) => ({
 				x: (p.x - box.x) / box.width,
@@ -1433,8 +1429,7 @@ const meshGradientKind = {
 			})),
 			units: "bounds"
 		});
-	},
-	toSvg: (id, fill) => meshGradientXml(id, asMesh(fill))
+	}
 };
 /**
 * The `<defs>` entry for a mesh paint, in weasel's own namespace.
@@ -1459,6 +1454,22 @@ function trim(n) {
 	return Number.isInteger(n) ? String(n) : String(Number(n.toFixed(4)));
 }
 //#endregion
+//#region src/core/paint/meshKind.ts
+const asMesh = (fill) => fill;
+const asFill = (mesh) => mesh;
+/** The `mesh-gradient` kind's registry entry. `./registerMesh` registers it;
+*  the paint-kind registry loads it on demand otherwise. */
+const meshGradientKind = {
+	...meshDrawKind,
+	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)),
+	toSvg: (id, fill) => meshGradientXml(id, asMesh(fill))
+};
+//#endregion
 export { meshGradientKind };
 
-//# sourceMappingURL=lazyKind.js.map
+//# sourceMappingURL=meshKindLazy.js.map