morphicons 1.7.1 → 2.0.1

package/dist/index.d.ts

@@ -1,50 +1,15 @@
-import { a as Sampled, c as SpringPreset, i as IconNodeAttrs, n as IconInput, o as SPRING_PRESETS, r as IconNode, s as Spring, t as CubicPath } from "./types-JAF3s76Y.js";
-//#region src/core/plan.d.ts
-interface PlanItem {
-  /** Points of A with the chosen correspondence (if A is a closed loop it
-   *  may come circularly re-indexed: same points, different cut). */
-  a: Float64Array;
-  /** A centered on its centroid. */
-  aC: Float64Array;
-  /** B brought into A's frame: R(−θ)·(b − c_B)/σ. */
-  bT: Float64Array;
-  /** B oriented, raw (for linear mode and for exact t=1). */
-  bO: Float64Array;
-  ca: readonly [number, number];
-  cb: readonly [number, number];
-  theta: number;
-  lnSigma: number;
-  res: number;
-  /** true if both endpoints are closed loops: the subpath flies with Z.
-   *  Closed → open flies open: the loop opens at the chosen cut. */
-  closed: boolean;
-  /** Block transport (set by the global hybrid, else null): mid-flight the
-   *  centroid rides the shared similarity around the global centroid instead
-   *  of lerping — off = c_A − g_A; drift closes c(1) = c_B exactly. */
-  block: {
-    off: readonly [number, number];
-    drift: readonly [number, number];
-  } | null;
-}
-interface MorphPlan {
-  items: PlanItem[];
-  n: number;
-}
-/** Builds the morph plan between two lists of sampled subpaths. The plan is
- *  cacheable and serializable; it accepts any list — including intermediate
- *  shapes (interruptions). */
-declare function buildPlan(srcSubs: readonly Sampled[], dstSubs: readonly Sampled[]): MorphPlan;
-//#endregion
+import { a as IconInput, c as Sampled, i as CubicPath, n as PlanItem, o as IconNode, r as buildPlan, s as IconNodeAttrs, t as MorphPlan } from "./plan-DhaDhEVq.js";
+import { n as Spring, r as SpringPreset, t as SPRING_PRESETS } from "./spring-BgZHrI2W.js";
 //#region src/core/interpolate.d.ts
 /** Preallocated output buffers for a plan (zero allocation per frame). */
-declare function allocOutputs(plan: MorphPlan): Float64Array[];
-declare function interpPolar(plan: MorphPlan, t: number, out: Float64Array[]): void;
+export declare function allocOutputs(plan: MorphPlan): Float64Array[];
+export declare function interpPolar(plan: MorphPlan, t: number, out: Float64Array[]): void;
 /** Raw coordinate lerp (same correspondence, no decomposition). */
-declare function interpLinear(plan: MorphPlan, t: number, out: Float64Array[]): void;
+export declare function interpLinear(plan: MorphPlan, t: number, out: Float64Array[]): void;
 //#endregion
 //#region src/core/normalize.d.ts
 /** Icon (IconNode or `d` string) → list of cubic subpaths. */
-declare function iconToCubics(input: IconInput): CubicPath[];
+export declare function iconToCubics(input: IconInput): CubicPath[];
 /** A source viewBox: `24`, `"0 0 20 20"` or `[minX, minY, w, h]`. */
 type ViewBox = number | string | readonly [number, number, number, number];
 /** Re-grids an icon drawn on `viewBox` onto the shared `grid` (24 by default),
@@ -55,7 +20,7 @@ type ViewBox = number | string | readonly [number, number, number, number];
  *  do not, and mixing them unfitted makes Procrustes read the scale/offset gap
  *  as rotation. Apply once at module scope (not per render) and pass the
  *  resulting `d` anywhere an icon is accepted. */
-declare function fitIcon(input: IconInput, viewBox: ViewBox, grid?: number): string;
+export declare function fitIcon(input: IconInput, viewBox: ViewBox, grid?: number): string;
 //#endregion
 //#region src/core/resample.d.ts
 /** Samples a cubic subpath at N points equidistant by arc length, anchoring
@@ -63,17 +28,17 @@ declare function fitIcon(input: IconInput, viewBox: ViewBox, grid?: number): str
  *  paths distribute N intervals around the loop (without duplicating the
  *  first point); the circular start-point freedom is resolved by the plan's
  *  circular correspondence. */
