@weasel-js/core 1.9.4 → 1.10.0

package/dist/core/geometry/poseFrame.js

@@ -1,44 +0,0 @@
-import { poseRotationOf as e, rotatePathAround as t } from "./poseRotation.js";
-import { invert as n, multiply as r, rotateAboutPoint as i, transformPath as a } from "@weasel-js/geom";
-//#region src/core/geometry/poseFrame.ts
-function o(e) {
-	let t = e?.transform;
-	return !Array.isArray(t) || t.length !== 4 || t[0] === 1 && t[1] === 0 && t[2] === 0 && t[3] === 1 ? null : t;
-}
-function s(e) {
-	let t = e;
-	if (!t || t.x == null || t.y == null || t.width == null || t.height == null) return null;
-	let n = o(t);
-	if (!t.rotation && !n) return null;
-	let a = t.x + t.width / 2, s = t.y + t.height / 2;
-	if (!n) return i(a, s, t.rotation);
-	let [c, l, u, d] = n, f = [
-		c,
-		l,
-		u,
-		d,
-		a - (c * a + u * s),
-		s - (l * a + d * s)
-	];
-	return t.rotation ? r(i(a, s, t.rotation), f) : f;
-}
-function c(t) {
-	if (!o(t)) {
-		let n = e(t);
-		return n && i(n.cx, n.cy, -n.rotation);
-	}
-	let r = s(t);
-	return r && n(r);
-}
-function l(n, r) {
-	if (o(r)) {
-		let e = s(r);
-		return e ? a(n, e) : n;
-	}
-	let i = e(r);
-	return i ? t(n, i.cx, i.cy, i.rotation) : n;
-}
-//#endregion
-export { l as pathThroughPoseFrame, c as poseFrameInverseOf, s as poseFrameOf, o as poseLinearOf };
-
-//# sourceMappingURL=poseFrame.js.map

package/dist/core/geometry/poseFrame.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"poseFrame.js","names":["poseLinearOf","pose","poseFrameOf","p","linear","cx","cy","rotateAboutPoint","a","b","c","about","multiply","poseFrameInverseOf","r","poseRotationOf","frame","invert","pathThroughPoseFrame","transformPath","path","rotatePathAround"],"sources":["../../../src/core/geometry/poseFrame.ts"],"sourcesContent":["/**\n * The one composition of a box pose into the matrix that carries its own\n * frame to its parent's: the rotation convention of `poseRotationOf`, and the\n * pose's residual `transform` inside it. Painting, culling, silhouettes, and\n * picking all read a pose through `poseFrameOf` so they agree on where the\n * node is.\n */\nimport {\n  invert, multiply, rotateAboutPoint, transformPath, type Mat3, type Path,\n} from '@weasel-js/geom';\nimport { poseRotationOf, rotatePathAround } from './poseRotation';\n\n/**\n * The linear part of a box pose that its box, rotation, and flips cannot\n * hold: a skew, or a scale that differs by axis. `[a, b, c, d]` in\n * `Mat3` order (`x' = a·x + c·y`, `y' = b·x + d·y`), applied about the\n * box center to what the node draws in its unrotated box, before the\n * rotation. Absent is the identity.\n *\n * The box, `rotation`, and flips keep their meaning beside it: a node at\n * `(x, y, width, height)` is laid out and painted in that box exactly as it\n * would be without a `transform`, and the result is then taken through\n * `rotate(rotation) · transform` about the box center.\n */\nexport type PoseLinear = readonly [a: number, b: number, c: number, d: number];\n\ninterface FramedBox {\n  x: number;\n  y: number;\n  width: number;\n  height: number;\n  rotation?: number;\n  transform?: PoseLinear;\n}\n\n/** `transform` when it changes anything, `null` for absent or the identity. */\nexport function poseLinearOf(pose: unknown): PoseLinear | null {\n  const t = (pose as { transform?: unknown } | null | undefined)?.transform;\n  if (!Array.isArray(t) || t.length !== 4) return null;\n  if (t[0] === 1 && t[1] === 0 && t[2] === 0 && t[3] === 1) return null;\n  return t as unknown as PoseLinear;\n}\n\n/**\n * The matrix taking a point in the pose's own unrotated box frame to where\n * the node draws it: `rotate(rotation) · transform`, about the box center.\n * `null` when the pose has neither, or is not a box, so a caller can skip\n * the step.\n */\nexport function poseFrameOf(pose: unknown): Mat3 | null {\n  const p = pose as Partial<FramedBox> | null | undefined;\n  if (!p || p.x == null || p.y == null || p.width == null || p.height == null) return null;\n  const linear = poseLinearOf(p);\n  if (!p.rotation && !linear) return null;\n  const cx = p.x + p.width / 2;\n  const cy = p.y + p.height / 2;\n  if (!linear) return rotateAboutPoint(cx, cy, p.rotation as number);\n  const [a, b, c, d] = linear;\n  const about: Mat3 = [a, b, c, d, cx - (a * cx + c * cy), cy - (b * cx + d * cy)];\n  return p.rotation ? multiply(rotateAboutPoint(cx, cy, p.rotation), about) : about;\n}\n\n/**\n * The inverse of {@link poseFrameOf}: where a parent-frame point falls in the\n * pose's unrotated box frame. `null` when there is no frame to undo, or when\n * the `transform` is singular and nothing maps back.\n */\nexport function poseFrameInverseOf(pose: unknown): Mat3 | null {\n  if (!poseLinearOf(pose)) {\n    // The same pivot turned back: exact, where inverting the matrix is not.\n    const r = poseRotationOf(pose);\n    return r && rotateAboutPoint(r.cx, r.cy, -r.rotation);\n  }\n  const frame = poseFrameOf(pose);\n  return frame && invert(frame);\n}\n\n/** `path`, given in the pose's unrotated box frame, as the node draws it. */\nexport function pathThroughPoseFrame(path: Path, pose: unknown): Path {\n  if (poseLinearOf(pose)) {\n    const frame = poseFrameOf(pose);\n    return frame ? transformPath(path, frame) : path;\n  }\n  const r = poseRotationOf(pose);\n  return r ? rotatePathAround(path, r.cx, r.cy, r.rotation) : path;\n}\n"],"mappings":";;;AAoCA,SAAgBA,EAAa,GAAkC;CAC7D,IAAM,IAAKC,GAAqD;CAGhE,OAFI,CAAC,MAAM,QAAQ,CAAC,KAAK,EAAE,WAAW,KAClC,EAAE,OAAO,KAAK,EAAE,OAAO,KAAK,EAAE,OAAO,KAAK,EAAE,OAAO,IAAU,OAC1D;AACT;AAQA,SAAgBC,EAAY,GAA4B;CACtD,IAAMC,IAAIF;CACV,IAAI,CAACE,KAAKA,EAAE,KAAK,QAAQA,EAAE,KAAK,QAAQA,EAAE,SAAS,QAAQA,EAAE,UAAU,MAAM,OAAO;CACpF,IAAMC,IAASJ,EAAaG,CAAC;CAC7B,IAAI,CAACA,EAAE,YAAY,CAACC,GAAQ,OAAO;CACnC,IAAMC,IAAKF,EAAE,IAAIA,EAAE,QAAQ,GACrBG,IAAKH,EAAE,IAAIA,EAAE,SAAS;CAC5B,IAAI,CAACC,GAAQ,OAAOG,EAAiBF,GAAIC,GAAIH,EAAE,QAAkB;CACjE,IAAM,CAACK,GAAGC,GAAGC,GAAG,KAAKN,GACfO,IAAc;EAACH;EAAGC;EAAGC;EAAG;EAAGL,KAAMG,IAAIH,IAAKK,IAAIJ;EAAKA,KAAMG,IAAIJ,IAAK,IAAIC;CAAG;CAC/E,OAAOH,EAAE,WAAWS,EAASL,EAAiBF,GAAIC,GAAIH,EAAE,QAAQ,GAAGQ,CAAK,IAAIA;AAC9E;AAOA,SAAgBE,EAAmB,GAA4B;CAC7D,IAAI,CAACb,EAAaC,CAAI,GAAG;EAEvB,IAAMa,IAAIC,EAAed,CAAI;EAC7B,OAAOa,KAAKP,EAAiBO,EAAE,IAAIA,EAAE,IAAI,CAACA,EAAE,QAAQ;CACtD;CACA,IAAME,IAAQd,EAAYD,CAAI;CAC9B,OAAOe,KAASC,EAAOD,CAAK;AAC9B;AAGA,SAAgBE,EAAqB,GAAY,GAAqB;CACpE,IAAIlB,EAAaC,CAAI,GAAG;EACtB,IAAMe,IAAQd,EAAYD,CAAI;EAC9B,OAAOe,IAAQG,EAAcC,GAAMJ,CAAK,IAAII;CAC9C;CACA,IAAMN,IAAIC,EAAed,CAAI;CAC7B,OAAOa,IAAIO,EAAiBD,GAAMN,EAAE,IAAIA,EAAE,IAAIA,EAAE,QAAQ,IAAIM;AAC9D"}

package/dist/core/geometry/poseRotation.js

