morphicons 1.7.0 → 2.0.0

package/dist/dom.js

@@ -1,5 +1,7 @@
-import { a as buildPlan, c as interpPolar, n as Spring, o as allocOutputs, r as resampleIcon, t as SPRING_PRESETS } from "./spring-CFHloqPP.js";
+import { a as interpPolar, 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 } from "./normalize-CYnN3Npw.js";
+import { a as buildPlan, d as reversePts, n as resamplePath, o as centroid, t as resampleIcon } from "./resample-CXlaZ5ZQ.js";
+import { a as paintOf, c as solid, o as painted, r as inside, s as signedArea } from "./region-BjECuWZR.js";
 //#region src/dom/index.ts
 const tickers = /* @__PURE__ */ new Set();
 let rafId = 0;
@@ -32,11 +34,33 @@ function removeTicker(tick) {
 const samples = /* @__PURE__ */ new WeakMap();
 const canon = /* @__PURE__ */ new WeakMap();
 const plans = /* @__PURE__ */ new WeakMap();
+function cubicsOf(icon) {
+	if (typeof icon === "string" || paintOf(icon) === "stroke") return iconToCubics(icon);
+	return solid(icon).flatMap((el) => {
+		const ps = iconToCubics([el]);
+		const odd = String(el[1]["fill-rule"]).trim() === "evenodd";
+		let sum = 0;
+		for (const p of ps) sum += signedArea(p.pts);
+		for (const p of ps) {
+			let flip = sum < 0;
+			if (odd) {
+				let pos = true;
+				for (const o of ps) if (o !== p && inside(p.pts[0], p.pts[1], o.pts)) pos = !pos;
+				flip = signedArea(p.pts) > 0 !== pos;
+			}
+			if (flip) p.pts = reversePts(p.pts);
+		}
+		return ps;
+	});
+}
 function sampledOf(icon) {
 	if (typeof icon === "string") return resampleIcon(icon);
 	let s = samples.get(icon);
 	if (!s) {
-		s = resampleIcon(icon);
+		s = cubicsOf(icon).map((p) => ({
+			pts: resamplePath(p, 64),
+			closed: p.closed
+		}));
 		samples.set(icon, s);
 	}
 	return s;
@@ -44,12 +68,13 @@ function sampledOf(icon) {
 /** Canonical `d` of an icon: the input string verbatim, or the real cubics
 *  quantized to 4 decimals (the at-rest snap; engine-stable bytes so SSR
 *  hydration matches, see fmtCanon in core/serialize). Exported because it
-*  is what a binding renders at SSR/rest before any runtime exists. */
+*  is what a binding renders at SSR/rest before any runtime exists. A fill
+*  icon's translucent duotone layer is left out (one path can't paint it). */
 function canonicalD(icon) {
 	if (typeof icon === "string") return icon;
 	let d = canon.get(icon);
 	if (!d) {
-		d = cubicsToPathD(iconToCubics(icon));
+		d = cubicsToPathD(cubicsOf(icon));
 		canon.set(icon, d);
 	}
 	return d;
@@ -68,6 +93,137 @@ function planBetween(src, dst) {
 	}
 	return p;
 }
+let regionMod = null;
+let regionLoading = null;
+let regionSince = 0;
+let regionFailed = false;
+let regionUrl;
+let regionGen = 0;
+let regionLoader = () => import("./region.js");
+/** Replaces how the region normalizer is loaded (default: dynamic import of
+*  the bundled chunk). E.g. `setRegionLoader(async () => region)` after a
+*  static `import * as region from "morphicons/region"` to never touch the
+*  network mid-interaction. The next need loads through the new loader. */
+function setRegionLoader(loader) {
+	regionLoader = loader;
+	regionGen++;
+	regionLoading = null;
+	regionMod = null;
+	regionFailed = false;
+	regionUrl = void 0;
+}
+const reload = (url) => new Promise((ok, ko) => {
+	const s = document.createElement("script");
+	s.type = "module";
+	s.onload = s.onerror = () => {
+		s.remove();
+		const m = globalThis[Symbol.for("morphicons.region")];
+		m ? ok(m) : ko(new Error(url));
+	};
+	s.src = `${url}#${Date.now()}`;
+	document.head.append(s);
+});
+const fromSource = () => {
+	const spec = /import\(\s*["'`]([^"'`]+)/.exec(String(regionLoader))?.[1];
+	const here = /\w+:\/\/[^\s)]+?(?=:\d+:\d+)/.exec(String((/* @__PURE__ */ new Error()).stack))?.[0];
+	try {
+		return spec && new URL(spec, here).href;
+	} catch {}
+};
+/** Starts (or joins) loading the region normalizer. Call it early — on
+*  idle, on hover — to keep the first stroke↔fill morph off the network. */
+function preloadRegion() {
+	if (regionMod) return Promise.resolve(regionMod);
+	if (!regionLoading) {
+		regionSince = Date.now();
+		const url = regionUrl;
+		const gen = regionGen;
+		regionLoading = regionLoader().catch((e) => url ? reload(url) : Promise.reject(e)).then((m) => {
+			if (gen === regionGen) regionMod = m;
+			return m;
+		}, (e) => {
+			if (gen !== regionGen) throw e;
+			regionLoading = null;
+			regionFailed = true;
+			regionUrl ??= /dynamically imported module:?\s*(\S+)/i.exec(String(e?.message))?.[1] ?? fromSource();
+			throw e;
+		});
+	}
+	return regionLoading;
+}
+const quietPreload = () => new Promise((ok, ko) => {
+	if (typeof navigator === "undefined" ? false : navigator.connection?.saveData) return;
+	const go = () => {
+		regionFailed ? ko() : preloadRegion().then(ok, ko);
+	};
+	typeof requestIdleCallback === "function" ? requestIdleCallback(go, { timeout: 2e3 }) : setTimeout(go, 200);
+});
+/** How long a morph waits for the region chunk before flying the fallback
+*  (RAIL's 100 ms response budget). A slow, failed or hanging load never
+*  leaves the icon stuck on the old shape; the load goes on in the
+*  background and the next morph flies. A load already older than the
+*  budget isn't waited for again. */
+const REGION_WAIT_MS = 100;
+const paintAttrs = (p) => p === "stroke" ? {
+	fill: "none",
+	stroke: "inherit"
+} : {
+	fill: "currentColor",
+	stroke: p === "fill" ? "none" : "inherit",
+	"fill-rule": "nonzero"
+};
+const looks = /* @__PURE__ */ new WeakMap();
+function restLook(icon) {
+	if (typeof icon === "string" || paintOf(icon) === "stroke") return "stroke";
+	let look = looks.get(icon);
+	if (look) return look;
+	let filled = 0;
+	let enclosed = -1;
+	look = "fill";
+	for (const el of solid(icon)) {
+		const s = painted(el[1].stroke);
+		const f = painted(el[1].fill) || el[1].fill === void 0 && !s;
+		if (s) look = "both";
+		let a = 0;
+		for (const p of iconToCubics([el])) a += Math.abs(signedArea(p.pts));
+		if (f) filled += a;
+		else if (s) enclosed = Math.max(enclosed, 0) + a;
+	}
+	if (enclosed > 1.5 * filled) look = "stroke";
+	looks.set(icon, look);
+	return look;
+}
+/** The paint attributes a binding renders on the `<path>` with its first
+*  icon (SSR included), so a fill icon is filled before any script runs.
+*  None for a stroke icon: it inherits the `<svg>`'s stroke as always. */
+function restAttrs(icon) {
+	if (icon === void 0 || paintOf(icon) === "stroke") return void 0;
+	return paintAttrs(restLook(icon));
+}
+function popPlan(from, to) {
+	const n = 64;
+	const item = ({ pts, closed }, half) => {
+		if (pts.length > 128) pts = pts.filter((_, i) => i % 4 < 2);
+		const c = centroid(pts);
+		const p = pts.map((v, i) => v - c[i & 1]);
+		const z = /* @__PURE__ */ new Float64Array(128);
+		return {
+			aC: half ? z : p,
+			bT: half ? p : z,
+			ca: c,
+			cb: c,
+			theta: 0,
+			lnSigma: 0,
+			closed,
+			half,
+			block: null
+		};
+	};
+	return {
+		n,
+		items: [...from.map((s) => item(s, 0)), ...to.map((s) => item(s, 1))]
+	};
+}
 function resolveSpring(s) {
 	if (typeof s === "string") return SPRING_PRESETS[s];
 	const d = SPRING_PRESETS.snappy;
@@ -80,6 +236,7 @@ function resolveSpring(s) {
 function createMorph(el, icon, options) {
 	const spring = new Spring();
 	let reducedMotion = options?.reducedMotion ?? "never";
+	let strokeWidth = options?.strokeWidth ?? 2;
 	let target = icon;
 	let rest = true;
 	let plan = null;
@@ -88,7 +245,32 @@ function createMorph(el, icon, options) {
 	let t = 1;
 	let flying = false;
 	let dead = false;
-	el.setAttribute("d", canonicalD(icon));
+	let regionFlight = false;
+	let drawn = false;
+	let pending = null;
+	let paint = "stroke";
+	let split = 0;
+	let popFrom = "stroke";
+	let popBase = null;
+	const paintAs = (p) => {
+		if (p === paint) return;
+		for (const [k, v] of Object.entries(paintAttrs(p))) el.setAttribute(k, v);
+		paint = p;
+	};
+	const paintRest = (ic) => {
+		const r = regionMod && paintOf(ic) === "fill" ? regionMod.regionOf(ic, strokeWidth) : ic;
+		el.setAttribute("d", canonicalD(r));
+		paintAs(restLook(r));
+	};
+	const upgrade = (load) => {
+		const icon = target;
+		load.then(() => {
+			if (!dead && rest && target === icon && pending === null) paintRest(icon);
+		}, () => {});
+	};
+	paintRest(icon);
+	if (paintOf(icon) === "fill" && !regionMod) upgrade(quietPreload());
+	const shown = (tt) => !split ? [0, plan?.items.length ?? 0] : tt < .5 ? [0, split] : [split, plan?.items.length ?? 0];
 	const render = (tt) => {
 		const p = plan;
 		const o = out;
@@ -96,7 +278,10 @@ function createMorph(el, icon, options) {
 		if (!p || !o || !cl) return;
 		t = tt;
 		interpPolar(p, tt, o);
-		el.setAttribute("d", serialize(o, cl));
+		drawn = true;
+		const [lo, hi] = shown(tt);
+		if (split) paintAs(tt < .5 ? popFrom : restLook(target));
+		el.setAttribute("d", serialize(o.slice(lo, hi), cl.slice(lo, hi)));
 	};
 	const stop = () => {
 		if (!flying) return;
@@ -119,7 +304,10 @@ function createMorph(el, icon, options) {
 		t = 1;
 		spring.x = 1;
 		spring.v = 0;
-		el.setAttribute("d", canonicalD(target));
+		regionFlight = false;
+		split = 0;
+		paintRest(target);
+		if (paintOf(target) === "fill" && !regionMod && (regionLoading || !regionFailed)) upgrade(preloadRegion());
 	};
 	/** The current shape as plan source: the at-rest icon, or the rendered
 	*  buffers (already N points per subpath). */
@@ -127,20 +315,73 @@ function createMorph(el, icon, options) {
 		const p = plan;
 		const o = out;
 		if (rest || !p || !o) return sampledOf(target);
-		return o.map((buf, k) => ({
+		const [lo, hi] = shown(t);
+		return o.slice(lo, hi).map((buf, k) => ({
 			pts: Float64Array.from(buf),
-			closed: p.items[k].closed
+			closed: p.items[lo + k].closed,
+			hole: p.items[lo + k].hole
 		}));
 	};
-	const retarget = (icon) => {
-		plan = rest ? planBetween(target, icon) : buildPlan(snapshot(), sampledOf(icon));
+	/** A morph from the current shape to `icon` needs regions when either
+	*  side is filled, or when the shape in flight already is a region. */
+	const needsRegion = (icon) => !rest && regionFlight || paintOf(icon) === "fill" || paintOf(target) === "fill";
+	const retarget = (icon, pop) => {
+		if (!rest && plan && out && !drawn) {
+			t = 0;
+			interpPolar(plan, 0, out);
+		}
+		if (pop || !rest && split) {
+			const from = snapshot();
+			popBase = rest ? target : null;
+			popFrom = paint;
+			plan = popPlan(from, sampledOf(icon));
+			split = from.length;
+			regionFlight = false;
+		} else if (needsRegion(icon)) {
+			const mod = regionMod;
+			plan = rest || !out ? mod.regionPlan(target, icon, strokeWidth) : mod.regionPlanFrom(regionFlight ? snapshot() : serialize(out, closed ?? void 0), icon, strokeWidth);
+			regionFlight = true;
+			split = 0;
+			paintAs("fill");
+		} else {
+			plan = rest ? planBetween(target, icon) : buildPlan(snapshot(), sampledOf(icon));
+			regionFlight = false;
+		}
 		out = allocOutputs(plan);
+		drawn = false;
 		closed = plan.items.map((it) => it.closed);
 		target = icon;
 		rest = false;
 	};
+	const whenRegion = (icon, run, fallback) => {
+		if (regionMod || !rest && split || !needsRegion(icon)) return false;
+		const req = {};
+		pending = req;
+		const give = () => {
+			if (dead || pending !== req) return;
+			pending = null;
+			fallback();
+		};
+		const load = preloadRegion();
+		if (Date.now() - regionSince > REGION_WAIT_MS) {
+			give();
+			return true;
+		}
+		const timer = setTimeout(give, REGION_WAIT_MS - (Date.now() - regionSince));
+		load.then(() => {
+			clearTimeout(timer);
+			if (dead || pending !== req) return;
+			pending = null;
+			run();
+		}, () => {
+			clearTimeout(timer);
+			give();
+		});
+		return true;
+	};
 	const setNow = (icon) => {
 		stop();
+		pending = null;
 		target = icon;
 		settle();
 	};
@@ -151,31 +392,44 @@ function createMorph(el, icon, options) {
 		if (typeof matchMedia === "undefined") return false;
 		return matchMedia?.("(prefers-reduced-motion: reduce)").matches ?? false;
 	};
-	const seek = (icon, tt) => {
+	const seek = (icon, tt, pop = false) => {
 		if (dead) return;
-		const reuse = !rest && plan !== null && icon === target;
+		if (!pop && whenRegion(icon, () => seek(icon, tt), () => seek(icon, tt, true))) return;
+		pending = null;
+		let reuse = !rest && plan !== null && icon === target;
+		if (reuse && split && regionMod && popBase !== null) {
+			target = popBase;
+			rest = true;
+			reuse = false;
+		}
 		stop();
 		spring.v = 0;
-		if (!reuse) retarget(icon);
+		if (!reuse) retarget(icon, pop);
 		render(tt);
 	};
+	const fly = (icon, sp, pop) => {
+		if (dead) return;
+		if (icon === target && (rest || flying)) {
+			pending = null;
+			return;
+		}
+		if (motionOff()) {
+			setNow(icon);
+			return;
+		}
+		if (!pop && whenRegion(icon, () => fly(icon, sp, false), () => fly(icon, sp, true))) return;
+		pending = null;
+		const { k, c } = resolveSpring(sp);
+		spring.config(k, c);
+		retarget(icon, pop);
+		spring.start();
+		if (!flying) {
+			flying = true;
+			addTicker(tick);
+		}
+	};
 	return {
-		morphTo(icon, sp) {
-			if (dead) return;
-			if (icon === target && (rest || flying)) return;
-			if (motionOff()) {
-				setNow(icon);
-				return;
-			}
-			const { k, c } = resolveSpring(sp);
-			spring.config(k, c);
-			retarget(icon);
-			spring.start();
-			if (!flying) {
-				flying = true;
-				addTicker(tick);
-			}
-		},
+		morphTo: (icon, sp) => fly(icon, sp, false),
 		set(icon) {
 			if (dead) return;
 			setNow(icon);
@@ -193,9 +447,16 @@ function createMorph(el, icon, options) {
 		set reducedMotion(v) {
 			reducedMotion = v;
 		},
+		get strokeWidth() {
+			return strokeWidth;
+		},
+		set strokeWidth(v) {
+			strokeWidth = v;
+		},
 		destroy() {
 			stop();
 			dead = true;
+			pending = null;
 			plan = null;
 			out = null;
 			closed = null;
@@ -203,4 +464,4 @@ function createMorph(el, icon, options) {
 	};
 }
 //#endregion
-export { canonicalD, createMorph };
+export { canonicalD, createMorph, preloadRegion, restAttrs, setRegionLoader };

package/dist/element.d.ts

@@ -1,9 +1,10 @@
-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 { n as computeInitialD, t as MorphHandle } from "./controller-Dkruvf3Y.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 { n as computeInitialD, r as computeInitialPaint, t as MorphHandle } from "./controller-DKm8s2ni.js";
 //#region src/element/index.d.ts
 declare const Base: typeof HTMLElement;
-declare class MorphIconElement extends Base implements MorphHandle {
+export declare class MorphIconElement extends Base implements MorphHandle {
   #private;
   static observedAttributes: string[];
   get icon(): IconInput | undefined;
@@ -26,11 +27,11 @@ declare class MorphIconElement extends Base implements MorphHandle {
 }
 /** Defines `<morph-icon>` (or a custom tag). Idempotent per tag; a no-op
  *  without a DOM (safe to call from code that also runs during SSR). */
-declare function defineMorphIcon(tag?: string): void;
+export declare function defineMorphIcon(tag?: string): void;
 declare global {
   interface HTMLElementTagNameMap {
     "morph-icon": MorphIconElement;
   }
 }
 //#endregion
-export { type IconInput, type IconNode, type Morph, type MorphHandle, MorphIconElement, type MorphOptions, type PathEl, type ReducedMotionMode, type Sampled, type SpringPreset, computeInitialD, defineMorphIcon };
+export { type IconInput, type IconNode, type Morph, type MorphHandle, type MorphOptions, type PathEl, type ReducedMotionMode, type Sampled, type SpringPreset, computeInitialD, computeInitialPaint };

package/dist/element.js

@@ -1,4 +1,4 @@
-import { n as createController, t as computeInitialD } from "./controller-CXZuwJ_M.js";
+import { n as computeInitialPaint, r as createController, t as computeInitialD } from "./controller--7SSBggk.js";
 //#region src/element/index.ts
 const SVG_NS = "http://www.w3.org/2000/svg";
 const REACTIVE = [
@@ -107,6 +107,7 @@ var MorphIconElement = class extends Base {
 			const path = this.#path;
 			const gate = this.#adopted && !this.#preConnectDirty;
 			this.#adopted = false;
+			this.#props.strokeWidth = this.#sw();
 			this.#ctrl = createController(this.#props);
 			if (gate) {
 				let armed = false;
@@ -165,6 +166,8 @@ var MorphIconElement = class extends Base {
 		if (PRESENTATION.has(name)) {
 			const svg = this.querySelector("svg");
 			if (svg) this.#applyPresentation(svg);
+			this.#props.strokeWidth = this.#sw();
+			this.#ctrl?.watch(this.#props);
 			return;
 		}
 		this.#watch();
@@ -208,7 +211,12 @@ var MorphIconElement = class extends Base {
 			const p = this.#props;
 			if (p.icon === void 0 && p.from === void 0 && p.to === void 0) {
 				const d = existing.getAttribute("d");
-				if (d) p.icon = d;
+				const fill = existing.getAttribute("fill");
+				if (d) p.icon = fill && fill !== "none" ? [["path", {
+					d,
+					fill,
+					"fill-rule": existing.getAttribute("fill-rule") ?? "nonzero"
+				}]] : d;
 			}
 			return;
 		}
@@ -222,16 +230,21 @@ var MorphIconElement = class extends Base {
 		this.#applyPresentation(svg);
 		const path = doc.createElementNS(SVG_NS, "path");
 		path.setAttribute("d", computeInitialD(this.#props));
+		for (const [k, v] of Object.entries(computeInitialPaint(this.#props) ?? {})) path.setAttribute(k, v);
 		svg.appendChild(path);
 		this.appendChild(svg);
 		this.#path = path;
 	}
+	/** The stroke width on the 24 grid, absolute-stroke-width resolved. */
+	#sw() {
+		return this.#absoluteStrokeWidth ? String(Number(this.#strokeWidth) * 24 / Number(this.#size)) : this.#strokeWidth;
+	}
 	#applyPresentation(svg) {
 		svg.setAttribute("width", this.#size);
 		svg.setAttribute("height", this.#size);
 		svg.setAttribute("stroke", this.#color);
-		const sw = this.#absoluteStrokeWidth ? String(Number(this.#strokeWidth) * 24 / Number(this.#size)) : this.#strokeWidth;
-		svg.setAttribute("stroke-width", sw);
+		svg.setAttribute("color", this.#color);
+		svg.setAttribute("stroke-width", this.#sw());
 		const label = this.#label;
 		let title = svg.querySelector("title");
 		if (label) {
@@ -258,4 +271,4 @@ function defineMorphIcon(tag = "morph-icon") {
 	registered = true;
 }
 //#endregion
-export { MorphIconElement, computeInitialD, defineMorphIcon };
+export { MorphIconElement, computeInitialD, computeInitialPaint, defineMorphIcon };

package/dist/index-DDNCPQ4Z.d.ts

@@ -0,0 +1,55 @@
+import { a as IconInput, c as Sampled, o as IconNode, t as MorphPlan } from "./plan-DhaDhEVq.js";
+//#endregion
+//#region src/region/plan.d.ts
+/** Samples a normalized region: one Sampled per contour, every one closed,
+ *  `hole` read from the winding (outers positive, holes negative). N per
+ *  contour: 64, or 128 for every contour of an icon that 64 can't follow
+ *  (snowflake tips, spiral turns: the landing would snap). */
+declare function resampleRegion(icon: IconInput, N?: number): Sampled[];
+/** Region plan: outers ↔ outers (holed contours never duplicated), holes ↔
+ *  overlapping holes of the paired outer, direction locked; whatever has no
+ *  partner collapses/grows without ever breaking the nesting (rules above).
+ *  Every item flies closed. */
+declare function buildRegionPlan(srcSubs: readonly Sampled[], dstSubs: readonly Sampled[]): MorphPlan;
+//#endregion
+//#region src/core/region.d.ts
+/** How an icon is painted: centerlines with a stroke, or filled surface. */
+type Paint = "stroke" | "fill";
+/** 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). */
+declare function paintOf(icon: IconInput): Paint;
+/** True when the icon is already a normalized region (no work left). */
+declare function isRegion(icon: IconInput): boolean;
+declare namespace index_d_exports {
+  export { Paint, RegionOptions, buildRegionPlan, isRegion, paintOf, regionContours, regionOf, regionPlan, regionPlanFrom, resampleRegion, toRegion };
+}
+interface RegionOptions {
+  /** Width for stroked elements that don't declare `stroke-width` (Lucide
+   *  data carries none: the binding draws it). Default 2. */
+  strokeWidth?: number;
+  /** Grid step of the distance field, in icon units (24-unit grid).
+   *  Default ⅛: corners are rebuilt exactly, curves deviate < 0.01. */
+  cell?: number;
+}
+/** Contours of the visible surface: closed, non-overlapping, outers
+ *  positive / holes negative (nesting depth decides which is which). */
+declare function regionContours(input: IconInput, options?: RegionOptions): Float64Array[];
+/** Any icon → its canonical region: one `<path>` (nonzero) whose contours
+ *  are the visible surface. Idempotent on regions. Stroke icons outline at
+ *  `strokeWidth` (round caps and joins — Lucide, Tabler, Feather,
+ *  Heroicons outline); fill icons honor each element's fill rule. */
+declare function toRegion(input: IconInput, options?: RegionOptions): IconNode;
+/** The region the driver draws for an icon (cached): a stroke icon
+ *  outlined at the element's stroke width, a fill icon as is. */
+declare function regionOf(icon: IconInput, strokeWidth: number): IconNode;
+/** Region plan from `src` at rest to `dst` (cached by reference). */
+declare function regionPlan(src: IconInput, dst: IconInput, strokeWidth: number): MorphPlan;
+/** Region plan from the shape in flight to `dst` (never cached): region
+ *  samples as they are, or a centerline `d` (a stroke morph interrupted
+ *  toward a fill icon), outlined as it is. */
+declare function regionPlanFrom(shape: Sampled[] | string, dst: IconInput, strokeWidth: number): MorphPlan;
+//#endregion
+export { regionPlan as a, Paint as c, buildRegionPlan as d, resampleRegion as f, regionOf as i, isRegion as l, index_d_exports as n, regionPlanFrom as o, regionContours as r, toRegion as s, RegionOptions as t, paintOf as u };

package/dist/{index-DXp5b6BU.d.ts → index-DpvKR75N.d.ts}

@@ -1,4 +1,6 @@
-import { c as SpringPreset, n as IconInput } from "./types-JAF3s76Y.js";
+import { n as index_d_exports } from "./index-DDNCPQ4Z.js";
+import { a as IconInput } from "./plan-DhaDhEVq.js";
+import { r as SpringPreset } from "./spring-BgZHrI2W.js";
 //#region src/dom/index.d.ts
 /** Target element, structurally typed: any object with setAttribute works
  *  (a real SVGPathElement, or a fake in tests). */
@@ -18,6 +20,11 @@ type ReducedMotionMode = "never" | "user" | "always";
 interface CreateMorphOptions {
   /** Reduced-motion policy; also live via the `reducedMotion` property. */
   reducedMotion?: ReducedMotionMode;
+  /** Stroke width the element draws with (24-unit grid). Only used to
+   *  outline stroke icons when they morph with a fill icon, so the region
+   *  in flight matches the stroke at rest. Default 2; live via the
+   *  `strokeWidth` property. */
+  strokeWidth?: number;
 }
 interface Morph {
   /** Animates toward the icon with spring physics. Interruptible: mid-flight
@@ -34,15 +41,31 @@ interface Morph {
   progress: number;
   /** Reduced-motion policy, live: assigning it applies to the next morphTo. */
   reducedMotion: ReducedMotionMode;
+  /** Stroke width used to outline stroke icons in stroke↔fill morphs. */
+  strokeWidth: number;
   /** Unregisters the instance; later calls are no-ops. */
   destroy(): void;
 }
 /** Canonical `d` of an icon: the input string verbatim, or the real cubics
  *  quantized to 4 decimals (the at-rest snap; engine-stable bytes so SSR
  *  hydration matches, see fmtCanon in core/serialize). Exported because it
- *  is what a binding renders at SSR/rest before any runtime exists. */
+ *  is what a binding renders at SSR/rest before any runtime exists. A fill
+ *  icon's translucent duotone layer is left out (one path can't paint it). */
 declare function canonicalD(icon: IconInput): string;
+type RegionModule = typeof index_d_exports;
+/** Replaces how the region normalizer is loaded (default: dynamic import of
+ *  the bundled chunk). E.g. `setRegionLoader(async () => region)` after a
+ *  static `import * as region from "morphicons/region"` to never touch the
+ *  network mid-interaction. The next need loads through the new loader. */
+declare function setRegionLoader(loader: () => Promise<RegionModule>): void;
+/** Starts (or joins) loading the region normalizer. Call it early — on
+ *  idle, on hover — to keep the first stroke↔fill morph off the network. */
+declare function preloadRegion(): Promise<RegionModule>;
+/** The paint attributes a binding renders on the `<path>` with its first
+ *  icon (SSR included), so a fill icon is filled before any script runs.
+ *  None for a stroke icon: it inherits the `<svg>`'s stroke as always. */
+declare function restAttrs(icon?: IconInput): Record<string, string> | undefined;
 /** Creates the morph instance over a `<path>` and paints the initial icon. */
 declare function createMorph(el: PathEl, icon: IconInput, options?: CreateMorphOptions): Morph;
 //#endregion
-export { ReducedMotionMode as a, PathEl as i, Morph as n, canonicalD as o, MorphOptions as r, createMorph as s, CreateMorphOptions as t };
+export { ReducedMotionMode as a, preloadRegion as c, PathEl as i, restAttrs as l, Morph as n, canonicalD as o, MorphOptions as r, createMorph as s, CreateMorphOptions as t, setRegionLoader as u };