-declare function resamplePath(path: CubicPath, N?: number, cornerThreshold?: number): Float64Array;
+export declare function resamplePath(path: CubicPath, N?: number, cornerThreshold?: number): Float64Array;
 /** Full input pipeline: icon → cubics → sampled subpaths with their
  *  topology (the plan needs to know which subpaths are closed loops). */
-declare function resampleIcon(input: IconInput, N?: number): Sampled[];
+export declare function resampleIcon(input: IconInput, N?: number): Sampled[];
 //#endregion
 //#region src/core/serialize.d.ts
 /** Sampled subpaths → polyline `d` attribute. `closed[k]` appends Z to
  *  subpath k (closed loops in flight); without flags everything is open. */
-declare function serialize(subs: readonly Float64Array[], closed?: readonly boolean[]): string;
+export declare function serialize(subs: readonly Float64Array[], closed?: readonly boolean[]): string;
 /** Cubic subpaths → canonical `d`, quantized to 4 decimals (engine-stable
  *  bytes; see fmtCanon). */
-declare function cubicsToPathD(paths: readonly CubicPath[]): string;
+export declare function cubicsToPathD(paths: readonly CubicPath[]): string;
 //#endregion
-export { type CubicPath, type IconInput, type IconNode, type IconNodeAttrs, type MorphPlan, type PlanItem, SPRING_PRESETS, type Sampled, Spring, type SpringPreset, type ViewBox, allocOutputs, buildPlan, cubicsToPathD, fitIcon, iconToCubics, interpLinear, interpPolar, resampleIcon, resamplePath, serialize };
+export { type CubicPath, type IconInput, type IconNode, type IconNodeAttrs, type MorphPlan, type PlanItem, SPRING_PRESETS, type Sampled, Spring, type SpringPreset, type ViewBox, buildPlan };

package/dist/index.js

@@ -1,3 +1,4 @@
-import { a as buildPlan, c as interpPolar, i as resamplePath, n as Spring, o as allocOutputs, r as resampleIcon, s as interpLinear, t as SPRING_PRESETS } from "./spring-CFHloqPP.js";
+import { a as interpPolar, i as interpLinear, n as Spring, r as allocOutputs, t as SPRING_PRESETS } from "./spring-B_P92nf6.js";
 import { i as serialize, n as iconToCubics, r as cubicsToPathD, t as fitIcon } from "./normalize-CYnN3Npw.js";
+import { a as buildPlan, n as resamplePath, t as resampleIcon } from "./resample-CXlaZ5ZQ.js";
 export { SPRING_PRESETS, Spring, allocOutputs, buildPlan, cubicsToPathD, fitIcon, iconToCubics, interpLinear, interpPolar, resampleIcon, resamplePath, serialize };

package/dist/plan-DhaDhEVq.d.ts