@@ -1,58 +0,0 @@
-import { PATH_L as e, PATH_M as t, PATH_Z as n, forEachSegment as r, pathCommandCoordCount as i } from "@weasel-js/geom";
-//#region src/core/geometry/poseRotation.ts
-function a(e) {
-	let t = e;
-	return t.rotation && t.x != null && t.y != null && t.width != null && t.height != null ? {
-		cx: t.x + t.width / 2,
-		cy: t.y + t.height / 2,
-		rotation: t.rotation
-	} : null;
-}
-function o(e, t, n, r) {
-	return e.kind === "rect" ? c(e.x, e.y, e.width, e.height, t, n, r) : s(e, t, n, r);
-}
-function s(e, t, n, a) {
-	let o = Math.cos(a), s = Math.sin(a), { commands: c, coords: l } = e, u = new Float32Array(l.length);
-	return r(c, l, (e, r) => {
-		for (let a = 0, c = i(e); a < c; a += 2) {
-			let e = l[r + a] - t, i = l[r + a + 1] - n;
-			u[r + a] = t + e * o - i * s, u[r + a + 1] = n + e * s + i * o;
-		}
-	}), {
-		kind: "polygon",
-		commands: e.commands,
-		coords: u,
-		fillRule: e.fillRule
-	};
-}
-function c(r, i, a, o, s, c, l) {
-	let u = Math.cos(l), d = Math.sin(l), f = (e, t) => {
-		let n = e - s, r = t - c;
-		return [s + n * u - r * d, c + n * d + r * u];
-	}, [p, m] = f(r, i), [h, g] = f(r + a, i), [_, v] = f(r + a, i + o), [y, b] = f(r, i + o);
-	return {
-		kind: "polygon",
-		commands: new Uint8Array([
-			t,
-			e,
-			e,
-			e,
-			n
-		]),
-		coords: new Float32Array([
-			p,
-			m,
-			h,
-			g,
-			_,
-			v,
-			y,
-			b
-		]),
-		fillRule: "nonzero"
-	};
-}
-//#endregion
-export { a as poseRotationOf, o as rotatePathAround };
-
-//# sourceMappingURL=poseRotation.js.map

package/dist/core/geometry/poseRotation.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"poseRotation.js","names":["poseRotationOf","p","pose","rotatePathAround","path","rotateRectCorners","cx","cy","rotation","rotatePolygon","cos","sin","next","coords","forEachSegment","commands","k","len","pathCommandCoordCount","cmd","dx","ci","dy","rotate","px","py","x0","y0","x","y","x1","y1","w","x2","y2","h","x3","y3","PATH_M","PATH_L","PATH_Z"],"sources":["../../../src/core/geometry/poseRotation.ts"],"sourcesContent":["/**\n * The kit's single encoding of the pose-rotation convention: \"rotate about the\n * pose's unrotated AABB center by `pose.rotation` (radians).\"\n *\n * Every consumer that needs to apply rotation — the render-tree wrap\n * (`canvas/poseRotation.ts`), the world coordinate bake (`pathInWorld`), the\n * silhouette/clip bake (`findShapeSilhouette`), the hit-test inverse\n * (`poseContainsRotated`), and selection chrome — derives its pivot + angle\n * from `poseRotationOf` rather than re-inlining the `if (rotation && x != null\n * …)` gate. If the convention ever changes (a different pivot, say), it\n * changes here.\n *\n * A pose may also carry a `transform` inside the rotation. `poseFrameOf`\n * (`./poseFrame`) composes the two, and is what a reader that draws, bounds,\n * or picks the node wants; this module is the angle and pivot alone.\n *\n * Lives in `core/geometry` so `core/`'s own adapters can bake rotation too.\n */\nimport {\n  forEachSegment,\n  pathCommandCoordCount,\n  PATH_L,\n  PATH_M,\n  PATH_Z,\n  type Path,\n  type PolygonPath,\n} from '@weasel-js/geom';\n\n/** Pivot (`cx`, `cy`) and angle resolved from a pose's rotation convention. */\nexport interface PoseRotation {\n  cx: number;\n  cy: number;\n  rotation: number;\n}\n\n/**\n * Resolve a pose's rotation transform, or `null` when the pose carries no\n * effective rotation. Non-null requires a nonzero `rotation` **and** all four\n * AABB fields (`x`, `y`, `width`, `height`) — the pivot is the unrotated AABB\n * center. Poses missing any AABB field (e.g. a bare polygon pose) or with\n * zero/absent rotation return `null`, so callers can treat `null` as \"draw /\n * hit / clip in the local frame, no rotation step.\"\n */\nexport function poseRotationOf(pose: unknown): PoseRotation | null {\n  const p = pose as Partial<{ x: number; y: number; width: number; height: number; rotation: number }>;\n  if (p.rotation && p.x != null && p.y != null && p.width != null && p.height != null) {\n    return { cx: p.x + p.width / 2, cy: p.y + p.height / 2, rotation: p.rotation };\n  }\n  return null;\n}\n\n/**\n * Rotate every coordinate of `path` about `(cx, cy)` by `rotation` radians.\n * A `rect` promotes to a four-corner polygon (axis-aligned rects can't encode\n * rotation); a polygon keeps its command list and rotates each coord. Returns\n * a fresh `PolygonPath`; never mutates the input. This is the coordinate-baking\n * companion to `poseRotationOf` — `pathInWorld` and `findShapeSilhouette` both\n * apply it so they share one rotation implementation.\n */\nexport function rotatePathAround(path: Path, cx: number, cy: number, rotation: number): PolygonPath {\n  if (path.kind === 'rect') {\n    return rotateRectCorners(path.x, path.y, path.width, path.height, cx, cy, rotation);\n  }\n  return rotatePolygon(path, cx, cy, rotation);\n}\n\nfunction rotatePolygon(path: PolygonPath, cx: number, cy: number, rotation: number): PolygonPath {\n  const cos = Math.cos(rotation);\n  const sin = Math.sin(rotation);\n  const { commands, coords } = path;\n  const next = new Float32Array(coords.length);\n  forEachSegment(commands, coords, (cmd, ci) => {\n    for (let k = 0, len = pathCommandCoordCount(cmd); k < len; k += 2) {\n      const dx = coords[ci + k] - cx;\n      const dy = coords[ci + k + 1] - cy;\n      next[ci + k] = cx + dx * cos - dy * sin;\n      next[ci + k + 1] = cy + dx * sin + dy * cos;\n    }\n  });\n  return { kind: 'polygon', commands: path.commands, coords: next, fillRule: path.fillRule };\n}\n\nfunction rotateRectCorners(\n  x: number, y: number, w: number, h: number,\n  cx: number, cy: number, rotation: number,\n): PolygonPath {\n  const cos = Math.cos(rotation);\n  const sin = Math.sin(rotation);\n  const rotate = (px: number, py: number): [number, number] => {\n    const dx = px - cx;\n    const dy = py - cy;\n    return [cx + dx * cos - dy * sin, cy + dx * sin + dy * cos];\n  };\n  const [x0, y0] = rotate(x, y);\n  const [x1, y1] = rotate(x + w, y);\n  const [x2, y2] = rotate(x + w, y + h);\n  const [x3, y3] = rotate(x, y + h);\n  // M, L, L, L, Z\n  const commands = new Uint8Array([PATH_M, PATH_L, PATH_L, PATH_L, PATH_Z]);\n  const coords = new Float32Array([x0, y0, x1, y1, x2, y2, x3, y3]);\n  return { kind: 'polygon', commands, coords, fillRule: 'nonzero' };\n}\n"],"mappings":";;AA2CA,SAAgBA,EAAe,GAAoC;CACjE,IAAMC,IAAIC;CAIV,OAHID,EAAE,YAAYA,EAAE,KAAK,QAAQA,EAAE,KAAK,QAAQA,EAAE,SAAS,QAAQA,EAAE,UAAU,OACtE;EAAE,IAAIA,EAAE,IAAIA,EAAE,QAAQ;EAAG,IAAIA,EAAE,IAAIA,EAAE,SAAS;EAAG,UAAUA,EAAE;CAAS,IAExE;AACT;AAUA,SAAgBE,EAAiB,GAAY,GAAY,GAAY,GAA+B;CAIlG,OAHIC,EAAK,SAAS,SACTC,EAAkBD,EAAK,GAAGA,EAAK,GAAGA,EAAK,OAAOA,EAAK,QAAQE,GAAIC,GAAIC,CAAQ,IAE7EC,EAAcL,GAAME,GAAIC,GAAIC,CAAQ;AAC7C;AAEA,SAASC,EAAc,GAAmB,GAAY,GAAY,GAA+B;CAC/F,IAAMC,IAAM,KAAK,IAAIF,CAAQ,GACvBG,IAAM,KAAK,IAAIH,CAAQ,GACvB,EAAE,aAAU,cAAWJ,GACvBQ,IAAO,IAAI,aAAaC,EAAO,MAAM;CAS3C,OARAC,EAAeC,GAAUF,IAAS,GAAK,MAAO;EAC5C,KAAK,IAAIG,IAAI,GAAGC,IAAMC,EAAsBC,CAAG,GAAGH,IAAIC,GAAK,KAAK,GAAG;GACjE,IAAMG,IAAKP,EAAOQ,IAAKL,KAAKV,GACtBgB,IAAKT,EAAOQ,IAAKL,IAAI,KAAKT;GAEhC,AADA,EAAKc,IAAKL,KAAKV,IAAKc,IAAKV,IAAMY,IAAKX,GACpC,EAAKU,IAAKL,IAAI,KAAKT,IAAKa,IAAKT,IAAMW,IAAKZ;EAC1C;CACF,CAAC,GACM;EAAE,MAAM;EAAW,UAAUN,EAAK;EAAU,QAAQQ;EAAM,UAAUR,EAAK;CAAS;AAC3F;AAEA,SAASC,EACP,GAAW,GAAW,GAAW,GACjC,GAAY,GAAY,GACX;CACb,IAAMK,IAAM,KAAK,IAAIF,CAAQ,GACvBG,IAAM,KAAK,IAAIH,CAAQ,GACvBe,KAAU,GAAY,MAAiC;EAC3D,IAAMH,IAAKI,IAAKlB,GACVgB,IAAKG,IAAKlB;EAChB,OAAO,CAACD,IAAKc,IAAKV,IAAMY,IAAKX,GAAKJ,IAAKa,IAAKT,IAAMW,IAAKZ,CAAG;CAC5D,GACM,CAACgB,GAAIC,KAAMJ,EAAOK,GAAGC,CAAC,GACtB,CAACC,GAAIC,KAAMR,EAAOK,IAAII,GAAGH,CAAC,GAC1B,CAACI,GAAIC,KAAMX,EAAOK,IAAII,GAAGH,IAAIM,CAAC,GAC9B,CAACC,GAAIC,KAAMd,EAAOK,GAAGC,IAAIM,CAAC;CAIhC,OAAO;EAAE,MAAM;EAAW,UAAA,IAFL,WAAW;GAACG;GAAQC;GAAQA;GAAQA;GAAQC;EAAM,CAE7C;EAAU,QAAA,IADjB,aAAa;GAACd;GAAIC;GAAIG;GAAIC;GAAIE;GAAIC;GAAIE;GAAIC;EAAE,CAC3B;EAAQ,UAAU;CAAU;AAClE"}

