morphicons 1.7.1 → 2.0.0

package/dist/MorphIcon.svelte

@@ -12,6 +12,7 @@
 import { onMount, untrack } from "svelte";
 import {
   computeInitialD,
+  computeInitialPaint,
   createController,
   type IconInput,
   type MorphIconProps,
@@ -37,21 +38,34 @@ let {
 // svelte-ignore state_referenced_locally — mount-time value on purpose: the
 // initial d must stay a constant so Svelte never rewrites the attribute.
 const initialD = computeInitialD({ icon, from, to, progress });
+const initialPaint = computeInitialPaint({ icon, from, to, progress });
 
 let pathEl: SVGPathElement | undefined = $state();
+const sw = $derived(
+  absoluteStrokeWidth ? (Number(strokeWidth) * 24) / Number(size) : strokeWidth,
+);
+
 // svelte-ignore state_referenced_locally — init-time values on purpose: they
 // seed the controller's watch baselines so the first $effect run is a no-op.
-const ctrl = createController({ icon, from, to, progress, reducedMotion });
+const ctrl = createController({
+  icon,
+  from,
+  to,
+  progress,
+  reducedMotion,
+  strokeWidth: sw,
+});
 
 onMount(() => {
-  if (pathEl) ctrl.mount(pathEl, { icon, from, to, progress, reducedMotion });
+  if (pathEl)
+    ctrl.mount(pathEl, { icon, from, to, progress, reducedMotion, strokeWidth: sw });
   return () => ctrl.destroy();
 });
 
 // Prop changes: one watcher owns the mode logic (controlled wins — change
 // detection and precedence live in shared.ts).
 $effect(() => {
-  const next = { icon, from, to, progress, spring, reducedMotion };
+  const next = { icon, from, to, progress, spring, reducedMotion, strokeWidth: sw };
   untrack(() => ctrl.watch(next));
 });
 
@@ -62,10 +76,6 @@ export function morphTo(i: IconInput, s?: SpringPreset | MorphOptions): void {
 export function set(i: IconInput): void {
   ctrl.set(i);
 }
-
-const sw = $derived(
-  absoluteStrokeWidth ? (Number(strokeWidth) * 24) / Number(size) : strokeWidth,
-);
 </script>
 
 <svg
@@ -75,6 +85,7 @@ const sw = $derived(
   viewBox="0 0 24 24"
   fill="none"
   stroke={color}
+  {color}
   stroke-width={sw}
   stroke-linecap="round"
   stroke-linejoin="round"
@@ -83,5 +94,5 @@ const sw = $derived(
   {...rest}
 >
   {#if label}<title>{label}</title>{/if}
-  <path bind:this={pathEl} d={initialD} />
+  <path bind:this={pathEl} d={initialD} {...initialPaint} />
 </svg>

package/dist/adapters.d.ts

@@ -1,5 +1,5 @@
-import { n as IconInput } from "./types-JAF3s76Y.js";
-import { i as PathEl } from "./index-DXp5b6BU.js";
+import { a as IconInput } from "./plan-DhaDhEVq.js";
+import { i as PathEl } from "./index-DpvKR75N.js";
 //#region src/adapters/canvas.d.ts
 /** The 2D context surface the target drives — structural, so a real
  *  CanvasRenderingContext2D, an OffscreenCanvasRenderingContext2D or a test
@@ -42,7 +42,7 @@ interface CanvasTargetOptions {
  *  the morph's geometry onto the canvas, so
  *  `createMorph(canvasTarget(canvas), icon)` animates pixels instead of an
  *  inline `<svg><path>`. */
-declare function canvasTarget(surface: CanvasSurface | Canvas2DContext, opts?: CanvasTargetOptions): PathEl;
+export declare function canvasTarget(surface: CanvasSurface | Canvas2DContext, opts?: CanvasTargetOptions): PathEl;
 //#endregion
 //#region src/adapters/mask.d.ts
 /** The subset of an element's inline style the mask target writes — structural
@@ -85,15 +85,16 @@ interface MaskPathEl extends PathEl {
  *  the back buffer and re-points `mask-image` at it: the property VALUE flips
  *  (`url(#a)` ↔ `url(#b)`) each frame, which forces reference re-resolution
  *  in every engine. Chromium/Gecko pay nothing extra for it. */
-declare function maskTarget(el: MaskEl, opts?: MaskTargetOptions): MaskPathEl;
+export declare function maskTarget(el: MaskEl, opts?: MaskTargetOptions): MaskPathEl;
 //#endregion
 //#region src/adapters/svg.d.ts
 /** SVG markup → an IconInput the pipeline can lower. Strips non-rendered
- *  containers, rejects what can't be honestly morphed (a fill-drawn icon with
- *  no stroke, a transform, an unsupported element), and re-grids onto 24 via
- *  the viewBox when one is present — so an off-grid collection lands on the
- *  shared grid automatically. Returns a `d` (when a viewBox forced a fit) or
- *  an IconNode. */
-declare function svgToIcon(markup: string): IconInput;
+ *  containers, rejects what it can't read (an unsupported element, empty
+ *  geometry) and re-grids onto 24 via the viewBox when one is present.
+ *  Stroke icons return a `d` (when a viewBox forced a fit) or an IconNode,
+ *  exactly as before; fill-drawn icons return an IconNode whose elements
+ *  carry their resolved paint (fill/stroke/stroke-width/fill-rule), which
+ *  is what makes the morph fly as a region. */
+export declare function svgToIcon(markup: string): IconInput;
 //#endregion
-export { type Canvas2DContext, type CanvasSurface, type CanvasTargetOptions, type MaskEl, type MaskPathEl, type MaskStyle, type MaskTargetOptions, canvasTarget, maskTarget, svgToIcon };
+export type { Canvas2DContext, CanvasSurface, CanvasTargetOptions, MaskEl, MaskPathEl, MaskStyle, MaskTargetOptions };

package/dist/adapters.js

@@ -1,4 +1,4 @@
-import { t as fitIcon } from "./normalize-CYnN3Npw.js";
+import { n as iconToCubics, r as cubicsToPathD, t as fitIcon } from "./normalize-CYnN3Npw.js";
 //#region src/adapters/canvas.ts
 /** Adapts a canvas (or its 2D context) into a `PathEl` whose writes stroke
 *  the morph's geometry onto the canvas, so
@@ -118,7 +118,7 @@ function maskTarget(el, opts = {}) {
 //#endregion
 //#region src/adapters/svg.ts
 const SVG_CONTAINER = /<(defs|mask|clipPath|symbol)\b[^>]*>[\s\S]*?<\/\1>/gi;
-const SVG_ELEMENT = /<([a-zA-Z][\w:-]*)((?:[^>"']|"[^"]*"|'[^']*')*?)\/?>/g;
+const SVG_TAG = /<(\/?)([a-zA-Z][\w:-]*)((?:[^>"']|"[^"]*"|'[^']*')*?)(\/?)>/g;
 const SVG_ATTR = /([\w:-]+)\s*=\s*"([^"]*)"|([\w:-]+)\s*=\s*'([^']*)'/g;
 const SVG_VIEWBOX = /<svg\b[^>]*\bviewBox\s*=\s*["']([^"']+)["']/i;
 const SVG_GEOMETRY = /* @__PURE__ */ new Set([
@@ -130,9 +130,12 @@ const SVG_GEOMETRY = /* @__PURE__ */ new Set([
 	"polyline",
 	"polygon"
 ]);
-const SVG_SKIP = /* @__PURE__ */ new Set([
+const SVG_GROUP = /* @__PURE__ */ new Set([
 	"svg",
 	"g",
+	"a"
+]);
+const SVG_SKIP = /* @__PURE__ */ new Set([
 	"title",
 	"desc",
 	"defs",
@@ -140,6 +143,16 @@ const SVG_SKIP = /* @__PURE__ */ new Set([
 	"clippath",
 	"symbol"
 ]);
+const PAINT = [
+	"fill",
+	"stroke",
+	"stroke-width",
+	"fill-rule",
+	"opacity",
+	"fill-opacity",
+	"visibility",
+	"display"
+];
 function readSvgAttrs(raw) {
 	const attrs = {};
 	SVG_ATTR.lastIndex = 0;
@@ -150,32 +163,219 @@ function readSvgAttrs(raw) {
 	}
 	return attrs;
 }
+function paintOf(parent, attrs) {
+	const out = { ...parent };
+	for (const k of PAINT) if (attrs[k] !== void 0) out[k] = String(attrs[k]);
+	for (const decl of String(attrs.style ?? "").split(";")) {
+		const i = decl.indexOf(":");
+		const k = decl.slice(0, i).trim().toLowerCase();
+		if (i > 0 && PAINT.includes(k)) out[k] = decl.slice(i + 1).trim();
+	}
+	return out;
+}
+const mul = (m, n) => [
+	m[0] * n[0] + m[2] * n[1],
+	m[1] * n[0] + m[3] * n[1],
+	m[0] * n[2] + m[2] * n[3],
+	m[1] * n[2] + m[3] * n[3],
+	m[0] * n[4] + m[2] * n[5] + m[4],
+	m[1] * n[4] + m[3] * n[5] + m[5]
+];
+function parseTransform(v) {
+	const s = String(v ?? "").trim();
+	if (!s) return null;
+	let m = [
+		1,
+		0,
+		0,
+		1,
+		0,
+		0
+	];
+	for (const [, fn, args] of s.matchAll(/(\w+)\s*\(([^)]*)\)/g)) {
+		const a = args.trim().split(/[\s,]+/).map(Number);
+		const rad = (a[0] ?? 0) * Math.PI / 180;
+		let t;
+		switch (fn) {
+			case "matrix":
+				t = [
+					a[0],
+					a[1],
+					a[2],
+					a[3],
+					a[4],
+					a[5]
+				];
+				break;
+			case "translate":
+				t = [
+					1,
+					0,
+					0,
+					1,
+					a[0],
+					a[1] ?? 0
+				];
+				break;
+			case "scale":
+				t = [
+					a[0],
+					0,
+					0,
+					a[1] ?? a[0],
+					0,
+					0
+				];
+				break;
+			case "rotate": {
+				const c = Math.cos(rad);
+				const n = Math.sin(rad);
+				const [cx = 0, cy = 0] = [a[1], a[2]];
+				t = [
+					c,
+					n,
+					-n,
+					c,
+					cx - c * cx + n * cy,
+					cy - n * cx - c * cy
+				];
+				break;
+			}
+			case "skewX":
+				t = [
+					1,
+					0,
+					Math.tan(rad),
+					1,
+					0,
+					0
+				];
+				break;
+			case "skewY":
+				t = [
+					1,
+					Math.tan(rad),
+					0,
+					1,
+					0,
+					0
+				];
+				break;
+			default: throw new Error(`morphicons: unsupported transform "${fn}"`);
+		}
+		if (t.some((x) => !Number.isFinite(x))) throw new Error(`morphicons: invalid transform "${s}"`);
+		m = mul(m, t);
+	}
+	return m;
+}
+function bake(tag, attrs, m) {
+	const paths = iconToCubics([[tag, attrs]]);
+	for (const { pts } of paths) for (let i = 0; i < pts.length; i += 2) {
+		const x = pts[i];
+		const y = pts[i + 1];
+		pts[i] = m[0] * x + m[2] * y + m[4];
+		pts[i + 1] = m[1] * x + m[3] * y + m[5];
+	}
+	return cubicsToPathD(paths);
+}
+function stripComments(markup) {
+	let out = markup;
+	let prev;
+	do {
+		prev = out;
+		out = out.replace(/<!--[\s\S]*?-->/g, "");
+	} while (out !== prev);
+	const open = out.indexOf("<!--");
+	return open === -1 ? out : out.slice(0, open);
+}
+const painted = (v) => v !== void 0 && v.trim().toLowerCase() !== "none";
 /** SVG markup → an IconInput the pipeline can lower. Strips non-rendered
-*  containers, rejects what can't be honestly morphed (a fill-drawn icon with
-*  no stroke, a transform, an unsupported element), and re-grids onto 24 via
-*  the viewBox when one is present — so an off-grid collection lands on the
-*  shared grid automatically. Returns a `d` (when a viewBox forced a fit) or
-*  an IconNode. */
+*  containers, rejects what it can't read (an unsupported element, empty
+*  geometry) and re-grids onto 24 via the viewBox when one is present.
+*  Stroke icons return a `d` (when a viewBox forced a fit) or an IconNode,
+*  exactly as before; fill-drawn icons return an IconNode whose elements
+*  carry their resolved paint (fill/stroke/stroke-width/fill-rule), which
+*  is what makes the morph fly as a region. */
 function svgToIcon(markup) {
 	if (markup.trimStart().charCodeAt(0) !== 60) throw new Error("morphicons: svgToIcon expects SVG markup — a d string or IconNode is already an IconInput");
-	const body = markup.replace(SVG_CONTAINER, "");
-	const hasStroke = /stroke\s*=\s*["'](?!\s*none\s*["'])/i.test(body);
-	const fillNone = /fill\s*=\s*["']\s*none\s*["']/i.test(body);
-	if (!hasStroke && !fillNone) throw new Error("morphicons: SVG looks fill-drawn (no stroke) — only stroke-centerline icons morph");
-	const node = [];
-	SVG_ELEMENT.lastIndex = 0;
-	let m;
-	while ((m = SVG_ELEMENT.exec(body)) !== null) {
-		const tag = m[1].toLowerCase();
+	const clean = stripComments(markup);
+	if (/<style\b/i.test(clean)) throw new Error("morphicons: unsupported SVG element <style>");
+	const body = clean.replace(SVG_CONTAINER, "");
+	const found = [];
+	const stack = [{
+		paint: {},
+		m: null
+	}];
+	SVG_TAG.lastIndex = 0;
+	let mt;
+	while ((mt = SVG_TAG.exec(body)) !== null) {
+		const tag = mt[2].toLowerCase();
+		const top = stack[stack.length - 1];
+		if (mt[1]) {
+			if (SVG_GROUP.has(tag) && stack.length > 1) stack.pop();
+			continue;
+		}
 		if (SVG_SKIP.has(tag)) continue;
+		const attrs = readSvgAttrs(mt[3]);
+		const own = parseTransform(attrs.transform);
+		const m = own ? top.m ? mul(top.m, own) : own : top.m;
+		const paint = paintOf(top.paint, attrs);
+		if (top.paint.display === "none") paint.display = "none";
+		if (SVG_GROUP.has(tag)) {
+			if (!mt[4]) stack.push({
+				paint,
+				m
+			});
+			continue;
+		}
 		if (!SVG_GEOMETRY.has(tag)) throw new Error(`morphicons: unsupported SVG element <${tag}>`);
-		const attrs = readSvgAttrs(m[2]);
-		if ("transform" in attrs) throw new Error(`morphicons: <${tag}> has a transform (unsupported)`);
-		node.push([tag, attrs]);
+		if (paint.display === "none" || /^(hidden|collapse)$/.test(paint.visibility ?? "")) continue;
+		found.push({
+			tag,
+			attrs,
+			paint,
+			m
+		});
+	}
+	if (found.length === 0) throw new Error("morphicons: no morphable geometry in SVG");
+	const fills = found.map(({ paint }) => paint.fill !== void 0 ? painted(paint.fill) : !painted(paint.stroke));
+	const vb = SVG_VIEWBOX.exec(clean);
+	if (!fills.some(Boolean)) {
+		const node = found.map(({ tag, attrs, m }) => {
+			if (!m) return [tag, attrs];
+			const { transform: _, ...rest } = attrs;
+			return ["path", {
+				...rest,
+				d: bake(tag, attrs, m)
+			}];
+		});
+		return vb ? fitIcon(node, vb[1]) : node;
 	}
-	if (node.length === 0) throw new Error("morphicons: no morphable geometry in SVG");
-	const vb = SVG_VIEWBOX.exec(markup);
-	return vb ? fitIcon(node, vb[1]) : node;
+	let scale = 1;
+	if (vb) {
+		const [, , w, h] = vb[1].trim().split(/[\s,]+/).map(Number);
+		scale = Math.min(24 / w, 24 / h);
+	}
+	return found.map(({ tag, attrs, paint, m }, i) => {
+		const d = m ? bake(tag, attrs, m) : tag === "path" ? String(attrs.d ?? "") : bake(tag, attrs, [
+			1,
+			0,
+			0,
+			1,
+			0,
+			0
+		]);
+		const out = {
+			d: vb ? fitIcon(d, vb[1]) : d,
+			fill: fills[i] ? "currentColor" : "none",
+			stroke: painted(paint.stroke) ? "currentColor" : "none"
+		};
+		if (painted(paint.stroke)) out["stroke-width"] = String(Number.parseFloat(paint["stroke-width"] ?? "1") * scale);
+		if (paint["fill-rule"]) out["fill-rule"] = paint["fill-rule"];
+		if (paint.opacity) out.opacity = paint.opacity;
+		if (paint["fill-opacity"]) out["fill-opacity"] = paint["fill-opacity"];
+		return ["path", out];
+	});
 }
 //#endregion
 export { canvasTarget, maskTarget, svgToIcon };

package/dist/{controller-CXZuwJ_M.js → controller--7SSBggk.js}

@@ -1,12 +1,23 @@
-import { a as buildPlan, c as interpPolar, o as allocOutputs, r as resampleIcon } from "./spring-CFHloqPP.js";
+import { a as interpPolar, r as allocOutputs } from "./spring-B_P92nf6.js";
 import { i as serialize } from "./normalize-CYnN3Npw.js";
-import { canonicalD, createMorph } from "./dom.js";
+import { a as buildPlan, t as resampleIcon } from "./resample-CXlaZ5ZQ.js";
+import { a as paintOf } from "./region-BjECuWZR.js";
+import { canonicalD, createMorph, restAttrs } from "./dom.js";
 //#region src/dom/controller.ts
+/** The endpoint a frozen controlled pair renders at rest at `t` (SSR
+*  included), or null mid-way for a stroke pair, interpolated with the pure
+*  core. A pair with a fill endpoint scrubs as a region morph, which only the
+*  lazy chunk draws: mid-way it renders `from` until the client's first seek. */
+function frozenEnd(from, to, t) {
+	if (t >= 1) return to;
+	if (t <= 0 || paintOf(from) === "fill" || paintOf(to) === "fill") return from;
+	return null;
+}
 /** Frozen shape of the from→to pair at t, using the pure core (SSR-safe).
 *  At exact endpoints returns the canonical `d` (real curves, not polyline). */
 function frozenD(from, to, t) {
-	if (t <= 0) return canonicalD(from);
-	if (t >= 1) return canonicalD(to);
+	const end = frozenEnd(from, to, t);
+	if (end !== null) return canonicalD(end);
 	const plan = buildPlan(resampleIcon(from), resampleIcon(to));
 	const out = allocOutputs(plan);
 	interpPolar(plan, t, out);
@@ -21,6 +32,17 @@ function computeInitialD({ icon, from, to, progress }) {
 	const first = icon ?? from ?? to;
 	return first !== void 0 ? canonicalD(first) : "";
 }
+/** Paint attributes of the initial `<path>` (SSR included), a constant like
+*  the initial d: a fill icon is filled before any script runs. A frozen
+*  stroke pair paints as the endpoint it is nearer to; one with a fill
+*  endpoint rests on `from` mid-way, like its d (frozenEnd). */
+function computeInitialPaint({ icon, from, to, progress }) {
+	if (from !== void 0 && to !== void 0) {
+		const t = progress ?? 0;
+		return restAttrs(frozenEnd(from, to, t) ?? (t < .5 ? from : to));
+	}
+	return restAttrs(icon ?? from ?? to);
+}
 /** Per-instance driver state — the exact logic of the React/Vue bindings
 *  (mount, mode watch, controlled seek with re-basing, imperative). Takes the
 *  init-time props: they seed the watch baselines so a watcher that fires on
@@ -37,11 +59,12 @@ function computeInitialD({ icon, from, to, progress }) {
 *    path back to `icon`.
 *  - Every exit from controlled mode (imperative call or icon takeover)
 *    invalidates the frozen pair, so returning to it re-bases on `from`. */
-function createController({ icon, from, to, progress, reducedMotion }) {
+function createController({ icon, from, to, progress, reducedMotion, strokeWidth }) {
 	let el = null;
 	let dead = false;
 	let morph = null;
 	let rm = reducedMotion ?? "never";
+	let sw = Number(strokeWidth ?? 2);
 	let based = false;
 	let pair = null;
 	let prevIcon = icon;
@@ -53,7 +76,10 @@ function createController({ icon, from, to, progress, reducedMotion }) {
 	const ensure = (birth) => {
 		if (morph) return morph;
 		if (dead || !el) return null;
-		morph = createMorph(el, birth, { reducedMotion: rm });
+		morph = createMorph(el, birth, {
+			reducedMotion: rm,
+			strokeWidth: sw
+		});
 		return morph;
 	};
 	/** Controlled mode: freeze the pair at `progress` via seek (no spring). */
@@ -80,13 +106,17 @@ function createController({ icon, from, to, progress, reducedMotion }) {
 		}
 	};
 	return {
-		mount(mountEl, { icon, from, to, progress, reducedMotion }) {
+		mount(mountEl, { icon, from, to, progress, reducedMotion, strokeWidth }) {
 			el = mountEl;
 			rm = reducedMotion ?? rm;
+			sw = Number(strokeWidth ?? sw);
 			const controlled = from !== void 0 && to !== void 0;
 			const initialIcon = icon ?? from ?? to;
 			if (initialIcon === void 0) return;
-			const m = createMorph(el, controlled ? from : initialIcon, { reducedMotion: rm });
+			const m = createMorph(el, controlled ? from : initialIcon, {
+				reducedMotion: rm,
+				strokeWidth: sw
+			});
 			morph = m;
 			if (controlled) {
 				pair = [from, to];
@@ -110,9 +140,13 @@ function createController({ icon, from, to, progress, reducedMotion }) {
 		/** Prop watcher: ONE owner decides per run — the controlled pair while it
 		*  is fully present, `icon` otherwise (mount doesn't fire thanks to the
 		*  init-time baselines). */
-		watch({ icon, from, to, progress, spring, reducedMotion }) {
+		watch({ icon, from, to, progress, spring, reducedMotion, strokeWidth }) {
 			rm = reducedMotion ?? "never";
-			if (morph) morph.reducedMotion = rm;
+			sw = Number(strokeWidth ?? 2);
+			if (morph) {
+				morph.reducedMotion = rm;
+				morph.strokeWidth = sw;
+			}
 			const controlled = from !== void 0 && to !== void 0;
 			const left = prevControlled && !controlled;
 			const iconChanged = icon !== prevIcon;
@@ -149,4 +183,4 @@ function createController({ icon, from, to, progress, reducedMotion }) {
 	};
 }
 //#endregion
-export { createController as n, computeInitialD as t };
+export { frozenEnd as i, computeInitialPaint as n, createController as r, computeInitialD as t };

package/dist/{controller-Dkruvf3Y.d.ts → controller-DKm8s2ni.d.ts}

@@ -1,5 +1,6 @@
-import { c as SpringPreset, n as IconInput } from "./types-JAF3s76Y.js";
-import { a as ReducedMotionMode, i as PathEl, r as MorphOptions } from "./index-DXp5b6BU.js";
+import { a as IconInput } from "./plan-DhaDhEVq.js";
+import { r as SpringPreset } from "./spring-BgZHrI2W.js";
+import { a as ReducedMotionMode, i as PathEl, r as MorphOptions } from "./index-DpvKR75N.js";
 //#region src/dom/controller.d.ts
 /** Imperative surface exposed by every binding (ref / bind:this / element). */
 interface MorphHandle {
@@ -15,6 +16,9 @@ interface MorphModeProps {
 }
 interface MorphCtrlProps extends MorphModeProps {
   reducedMotion?: ReducedMotionMode;
+  /** The stroke width on the 24 grid (absoluteStrokeWidth already resolved):
+   *  what a stroke icon is outlined at when it morphs with a fill icon. */
+  strokeWidth?: number | string;
 }
 interface MorphWatchProps extends MorphCtrlProps {
   spring?: SpringPreset | MorphOptions;
@@ -24,6 +28,11 @@ interface MorphWatchProps extends MorphCtrlProps {
  *  without mismatch) and from then on only the driver mutates it outside the
  *  template. */
 declare function computeInitialD({ icon, from, to, progress }: MorphModeProps): string;
+/** Paint attributes of the initial `<path>` (SSR included), a constant like
+ *  the initial d: a fill icon is filled before any script runs. A frozen
+ *  stroke pair paints as the endpoint it is nearer to; one with a fill
+ *  endpoint rests on `from` mid-way, like its d (frozenEnd). */
+declare function computeInitialPaint({ icon, from, to, progress }: MorphModeProps): Record<string, string> | undefined;
 /** Per-instance driver state — the exact logic of the React/Vue bindings
  *  (mount, mode watch, controlled seek with re-basing, imperative). Takes the
  *  init-time props: they seed the watch baselines so a watcher that fires on
@@ -40,15 +49,15 @@ declare function computeInitialD({ icon, from, to, progress }: MorphModeProps):
  *    path back to `icon`.
  *  - Every exit from controlled mode (imperative call or icon takeover)
  *    invalidates the frozen pair, so returning to it re-bases on `from`. */
-declare function createController({ icon, from, to, progress, reducedMotion }: MorphCtrlProps): {
-  mount(mountEl: PathEl, { icon, from, to, progress, reducedMotion }: MorphCtrlProps): void;
+declare function createController({ icon, from, to, progress, reducedMotion, strokeWidth }: MorphCtrlProps): {
+  mount(mountEl: PathEl, { icon, from, to, progress, reducedMotion, strokeWidth }: MorphCtrlProps): void;
   destroy(): void;
   /** Prop watcher: ONE owner decides per run — the controlled pair while it
    *  is fully present, `icon` otherwise (mount doesn't fire thanks to the
    *  init-time baselines). */
-  watch({ icon, from, to, progress, spring, reducedMotion }: MorphWatchProps): void;
+  watch({ icon, from, to, progress, spring, reducedMotion, strokeWidth }: MorphWatchProps): void;
   morphTo(icon: IconInput, spring?: SpringPreset | MorphOptions): void;
   set(icon: IconInput): void;
 };
 //#endregion
-export { computeInitialD as n, createController as r, MorphHandle as t };
+export { createController as i, computeInitialD as n, computeInitialPaint as r, MorphHandle as t };

package/dist/dom.d.ts

@@ -1,2 +1,2 @@
-import { a as ReducedMotionMode, i as PathEl, n as Morph, o as canonicalD, r as MorphOptions, s as createMorph, t as CreateMorphOptions } from "./index-DXp5b6BU.js";
-export { CreateMorphOptions, Morph, MorphOptions, PathEl, ReducedMotionMode, canonicalD, createMorph };
+import { a as ReducedMotionMode, c as preloadRegion, i as PathEl, l as restAttrs, n as Morph, o as canonicalD, r as MorphOptions, s as createMorph, t as CreateMorphOptions, u as setRegionLoader } from "./index-DpvKR75N.js";
+export { CreateMorphOptions, Morph, MorphOptions, PathEl, ReducedMotionMode, canonicalD, createMorph, preloadRegion, restAttrs, setRegionLoader };