@@ -0,0 +1,76 @@
+//#region src/core/types.d.ts
+/** Attributes of an icon node (values as Lucide exports them: string or
+ *  number). `undefined` is allowed on purpose — lucide's SVGProps includes it
+ *  and the runtime treats an undefined attr as absent (fallback). */
+type IconNodeAttrs = Record<string, string | number | undefined>;
+/** Lucide-style icon data: a `[tag, attrs]` list. Structurally typed —
+ *  Lucide is neither a dependency nor a peer; Feather/Tabler/custom paths
+ *  work just the same. */
+type IconNode = ReadonlyArray<readonly [string, IconNodeAttrs]>;
+/** Input accepted by the core: an IconNode or a raw `d` attribute.
+ *  (SVGElement is resolved in the dom layer — the core never touches DOM.) */
+type IconInput = IconNode | string;
+/** Normalized subpath: a chain of cubics packed as points
+ *  [p0, c1, c2, p1, c1', c2', p2, …] → Float64Array of length 2·(3m+1),
+ *  with m = number of segments. Consecutive segments share an endpoint. */
+interface CubicPath {
+  pts: Float64Array;
+  closed: boolean;
+}
+/** Subpath sampled at N points by arc length + its topology. It is the
+ *  currency between resample and plan; an intermediate shape (interruption)
+ *  is also a list of Sampled. */
+interface Sampled {
+  pts: Float64Array;
+  closed: boolean;
+  /** Region contours only: true for a hole (negative winding). Carried
+   *  explicitly because a hole collapsing mid-flight has ~zero area and
+   *  could not be re-classified from its points. */
+  hole?: boolean;
+}
+//#endregion
+//#region src/core/plan.d.ts
+interface PlanItem {
+  /** Points of A with the chosen correspondence (if A is a closed loop it
+   *  may come circularly re-indexed: same points, different cut). */
+  a: Float64Array;
+  /** A centered on its centroid. */
+  aC: Float64Array;
+  /** B brought into A's frame: R(−θ)·(b − c_B)/σ. */
+  bT: Float64Array;
+  /** B oriented, raw (for linear mode and for exact t=1). */
+  bO: Float64Array;
+  ca: readonly [number, number];
+  cb: readonly [number, number];
+  theta: number;
+  lnSigma: number;
+  res: number;
+  /** true if both endpoints are closed loops: the subpath flies with Z.
+   *  Closed → open flies open: the loop opens at the chosen cut. */
+  closed: boolean;
+  /** Region plans only: the item is a hole (negative winding). Collapsing
+   *  and growing holes are items too — their far endpoint is one point. */
+  hole?: boolean;
+  /** Region plans only: a hole that vanishes or appears blends its shape on
+   *  one half of the flight (0 = collapses on [0, ½], 1 = grows on [½, 1])
+   *  while it keeps riding its outer the whole way. */
+  half?: 0 | 1;
+  /** Block transport (set by the global hybrid, else null): mid-flight the
+   *  centroid rides the shared similarity around the global centroid instead
+   *  of lerping — off = c_A − g_A; drift closes c(1) = c_B exactly. */
+  block: {
+    off: readonly [number, number];
+    drift: readonly [number, number];
+  } | null;
+}
+interface MorphPlan {
+  items: PlanItem[];
+  n: number;
+}
+/** Builds the morph plan between two lists of sampled subpaths. The plan is
+ *  cacheable and serializable; it accepts any list — including intermediate
+ *  shapes (interruptions). Filled regions use buildRegionPlan (lazy chunk,
+ *  src/region/plan.ts) instead. */
+declare function buildPlan(srcSubs: readonly Sampled[], dstSubs: readonly Sampled[]): MorphPlan;
+//#endregion
+export { IconInput as a, Sampled as c, CubicPath as i, PlanItem as n, IconNode as o, buildPlan as r, IconNodeAttrs as s, MorphPlan as t };

package/dist/react-native.d.ts

@@ -1,13 +1,14 @@
-import { a as Sampled, c as SpringPreset, n as IconInput, r as IconNode } from "./types-JAF3s76Y.js";
-import { a as ReducedMotionMode, i as PathEl, n as Morph, r as MorphOptions } from "./index-DXp5b6BU.js";
+import { a as IconInput, c as Sampled, o as IconNode } from "./plan-DhaDhEVq.js";
+import { r as SpringPreset } from "./spring-BgZHrI2W.js";
+import { a as ReducedMotionMode, i as PathEl, n as Morph, r as MorphOptions } from "./index-DpvKR75N.js";
 import { SvgProps } from "react-native-svg";
 //#region src/react-native/index.d.ts
 /** Imperative surface exposed via ref. */