package/dist/core/gradient.js

@@ -1,136 +0,0 @@
-import { resolveColor as e, rgbaToHex as t } from "../renderer/math/color.js";
-import { lerpColorArray as n } from "@weasel-js/paint";
-//#region src/core/gradient.ts
-function r(e) {
-	return e == null ? !1 : e.fill === "linear-gradient" || e.fill === "radial-gradient" || e.fill === "conic-gradient";
-}
-function i(t) {
-	return [...t].sort((e, t) => e.offset - t.offset).map((t) => ({
-		offset: t.offset,
-		rgba: e(t.color)
-	}));
-}
-function a(e, t, r = "rgb") {
-	if (e.length === 0) return o;
-	let i = e[0], a = e[e.length - 1];
-	if (t <= i.offset) return i.rgba;
-	if (t >= a.offset) return a.rgba;
-	for (let i = 0; i < e.length - 1; i++) {
-		let a = e[i], o = e[i + 1];
-		if (t < a.offset || t > o.offset) continue;
-		let s = o.offset - a.offset;
-		if (s <= 0) return o.rgba;
-		let c = (t - a.offset) / s, [l, u, d, f] = n(a.rgba, o.rgba, c, r);
-		return [
-			l,
-			u,
-			d,
-			f
-		];
-	}
-	return a.rgba;
-}
-var o = [
-	0,
-	0,
-	0,
-	0
-];
-function s(e, n, r = "rgb") {
-	return e.length === 0 ? "rgba(0,0,0,0)" : t(a(i(e), n, r));
-}
-function c(e, t) {
-	if (e.fill === t) return e;
-	let n = {
-		stops: e.stops,
-		units: e.units,
-		interpolate: e.interpolate,
-		opacity: e.opacity
-	}, { center: r, radius: i, angle: a } = l(e);
-	if (t === "linear-gradient") {
-		let e = Math.cos(a) * i, t = Math.sin(a) * i;
-		return {
-			fill: "linear-gradient",
-			from: {
-				x: r.x - e,
-				y: r.y - t
-			},
-			to: {
-				x: r.x + e,
-				y: r.y + t
-			},
-			...n
-		};
-	}
-	return t === "radial-gradient" ? {
-		fill: "radial-gradient",
-		center: r,
-		radius: i,
-		...n
-	} : {
-		fill: "conic-gradient",
-		center: r,
-		angle: a,
-		...n
-	};
-}
-function l(e) {
-	if (e.fill === "linear-gradient") {
-		let t = e.to.x - e.from.x, n = e.to.y - e.from.y;
-		return {
-			center: {
-				x: (e.from.x + e.to.x) / 2,
-				y: (e.from.y + e.to.y) / 2
-			},
-			radius: Math.hypot(t, n) / 2,
-			angle: Math.atan2(n, t)
-		};
-	}
-	return e.fill === "radial-gradient" ? {
-		center: e.center,
-		radius: e.radius,
-		angle: 0
-	} : {
-		center: e.center,
-		radius: u(e.units),
-		angle: e.angle
-	};
-}
-function u(e) {
-	return e === "bounds" ? .5 : 50;
-}
-function d(e, t, n, r) {
-	let i = {
-		x: t.x + t.width / 2,
-		y: t.y + t.height / 2
-	};
-	return e === "linear-gradient" ? {
-		fill: "linear-gradient",
-		from: {
-			x: t.x,
-			y: i.y
-		},
-		to: {
-			x: t.x + t.width,
-			y: i.y
-		},
-		stops: n,
-		units: r
-	} : e === "radial-gradient" ? {
-		fill: "radial-gradient",
-		center: i,
-		radius: Math.max(t.width, t.height) / 2,
-		stops: n,
-		units: r
-	} : {
-		fill: "conic-gradient",
-		center: i,
-		angle: 0,
-		stops: n,
-		units: r
-	};
-}
-//#endregion
-export { d as gradientForBounds, l as gradientGeometry, r as isGradientFill, i as resolveGradientStops, s as sampleGradientStops, a as sampleResolvedStops, c as withGradientKind };
-
-//# sourceMappingURL=gradient.js.map

package/dist/core/gradient.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"gradient.js","names":["isGradientFill","fill","resolveGradientStops","stops","a","b","s","resolveColor","sampleResolvedStops","TRANSPARENT","first","last","lo","hi","span","f","r","g","lerpColorArray","space","sampleGradientStops","rgbaToHex","t","withGradientKind","kind","common","gradientGeometry","dx","angle","radius","dy","center","conicArmRadius","units","gradientForBounds","bounds"],"sources":["../../src/core/gradient.ts"],"sourcesContent":["/**\n * Gradient helpers shared by renderers, editors and exporters: reading a\n * color out of a stop list, and moving a gradient between its three kinds.\n *\n * The stop list is the part every consumer agrees on; the geometry\n * (`from`/`to`, `center`, `radius`, `angle`) differs per kind, which is what\n * `withGradientKind` exists to translate.\n */\n\nimport { resolveColor, rgbaToHex } from '../renderer/math/color';\nimport { lerpColorArray } from '@weasel-js/paint';\nimport type { ColorSpace, FillStyle, GradStop, GradientFill, GradientKind } from '@weasel-js/paint';\n\n/** A stop with its color already parsed to 0..1 RGBA. */\nexport interface ResolvedGradientStop {\n  offset: number;\n  rgba: readonly [number, number, number, number];\n}\n\n/** Narrow a paint to the gradient members of `FillStyle`. The three\n *  discriminants are the union's own definition of `GradientFill`, so every\n *  consumer that reaches for gradient geometry starts here. */\nexport function isGradientFill(fill: FillStyle | null | undefined): fill is GradientFill {\n  if (fill == null) return false;\n  return fill.fill === 'linear-gradient'\n    || fill.fill === 'radial-gradient'\n    || fill.fill === 'conic-gradient';\n}\n\n/**\n * Sort a stop list by offset and parse each color to 0..1 RGBA — the reading\n * of a stop list that `sampleResolvedStops` works from, hoisted out so a\n * caller sampling many positions (the GL ramp) parses each color once.\n *\n * Colors go through `resolveColor`, so any CSS color the kit understands is a\n * legal stop, not just hex.\n */\nexport function resolveGradientStops(stops: readonly GradStop[]): ResolvedGradientStop[] {\n  return [...stops]\n    .sort((a, b) => a.offset - b.offset)\n    .map((s) => ({ offset: s.offset, rgba: resolveColor(s.color) }));\n}\n\n/**\n * RGBA (0..1) at position `t` along resolved stops: flat extension past\n * either end, interpolation between neighbors in `space`, alpha included.\n *\n * The single definition of what a stop list means. The GL ramp texture bakes\n * this at 256 positions and an editor calls it per pixel of a track; a second\n * implementation is a gradient that paints differently from its own swatch.\n *\n * `space` is a gradient's `interpolate`. Alpha is linear in every space —\n * only the color channels travel through OKLab or OKLCh.\n *\n * Returns transparent black for an empty list.\n */\nexport function sampleResolvedStops(\n  stops: readonly ResolvedGradientStop[], t: number, space: ColorSpace = 'rgb',\n): readonly [number, number, number, number] {\n  if (stops.length === 0) return TRANSPARENT;\n  const first = stops[0];\n  const last = stops[stops.length - 1];\n  if (t <= first.offset) return first.rgba;\n  if (t >= last.offset) return last.rgba;\n\n  for (let i = 0; i < stops.length - 1; i++) {\n    const lo = stops[i];\n    const hi = stops[i + 1];\n    if (t < lo.offset || t > hi.offset) continue;\n    const span = hi.offset - lo.offset;\n    // Coincident stops are a hard color break: take the later one.\n    if (span <= 0) return hi.rgba;\n    const f = (t - lo.offset) / span;\n    const [r, g, b, a] = lerpColorArray(lo.rgba, hi.rgba, f, space);\n    return [r, g, b, a];\n  }\n  return last.rgba;\n}\n\nconst TRANSPARENT: readonly [number, number, number, number] = [0, 0, 0, 0];\n\n/**\n * Color at position `t` (0..1) along a stop list, as a hex string — the same\n * sampling the GL ramp texture bakes, so an editor track and the painted\n * gradient cannot disagree.\n *\n * Returns transparent black for an empty list.\n */\nexport function sampleGradientStops(\n  stops: readonly GradStop[], t: number, space: ColorSpace = 'rgb',\n): string {\n  if (stops.length === 0) return 'rgba(0,0,0,0)';\n  return rgbaToHex(sampleResolvedStops(resolveGradientStops(stops), t, space));\n}\n\n/**\n * Retarget a gradient to a different kind, preserving stops, `units` and\n * `opacity`, and carrying the geometry across as faithfully as the kinds\n * allow.\n *\n * Linear carries a segment; radial and conic carry a center. Converting\n * between them keeps the center fixed and reads the radius / angle off the\n * segment, so switching kind in an editor moves the paint as little as\n * possible instead of snapping to an arbitrary default.\n *\n * Lossy in both directions, because the kinds hold different information: a\n * radial gradient stores no angle, so a round trip through one leaves the\n * segment horizontal; a conic stores no radius, so a round trip through one\n * resets the segment's length. An editor that wants a kind switch to be\n * undoable should keep the original paint rather than converting back.\n */\nexport function withGradientKind(fill: GradientFill, kind: GradientKind): GradientFill {\n  if (fill.fill === kind) return fill;\n  const common = {\n    stops: fill.stops, units: fill.units,\n    interpolate: fill.interpolate, opacity: fill.opacity,\n  };\n  const { center, radius, angle } = gradientGeometry(fill);\n\n  if (kind === 'linear-gradient') {\n    const dx = Math.cos(angle) * radius;\n    const dy = Math.sin(angle) * radius;\n    return {\n      fill: 'linear-gradient',\n      from: { x: center.x - dx, y: center.y - dy },\n      to: { x: center.x + dx, y: center.y + dy },\n      ...common,\n    };\n  }\n  if (kind === 'radial-gradient') {\n    return { fill: 'radial-gradient', center, radius, ...common };\n  }\n  return { fill: 'conic-gradient', center, angle, ...common };\n}\n\n/**\n * Center / radius / angle for any gradient kind — the shared polar reading\n * `withGradientKind` converts through, and what on-canvas handles position\n * themselves from.\n *\n * For a linear gradient the center is the segment midpoint, the radius is\n * half its length, and the angle is its direction.\n */\nexport function gradientGeometry(fill: GradientFill): {\n  center: { x: number; y: number };\n  radius: number;\n  angle: number;\n} {\n  if (fill.fill === 'linear-gradient') {\n    const dx = fill.to.x - fill.from.x;\n    const dy = fill.to.y - fill.from.y;\n    return {\n      center: { x: (fill.from.x + fill.to.x) / 2, y: (fill.from.y + fill.to.y) / 2 },\n      radius: Math.hypot(dx, dy) / 2,\n      angle: Math.atan2(dy, dx),\n    };\n  }\n  if (fill.fill === 'radial-gradient') {\n    return { center: fill.center, radius: fill.radius, angle: 0 };\n  }\n  return { center: fill.center, radius: conicArmRadius(fill.units), angle: fill.angle };\n}\n\n/**\n * Conic gradients carry no radius, but converting one to a linear or radial\n * gradient needs a non-zero length to build from.\n *\n * Unit-dependent, and that is the whole point: `'bounds'` geometry runs `0..1`\n * across the box, so a pixel-flavored default there does not mean \"a bit under\n * half the box\", it means fifty times it.\n */\nfunction conicArmRadius(units: GradientFill['units']): number {\n  return units === 'bounds' ? 0.5 : 50;\n}\n\n/**\n * A gradient spanning a box left edge to right edge through its vertical\n * center (linear) or filling it (radial / conic) — the sensible starting\n * geometry when a consumer turns a solid fill into a gradient and has only\n * the shape's bounds to go on.\n */\nexport function gradientForBounds(\n  kind: GradientKind,\n  bounds: { x: number; y: number; width: number; height: number },\n  stops: GradStop[],\n  units?: GradientFill['units'],\n): GradientFill {\n  const center = { x: bounds.x + bounds.width / 2, y: bounds.y + bounds.height / 2 };\n  if (kind === 'linear-gradient') {\n    return {\n      fill: 'linear-gradient',\n      from: { x: bounds.x, y: center.y },\n      to: { x: bounds.x + bounds.width, y: center.y },\n      stops,\n      units,\n    };\n  }\n  if (kind === 'radial-gradient') {\n    return {\n      fill: 'radial-gradient',\n      center,\n      radius: Math.max(bounds.width, bounds.height) / 2,\n      stops,\n      units,\n    };\n  }\n  return { fill: 'conic-gradient', center, angle: 0, stops, units };\n}\n"],"mappings":";;;AAsBA,SAAgBA,EAAe,GAA0D;CAEvF,OADIC,KAAQ,OAAa,KAClBA,EAAK,SAAS,qBAChBA,EAAK,SAAS,qBACdA,EAAK,SAAS;AACrB;AAUA,SAAgBC,EAAqB,GAAoD;CACvF,OAAO,CAAC,GAAGC,CAAK,CAAC,CACd,MAAM,GAAG,MAAMC,EAAE,SAASC,EAAE,MAAM,CAAC,CACnC,KAAK,OAAO;EAAE,QAAQC,EAAE;EAAQ,MAAMC,EAAaD,EAAE,KAAK;CAAE,EAAE;AACnE;AAeA,SAAgBE,EACd,GAAwC,GAAW,IAAoB,OAC5B;CAC3C,IAAIL,EAAM,WAAW,GAAG,OAAOM;CAC/B,IAAMC,IAAQP,EAAM,IACdQ,IAAOR,EAAMA,EAAM,SAAS;CAClC,IAAI,KAAKO,EAAM,QAAQ,OAAOA,EAAM;CACpC,IAAI,KAAKC,EAAK,QAAQ,OAAOA,EAAK;CAElC,KAAK,IAAI,IAAI,GAAG,IAAIR,EAAM,SAAS,GAAG,KAAK;EACzC,IAAMS,IAAKT,EAAM,IACXU,IAAKV,EAAM,IAAI;EACrB,IAAI,IAAIS,EAAG,UAAU,IAAIC,EAAG,QAAQ;EACpC,IAAMC,IAAOD,EAAG,SAASD,EAAG;EAE5B,IAAIE,KAAQ,GAAG,OAAOD,EAAG;EACzB,IAAME,KAAK,IAAIH,EAAG,UAAUE,GACtB,CAACE,GAAGC,GAAGZ,GAAGD,KAAKc,EAAeN,EAAG,MAAMC,EAAG,MAAME,GAAGI,CAAK;EAC9D,OAAO;GAACH;GAAGC;GAAGZ;GAAGD;EAAC;CACpB;CACA,OAAOO,EAAK;AACd;AAEA,IAAMF,IAAyD;CAAC;CAAG;CAAG;CAAG;AAAC;AAS1E,SAAgBW,EACd,GAA4B,GAAW,IAAoB,OACnD;CAER,OADIjB,EAAM,WAAW,IAAU,kBACxBkB,EAAUb,EAAoBN,EAAqBC,CAAK,GAAGmB,GAAGH,CAAK,CAAC;AAC7E;AAkBA,SAAgBI,EAAiB,GAAoB,GAAkC;CACrF,IAAItB,EAAK,SAASuB,GAAM,OAAOvB;CAC/B,IAAMwB,IAAS;EACb,OAAOxB,EAAK;EAAO,OAAOA,EAAK;EAC/B,aAAaA,EAAK;EAAa,SAASA,EAAK;CAC/C,GACM,EAAE,WAAQ,WAAQ,aAAUyB,EAAiBzB,CAAI;CAEvD,IAAIuB,MAAS,mBAAmB;EAC9B,IAAMG,IAAK,KAAK,IAAIC,CAAK,IAAIC,GACvBC,IAAK,KAAK,IAAIF,CAAK,IAAIC;EAC7B,OAAO;GACL,MAAM;GACN,MAAM;IAAE,GAAGE,EAAO,IAAIJ;IAAI,GAAGI,EAAO,IAAID;GAAG;GAC3C,IAAI;IAAE,GAAGC,EAAO,IAAIJ;IAAI,GAAGI,EAAO,IAAID;GAAG;GACzC,GAAGL;EACL;CACF;CAIA,OAHID,MAAS,oBACJ;EAAE,MAAM;EAAmB;EAAQ;EAAQ,GAAGC;CAAO,IAEvD;EAAE,MAAM;EAAkB;EAAQ;EAAO,GAAGA;CAAO;AAC5D;AAUA,SAAgBC,EAAiB,GAI/B;CACA,IAAIzB,EAAK,SAAS,mBAAmB;EACnC,IAAM0B,IAAK1B,EAAK,GAAG,IAAIA,EAAK,KAAK,GAC3B6B,IAAK7B,EAAK,GAAG,IAAIA,EAAK,KAAK;EACjC,OAAO;GACL,QAAQ;IAAE,IAAIA,EAAK,KAAK,IAAIA,EAAK,GAAG,KAAK;IAAG,IAAIA,EAAK,KAAK,IAAIA,EAAK,GAAG,KAAK;GAAE;GAC7E,QAAQ,KAAK,MAAM0B,GAAIG,CAAE,IAAI;GAC7B,OAAO,KAAK,MAAMA,GAAIH,CAAE;EAC1B;CACF;CAIA,OAHI1B,EAAK,SAAS,oBACT;EAAE,QAAQA,EAAK;EAAQ,QAAQA,EAAK;EAAQ,OAAO;CAAE,IAEvD;EAAE,QAAQA,EAAK;EAAQ,QAAQ+B,EAAe/B,EAAK,KAAK;EAAG,OAAOA,EAAK;CAAM;AACtF;AAUA,SAAS+B,EAAe,GAAsC;CAC5D,OAAOC,MAAU,WAAW,KAAM;AACpC;AAQA,SAAgBC,EACd,GACA,GACA,GACA,GACc;CACd,IAAMH,IAAS;EAAE,GAAGI,EAAO,IAAIA,EAAO,QAAQ;EAAG,GAAGA,EAAO,IAAIA,EAAO,SAAS;CAAE;CAmBjF,OAlBIX,MAAS,oBACJ;EACL,MAAM;EACN,MAAM;GAAE,GAAGW,EAAO;GAAG,GAAGJ,EAAO;EAAE;EACjC,IAAI;GAAE,GAAGI,EAAO,IAAIA,EAAO;GAAO,GAAGJ,EAAO;EAAE;EAC9C;EACA;CACF,IAEEP,MAAS,oBACJ;EACL,MAAM;EACN;EACA,QAAQ,KAAK,IAAIW,EAAO,OAAOA,EAAO,MAAM,IAAI;EAChD;EACA;CACF,IAEK;EAAE,MAAM;EAAkB;EAAQ,OAAO;EAAG;EAAO;CAAM;AAClE"}