-interface MorphHandle {
+export interface MorphHandle {
   morphTo(icon: IconInput, spring?: SpringPreset | MorphOptions): void;
   set(icon: IconInput): void;
 }
-interface MorphIconProps extends Omit<SvgProps, "from" | "to"> {
+export interface MorphIconProps extends Omit<SvgProps, "from" | "to"> {
   /** Uncontrolled mode: the current icon; changing the prop animates. */
   icon?: IconInput;
   /** Controlled mode: source endpoint of the pair. */
@@ -31,6 +32,6 @@ interface MorphIconProps extends Omit<SvgProps, "from" | "to"> {
   /** Accessibility: with label → role="img" + aria-label; without → aria-hidden. */
   label?: string;
 }
-declare const MorphIcon: import("react").ForwardRefExoticComponent<MorphIconProps & import("react").RefAttributes<MorphHandle>>;
+export declare const MorphIcon: import("react").ForwardRefExoticComponent<MorphIconProps & import("react").RefAttributes<MorphHandle>>;
 //#endregion
-export { type IconInput, type IconNode, type Morph, MorphHandle, MorphIcon, MorphIconProps, type MorphOptions, type PathEl, type ReducedMotionMode, type Sampled, type SpringPreset };
+export type { IconInput, IconNode, Morph, MorphOptions, PathEl, ReducedMotionMode, Sampled, SpringPreset };

package/dist/react-native.js

@@ -1,6 +1,8 @@
-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 { canonicalD, createMorph, restAttrs } from "./dom.js";
+import { i as frozenEnd } from "./controller--7SSBggk.js";
 import { forwardRef, useCallback, useEffect, useImperativeHandle, useLayoutEffect, useRef, useState } from "react";
 import { jsx } from "react/jsx-runtime";
 import { AccessibilityInfo } from "react-native";
@@ -23,11 +25,23 @@ function initReducedMotion() {
 		});
 	} catch {}
 }
+const PAINT_PROPS = {
+	fill: "fill",
+	stroke: "stroke",
+	"fill-rule": "fillRule"
+};
+/** The driver's paint in native terms: currentColor (fill) and inherit
+*  (stroke) are the `color` prop — there is no cascade to resolve them. */
+function tint(p, color) {
+	const out = {};
+	for (const [k, v] of Object.entries(p)) out[k] = v === "currentColor" || v === "inherit" ? color : v;
+	return out;
+}
 /** Frozen shape of the from→to pair at t, using the pure core. 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);
@@ -43,23 +57,48 @@ const MorphIcon = forwardRef(function MorphIcon(props, ref) {
 	});
 	const liveD = useRef(initialD);
 	const declaredD = liveD.current;
+	const [initialPaint] = useState(() => {
+		const a = restAttrs(controlled ? frozenEnd(from, to, progress ?? 0) ?? ((progress ?? 0) < .5 ? from : to) : initialIcon);
+		return a ? {
+			fill: a.fill,
+			stroke: a.stroke,
+			fillRule: a["fill-rule"]
+		} : {};
+	});
+	const livePaint = useRef(initialPaint);
+	const declaredPaint = livePaint.current;
+	const colorRef = useRef(color);
+	colorRef.current = color;
 	const pathRef = useRef(null);
 	const morphRef = useRef(null);
 	const springRef = useRef(spring);
 	springRef.current = spring;
 	const rmRef = useRef(reducedMotion);
 	rmRef.current = reducedMotion;
+	const gridSw = Number(absoluteStrokeWidth ? Number(strokeWidth) * 24 / Number(size) : strokeWidth);
+	const swRef = useRef(gridSw);
+	swRef.current = gridSw;
 	const prevIcon = useRef(icon);
 	const prevControlled = useRef(controlled);
 	const dead = useRef(false);
 	const based = useRef(false);
 	const pair = useRef(null);
-	/** The PathEl shim: createMorph only ever writes `d`, and Path forwards
-	*  it to the native view without re-rendering. Stable identity. */
+	/** The PathEl shim: createMorph writes `d` (every frame) and paint (on
+	*  a stroke ↔ fill change), and Path forwards both to the native view
+	*  without re-rendering. Stable identity. */
 	const el = useRef({ setAttribute: (name, value) => {
-		if (name !== "d") return;
-		liveD.current = value;
-		pathRef.current?.setNativeProps({ d: value });
+		if (name === "d") {
+			liveD.current = value;
+			pathRef.current?.setNativeProps({ d: value });
+			return;
+		}
+		const key = PAINT_PROPS[name];
+		if (!key) return;
+		livePaint.current = {
+			...livePaint.current,
+			[key]: value
+		};
+		pathRef.current?.setNativeProps(tint({ [key]: value }, colorRef.current));
 	} });
 	/** morphTo that applies the reduced-motion policy ("user" reads the OS
 	*  setting via AccessibilityInfo, best-effort). */