package/dist/core/markerInset.js

@@ -1,24 +0,0 @@
-import { getMarker as e } from "./strokeMarkers.js";
-import { resolveScreenLength as t } from "@weasel-js/paint";
-//#region src/core/markerInset.ts
-function n(e, n, r = 1) {
-	return typeof e == "string" || e.size === void 0 ? n : t(e.size, r);
-}
-function r(e) {
-	return typeof e == "string" ? e : e.key;
-}
-function i(t, i, a = 1) {
-	if (t === void 0) return 0;
-	let o = e(r(t));
-	return o === void 0 ? 0 : (o.inset ?? 0) * n(t, i, a);
-}
-function a(e, t) {
-	return {
-		start: i(e.markerStart, t),
-		end: i(e.markerEnd, t)
-	};
-}
-//#endregion
-export { i as markerInset, r as markerKeyOf, n as resolveMarkerSize, a as strokeInsets };
-
-//# sourceMappingURL=markerInset.js.map

package/dist/core/markerInset.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"markerInset.js","names":["resolveMarkerSize","ref","strokeWidth","resolveScreenLength","scale","markerKeyOf","markerInset","entry","getMarker","strokeInsets","stroke"],"sources":["../../src/core/markerInset.ts"],"sourcesContent":["/**\n * Resolving a `MarkerRef` to the distance the ribbon must stop short.\n *\n * The tessellation layer takes these as plain numbers and knows nothing about\n * the registry — keeping that layer free of upward dependencies is deliberate.\n * The ribbon cache, the SVG serializer and `inkReach` all resolve through here,\n * so the ribbon, the export and the hit region cannot disagree about where the\n * line ends.\n */\n\nimport { resolveScreenLength, type MarkerRef, type Stroke } from '@weasel-js/paint';\nimport { getMarker } from './strokeMarkers';\n\n/** The size of one marker unit, in the same world units as `strokeWidth`.\n *  `scale` is the view scale a `{ px }` size resolves against, as a `{ px }`\n *  stroke width does. */\nexport function resolveMarkerSize(ref: MarkerRef, strokeWidth: number, scale = 1): number {\n  if (typeof ref === 'string' || ref.size === undefined) return strokeWidth;\n  return resolveScreenLength(ref.size, scale);\n}\n\n/** The registry key a `MarkerRef` names, whether given bare or with a size. */\nexport function markerKeyOf(ref: MarkerRef): string {\n  return typeof ref === 'string' ? ref : ref.key;\n}\n\n/**\n * How far back the ribbon stops for `ref`, in world units. Zero for an absent\n * marker, an unregistered key, or an open head — never throws, because an\n * unknown key is a data problem and dropping the head is the graceful answer.\n */\nexport function markerInset(ref: MarkerRef | undefined, strokeWidth: number, scale = 1): number {\n  if (ref === undefined) return 0;\n  const entry = getMarker(markerKeyOf(ref));\n  if (entry === undefined) return 0;\n  return (entry.inset ?? 0) * resolveMarkerSize(ref, strokeWidth, scale);\n}\n\n/** The start and end insets a stroke asks for. `markerMid` never insets —\n *  trimming at an interior vertex would cut the line in two. */\nexport function strokeInsets(stroke: Stroke, strokeWidth: number): { start: number; end: number } {\n  return {\n    start: markerInset(stroke.markerStart, strokeWidth),\n    end: markerInset(stroke.markerEnd, strokeWidth),\n  };\n}\n"],"mappings":";;;AAgBA,SAAgBA,EAAkB,GAAgB,GAAqB,IAAQ,GAAW;CAExF,OADI,OAAOC,KAAQ,YAAYA,EAAI,SAAS,KAAA,IAAkBC,IACvDC,EAAoBF,EAAI,MAAMG,CAAK;AAC5C;AAGA,SAAgBC,EAAY,GAAwB;CAClD,OAAO,OAAOJ,KAAQ,WAAWA,IAAMA,EAAI;AAC7C;AAOA,SAAgBK,EAAY,GAA4B,GAAqB,IAAQ,GAAW;CAC9F,IAAIL,MAAQ,KAAA,GAAW,OAAO;CAC9B,IAAMM,IAAQC,EAAUH,EAAYJ,CAAG,CAAC;CAExC,OADIM,MAAU,KAAA,IAAkB,KACxBA,EAAM,SAAS,KAAKP,EAAkBC,GAAKC,GAAaE,CAAK;AACvE;AAIA,SAAgBK,EAAa,GAAgB,GAAqD;CAChG,OAAO;EACL,OAAOH,EAAYI,EAAO,aAAaR,CAAW;EAClD,KAAKI,EAAYI,EAAO,WAAWR,CAAW;CAChD;AACF"}

package/dist/core/mixed.js

@@ -1,6 +0,0 @@
-//#region src/core/mixed.ts
-var e = Symbol("weasel:mixed");
-//#endregion
-export { e as MIXED };
-
-//# sourceMappingURL=mixed.js.map

package/dist/core/mixed.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"mixed.js","names":["MIXED"],"sources":["../../src/core/mixed.ts"],"sourcesContent":["/**\n * The kit-wide \"these values disagree\" sentinel. Used wherever a value is\n * aggregated across more than one source and the sources don't agree — e.g.\n * a UI panel aggregating a property across a multi-node selection, or text\n * styling aggregated across the runs in a character range. One symbol, one\n * `isMixed` check, regardless of what's being aggregated.\n */\nexport const MIXED: unique symbol = Symbol('weasel:mixed');\n/** The type of {@link MIXED}. Property panels use it to say \"the selection\n *  does not agree on this value\" without colliding with any real value. */\nexport type Mixed = typeof MIXED;\n"],"mappings":";AAOA,IAAaA,IAAuB,OAAO,cAAc"}

package/dist/core/paintKinds.js

@@ -1,156 +0,0 @@
-import { gradientForBounds as e, isGradientFill as t, withGradientKind as n } from "./gradient.js";
-import { getProgramSource as r, registerProgram as i } from "../renderer/shaders/registerProgram.js";
-import { bumpNodeMemoGeneration as a } from "./scene/nodeMemo.js";
-import { createReflectable as o } from "@weasel-js/registry";
-//#region src/core/paintKinds.ts
-var s = [
-	{
-		id: "solid",
-		label: "Solid",
-		icon: "paintSolid",
-		seed: (e) => ({ color: e }),
-		colorOf: (e) => (e.fill ?? "solid") === "solid" ? e.color : void 0
-	},
-	c("linear-gradient", "Linear", "paintLinear"),
-	c("radial-gradient", "Radial", "paintRadial"),
-	c("conic-gradient", "Conic", "paintConic"),
-	{
-		id: "pattern",
-		label: "Pattern",
-		icon: "paintPattern",
-		seed: (e) => ({
-			fill: "pattern",
-			pattern: {
-				tile: "hatch",
-				color: e
-			},
-			units: "bounds"
-		}),
-		colorOf: (e) => e.fill === "pattern" ? e.pattern.color : void 0
-	}
-];
-function c(t, n, r) {
-	return {
-		id: t,
-		label: n,
-		icon: r,
-		seed: (n) => e(t, l, u(n), "bounds"),
-		colorOf: (e) => e.stops?.[0]?.color,
-		stopsOf: (e) => e.stops,
-		fromStops: (n) => e(t, l, n, "bounds")
-	};
-}
-var l = {
-	x: 0,
-	y: 0,
-	width: 1,
-	height: 1
-};
-function u(e) {
-	let t = e.slice(0, 7).toLowerCase() === "#ffffff";
-	return [{
-		offset: 0,
-		color: e
-	}, {
-		offset: 1,
-		color: t ? "#000000ff" : "#ffffffff"
-	}];
-}
-var d = o();
-function f() {
-	for (let e of s) d.push(e.id, e, { source: "kit" });
-}
-f(), d.subscribe(a);
-var p = d.reflection;
-function m(e) {
-	return e;
-}
-function h(e) {
-	if (e.stopsOf === void 0 != (e.fromStops === void 0)) {
-		let t = e.stopsOf === void 0 ? "stopsOf" : "fromStops";
-		throw Error(`weasel registerPaintKind: kind "${e.id}" is missing ${t}. A gradient kind reads as a stop list and builds from one; supply both or neither.`);
-	}
-	if (e.inPoseFrame === void 0 != (e.toBoundsFrame === void 0)) {
-		let t = e.inPoseFrame === void 0 ? "inPoseFrame" : "toBoundsFrame";
-		throw Error(`weasel registerPaintKind: kind "${e.id}" is missing ${t}. A kind that converts one frame direction and not the other drifts on the next resize; supply both or neither.`);
-	}
-	for (let [t, n] of Object.entries(e.programs ?? {})) {
-		let e = r(t);
-		(!e || e.vert !== n.vert || e.frag !== n.frag) && i(t, n.vert, n.frag);
-	}
-	return d.push(e.id, e);
-}
-function g(e) {
-	let t = e ?? "solid", n = d.get(t);
-	return !n && _.has(t) && S(t).catch(() => {}), n;
-}
-var _ = /* @__PURE__ */ new Map(), v = /* @__PURE__ */ new Map(), y = [["mesh-gradient", async () => (await import("../features/meshPaint/lazyKind.js")).meshGradientKind]];
-function b() {
-	_.clear(), v.clear();
-	for (let [e, t] of y) _.set(e, t);
-}
-b();
-function x(e, t) {
-	return _.set(e, t), () => {
-		_.get(e) === t && _.delete(e);
-	};
-}
-function S(e) {
-	let t = v.get(e);
-	if (t) return t;
-	let n = _.get(e)().then((t) => {
-		if (t.id !== e) throw Error(`weasel: the loader for paint kind "${e}" resolved to "${t.id}".`);
-		d.has(e) || h(t);
-	}).catch((t) => {
-		throw console.error(`weasel: paint kind "${e}" failed to load:`, t), t;
-	});
-	return v.set(e, n), n;
-}
-function C(e) {
-	return d.has(e) || _.has(e);
-}
-function w(e) {
-	let t = e ?? [..._.keys()], n = [];
-	for (let e of t) if (!d.has(e)) {
-		if (!_.has(e)) return Promise.reject(/* @__PURE__ */ Error(`weasel warmPaintKinds: "${e}" is neither registered nor loadable.`));
-		n.push(S(e));
-	}
-	return Promise.all(n).then(() => void 0);
-}
-function T(e) {
-	let t, n = [];
-	return () => {
-		let r = d.entries();
-		return r !== t && (t = r, n = Object.freeze(e(r))), n;
-	};
-}
-function E() {
-	return D();
-}
-var D = T((e) => e.map((e) => e.value));
-function O() {
-	return k();
-}
-var k = T((e) => e.map((e) => e.value).filter((e) => e.stopsOf && e.fromStops));
-function A(e, r) {
-	let i = j(e), a = g(r);
-	if (!i?.stopsOf || !a?.fromStops) return;
-	if (i.id === a.id) return e;
-	if (t(e) && t({ fill: r })) return n(e, r);
-	let { interpolate: o, opacity: s } = e;
-	return {
-		...a.fromStops(i.stopsOf(e)),
-		...o === void 0 ? {} : { interpolate: o },
-		...s === void 0 ? {} : { opacity: s }
-	};
-}
-function j(e) {
-	return g(e.fill ?? "solid");
-}
-function M() {
-	d.clear(), f(), b();
-}
-//#endregion
-export { M as _resetPaintKindsForTests, m as asPaint, g as getPaintKind, C as isPaintKindKnown, O as listGradientKinds, E as listPaintKinds, j as paintKindOf, p as paintKindRegistry, h as registerPaintKind, x as registerPaintKindLoader, A as switchGradientKind, w as warmPaintKinds };
-
-//# sourceMappingURL=paintKinds.js.map