@@ -78,13 +117,13 @@ const MorphIcon = forwardRef(function MorphIcon(props, ref) {
 	const ensure = useCallback((birth) => {
 		if (morphRef.current) return morphRef.current;
 		if (dead.current || !pathRef.current) return null;
-		morphRef.current = createMorph(el.current, birth);
+		morphRef.current = createMorph(el.current, birth, { strokeWidth: swRef.current });
 		return morphRef.current;
 	}, []);
 	useIsoLayoutEffect(() => {
 		dead.current = false;
 		if (pathRef.current && initialIcon !== void 0) {
-			const m = createMorph(el.current, controlled ? from : initialIcon);
+			const m = createMorph(el.current, controlled ? from : initialIcon, { strokeWidth: swRef.current });
 			morphRef.current = m;
 			if (controlled) {
 				pair.current = [from, to];
@@ -107,10 +146,15 @@ const MorphIcon = forwardRef(function MorphIcon(props, ref) {
 	}, []);
 	useIsoLayoutEffect(() => {
 		if (liveD.current !== declaredD) pathRef.current?.setNativeProps({ d: liveD.current });
+		if (livePaint.current !== declaredPaint) pathRef.current?.setNativeProps(tint(livePaint.current, colorRef.current));
 	});
 	useEffect(() => {
 		if (reducedMotion === "user") initReducedMotion();
 	}, [reducedMotion]);
+	useEffect(() => {
+		const m = morphRef.current;
+		if (m) m.strokeWidth = gridSw;
+	}, [gridSw]);
 	useEffect(() => {
 		const left = prevControlled.current && !controlled;
 		prevControlled.current = controlled;
@@ -189,7 +233,8 @@ const MorphIcon = forwardRef(function MorphIcon(props, ref) {
 		...rest,
 		children: /* @__PURE__ */ jsx(Path, {
 			ref: pathRef,
-			d: declaredD
+			d: declaredD,
+			...tint(declaredPaint, color)
 		})
 	});
 });

package/dist/react.d.ts

@@ -1,13 +1,14 @@
-import { a as Sampled, c as SpringPreset, n as IconInput, r as IconNode } from "./types-JAF3s76Y.js";
-import { a as ReducedMotionMode, i as PathEl, n as Morph, r as MorphOptions } from "./index-DXp5b6BU.js";
+import { a as IconInput, c as Sampled, o as IconNode } from "./plan-DhaDhEVq.js";
+import { r as SpringPreset } from "./spring-BgZHrI2W.js";
+import { a as ReducedMotionMode, i as PathEl, n as Morph, r as MorphOptions } from "./index-DpvKR75N.js";
 import { SVGProps } from "react";
 //#region src/react/index.d.ts
 /** Imperative surface exposed via ref. */
-interface MorphHandle {
+export interface MorphHandle {
   morphTo(icon: IconInput, spring?: SpringPreset | MorphOptions): void;
   set(icon: IconInput): void;
 }
-interface MorphIconProps extends Omit<SVGProps<SVGSVGElement>, "from" | "to" | "ref"> {
+export interface MorphIconProps extends Omit<SVGProps<SVGSVGElement>, "from" | "to" | "ref"> {
   /** Uncontrolled mode: the current icon; changing the prop animates. */
   icon?: IconInput;
   /** Controlled mode: source endpoint of the pair. */
@@ -30,6 +31,6 @@ interface MorphIconProps extends Omit<SVGProps<SVGSVGElement>, "from" | "to" | "
   /** Accessibility: with label → role="img" + <title>; without → aria-hidden. */
   label?: string;
 }
-declare const MorphIcon: import("react").ForwardRefExoticComponent<MorphIconProps & import("react").RefAttributes<MorphHandle>>;
+export declare const MorphIcon: import("react").ForwardRefExoticComponent<MorphIconProps & import("react").RefAttributes<MorphHandle>>;
 //#endregion
-export { type IconInput, type IconNode, type Morph, MorphHandle, MorphIcon, MorphIconProps, type MorphOptions, type PathEl, type ReducedMotionMode, type Sampled, type SpringPreset };
+export type { IconInput, IconNode, Morph, MorphOptions, PathEl, ReducedMotionMode, Sampled, SpringPreset };

package/dist/react.js

@@ -1,6 +1,8 @@
-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 { canonicalD, createMorph, restAttrs } from "./dom.js";
+import { i as frozenEnd } from "./controller--7SSBggk.js";
 import { forwardRef, useCallback, useEffect, useImperativeHandle, useLayoutEffect, useRef, useState } from "react";
 import { jsx, jsxs } from "react/jsx-runtime";
 //#region src/react/index.tsx
@@ -8,8 +10,8 @@ const useIsoLayoutEffect = typeof document === "undefined" ? useEffect : useLayo
 /** 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);
@@ -23,12 +25,23 @@ const MorphIcon = forwardRef(function MorphIcon(props, ref) {
 		if (controlled) return frozenD(from, to, progress ?? 0);
 		return initialIcon !== void 0 ? canonicalD(initialIcon) : "";
 	});
+	const [initialPaint] = useState(() => {
+		const a = restAttrs(controlled ? frozenEnd(from, to, progress ?? 0) ?? ((progress ?? 0) < .5 ? from : to) : initialIcon);
+		return a && {
+			fill: a.fill,
+			stroke: a.stroke,
+			fillRule: a["fill-rule"]
+		};
+	});
 	const pathRef = useRef(null);
 	const morphRef = useRef(null);
 	const springRef = useRef(spring);
 	springRef.current = spring;
 	const rmRef = useRef(reducedMotion);
 	rmRef.current = reducedMotion;
+	const gridSw = Number(absoluteStrokeWidth ? Number(strokeWidth) * 24 / Number(size) : strokeWidth);
+	const swRef = useRef(gridSw);
+	swRef.current = gridSw;
 	const prevIcon = useRef(icon);
 	const prevControlled = useRef(controlled);
 	const dead = useRef(false);
@@ -42,14 +55,20 @@ const MorphIcon = forwardRef(function MorphIcon(props, ref) {
 		if (morphRef.current) return morphRef.current;
 		const el = pathRef.current;
 		if (dead.current || !el) return null;
-		morphRef.current = createMorph(el, birth, { reducedMotion: rmRef.current });
+		morphRef.current = createMorph(el, birth, {
+			reducedMotion: rmRef.current,
+			strokeWidth: swRef.current
+		});
 		return morphRef.current;
 	}, []);
 	useIsoLayoutEffect(() => {
 		dead.current = false;
 		const el = pathRef.current;
 		if (el && initialIcon !== void 0) {
-			const m = createMorph(el, controlled ? from : initialIcon, { reducedMotion: rmRef.current });
+			const m = createMorph(el, controlled ? from : initialIcon, {
+				reducedMotion: rmRef.current,
+				strokeWidth: swRef.current
+			});
 			morphRef.current = m;
 			if (controlled) {
 				pair.current = [from, to];
@@ -74,6 +93,10 @@ const MorphIcon = forwardRef(function MorphIcon(props, ref) {
 		const m = morphRef.current;
 		if (m) m.reducedMotion = reducedMotion ?? "never";
 	}, [reducedMotion]);
+	useEffect(() => {
+		const m = morphRef.current;
+		if (m) m.strokeWidth = gridSw;
+	}, [gridSw]);
 	useEffect(() => {
 		const left = prevControlled.current && !controlled;
 		prevControlled.current = controlled;
@@ -144,6 +167,7 @@ const MorphIcon = forwardRef(function MorphIcon(props, ref) {
 		viewBox: "0 0 24 24",
 		fill: "none",
 		stroke: color,
+		color,
 		strokeWidth: sw,
 		strokeLinecap: "round",
 		strokeLinejoin: "round",
@@ -152,7 +176,8 @@ const MorphIcon = forwardRef(function MorphIcon(props, ref) {
 		...rest,
 		children: [label ? /* @__PURE__ */ jsx("title", { children: label }) : null, /* @__PURE__ */ jsx("path", {
 			ref: pathRef,
-			d: initialD
+			d: initialD,
+			...initialPaint
 		})]
 	});
 });

package/dist/region-BjECuWZR.js

@@ -0,0 +1,60 @@
+//#region src/core/region.ts
+/** Attribute that marks an IconNode as an already-normalized region (the
+*  output of `toRegion`): one `<path>` of non-overlapping closed contours,
+*  outers positive, holes negative. Normalization skips it. */
+const REGION_ATTR = "data-region";
+/** A paint attribute that paints (not absent, not `none`). */
+const painted = (v) => v !== void 0 && String(v).trim().toLowerCase() !== "none";
+/** Paint of an icon. Raw `d` strings and IconNodes that never declare a
+*  painted fill are stroke icons — the historical contract, so every
+*  existing input keeps its meaning. One element with a painted `fill` makes
+*  the whole icon a fill icon (mixed stroke+fill icons need the region path
+*  too: their silhouette is not a set of centerlines). */
+function paintOf(icon) {
+	if (typeof icon === "string") return "stroke";
+	for (const [, a] of icon) if (painted(a.fill)) return "fill";
+	return "stroke";
+}
+/** A duotone background layer (Phosphor: opacity 0.2) is not part of a
+*  monochrome silhouette: one path can't paint it translucent, so it is
+*  dropped from a fill icon rather than painted opaque. */
+const translucent = (a) => Number.parseFloat(String(a.opacity)) < .5 || Number.parseFloat(String(a["fill-opacity"])) < .5;
+/** The elements a fill icon actually draws: its translucent layers out. */
+function solid(icon) {
+	return typeof icon === "string" || paintOf(icon) === "stroke" ? icon : icon.filter(([, a]) => !translucent(a));
+}
+/** True when the icon is already a normalized region (no work left). */
+function isRegion(icon) {
+	return typeof icon !== "string" && icon.length === 1 && "data-region" in icon[0][1];
+}
+/** Even-odd point-in-polygon against a closed point cloud. */
+function inside(px, py, p) {
+	const n = p.length / 2;
+	let c = false;
+	for (let i = 0, j = n - 1; i < n; j = i++) {
+		const yi = p[2 * i + 1];
+		const yj = p[2 * j + 1];
+		if (yi > py !== yj > py && px < (p[2 * j] - p[2 * i]) * (py - yi) / (yj - yi) + p[2 * i]) c = !c;
+	}
+	return c;
+}
+/** Distance from (px, py) to the segment ab. */
+function distSeg(px, py, ax, ay, bx, by) {
+	const dx = bx - ax;
+	const dy = by - ay;
+	const l2 = dx * dx + dy * dy;
+	let t = l2 > 0 ? ((px - ax) * dx + (py - ay) * dy) / l2 : 0;
+	t = t < 0 ? 0 : t > 1 ? 1 : t;
+	const ex = px - ax - t * dx;
+	const ey = py - ay - t * dy;
+	return Math.sqrt(ex * ex + ey * ey);
+}
+/** Shoelace signed area of a closed point cloud (SVG axes: y down). */
+function signedArea(p) {
+	const n = p.length / 2;
+	let a = 0;
+	for (let i = 0, j = n - 1; i < n; j = i++) a += p[2 * j] * p[2 * i + 1] - p[2 * i] * p[2 * j + 1];
+	return a / 2;
+}
+//#endregion
+export { paintOf as a, solid as c, isRegion as i, translucent as l, distSeg as n, painted as o, inside as r, signedArea as s, REGION_ATTR as t };

package/dist/region.d.ts

@@ -0,0 +1,2 @@
+import { a as regionPlan, c as Paint, d as buildRegionPlan, f as resampleRegion, i as regionOf, l as isRegion, o as regionPlanFrom, r as regionContours, s as toRegion, t as RegionOptions, u as paintOf } from "./index-DDNCPQ4Z.js";
+export { type Paint, RegionOptions, buildRegionPlan, isRegion, paintOf, regionContours, regionOf, regionPlan, regionPlanFrom, resampleRegion, toRegion };