package/dist/core/paintKinds.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"paintKinds.js","names":["BUILTINS","paint","gradientKind","gradientForBounds","id","UNIT_BOX","twoStopRamp","color","stops","isWhite","KINDS","createReflectable","seedBuiltins","entry","bumpNodeMemoGeneration","paintKindRegistry","asPaint","registerPaintKind","missing","src","have","getProgramSource","registerProgram","getPaintKind","kind","LOADERS","startLoad","LOADS","LAZY_BUILTINS","seedLoaders","load","registerPaintKindLoader","running","done","err","isPaintKindKnown","warmPaintKinds","ids","kinds","loads","derivedList","from","list","entries","derive","listPaintKinds","allKinds","all","listGradientKinds","gradientKinds","switchGradientKind","paintKindOf","to","isGradientFill","withGradientKind","interpolate","opacity","fill","_resetPaintKindsForTests"],"sources":["../../src/core/paintKinds.ts"],"sourcesContent":["/**\n * The paint-kind registry — what makes `FillStyle` open.\n *\n * A consumer registers a sixth kind and it renders, converts between the\n * bounds and pose frames, and serializes, with no kit edits. The five built-in\n * kinds are registered here at module load so an editor's kind bar can\n * enumerate every kind through one list.\n *\n * Each kit layer consults this registry for a kind it does not recognize and\n * otherwise runs its own built-in branch. That split is not laziness: a built-in\n * kind's render slot lives in the GL renderer, its serialize slot lives in\n * `@weasel-js/svg`, and neither can be imported from here without inverting a\n * package dependency.\n */\n\nimport type {\n  ColorSpace, FillStyle, GradientFill, GradientKind, GradientUnits, GradStop, TilePatternSpec,\n} from '@weasel-js/paint';\nimport { gradientForBounds, isGradientFill, withGradientKind } from './gradient';\nimport { bumpNodeMemoGeneration } from './scene/nodeMemo';\nimport type { ComponentType } from 'react';\nimport { createReflectable, type ReflectedEntry, type Reflection } from '@weasel-js/registry';\nimport type { FillPoseBox } from './fillInPoseFrame';\nimport type { GlMat3 } from '../renderer/math/mat3';\nimport type { ShaderProgram } from '../renderer/shaders/ShaderProgram';\nimport { getProgramSource, registerProgram, type ProgramSource } from '../renderer/shaders/registerProgram';\n\n/** A compiled GL program. A paint kind gets one from\n *  {@link PaintBindContext.program} and hands it back from `bind`. */\nexport type PaintProgram = ShaderProgram;\n\n/**\n * `FillStyle`'s discriminant, open on the string the way `ChromeId` is: the\n * five kinds the kit ships, plus whatever a consumer registers.\n */\nexport type PaintKind = 'solid' | 'linear-gradient' | 'radial-gradient' | 'conic-gradient' | 'pattern' | (string & {});\n\n/** What a registered kind's editor renders. `PaintInput` in `@weasel-js/ui`\n *  is the control that mounts it. */\nexport interface PaintKindEditorProps {\n  value: FillStyle;\n  onInput?(next: FillStyle): void;\n  onChange(next: FillStyle): void;\n}\n\n/**\n * The lifetime a paint kind's GPU state belongs to: one renderer on one live\n * context. The object itself is the key — a kind caches textures in a\n * `WeakMap` on it, so two renderers sharing a context never trade them — and\n * `onRelease` is where it frees them.\n */\nexport interface PaintResources {\n  /** Run `release` once, when this lifetime ends: the renderer is disposed, or\n   *  its context was lost and restored. Free every GL object made under it\n   *  there. */\n  onRelease(release: () => void): void;\n}\n\n/**\n * The renderer surface a paint kind binds against, narrowed to what a paint\n * needs. The full `DrawContext` is not consumer surface.\n */\nexport interface PaintBindContext {\n  readonly gl: WebGL2RenderingContext;\n  /** The group alpha this draw inherits — multiply it into the paint's own. */\n  readonly alpha: number;\n  /**\n   * The compiled program for a `registerProgram` id, compiled against this\n   * renderer on first use. `null` when no source is registered under `id` or\n   * compilation failed.\n   */\n  program(id: string): PaintProgram | null;\n  /** Send `u_proj` and `u_model`, which every kit vertex shader takes. */\n  setProjAndModel(program: PaintProgram): void;\n  /**\n   * `u_worldInv` for a paint declaring `units` — the inverse of the transform\n   * from the paint's space to the frame the geometry arrives in. Paired with\n   * the vertex shader's `v_world` varying this is *the* paint-space\n   * convention; it is not gradient-specific.\n   *\n   * `null` when that space has no inverse — a transform or view that flattens\n   * an axis. Nothing the paint draws there means anything, so `bind` should\n   * return `null` and draw nothing.\n   */\n  spaceInverse(units: GradientUnits | undefined): GlMat3 | null;\n  /**\n   * The transform from the space `units` names to device pixels of the target\n   * this draw lands in — screen pixels times the pixel ratio on screen, output\n   * pixels in a headless render. It is what a paint baking a texture measures\n   * its resolution against. `null` where `spaceInverse` is.\n   */\n  spaceToDevice(units: GradientUnits | undefined): GlMat3 | null;\n  /** The largest texture side this context accepts, `MAX_TEXTURE_SIZE`. */\n  readonly maxTextureSize: number;\n  /** The lifetime GPU state made for this draw belongs to. Stable across the\n   *  frames of one renderer, so it is the key for a kind's texture cache. */\n  readonly resources: PaintResources;\n  /**\n   * Bake a stop ramp into the frame's ramp atlas, bind that atlas to a texture\n   * unit, and return the `v` the ramp's own row sits at — every ramp in a\n   * frame shares one texture, so a paint must sample at the returned `v` and\n   * not at a constant.\n   *\n   * `space` is the blend the stops are baked through, defaulting to `'rgb'`.\n   * It is part of the atlas key, so the same stops under two spaces take two\n   * rows rather than colliding.\n   */\n  bindRamp(stops: GradStop[], unit: number, space?: ColorSpace): number;\n}\n\n/**\n * One paint kind.\n *\n * `seed`, `label` and `colorOf` are the editor's slots and every kind has\n * them. The rest are optional because a kind may not need them — but\n * `inPoseFrame` and `toBoundsFrame` come as a pair or not at all: a kind that\n * converts one direction and not the other paints correctly once and then\n * drifts on the next resize.\n */\nexport interface PaintKindEntry {\n  id: string;\n  label: string;\n  /** Glyph naming this kind in an editor's kind bar, as an icon name the UI\n   *  layer resolves — the same indirection `PrefBase.icon` uses. A kind\n   *  without one is named by its `label`. */\n  icon?: string;\n  /** A paint of this kind seeded from a color — what an editor writes when a\n   *  consumer switches a solid to this kind. */\n  seed(fromColor: string): FillStyle;\n  /** The single color this paint shows, or `undefined` when it has none. */\n  colorOf(paint: FillStyle): string | undefined;\n  /** Editor slot. */\n  Editor?: ComponentType<PaintKindEditorProps>;\n  /**\n   * The stop list this paint reads as. With `fromStops`, it is what makes a\n   * kind a gradient: `listGradientKinds` returns the kinds carrying both, and\n   * `switchGradientKind` converts between any two of them through the list.\n   */\n  stopsOf?(paint: FillStyle): GradStop[];\n  /** A paint of this kind built from a stop list, in `bounds` units. The\n   *  converse of `stopsOf`; supply both or neither. */\n  fromStops?(stops: GradStop[]): FillStyle;\n  /**\n   * Render slot: bind program, uniforms and textures for `fill` and return the\n   * bound program; `null` declines the paint.\n   *\n   * Binding is split from drawing on purpose — a caller owning its own stencil\n   * state (an inner/outer-aligned stroke, an even-odd fill) must issue its own\n   * draw call, and the kit's draw wrapper would clobber that state. Shader\n   * output must be premultiplied: `outColor = vec4(rgb * a, a)`.\n   *\n   * The geometry is not always the node's own. Text below the outline tier\n   * paints by drawing a quad over its glyphs' screen box into an offscreen\n   * buffer and masking that with glyph coverage, so a paint must come from\n   * `v_world` through `spaceInverse`, not from where `a_position` happens to\n   * lie.\n   */\n  bind?(ctx: PaintBindContext, fill: FillStyle): PaintProgram | null;\n  /** Bounds frame → the frame the node is painted in. */\n  inPoseFrame?(fill: FillStyle, box: FillPoseBox): FillStyle;\n  /** The inverse. Required whenever `inPoseFrame` is supplied. */\n  toBoundsFrame?(fill: FillStyle, box: FillPoseBox): FillStyle;\n  /**\n   * The `<defs>` entry backing a `url(#id)` reference.\n   *\n   * SVG has paint servers for two gradients and a pattern and nothing else, so\n   * a kind beyond those has no element to target: write a foreign-namespaced\n   * one under the `wzl:` prefix `@weasel-js/svg` declares on the root whenever\n   * a document holds such a paint. That package emits the fallback color\n   * beside the reference on its own, from `colorOf`.\n   */\n  toSvg?(id: string, fill: FillStyle): string;\n  /**\n   * Shader programs `bind` looks up through `ctx.program`, keyed by program\n   * id; registering the kind registers them. Declaring them here rather than\n   * calling `registerProgram` at import keeps a kind loaded by\n   * {@link registerPaintKindLoader} free of core's registries.\n   */\n  programs?: Readonly<Record<string, ProgramSource>>;\n}\n\nconst BUILTINS: readonly PaintKindEntry[] = [\n  {\n    id: 'solid',\n    label: 'Solid',\n    icon: 'paintSolid',\n    seed: (color) => ({ color }),\n    colorOf: (paint) => ((paint.fill ?? 'solid') === 'solid'\n      ? (paint as { color: string }).color\n      : undefined),\n  },\n  gradientKind('linear-gradient', 'Linear', 'paintLinear'),\n  gradientKind('radial-gradient', 'Radial', 'paintRadial'),\n  gradientKind('conic-gradient', 'Conic', 'paintConic'),\n  {\n    id: 'pattern',\n    label: 'Pattern',\n    icon: 'paintPattern',\n    seed: (color) => ({\n      fill: 'pattern',\n      pattern: { tile: 'hatch', color },\n      units: 'bounds',\n    }),\n    colorOf: (paint) => (paint.fill === 'pattern'\n      ? (paint.pattern as Partial<TilePatternSpec>).color\n      : undefined),\n  },\n];\n\nfunction gradientKind(id: GradientKind, label: string, icon: string): PaintKindEntry {\n  return {\n    id,\n    label,\n    icon,\n    // `bounds` units make the seed independent of the node's actual size.\n    seed: (color) => gradientForBounds(id, UNIT_BOX, twoStopRamp(color), 'bounds'),\n    colorOf: (paint) => (paint as Partial<GradientFill>).stops?.[0]?.color,\n    stopsOf: (paint) => (paint as GradientFill).stops,\n    fromStops: (stops) => gradientForBounds(id, UNIT_BOX, stops, 'bounds'),\n  };\n}\n\nconst UNIT_BOX = { x: 0, y: 0, width: 1, height: 1 };\n\n/** `color` to a contrasting end — white reads against any hue; against white\n *  itself, black does. */\nfunction twoStopRamp(color: string): GradStop[] {\n  const isWhite = color.slice(0, 7).toLowerCase() === '#ffffff';\n  return [{ offset: 0, color }, { offset: 1, color: isWhite ? '#000000ff' : '#ffffffff' }];\n}\n\nconst KINDS = createReflectable<PaintKindEntry>();\n\nfunction seedBuiltins(): void {\n  for (const entry of BUILTINS) KINDS.push(entry.id, entry, { source: 'kit' });\n}\nseedBuiltins();\n// `NodeShape`'s paint slot memoizes per node and resolves a fill's frame\n// inside it, so the kind set is ambient state that memo cannot see change.\nKINDS.subscribe(bumpNodeMemoGeneration);\n\n/** Every registered paint kind, with the overrides each displaced. */\nexport const paintKindRegistry: Reflection<PaintKindEntry> = KINDS.reflection;\n\n/**\n * A consumer's own paint, typed as a `FillStyle`.\n *\n * `FillStyle` stays a closed union: opening its discriminant would widen every\n * built-in member and break the narrowing the kit's own branches depend on.\n * A registered kind declares its own interface instead and passes it through\n * here — the kit reads only `fill` and hands the whole object back to that\n * kind's slots.\n */\nexport function asPaint<T extends { fill: string }>(paint: T): FillStyle {\n  return paint as unknown as FillStyle;\n}\n\n/** Register a paint kind. Returns a disposer that removes it. Re-registering an\n *  existing id is an override; disposing it uncovers whatever it displaced. */\nexport function registerPaintKind(entry: PaintKindEntry): () => void {\n  if ((entry.stopsOf === undefined) !== (entry.fromStops === undefined)) {\n    const missing = entry.stopsOf === undefined ? 'stopsOf' : 'fromStops';\n    throw new Error(\n      `weasel registerPaintKind: kind \"${entry.id}\" is missing ${missing}. A ` +\n      'gradient kind reads as a stop list and builds from one; supply both or neither.',\n    );\n  }\n  if ((entry.inPoseFrame === undefined) !== (entry.toBoundsFrame === undefined)) {\n    const missing = entry.inPoseFrame === undefined ? 'inPoseFrame' : 'toBoundsFrame';\n    throw new Error(\n      `weasel registerPaintKind: kind \"${entry.id}\" is missing ${missing}. A kind ` +\n      'that converts one frame direction and not the other drifts on the next ' +\n      'resize; supply both or neither.',\n    );\n  }\n  for (const [id, src] of Object.entries(entry.programs ?? {})) {\n    const have = getProgramSource(id);\n    if (!have || have.vert !== src.vert || have.frag !== src.frag) registerProgram(id, src.vert, src.frag);\n  }\n  // Re-registering a built-in id is how a consumer closes a gap the kit leaves,\n  // so disposing that override puts the built-in back rather than deleting the\n  // kind.\n  return KINDS.push(entry.id, entry);\n}\n\n/** The entry for `kind`, or `undefined`. A lookup that misses on a kind with\n *  a loader starts that load; see {@link registerPaintKindLoader}. */\nexport function getPaintKind(kind: string | undefined): PaintKindEntry | undefined {\n  const id = kind ?? 'solid';\n  const entry = KINDS.get(id);\n  if (!entry && LOADERS.has(id)) void startLoad(id).catch(() => {});\n  return entry;\n}\n\n/** Resolves with the entry for a kind that is loaded on first use. */\nexport type PaintKindLoader = () => Promise<PaintKindEntry>;\n\nconst LOADERS = new Map<string, PaintKindLoader>();\n\n/** One load per kind, kept after it settles: a failed load is not retried on\n *  every frame that meets the kind. */\nconst LOADS = new Map<string, Promise<void>>();\n\n// A built-in kind heavy enough to keep off a consumer's bundle until a paint\n// of it turns up. Importing the module statically still registers it at once.\nconst LAZY_BUILTINS: ReadonlyArray<readonly [string, PaintKindLoader]> = [\n  ['mesh-gradient', async () => (await import('../features/meshPaint/lazyKind')).meshGradientKind],\n];\n\nfunction seedLoaders(): void {\n  LOADERS.clear();\n  LOADS.clear();\n  for (const [id, load] of LAZY_BUILTINS) LOADERS.set(id, load);\n}\nseedLoaders();\n\n/**\n * Declare a paint kind that is loaded the first time something looks it up,\n * so its code stays out of the bundle until a paint of it appears — typically\n * `() => import('./myKind').then((m) => m.myKindEntry)`.\n *\n * Until it lands the kind is unregistered: the renderer draws nothing for its\n * paints, and every other reader treats it as unknown. Registering it fires\n * `paintKindRegistry`'s subscribers, which is what `<SceneCanvas>` repaints\n * on. Call {@link warmPaintKinds} to load ahead of the first frame instead.\n *\n * A kind that is already registered never calls its loader. Returns a\n * disposer that removes the loader.\n */\nexport function registerPaintKindLoader(id: string, load: PaintKindLoader): () => void {\n  LOADERS.set(id, load);\n  return () => {\n    if (LOADERS.get(id) === load) LOADERS.delete(id);\n  };\n}\n\nfunction startLoad(id: string): Promise<void> {\n  const running = LOADS.get(id);\n  if (running) return running;\n  const load = LOADERS.get(id)!;\n  const done = load().then(\n    (entry) => {\n      if (entry.id !== id) {\n        throw new Error(`weasel: the loader for paint kind \"${id}\" resolved to \"${entry.id}\".`);\n      }\n      if (!KINDS.has(id)) registerPaintKind(entry);\n    },\n  ).catch((err: unknown) => {\n    console.error(`weasel: paint kind \"${id}\" failed to load:`, err);\n    throw err;\n  });\n  LOADS.set(id, done);\n  return done;\n}\n\n/** Is `id` registered, or declared with a loader? */\nexport function isPaintKindKnown(id: string): boolean {\n  return KINDS.has(id) || LOADERS.has(id);\n}\n\n/**\n * Load paint kinds ahead of their first use, so the first frame that meets\n * one draws it rather than a blank. With no list, loads every kind that has a\n * loader — the kit's lazily loaded built-ins (`mesh-gradient`) plus any a\n * consumer declared with {@link registerPaintKindLoader}.\n *\n * Resolves once every kind is registered; a kind already registered counts\n * as loaded. Rejects when a load fails, or for a kind that is neither\n * registered nor loadable.\n */\nexport function warmPaintKinds(kinds?: readonly string[]): Promise<void> {\n  const ids = kinds ?? [...LOADERS.keys()];\n  const loads: Promise<void>[] = [];\n  for (const id of ids) {\n    if (KINDS.has(id)) continue;\n    if (!LOADERS.has(id)) {\n      return Promise.reject(new Error(\n        `weasel warmPaintKinds: \"${id}\" is neither registered nor loadable.`,\n      ));\n    }\n    loads.push(startLoad(id));\n  }\n  return Promise.all(loads).then(() => undefined);\n}\n\n/** A list derived from the registry, recomputed only when it changes — so\n *  its identity is a `useSyncExternalStore` snapshot. */\nfunction derivedList(\n  derive: (all: readonly ReflectedEntry<PaintKindEntry>[]) => readonly PaintKindEntry[],\n): () => readonly PaintKindEntry[] {\n  let from: readonly ReflectedEntry<PaintKindEntry>[] | undefined;\n  let list: readonly PaintKindEntry[] = [];\n  return () => {\n    const entries = KINDS.entries();\n    if (entries !== from) {\n      from = entries;\n      list = Object.freeze(derive(entries));\n    }\n    return list;\n  };\n}\n\n/** Every registered kind, built-ins first, in registration order. The same\n *  array until the registry changes. */\nexport function listPaintKinds(): readonly PaintKindEntry[] {\n  return allKinds();\n}\nconst allKinds = derivedList((all) => all.map((e) => e.value));\n\n/** Every registered gradient kind — the ones that read as and build from a\n *  stop list — in registration order. The same array until the registry\n *  changes. */\nexport function listGradientKinds(): readonly PaintKindEntry[] {\n  return gradientKinds();\n}\nconst gradientKinds = derivedList(\n  (all) => all.map((e) => e.value).filter((entry) => entry.stopsOf && entry.fromStops),\n);\n\n/**\n * `paint` retargeted to gradient kind `kind`, or `undefined` when either side\n * is not a gradient kind.\n *\n * Between two of the stop gradients this is `withGradientKind`, which carries\n * the geometry. Any other pair goes through the stop list — `stopsOf` on the\n * way out, `fromStops` on the way in — keeping `interpolate` and `opacity`.\n * Lossy wherever the kinds hold different information; an editor that wants a\n * switch to be undoable should keep the original paint.\n */\nexport function switchGradientKind(paint: FillStyle, kind: PaintKind): FillStyle | undefined {\n  const from = paintKindOf(paint);\n  const to = getPaintKind(kind);\n  if (!from?.stopsOf || !to?.fromStops) return undefined;\n  if (from.id === to.id) return paint;\n  if (isGradientFill(paint) && isGradientFill({ fill: kind } as FillStyle)) {\n    return withGradientKind(paint, kind as GradientKind);\n  }\n  const { interpolate, opacity } = paint as { interpolate?: ColorSpace; opacity?: number };\n  return {\n    ...to.fromStops(from.stopsOf(paint)),\n    ...(interpolate !== undefined ? { interpolate } : {}),\n    ...(opacity !== undefined ? { opacity } : {}),\n  } as FillStyle;\n}\n\n/** The registry entry for a paint, or `undefined` when its kind is unknown. */\nexport function paintKindOf(fill: FillStyle): PaintKindEntry | undefined {\n  return getPaintKind(fill.fill ?? 'solid');\n}\n\n/** @internal Test helper — do not call from product code. */\nexport function _resetPaintKindsForTests(): void {\n  KINDS.clear();\n  seedBuiltins();\n  seedLoaders();\n}\n"],"mappings":"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"}

package/dist/core/scene/pickability.js

@@ -1,6 +0,0 @@
-//#region src/core/scene/pickability.ts
-var e = (e) => e.pickable === void 0 ? {} : { pickable: e.pickable };
-//#endregion
-export { e as pickability };
-
-//# sourceMappingURL=pickability.js.map

package/dist/core/scene/pickability.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"pickability.js","names":["pickability","n"],"sources":["../../../src/core/scene/pickability.ts"],"sourcesContent":["/** The `pickable` field of a node as a spread for `scene.add`: present only\n *  when the node states it, so an unstated one keeps the scene's default. */\nexport const pickability = (n: { pickable?: boolean }): { pickable?: boolean } =>\n  n.pickable !== undefined ? { pickable: n.pickable } : {};\n"],"mappings":";AAEA,IAAaA,KAAe,MAC1BC,EAAE,aAAa,KAAA,IAAuC,CAAC,IAA5B,EAAE,UAAUA,EAAE,SAAS"}