@weasel-js/core 1.7.0 → 1.7.1

package/dist/features/simulation/useSimulation.js

@@ -0,0 +1,74 @@
+import { createSimulation as e } from "./createSimulation.js";
+import { useVisibleRaf as t } from "../../scheduling/useVisibleRaf.js";
+import { useLayoutEffect as n, useMemo as r, useRef as i } from "react";
+import { useLatest as a } from "@weasel-js/react";
+//#region src/features/simulation/useSimulation.ts
+function o(o) {
+	let s = a(o), c = i(null);
+	c.current ??= e(o);
+	let l = c.current, u = i(!1), d = i(!0), f = t(() => {
+		m();
+	}, {
+		requestFrame: o.requestFrame,
+		cancelFrame: o.cancelFrame
+	}), p = () => {
+		f.cancel();
+	}, m = () => {
+		if (d.current) {
+			if (l.tick(), s.current.onTick?.(l.nodes), l.alpha() < l.alphaMin()) {
+				p(), u.current || (u.current = !0, s.current.onEnd?.());
+				return;
+			}
+			f.request();
+		}
+	}, h = () => {
+		d.current && f.request();
+	};
+	return n(() => (d.current = !0, f.request(), () => {
+		d.current = !1, f.cancel();
+	}), [f]), r(() => {
+		let e = {
+			get nodes() {
+				return l.nodes;
+			},
+			setNodes(t) {
+				return l.setNodes(t), e;
+			},
+			setForces(t) {
+				return l.setForces(t), e;
+			},
+			alpha(t) {
+				return t === void 0 ? l.alpha() : (l.alpha(t), t >= l.alphaMin() && (u.current = !1), e);
+			},
+			alphaTarget(t) {
+				return t === void 0 ? l.alphaTarget() : (l.alphaTarget(t), t > 0 && (u.current = !1), e);
+			},
+			alphaDecay(t) {
+				return t === void 0 ? l.alphaDecay() : (l.alphaDecay(t), e);
+			},
+			alphaMin(t) {
+				return t === void 0 ? l.alphaMin() : (l.alphaMin(t), e);
+			},
+			velocityDecay(t) {
+				return t === void 0 ? l.velocityDecay() : (l.velocityDecay(t), e);
+			},
+			restart() {
+				return l.alpha() < l.alphaMin() && l.alpha(1), u.current = !1, h(), e;
+			},
+			stop() {
+				return p(), e;
+			},
+			tick(t = 1) {
+				return l.tick(t), e;
+			},
+			isSettled() {
+				return l.isSettled();
+			}
+		};
+		return e;
+	}, []);
+}
+//#endregion
+export { o as useSimulation };
+
+//# sourceMappingURL=useSimulation.js.map

package/dist/features/simulation/useSimulation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSimulation.js","names":["useSimulation","optsRef","useLatest","opts","coreRef","useRef","createSimulation","core","endedRef","mountedRef","frameLoop","useVisibleRaf","stopRaf","rafTick","startRaf","useLayoutEffect","useMemo","h","newNodes","newForces","value","iterations"],"sources":["../../../src/features/simulation/useSimulation.ts"],"sourcesContent":["import { useLayoutEffect, useMemo, useRef } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport { useVisibleRaf } from '../../scheduling/useVisibleRaf';\nimport { createSimulation } from './createSimulation';\nimport {\n  type Simulation,\n  type SimulationCore,\n  type SimulationForce,\n  type SimulationNode,\n  type UseSimulationOptions,\n} from './types';\n\n/**\n * Continuous N-body simulation primitive: `createSimulation`'s integrator on a\n * frame loop.\n *\n * The kit is adapter-agnostic — `onTick(nodes)` fires after each integration\n * step and the consumer decides how (and whether) to write through to scene\n * state. Per-tick history bypass and settle-commit semantics are consumer\n * concerns; the kit doesn't have an opinion.\n */\nexport function useSimulation<TNode extends SimulationNode>(\n  opts: UseSimulationOptions<TNode>,\n): Simulation<TNode> {\n  const optsRef = useLatest(opts);\n\n  const coreRef = useRef<SimulationCore<TNode> | null>(null);\n  coreRef.current ??= createSimulation(opts);\n  const core = coreRef.current;\n\n  /** Whether onEnd has fired since the last energization (restart / alpha set / target raise). */\n  const endedRef = useRef(false);\n  const mountedRef = useRef(true);\n\n  // The loop runs behind the visibility gate: a settling simulation stops\n  // integrating on a page nobody is looking at, and picks up where it left off.\n  // Its step is fixed rather than time-based, so there is no clock to rebase.\n  // The gate defaults an absent clock to `requestAnimationFrame`, so an\n  // injected one passes straight through rather than being defaulted twice.\n  const frameLoop = useVisibleRaf(\n    () => { rafTick(); },\n    {\n      requestFrame: opts.requestFrame,\n      cancelFrame: opts.cancelFrame,\n    },\n  );\n\n  const stopRaf = (): void => { frameLoop.cancel(); };\n\n  const rafTick = (): void => {\n    if (!mountedRef.current) return;\n\n    core.tick();\n    optsRef.current.onTick?.(core.nodes);\n\n    if (core.alpha() < core.alphaMin()) {\n      stopRaf();\n      if (!endedRef.current) {\n        endedRef.current = true;\n        optsRef.current.onEnd?.();\n      }\n      return;\n    }\n\n    frameLoop.request();\n  };\n\n  const startRaf = (): void => {\n    if (!mountedRef.current) return;\n    frameLoop.request();\n  };\n\n  // Starts on every mount, StrictMode's simulated remount included, and in a\n  // layout effect so a host's own layout effects can already `stop()` it.\n  // `createSimulation` has already primed the nodes.\n  useLayoutEffect(() => {\n    mountedRef.current = true;\n    frameLoop.request();\n    return () => {\n      mountedRef.current = false;\n      frameLoop.cancel();\n    };\n  }, [frameLoop]);\n\n  // Stable handle. All methods read through the core, so a fixed identity is safe.\n  const handle = useMemo<Simulation<TNode>>(() => {\n    /* eslint-disable @typescript-eslint/no-explicit-any */\n    const h: any = {\n      get nodes() {\n        return core.nodes;\n      },\n      setNodes(newNodes: TNode[]) {\n        core.setNodes(newNodes);\n        return h;\n      },\n      setForces(newForces: SimulationForce<TNode>[]) {\n        core.setForces(newForces);\n        return h;\n      },\n      alpha(value?: number) {\n        if (value === undefined) return core.alpha();\n        core.alpha(value);\n        if (value >= core.alphaMin()) endedRef.current = false;\n        return h;\n      },\n      alphaTarget(value?: number) {\n        if (value === undefined) return core.alphaTarget();\n        core.alphaTarget(value);\n        if (value > 0) endedRef.current = false;\n        return h;\n      },\n      alphaDecay(value?: number) {\n        if (value === undefined) return core.alphaDecay();\n        core.alphaDecay(value);\n        return h;\n      },\n      alphaMin(value?: number) {\n        if (value === undefined) return core.alphaMin();\n        core.alphaMin(value);\n        return h;\n      },\n      velocityDecay(value?: number) {\n        if (value === undefined) return core.velocityDecay();\n        core.velocityDecay(value);\n        return h;\n      },\n      restart() {\n        if (core.alpha() < core.alphaMin()) core.alpha(1);\n        endedRef.current = false;\n        startRaf();\n        return h;\n      },\n      stop() {\n        stopRaf();\n        return h;\n      },\n      tick(iterations: number = 1) {\n        core.tick(iterations);\n        return h;\n      },\n      isSettled() {\n        return core.isSettled();\n      },\n    };\n    return h as Simulation<TNode>;\n    /* eslint-enable @typescript-eslint/no-explicit-any */\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, []);\n\n  return handle;\n}\n"],"mappings":";;;;;AAqBA,SAAgBA,EACd,GACmB;CACnB,IAAMC,IAAUC,EAAUC,CAAI,GAExBC,IAAUC,EAAqC,IAAI;CACzD,EAAQ,YAAYC,EAAiBH,CAAI;CACzC,IAAMI,IAAOH,EAAQ,SAGfI,IAAWH,EAAO,EAAK,GACvBI,IAAaJ,EAAO,EAAI,GAOxBK,IAAYC,QACV;EAAE,EAAQ;CAAG,GACnB;EACE,cAAcR,EAAK;EACnB,aAAaA,EAAK;CACpB,CACF,GAEMS,UAAsB;EAAE,EAAU,OAAO;CAAG,GAE5CC,UAAsB;EAC1B,IAAKJ,EAAW,SAKhB;OAHAF,EAAK,KAAK,GACVN,EAAQ,QAAQ,SAASM,EAAK,KAAK,GAE/BA,EAAK,MAAM,IAAIA,EAAK,SAAS,GAAG;IAElC,AADAK,EAAQ,GACHJ,EAAS,YACZ,EAAS,UAAU,IACnBP,EAAQ,QAAQ,QAAQ;IAE1B;GACF;GAEA,EAAU,QAAQ;EAFlB;CAGF,GAEMa,UAAuB;EAC3B,AAAKL,EAAW,WAChBC,EAAU,QAAQ;CACpB;CA+EA,OA1EAK,SACE,EAAW,UAAU,IACrBL,EAAU,QAAQ,SACL;EAEX,AADA,EAAW,UAAU,IACrBA,EAAU,OAAO;CACnB,IACC,CAACA,CAAS,CAAC,GAGCM,QAAiC;EAE9C,IAAMC,IAAS;GACb,IAAI,QAAQ;IACV,OAAOV,EAAK;GACd;GACA,SAAS,GAAmB;IAE1B,OADAA,EAAK,SAASW,CAAQ,GACfD;GACT;GACA,UAAU,GAAqC;IAE7C,OADAV,EAAK,UAAUY,CAAS,GACjBF;GACT;GACA,MAAM,GAAgB;IAIpB,OAHIG,MAAU,KAAA,IAAkBb,EAAK,MAAM,KAC3CA,EAAK,MAAMa,CAAK,GACZA,KAASb,EAAK,SAAS,MAAG,EAAS,UAAU,KAC1CU;GACT;GACA,YAAY,GAAgB;IAI1B,OAHIG,MAAU,KAAA,IAAkBb,EAAK,YAAY,KACjDA,EAAK,YAAYa,CAAK,GAClBA,IAAQ,MAAG,EAAS,UAAU,KAC3BH;GACT;GACA,WAAW,GAAgB;IAGzB,OAFIG,MAAU,KAAA,IAAkBb,EAAK,WAAW,KAChDA,EAAK,WAAWa,CAAK,GACdH;GACT;GACA,SAAS,GAAgB;IAGvB,OAFIG,MAAU,KAAA,IAAkBb,EAAK,SAAS,KAC9CA,EAAK,SAASa,CAAK,GACZH;GACT;GACA,cAAc,GAAgB;IAG5B,OAFIG,MAAU,KAAA,IAAkBb,EAAK,cAAc,KACnDA,EAAK,cAAca,CAAK,GACjBH;GACT;GACA,UAAU;IAIR,OAHIV,EAAK,MAAM,IAAIA,EAAK,SAAS,KAAGA,EAAK,MAAM,CAAC,GAChD,EAAS,UAAU,IACnBO,EAAS,GACFG;GACT;GACA,OAAO;IAEL,OADAL,EAAQ,GACDK;GACT;GACA,KAAK,IAAqB,GAAG;IAE3B,OADAV,EAAK,KAAKc,CAAU,GACbJ;GACT;GACA,YAAY;IACV,OAAOV,EAAK,UAAU;GACxB;EACF;EACA,OAAOU;CAGT,GAAG,CAAC,CAEG;AACT"}

package/dist/features/text/domRuns.js

@@ -0,0 +1,258 @@
+import { cssFontFamily as e } from "@weasel-js/font";
+import { DEFAULT_TEXT_STYLE as t, SMALL_CAPS_SCALE as n, isHardLineBreak as r, numericWeight as i, smallCapsScaleFor as a, smallCapsText as o, transformRunTexts as s } from "@weasel-js/text";
+//#region src/features/text/domRuns.ts
+function c(e) {
+	return e && "color" in e ? e.color : null;
+}
+var l = /* @__PURE__ */ new Set([
+	"none",
+	"uppercase",
+	"lowercase",
+	"capitalize"
+]), u = {
+	bold: !1,
+	italic: !1,
+	underline: !1,
+	strikethrough: !1,
+	overline: !1
+};
+function d(e) {
+	let t = parseFloat(e);
+	if (!Number.isFinite(t)) return;
+	let n = /^-?[\d.]+([a-z%]+)$/i.exec(e.trim())?.[1]?.toLowerCase();
+	return n && n !== "px" && console.warn(`weasel domRuns: letter-spacing "${e}" uses unit "${n}", which is not converted; treated as ${t} world units`), t;
+}
+var f = (e) => e.hasAttribute("data-small-caps");
+function p(e) {
+	let t = e.style.fontVariant || e.style.getPropertyValue("font-variant-caps");
+	return t === "small-caps" || t === "normal" ? t : void 0;
+}
+function m(e, t) {
+	if (f(e)) return t;
+	let n = { ...t }, r = e.tagName;
+	if ((r === "B" || r === "STRONG") && (n.bold = !0, n.fontWeight = void 0), (r === "I" || r === "EM") && (n.italic = !0), r === "U" && (n.underline = !0), (r === "S" || r === "STRIKE" || r === "DEL") && (n.strikethrough = !0), r === "SUP" && (n.script = "super"), r === "SUB" && (n.script = "sub"), e instanceof HTMLElement) {
+		let t = e.style.fontWeight, r = Number(e.getAttribute("data-font-weight") ?? t);
+		e.hasAttribute("data-font-weight") || ![
+			"",
+			"700",
+			"bold",
+			"400",
+			"normal"
+		].includes(t) ? Number.isFinite(r) && r > 0 && (n.fontWeight = r, n.bold = !1) : t !== "" && (n.bold = t === "700" || t === "bold", n.fontWeight = void 0);
+		let i = e.style.fontStyle;
+		i === "italic" && (n.italic = !0), i === "normal" && (n.italic = !1);
+		let a = e.style.textDecoration || e.style.textDecorationLine;
+		if (a && !a.includes("none") && (n.underline ||= a.includes("underline"), n.strikethrough ||= a.includes("line-through"), n.overline ||= a.includes("overline")), e.style.fontSize) {
+			let t = parseFloat(e.style.fontSize);
+			Number.isFinite(t) && (e.style.fontSize.trim().endsWith("%") ? n.fontScale = t / 100 : n.fontSize = t);
+		}
+		let o = e.style.verticalAlign;
+		(o === "super" || o === "sub") && (n.script = o === "super" ? "super" : "sub"), o === "baseline" && (n.script = void 0);
+		let s = e.getAttribute("data-baseline-shift");
+		if (s != null) {
+			let e = parseFloat(s);
+			Number.isFinite(e) && (n.baselineShift = e);
+		}
+		let c = e.style.textTransform;
+		l.has(c) && (n.textTransform = c);
+		let u = p(e);
+		u && (n.fontVariantCaps = u);
+		let f = e.getAttribute("data-font-family") ?? e.style.fontFamily;
+		f && (n.fontFamily = f), e.style.color && (n.color = e.style.color);
+		let m = e.style.letterSpacing;
+		if (m === "normal") n.letterSpacing = void 0;
+		else if (m) {
+			let e = d(m);
+			e != null && (n.letterSpacing = e);
+		}
+	}
+	return n;
+}
+function h(e, t) {
+	return e.bold === t.bold && e.italic === t.italic && e.underline === t.underline && e.strikethrough === t.strikethrough && e.overline === t.overline && e.fontWeight === t.fontWeight && e.fontSize === t.fontSize && e.fontFamily === t.fontFamily && e.color === t.color && e.letterSpacing === t.letterSpacing && e.script === t.script && e.baselineShift === t.baselineShift && e.fontScale === t.fontScale && e.textTransform === t.textTransform && e.fontVariantCaps === t.fontVariantCaps;
+}
+function g(e, t) {
+	let n = { text: e };
+	return t.bold && (n.bold = !0), t.italic && (n.italic = !0), t.fontWeight != null && (n.fontWeight = t.fontWeight), t.fontSize != null && (n.fontSize = t.fontSize), t.fontFamily != null && (n.fontFamily = t.fontFamily), t.color != null && (n.fill = {
+		fill: "solid",
+		color: t.color
+	}), t.letterSpacing != null && (n.letterSpacing = t.letterSpacing), t.underline && (n.underline = !0), t.strikethrough && (n.strikethrough = !0), t.overline && (n.overline = !0), t.script != null && (n.script = t.script), t.baselineShift != null && (n.baselineShift = t.baselineShift), t.fontScale != null && (n.fontScale = t.fontScale), t.textTransform != null && (n.textTransform = t.textTransform), t.fontVariantCaps != null && (n.fontVariantCaps = t.fontVariantCaps), n;
+}
+var _ = "data-break";
+function v(e) {
+	let t = e.textContent ?? "", n = parseInt(e.getAttribute(_) ?? "", 16);
+	return t.startsWith("\n") && Number.isFinite(n) ? String.fromCharCode(n) + t.slice(1) : t;
+}
+function y(e, t) {
+	let n = 0;
+	for (let i = 0; i < t.length; i++) {
+		let a = t.charCodeAt(i);
+		if (a === 10 || !r(a) || a === 13 && t.charCodeAt(i + 1) === 10) continue;
+		i > n && e.appendChild(document.createTextNode(t.slice(n, i)));
+		let o = document.createElement("span");
+		o.setAttribute(_, a.toString(16)), o.textContent = "\n", e.appendChild(o), n = i + 1;
+	}
+	n < t.length && e.appendChild(document.createTextNode(t.slice(n)));
+}
+function b(e) {
+	let t = [];
+	function n(e, r) {
+		if (e.nodeType === Node.TEXT_NODE) {
+			let n = e.data;
+			n.length > 0 && t.push({
+				text: n,
+				style: r
+			});
+			return;
+		}
+		if (e.nodeType !== Node.ELEMENT_NODE) return;
+		let i = e;
+		if (i.tagName === "BR") {
+			t.push({
+				text: "\n",
+				style: r
+			});
+			return;
+		}
+		if (i.hasAttribute(_)) {
+			let e = v(i);
+			e.length > 0 && t.push({
+				text: e,
+				style: r
+			});
+			return;
+		}
+		i.tagName === "DIV" && t.length > 0 && t.push({
+			text: "\n",
+			style: r
+		});
+		let a = m(i, r);
+		for (let e of Array.from(i.childNodes)) n(e, a);
+	}
+	for (let t of Array.from(e.childNodes)) n(t, u);
+	let r = [], i = 0;
+	for (; i < t.length;) {
+		let e = i + 1;
+		for (; e < t.length && h(t[i].style, t[e].style);) e++;
+		let n = t.slice(i, e).map((e) => e.text).join("");
+		r.push(g(n, t[i].style)), i = e;
+	}
+	return r;
+}
+var x = "--weasel-small-caps";
+function S(e, t) {
+	let [n] = s([e], [t]), r = o(n.text, n.srcMap), i = Array(e.length).fill(!1);
+	r.small?.forEach((e, t) => {
+		e && (i[r.srcMap ? r.srcMap.starts[t] : t] = !0);
+	});
+	let a = [], c = 0;
+	for (let t of e) {
+		let e = a[a.length - 1];
+		e && e.small === i[c] ? e.text += t : a.push({
+			text: t,
+			small: i[c]
+		}), c += t.length;
+	}
+	return a;
+}
+function C(e, t, r) {
+	e.replaceChildren();
+	for (let i of S(t, r)) {
+		if (!i.small) {
+			y(e, i.text);
+			continue;
+		}
+		let t = document.createElement("span");
+		t.setAttribute("data-small-caps", ""), t.style.fontSize = `calc(var(${x}, ${n}) * 1em)`, t.style.textTransform = "uppercase", t.textContent = i.text, e.appendChild(t);
+	}
+}
+function w(n, r, o = t) {
+	r.replaceChildren();
+	for (let t of n) {
+		let n = document.createElement("span");
+		if (n.setAttribute("data-run", ""), (t.fontVariantCaps ?? o.fontVariantCaps) === "small-caps") {
+			let e = a(t.fontFamily ?? o.fontFamily, t.fontWeight ?? (t.bold ? 700 : i(o.fontWeight)), t.italic ? "italic" : o.fontStyle);
+			n.style.setProperty(x, String(e)), C(n, t.text, t.textTransform ?? o.textTransform);
+		} else y(n, t.text);
+		t.fontVariantCaps != null && (n.style.fontVariant = t.fontVariantCaps), t.fontWeight == null ? t.bold && (n.style.fontWeight = "700") : (n.style.fontWeight = String(t.fontWeight), n.setAttribute("data-font-weight", String(t.fontWeight))), t.italic && (n.style.fontStyle = "italic"), t.fontSize == null ? t.fontScale != null && (n.style.fontSize = `${t.fontScale * 100}%`) : n.style.fontSize = `${t.fontSize}px`, t.fontFamily != null && (n.style.fontFamily = e(t.fontFamily, {
+			weight: t.fontWeight ?? (t.bold ? 700 : void 0),
+			style: t.italic ? "italic" : void 0
+		}), n.setAttribute("data-font-family", t.fontFamily));
+		let s = c(t.fill);
+		s != null && (n.style.color = s);
+		let l = [];
+		t.underline && l.push("underline"), t.strikethrough && l.push("line-through"), t.overline && l.push("overline"), l.length > 0 && (n.style.textDecoration = l.join(" ")), t.script != null && (n.style.verticalAlign = t.script), t.baselineShift != null && n.setAttribute("data-baseline-shift", String(t.baselineShift)), t.letterSpacing != null && (n.style.letterSpacing = `${t.letterSpacing}px`), t.textTransform != null && (n.style.textTransform = t.textTransform), r.appendChild(n);
+	}
+}
+function T(e) {
+	let t = "";
+	for (let n of e.childNodes) n.nodeType === Node.TEXT_NODE ? t += n.data : n instanceof Element && (t += n.hasAttribute(_) ? v(n) : T(n));
+	return t;
+}
+function E(e, t) {
+	let n = S(T(e), t), r = [];
+	for (let t of e.childNodes) {
+		let e, n;
+		if (t.nodeType === Node.TEXT_NODE) e = !1, n = t.data;
+		else if (t instanceof HTMLElement && t.hasAttribute(_)) e = !1, n = v(t);
+		else if (t instanceof HTMLElement && f(t) && t.children.length === 0) e = !0, n = t.textContent ?? "";
+		else return !1;
+		if (n.length === 0) continue;
+		let i = r[r.length - 1];
+		i && i.small === e ? i.text += n : r.push({
+			text: n,
+			small: e
+		});
+	}
+	return n.length === r.length && n.every((e, t) => e.text === r[t].text && e.small === r[t].small);
+}
+function D(e) {
+	let t = !1, n = (e, r, i) => {
+		let a = p(e) ?? r, o = e.style.textTransform, s = l.has(o) ? o : i;
+		if (e.hasAttribute("data-run")) {
+			if (a === "small-caps") E(e, s) || (C(e, T(e), s), t = !0);
+			else if (e.querySelector("[data-small-caps]")) {
+				let n = T(e);
+				e.replaceChildren(), y(e, n), t = !0;
+			}
+			return;
+		}
+		for (let t of e.children) t instanceof HTMLElement && n(t, a, s);
+	};
+	return n(e, "normal", "none"), t;
+}
+function O(e, t) {
+	let n = t, r = document.createTreeWalker(e, NodeFilter.SHOW_TEXT), i = null, a = r.nextNode();
+	for (; a;) {
+		let e = a.data.length;
+		if (n <= e) return {
+			node: a,
+			offset: n
+		};
+		n -= e, i = a, a = r.nextNode();
+	}
+	return i ? {
+		node: i,
+		offset: i.data.length
+	} : {
+		node: e,
+		offset: 0
+	};
+}
+function k(e, t, n) {
+	let r = 0, i = document.createTreeWalker(e, NodeFilter.SHOW_TEXT), a = i.nextNode();
+	if (t.nodeType === Node.TEXT_NODE) {
+		for (; a;) {
+			if (a === t) return r + n;
+			r += a.data.length, a = i.nextNode();
+		}
+		return r;
+	}
+	let o = document.createRange();
+	for (o.setStart(t, Math.max(0, Math.min(n, t.childNodes.length))), o.collapse(!0); a;) o.comparePoint(a, 0) < 0 && (r += a.data.length), a = i.nextNode();
+	return r;
+}
+//#endregion
+export { x as SMALL_CAPS_SCALE_PROPERTY, y as appendOverlayText, O as charOffsetToDomPosition, k as domPositionToCharOffset, b as domToRuns, D as normalizeSmallCaps, w as runsToDom };
+
+//# sourceMappingURL=domRuns.js.map

package/dist/features/text/domRuns.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"domRuns.js","names":["solidColor","p","TRANSFORMS","EMPTY_STYLE","parseLetterSpacing","n","raw","unit","isSmallCapsPiece","el","cssFontVariant","v","styleStateFromElement","parent","next","tag","fw","ownWeight","fs","td","size","va","rawShift","shift","tt","fv","family","ls","px","styleEquals","a","b","toRun","run","style","BREAK_ATTR","restoreBreak","text","code","appendOverlayText","from","c","isHardLineBreak","span","domToRuns","fragments","visit","node","restored","nextStyle","child","runs","j","merged","f","SMALL_CAPS_SCALE_PROPERTY","smallCapsPieces","shown","transformRunTexts","transform","caps","smallCapsText","small","s","i","out","at","ch","last","writeSmallCaps","piece","SMALL_CAPS_SCALE","runsToDom","DEFAULT_TEXT_STYLE","base","scale","smallCapsScaleFor","numericWeight","cssFontFamily","color","decorations","sourceText","piecesMatch","want","have","normalizeSmallCaps","changed","variant","t","charOffsetToDomPosition","remaining","offset","walker","len","domPositionToCharOffset","total","cur","point"],"sources":["../../../src/features/text/domRuns.ts"],"sourcesContent":["/**\n * Pure DOM ↔ `StyledRun[]` serializers for the contenteditable overlay\n * used by `useTextEdit`. The overlay's children are a flat sequence of\n * `<span data-run>` elements, each carrying one run's text and inline\n * styles. Newlines inside a run are literal `\\n` characters; the overlay\n * has `white-space: pre-wrap` so they render as line breaks. The browser\n * breaks at no other UAX #14 hard break, so each of those is written as a\n * `<span data-break>` holding a `\\n` in its place — one character for one,\n * which keeps DOM offsets equal to source offsets.\n *\n * A small-caps run is the one exception to one text node per span: its\n * lowercase letters sit in `<span data-small-caps>` pieces, uppercased and\n * sized at the scale the canvas draws them with, since a browser's own\n * synthesis uses a fixed factor of its own. The pieces are presentation\n * only — `domToRuns` reads straight through them.\n */\n\nimport type { FillStyle } from '@weasel-js/paint';\nimport {\n  DEFAULT_TEXT_STYLE, isHardLineBreak, numericWeight, smallCapsScaleFor, smallCapsText, transformRunTexts,\n  SMALL_CAPS_SCALE,\n  type FontVariantCaps, type ResolvedTextStyle, type StyledRun, type TextTransform,\n} from '@weasel-js/text';\nimport { cssFontFamily } from '@weasel-js/font';\n\nfunction solidColor(p: FillStyle | undefined): string | null {\n  if (!p) return null;\n  if ('color' in p) return p.color;\n  return null;\n}\n\ninterface StyleState {\n  bold: boolean;\n  italic: boolean;\n  underline: boolean;\n  strikethrough: boolean;\n  overline: boolean;\n  fontWeight?: number;\n  fontSize?: number;\n  fontFamily?: string;\n  color?: string;\n  letterSpacing?: number;\n  script?: 'super' | 'sub';\n  baselineShift?: number;\n  fontScale?: number;\n  textTransform?: TextTransform;\n  fontVariantCaps?: FontVariantCaps;\n}\n\nconst TRANSFORMS: ReadonlySet<string> = new Set(['none', 'uppercase', 'lowercase', 'capitalize']);\n\nconst EMPTY_STYLE: StyleState = {\n  bold: false,\n  italic: false,\n  underline: false,\n  strikethrough: false,\n  overline: false,\n};\n\n/**\n * Parse a CSS `letter-spacing` value into world units. `runsToDom` only ever\n * writes `px`, but paste is a live path into the contenteditable and CSSOM\n * keeps whatever unit the pasted markup used. Any other unit is still\n * numerically coerced — `parseFloat` reads the leading digits — but flagged,\n * since e.g. `0.1em` silently becomes `0.1` world units, off by a factor of\n * the font size. Mirrors `parseLetterSpacing` in the SVG reader.\n */\nfunction parseLetterSpacing(raw: string): number | undefined {\n  const n = parseFloat(raw);\n  if (!Number.isFinite(n)) return undefined;\n  const unit = /^-?[\\d.]+([a-z%]+)$/i.exec(raw.trim())?.[1]?.toLowerCase();\n  if (unit && unit !== 'px') {\n    console.warn(\n      `weasel domRuns: letter-spacing \"${raw}\" uses unit \"${unit}\", which is not converted; treated as ${n} world units`,\n    );\n  }\n  return n;\n}\n\n/** A small-caps piece is presentation `runsToDom` split a run into, not styling. */\nconst isSmallCapsPiece = (el: Element): boolean => el.hasAttribute('data-small-caps');\n\n/** The element's own `font-variant`, from the shorthand or the caps longhand\n *  pasted markup may carry alone. */\nfunction cssFontVariant(el: HTMLElement): FontVariantCaps | undefined {\n  const v = el.style.fontVariant || el.style.getPropertyValue('font-variant-caps');\n  return v === 'small-caps' || v === 'normal' ? v : undefined;\n}\n\nfunction styleStateFromElement(el: Element, parent: StyleState): StyleState {\n  if (isSmallCapsPiece(el)) return parent;\n  const next: StyleState = { ...parent };\n  const tag = el.tagName;\n  if (tag === 'B' || tag === 'STRONG') {\n    next.bold = true;\n    next.fontWeight = undefined;\n  }\n  if (tag === 'I' || tag === 'EM') next.italic = true;\n  // `runsToDom` never emits these, but a browser contenteditable can (Cmd+U\n  // runs the native `underline` command, which produces `<u>` in Chrome), so\n  // read them for the same reason `<b>`/`<i>` are read.\n  if (tag === 'U') next.underline = true;\n  if (tag === 'S' || tag === 'STRIKE' || tag === 'DEL') next.strikethrough = true;\n  if (tag === 'SUP') next.script = 'super';\n  if (tag === 'SUB') next.script = 'sub';\n  if (el instanceof HTMLElement) {\n    // 700 and 400 are the bold flag on and off, which is what pasted markup\n    // means by them. A run's own weight is written with an attribute beside\n    // the CSS, so a stored 400 or 700 comes back as the weight it was.\n    const fw = el.style.fontWeight;\n    const ownWeight = Number(el.getAttribute('data-font-weight') ?? fw);\n    if (el.hasAttribute('data-font-weight') || !['', '700', 'bold', '400', 'normal'].includes(fw)) {\n      if (Number.isFinite(ownWeight) && ownWeight > 0) {\n        next.fontWeight = ownWeight;\n        next.bold = false;\n      }\n    } else if (fw !== '') {\n      next.bold = fw === '700' || fw === 'bold';\n      next.fontWeight = undefined;\n    }\n    const fs = el.style.fontStyle;\n    if (fs === 'italic') next.italic = true;\n    if (fs === 'normal') next.italic = false;\n    // Decoration accumulates down the tree — unlike `font-weight`/`font-style`\n    // above, `text-decoration` does not inherit, it *propagates*, and a\n    // descendant cannot cancel what an ancestor drew. So OR the flags in\n    // rather than overwriting: `<u><span style=\"text-decoration: line-through\">`\n    // renders both lines, and that is a reachable shape here, since `runsToDom`\n    // emits the span and an unintercepted Cmd+U supplies the `<u>`. An explicit\n    // `none` contributes no tokens and cancels nothing.\n    //\n    // A declaration block carrying only the longhand serializes the shorthand\n    // as `''` (the shorthand needs the full set), and browsers and pasted HTML\n    // both produce that, so fall back to `text-decoration-line`.\n    const td = el.style.textDecoration || el.style.textDecorationLine;\n    if (td && !td.includes('none')) {\n      next.underline ||= td.includes('underline');\n      next.strikethrough ||= td.includes('line-through');\n      next.overline ||= td.includes('overline');\n    }\n    // A percentage is `fontScale`'s own spelling — CSS resolves it against the\n    // parent, which is exactly what the field means. Any other unit is an\n    // absolute size.\n    if (el.style.fontSize) {\n      const size = parseFloat(el.style.fontSize);\n      if (Number.isFinite(size)) {\n        if (el.style.fontSize.trim().endsWith('%')) next.fontScale = size / 100;\n        else next.fontSize = size;\n      }\n    }\n    const va = el.style.verticalAlign;\n    if (va === 'super' || va === 'sub') next.script = va === 'super' ? 'super' : 'sub';\n    if (va === 'baseline') next.script = undefined;\n    const rawShift = el.getAttribute('data-baseline-shift');\n    if (rawShift != null) {\n      const shift = parseFloat(rawShift);\n      if (Number.isFinite(shift)) next.baselineShift = shift;\n    }\n    const tt = el.style.textTransform;\n    if (TRANSFORMS.has(tt)) next.textTransform = tt as TextTransform;\n    const fv = cssFontVariant(el);\n    if (fv) next.fontVariantCaps = fv;\n    // The attribute holds the run's family; the CSS holds the face it maps to.\n    const family = el.getAttribute('data-font-family') ?? el.style.fontFamily;\n    if (family) next.fontFamily = family;\n    if (el.style.color) next.color = el.style.color;\n    const ls = el.style.letterSpacing;\n    if (ls === 'normal') {\n      next.letterSpacing = undefined;\n    } else if (ls) {\n      const px = parseLetterSpacing(ls);\n      if (px != null) next.letterSpacing = px;\n    }\n  }\n  return next;\n}\n\nfunction styleEquals(a: StyleState, b: StyleState): boolean {\n  return (\n    a.bold === b.bold &&\n    a.italic === b.italic &&\n    a.underline === b.underline &&\n    a.strikethrough === b.strikethrough &&\n    a.overline === b.overline &&\n    a.fontWeight === b.fontWeight &&\n    a.fontSize === b.fontSize &&\n    a.fontFamily === b.fontFamily &&\n    a.color === b.color &&\n    a.letterSpacing === b.letterSpacing &&\n    a.script === b.script &&\n    a.baselineShift === b.baselineShift &&\n    a.fontScale === b.fontScale &&\n    a.textTransform === b.textTransform &&\n    a.fontVariantCaps === b.fontVariantCaps\n  );\n}\n\nfunction toRun(text: string, style: StyleState): StyledRun {\n  const run: StyledRun = { text };\n  if (style.bold) run.bold = true;\n  if (style.italic) run.italic = true;\n  if (style.fontWeight != null) run.fontWeight = style.fontWeight;\n  if (style.fontSize != null) run.fontSize = style.fontSize;\n  if (style.fontFamily != null) run.fontFamily = style.fontFamily;\n  if (style.color != null) run.fill = { fill: 'solid', color: style.color };\n  // `letterSpacing: 0` is a meaningful override (it cancels node-level\n  // tracking for this run), so test for presence, not truthiness.\n  if (style.letterSpacing != null) run.letterSpacing = style.letterSpacing;\n  // Run-level flags are additive over the node style — a run cannot un-set\n  // one — so an undecorated run gets an absent key, never `false`.\n  if (style.underline) run.underline = true;\n  if (style.strikethrough) run.strikethrough = true;\n  if (style.overline) run.overline = true;\n  if (style.script != null) run.script = style.script;\n  // Both are meaningful at values that test falsy — a 0 shift cancels an\n  // inherited script's rise — so test for presence, as `letterSpacing` does.\n  if (style.baselineShift != null) run.baselineShift = style.baselineShift;\n  if (style.fontScale != null) run.fontScale = style.fontScale;\n  if (style.textTransform != null) run.textTransform = style.textTransform;\n  if (style.fontVariantCaps != null) run.fontVariantCaps = style.fontVariantCaps;\n  return run;\n}\n\nconst BREAK_ATTR = 'data-break';\n\n/** A break stand-in's source text: its hard break, and anything typed into it after. */\nfunction restoreBreak(el: Element): string {\n  const text = el.textContent ?? '';\n  const code = parseInt(el.getAttribute(BREAK_ATTR) ?? '', 16);\n  return text.startsWith('\\n') && Number.isFinite(code) ? String.fromCharCode(code) + text.slice(1) : text;\n}\n\n/**\n * Append `text` to `parent` as the overlay sets it: a hard break the browser\n * would not break at becomes a `<span data-break>` holding a `\\n`, carrying\n * the original's code as hex for `domToRuns` to restore. A CR that opens a\n * CRLF is left as it is — the LF breaks, and the CR draws nothing.\n */\nexport function appendOverlayText(parent: Node, text: string): void {\n  let from = 0;\n  for (let i = 0; i < text.length; i++) {\n    const c = text.charCodeAt(i);\n    if (c === 10 || !isHardLineBreak(c) || (c === 13 && text.charCodeAt(i + 1) === 10)) continue;\n    if (i > from) parent.appendChild(document.createTextNode(text.slice(from, i)));\n    const span = document.createElement('span');\n    span.setAttribute(BREAK_ATTR, c.toString(16));\n    span.textContent = '\\n';\n    parent.appendChild(span);\n    from = i + 1;\n  }\n  if (from < text.length) parent.appendChild(document.createTextNode(text.slice(from)));\n}\n\n/** Walk an overlay tree and emit a coalesced `StyledRun[]`. */\nexport function domToRuns(parent: HTMLElement): StyledRun[] {\n  const fragments: Array<{ text: string; style: StyleState }> = [];\n\n  function visit(node: Node, style: StyleState): void {\n    if (node.nodeType === Node.TEXT_NODE) {\n      const text = (node as Text).data;\n      if (text.length > 0) fragments.push({ text, style });\n      return;\n    }\n    if (node.nodeType !== Node.ELEMENT_NODE) return;\n    const el = node as Element;\n    if (el.tagName === 'BR') {\n      fragments.push({ text: '\\n', style });\n      return;\n    }\n    if (el.hasAttribute(BREAK_ATTR)) {\n      const restored = restoreBreak(el);\n      if (restored.length > 0) fragments.push({ text: restored, style });\n      return;\n    }\n    if (el.tagName === 'DIV' && fragments.length > 0) {\n      fragments.push({ text: '\\n', style });\n    }\n    const nextStyle = styleStateFromElement(el, style);\n    for (const child of Array.from(el.childNodes)) {\n      visit(child, nextStyle);\n    }\n  }\n\n  for (const child of Array.from(parent.childNodes)) {\n    visit(child, EMPTY_STYLE);\n  }\n\n  // Coalesce adjacent fragments with identical style.\n  const runs: StyledRun[] = [];\n  let i = 0;\n  while (i < fragments.length) {\n    let j = i + 1;\n    while (j < fragments.length && styleEquals(fragments[i].style, fragments[j].style)) {\n      j++;\n    }\n    const merged = fragments.slice(i, j).map((f) => f.text).join('');\n    runs.push(toRun(merged, fragments[i].style));\n    i = j;\n  }\n  return runs;\n}\n\n/** What a run inherits from its node, for the overlay's small caps: which\n *  runs have it, and the face and transform that decide their pieces. */\nexport type OverlayRunBase = Pick<\n  ResolvedTextStyle, 'fontFamily' | 'fontWeight' | 'fontStyle' | 'textTransform' | 'fontVariantCaps'\n>;\n\n/** The custom property carrying a small-caps run's scale down to its pieces. */\nexport const SMALL_CAPS_SCALE_PROPERTY = '--weasel-small-caps';\n\n/** A run's source text cut where small caps changes size, per `smallCapsText`\n *  over the text as `transform` draws it. */\nfunction smallCapsPieces(text: string, transform: TextTransform): Array<{ text: string; small: boolean }> {\n  const [shown] = transformRunTexts([text], [transform]);\n  const caps = smallCapsText(shown.text, shown.srcMap);\n  const small = new Array<boolean>(text.length).fill(false);\n  caps.small?.forEach((s, i) => {\n    if (s) small[caps.srcMap ? caps.srcMap.starts[i] : i] = true;\n  });\n  const out: Array<{ text: string; small: boolean }> = [];\n  let at = 0;\n  for (const ch of text) {\n    const last = out[out.length - 1];\n    if (last && last.small === small[at]) last.text += ch;\n    else out.push({ text: ch, small: small[at] });\n    at += ch.length;\n  }\n  return out;\n}\n\n/** Replace `span`'s children with `text`, its small-caps letters in pieces. */\nfunction writeSmallCaps(span: HTMLElement, text: string, transform: TextTransform): void {\n  span.replaceChildren();\n  for (const p of smallCapsPieces(text, transform)) {\n    if (!p.small) { appendOverlayText(span, p.text); continue; }\n    const piece = document.createElement('span');\n    piece.setAttribute('data-small-caps', '');\n    piece.style.fontSize = `calc(var(${SMALL_CAPS_SCALE_PROPERTY}, ${SMALL_CAPS_SCALE}) * 1em)`;\n    piece.style.textTransform = 'uppercase';\n    piece.textContent = p.text;\n    span.appendChild(piece);\n  }\n}\n\n/**\n * Build a flat sequence of `<span data-run>` children from `runs`, replacing\n * any existing children of `parent`. `base` is the node's style, which a run\n * inheriting small caps needs to be split by; without it the kit defaults\n * stand in.\n */\nexport function runsToDom(\n  runs: readonly StyledRun[],\n  parent: HTMLElement,\n  base: OverlayRunBase = DEFAULT_TEXT_STYLE,\n): void {\n  parent.replaceChildren();\n  for (const run of runs) {\n    const span = document.createElement('span');\n    span.setAttribute('data-run', '');\n    if ((run.fontVariantCaps ?? base.fontVariantCaps) === 'small-caps') {\n      const scale = smallCapsScaleFor(\n        run.fontFamily ?? base.fontFamily,\n        run.fontWeight ?? (run.bold ? 700 : numericWeight(base.fontWeight)),\n        run.italic ? 'italic' : base.fontStyle,\n      );\n      span.style.setProperty(SMALL_CAPS_SCALE_PROPERTY, String(scale));\n      writeSmallCaps(span, run.text, run.textTransform ?? base.textTransform);\n    } else {\n      appendOverlayText(span, run.text);\n    }\n    // CSS as well as the pieces: it is what pasted markup says, and it gives a\n    // letter typed outside a piece a small cap until the next normalize.\n    if (run.fontVariantCaps != null) span.style.fontVariant = run.fontVariantCaps;\n    if (run.fontWeight != null) {\n      span.style.fontWeight = String(run.fontWeight);\n      span.setAttribute('data-font-weight', String(run.fontWeight));\n    } else if (run.bold) span.style.fontWeight = '700';\n    if (run.italic) span.style.fontStyle = 'italic';\n    // An absolute size wins over a relative one, as it does in `resolveRuns`.\n    if (run.fontSize != null) span.style.fontSize = `${run.fontSize}px`;\n    else if (run.fontScale != null) span.style.fontSize = `${run.fontScale * 100}%`;\n    if (run.fontFamily != null) {\n      span.style.fontFamily = cssFontFamily(run.fontFamily, {\n        weight: run.fontWeight ?? (run.bold ? 700 : undefined),\n        style: run.italic ? 'italic' : undefined,\n      });\n      span.setAttribute('data-font-family', run.fontFamily);\n    }\n    const color = solidColor(run.fill);\n    if (color != null) span.style.color = color;\n    // Decoration goes on the span as an inline style rather than `<u>`/`<s>`\n    // wrappers: one representation for `domToRuns` to unwrap, and one element\n    // per run so the caret-offset walkers stay flat.\n    const decorations: string[] = [];\n    if (run.underline) decorations.push('underline');\n    if (run.strikethrough) decorations.push('line-through');\n    if (run.overline) decorations.push('overline');\n    if (decorations.length > 0) span.style.textDecoration = decorations.join(' ');\n    if (run.script != null) span.style.verticalAlign = run.script;\n    // The one run field with no CSS spelling: `vertical-align` takes a length\n    // or a percentage of the *line height*, and this is a fraction of the\n    // parent's font size. An attribute keeps the round-trip exact; the canvas\n    // underneath is what actually draws the run at its offset.\n    if (run.baselineShift != null) {\n      span.setAttribute('data-baseline-shift', String(run.baselineShift));\n    }\n    // World units — the overlay's own node-level tracking is screen-scaled,\n    // but a run override is stored as-is so the round-trip is lossless. CSS\n    // `letter-spacing` is inherited and a child declaration *replaces* the\n    // inherited value, so this composes with the overlay's rather than adding.\n    if (run.letterSpacing != null) span.style.letterSpacing = `${run.letterSpacing}px`;\n    // CSS draws the transform, so the span's text stays the source and the\n    // caret-offset walkers below need no map.\n    if (run.textTransform != null) span.style.textTransform = run.textTransform;\n    parent.appendChild(span);\n  }\n}\n\n/** `el`'s text as `domToRuns` reads it: each break stand-in restored. */\nfunction sourceText(el: Element): string {\n  let out = '';\n  for (const n of el.childNodes) {\n    if (n.nodeType === Node.TEXT_NODE) out += (n as Text).data;\n    else if (n instanceof Element) out += n.hasAttribute(BREAK_ATTR) ? restoreBreak(n) : sourceText(n);\n  }\n  return out;\n}\n\n/** Whether `span`'s children are the pieces `writeSmallCaps` would write. */\nfunction piecesMatch(span: HTMLElement, transform: TextTransform): boolean {\n  const want = smallCapsPieces(sourceText(span), transform);\n  const have: Array<{ text: string; small: boolean }> = [];\n  for (const n of span.childNodes) {\n    let small: boolean;\n    let text: string;\n    if (n.nodeType === Node.TEXT_NODE) { small = false; text = (n as Text).data; }\n    else if (n instanceof HTMLElement && n.hasAttribute(BREAK_ATTR)) { small = false; text = restoreBreak(n); }\n    else if (n instanceof HTMLElement && isSmallCapsPiece(n) && n.children.length === 0) { small = true; text = n.textContent ?? ''; }\n    else return false;\n    if (text.length === 0) continue;\n    const last = have[have.length - 1];\n    if (last && last.small === small) last.text += text;\n    else have.push({ text, small });\n  }\n  return want.length === have.length\n    && want.every((p, i) => p.text === have[i].text && p.small === have[i].small);\n}\n\n/**\n * Put every run span's small-caps pieces back where its text now needs them —\n * typing lands a letter in whichever piece holds the caret, not the one its\n * case belongs in. Returns whether anything was rewritten, which moves the\n * DOM selection: the caller restores it by character offset.\n */\nexport function normalizeSmallCaps(parent: HTMLElement): boolean {\n  let changed = false;\n  const visit = (el: HTMLElement, variant: FontVariantCaps, transform: TextTransform): void => {\n    const v = cssFontVariant(el) ?? variant;\n    const tt = el.style.textTransform;\n    const t = TRANSFORMS.has(tt) ? (tt as TextTransform) : transform;\n    if (el.hasAttribute('data-run')) {\n      if (v === 'small-caps') {\n        if (!piecesMatch(el, t)) { writeSmallCaps(el, sourceText(el), t); changed = true; }\n      } else if (el.querySelector('[data-small-caps]')) {\n        const text = sourceText(el);\n        el.replaceChildren();\n        appendOverlayText(el, text);\n        changed = true;\n      }\n      return;\n    }\n    for (const child of el.children) if (child instanceof HTMLElement) visit(child, v, t);\n  };\n  visit(parent, 'normal', 'none');\n  return changed;\n}\n\n/**\n * Walk the overlay's text nodes in document order and find the text node\n * + offset that corresponds to plain-text character position `offset`.\n * Offsets beyond the total text length clamp to the end of the last text\n * node. Returns `{ node: parent, offset: 0 }` when there are no text nodes.\n */\nexport function charOffsetToDomPosition(\n  parent: HTMLElement,\n  offset: number,\n): { node: Node; offset: number } | null {\n  let remaining = offset;\n  const walker = document.createTreeWalker(parent, NodeFilter.SHOW_TEXT);\n  let last: Text | null = null;\n  let node = walker.nextNode() as Text | null;\n  while (node) {\n    const len = node.data.length;\n    if (remaining <= len) {\n      return { node, offset: remaining };\n    }\n    remaining -= len;\n    last = node;\n    node = walker.nextNode() as Text | null;\n  }\n  if (last) return { node: last, offset: last.data.length };\n  return { node: parent, offset: 0 };\n}\n\n/**\n * Inverse of `charOffsetToDomPosition`. Walks text nodes in document order;\n * sums the lengths of every text node preceding `node` and adds `offset`.\n *\n * When `node` is an element the DOM offset indexes *child nodes*, not\n * characters, so it can't simply be added — `(overlay, 0)` is the start of\n * the text and `(overlay, childNodes.length)` its end. That shape is not\n * exotic: `Range.selectNodeContents`, which `useTextEdit` uses for its\n * select-all caret, produces exactly it. So resolve an element position by\n * counting the text that precedes the boundary point. A text node can never\n * *contain* that point (the container isn't one), so each is wholly before\n * or wholly after it.\n */\nexport function domPositionToCharOffset(\n  parent: HTMLElement,\n  node: Node,\n  offset: number,\n): number {\n  let total = 0;\n  const walker = document.createTreeWalker(parent, NodeFilter.SHOW_TEXT);\n  let cur = walker.nextNode() as Text | null;\n  if (node.nodeType === Node.TEXT_NODE) {\n    while (cur) {\n      if (cur === node) return total + offset;\n      total += cur.data.length;\n      cur = walker.nextNode() as Text | null;\n    }\n    return total;\n  }\n  const point = document.createRange();\n  point.setStart(node, Math.max(0, Math.min(offset, node.childNodes.length)));\n  point.collapse(true);\n  while (cur) {\n    if (point.comparePoint(cur, 0) < 0) total += cur.data.length;\n    cur = walker.nextNode() as Text | null;\n  }\n  return total;\n}\n"],"mappings":"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"}

package/dist/features/text/fitTextPose.js

@@ -0,0 +1,38 @@
+import { layoutTextPose as e } from "@weasel-js/text";
+//#region src/features/text/fitTextPose.ts
+function t(t, r = {}) {
+	let i = r.axis ?? "height", { padX: a, padY: o } = n(r.padding), { bounds: s } = e(i === "height" ? {
+		...t,
+		width: t.width - a * 2
+	} : {
+		...t,
+		style: {
+			...t.style,
+			wrap: !1
+		}
+	}).laid;
+	return i === "height" ? {
+		...t,
+		height: s.height + o * 2
+	} : {
+		...t,
+		width: s.width + a * 2,
+		height: s.height + o * 2
+	};
+}
+function n(e) {
+	return e == null ? {
+		padX: 0,
+		padY: 0
+	} : typeof e == "number" ? {
+		padX: e,
+		padY: e
+	} : {
+		padX: e.x ?? 0,
+		padY: e.y ?? 0
+	};
+}
+//#endregion
+export { t as fitTextPose };
+
+//# sourceMappingURL=fitTextPose.js.map

package/dist/features/text/fitTextPose.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fitTextPose.js","names":["fitTextPose","axis","opts","resolvePadding","layoutTextPose","pose","padX","bounds","padY","p"],"sources":["../../../src/features/text/fitTextPose.ts"],"sourcesContent":["/**\n * Resize a text node's pose to fit its content. Pure helper — does not own\n * scene state. Call it whenever the text, style, or relevant axis changes,\n * and write the returned pose back through your adapter.\n *\n * Two modes:\n *\n *   - `axis: 'height'` (default): keep `pose.width`, recompute `height` as\n *     the block height plus optional vertical padding — wrapped at the width\n *     inside the horizontal padding when the style declares `wrap`. The\n *     common case for column-layout text — chat bubbles, sticky notes.\n *\n *   - `axis: 'both'`: ignore wrapping; recompute both `width` (longest\n *     `\\n`-split line) and `height` (line count × line height) plus padding.\n *     For badges and inline labels where the rect hugs the text on both\n *     axes. Newlines are still respected.\n *\n * `pose.x` / `pose.y` are preserved. The caller picks the anchor — if you\n * want a different growth direction (e.g. anchor bottom-right), adjust\n * `x` / `y` after calling.\n */\n\nimport { layoutTextPose } from '@weasel-js/text';\nimport type { TextPose } from '@weasel-js/text';\n\n/** Options for `fitTextPose`. */\nexport interface FitTextPoseOptions {\n  /** Which axis (or axes) to recompute. Default: `'height'`. */\n  axis?: 'height' | 'both';\n  /** Padding (world units) added to all four sides. Default 0. */\n  padding?: number | { x?: number; y?: number };\n}\n\n/** Recompute a `TextPose`'s `width`/`height` to fit its content; pure helper, doesn't mutate scene state. */\nexport function fitTextPose(\n  pose: TextPose,\n  opts: FitTextPoseOptions = {},\n): TextPose {\n  const axis = opts.axis ?? 'height';\n  const { padX, padY } = resolvePadding(opts.padding);\n  const { bounds } = layoutTextPose(axis === 'height'\n    ? { ...pose, width: pose.width - padX * 2 }\n    : { ...pose, style: { ...pose.style, wrap: false } }).laid;\n  if (axis === 'height') return { ...pose, height: bounds.height + padY * 2 };\n  return {\n    ...pose,\n    width: bounds.width + padX * 2,\n    height: bounds.height + padY * 2,\n  };\n}\n\nfunction resolvePadding(p: FitTextPoseOptions['padding']): { padX: number; padY: number } {\n  if (p == null) return { padX: 0, padY: 0 };\n  if (typeof p === 'number') return { padX: p, padY: p };\n  return { padX: p.x ?? 0, padY: p.y ?? 0 };\n}\n"],"mappings":";;AAkCA,SAAgBA,EACd,GACA,IAA2B,CAAC,GAClB;CACV,IAAMC,IAAOC,EAAK,QAAQ,UACpB,EAAE,SAAM,YAASC,EAAeD,EAAK,OAAO,GAC5C,EAAE,cAAWE,EAAeH,MAAS,WACvC;EAAE,GAAGI;EAAM,OAAOA,EAAK,QAAQC,IAAO;CAAE,IACxC;EAAE,GAAGD;EAAM,OAAO;GAAE,GAAGA,EAAK;GAAO,MAAM;EAAM;CAAE,CAAC,CAAC,CAAC;CAExD,OADIJ,MAAS,WAAiB;EAAE,GAAGI;EAAM,QAAQE,EAAO,SAASC,IAAO;CAAE,IACnE;EACL,GAAGH;EACH,OAAOE,EAAO,QAAQD,IAAO;EAC7B,QAAQC,EAAO,SAASC,IAAO;CACjC;AACF;AAEA,SAASL,EAAe,GAAkE;CAGxF,OAFIM,KAAK,OAAa;EAAE,MAAM;EAAG,MAAM;CAAE,IACrC,OAAOA,KAAM,WAAiB;EAAE,MAAMA;EAAG,MAAMA;CAAE,IAC9C;EAAE,MAAMA,EAAE,KAAK;EAAG,MAAMA,EAAE,KAAK;CAAE;AAC1C"}

package/dist/features/text/hitTest.js

@@ -0,0 +1,45 @@
+import { layoutTextPose as e } from "@weasel-js/text";
+//#region src/features/text/hitTest.ts
+function t(e) {
+	let t = [];
+	for (let n of e) {
+		let e = t[t.length - 1];
+		if (e && e.srcIndex === n.srcIndex && e.srcEnd === n.srcEnd) {
+			let r = Math.min(e.x, n.x), i = Math.max(e.x + e.advance, n.x + n.advance);
+			t[t.length - 1] = {
+				...e,
+				x: r,
+				advance: i - r
+			};
+		} else t.push(n);
+	}
+	return t;
+}
+function n(e, t, n, r = {}) {
+	let i = r.padding ?? 0;
+	return e >= n.x - i && e <= n.x + n.width + i && t >= n.y - i && t <= n.y + n.height + i;
+}
+function r(n, r, i) {
+	let { laid: a, x: o, y: s } = e(i), c = a.lines;
+	if (c.length === 0) return 0;
+	let l = c[c.length - 1];
+	if (r < s + c[0].y0) return c[0].cells[0]?.srcIndex ?? c[0].srcEnd;
+	if (r >= s + l.y1) return l.srcEnd;
+	let u = l;
+	for (let e of c) if (r < s + e.y1) {
+		u = e;
+		break;
+	}
+	if (u.cells.length === 0) return u.srcEnd;
+	let d = t(u.cells), f = d.map((e, t) => t).sort((e, t) => d[e].x - d[t].x);
+	for (let e of f) {
+		let t = d[e];
+		if (!(n >= o + t.x + t.advance / 2)) return t.level % 2 == 1 ? t.srcEnd : t.srcIndex;
+	}
+	let p = d[f[f.length - 1]];
+	return p.level % 2 == 1 ? p.srcIndex : p.srcEnd;
+}
+//#endregion
+export { r as caretIndexAt, n as pointInTextPose };
+
+//# sourceMappingURL=hitTest.js.map

package/dist/features/text/hitTest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hitTest.js","names":["sourceClusters","out","c","cells","prev","x0","x1","pointInTextPose","p","opts","x","pose","y","caretIndexAt","dx","dy","layoutTextPose","lines","laid","last","line","candidate","visual","i","a","b","trailing"],"sources":["../../../src/features/text/hitTest.ts"],"sourcesContent":["/**\n * Hit-testing for text nodes.\n *\n * `pointInTextPose` does a coarse pose-rect test — suitable for click-to-edit\n * where the pose rect is the authoritative bounding box (selection outline,\n * drag target).\n *\n * `caretIndexAt` does the finer test: given a world-space (x, y) inside the\n * pose, returns the corresponding character offset so the consumer can place\n * the caret on click. It reads the caret stops off `layoutTextPose`, the\n * layout the painters draw and `textLineBoxes` picks against, so the caret\n * cannot land on a different line — or between different glyphs — than the\n * one under the pointer.\n */\n\nimport { layoutTextPose } from '@weasel-js/text';\nimport type { LaidOutCell, TextPose } from '@weasel-js/text';\n\n/**\n * Merge neighboring cells drawn from one source character — the two `S`s an\n * uppercased `ß` becomes — into one cell spanning both, so no caret stop falls\n * between them.\n */\nfunction sourceClusters(cells: readonly LaidOutCell[]): LaidOutCell[] {\n  const out: LaidOutCell[] = [];\n  for (const c of cells) {\n    const prev = out[out.length - 1];\n    if (prev && prev.srcIndex === c.srcIndex && prev.srcEnd === c.srcEnd) {\n      const x0 = Math.min(prev.x, c.x);\n      const x1 = Math.max(prev.x + prev.advance, c.x + c.advance);\n      out[out.length - 1] = { ...prev, x: x0, advance: x1 - x0 };\n    } else {\n      out.push(c);\n    }\n  }\n  return out;\n}\n\n/** Options for `pointInTextPose`. */\nexport interface PointInTextPoseOpts {\n  /** Extra padding (world units) added to the rect on all sides. Default 0. */\n  padding?: number;\n}\n\n/** Coarse pose-rect hit-test for a text node — suitable for click-to-edit dispatch. */\nexport function pointInTextPose(\n  x: number,\n  y: number,\n  pose: TextPose,\n  opts: PointInTextPoseOpts = {},\n): boolean {\n  const p = opts.padding ?? 0;\n  return (\n    x >= pose.x - p &&\n    x <= pose.x + pose.width + p &&\n    y >= pose.y - p &&\n    y <= pose.y + pose.height + p\n  );\n}\n\n/**\n * Map a world-space point inside `pose` to a character offset into the pose's\n * text (0..length). Clicks above the first line clamp to 0; clicks below the\n * last line clamp to the end. Within a line, the caret lands between two\n * glyphs at whichever side of the advance cell's midpoint `x` falls on — the\n * standard \"snap caret to nearest character boundary\" rule.\n *\n * Honors `pose.runs` (a mixed-size line snaps on the cells each run actually\n * produced) and `pose.verticalAlign`. The offset is into the runs'\n * concatenated text, which `TextPose` requires to equal `pose.text`.\n */\nexport function caretIndexAt(x: number, y: number, pose: TextPose): number {\n  const { laid, x: dx, y: dy } = layoutTextPose(pose);\n  const lines = laid.lines;\n  if (lines.length === 0) return 0;\n\n  const last = lines[lines.length - 1];\n  if (y < dy + lines[0].y0) return lines[0].cells[0]?.srcIndex ?? lines[0].srcEnd;\n  if (y >= dy + last.y1) return last.srcEnd;\n\n  let line = last;\n  for (const candidate of lines) {\n    if (y < dy + candidate.y1) { line = candidate; break; }\n  }\n\n  // Cells are in logical order and their x values need not ascend, so the\n  // sweep has to be in visual order and each cell's own extent is what it is\n  // tested against — the next cell along is not its right edge.\n  if (line.cells.length === 0) return line.srcEnd;\n  const cells = sourceClusters(line.cells);\n  const visual = cells.map((_, i) => i).sort((a, b) => cells[a].x - cells[b].x);\n\n  for (const i of visual) {\n    const c = cells[i];\n    if (x >= dx + c.x + c.advance / 2) continue;\n    // A right-to-left cell reads the other way, so its visually-leading half\n    // is the character's logical end.\n    return c.level % 2 === 1 ? c.srcEnd : c.srcIndex;\n  }\n  const trailing = cells[visual[visual.length - 1]];\n  return trailing.level % 2 === 1 ? trailing.srcIndex : trailing.srcEnd;\n}\n"],"mappings":";;AAuBA,SAASA,EAAe,GAA8C;CACpE,IAAMC,IAAqB,CAAC;CAC5B,KAAK,IAAMC,KAAKC,GAAO;EACrB,IAAMC,IAAOH,EAAIA,EAAI,SAAS;EAC9B,IAAIG,KAAQA,EAAK,aAAaF,EAAE,YAAYE,EAAK,WAAWF,EAAE,QAAQ;GACpE,IAAMG,IAAK,KAAK,IAAID,EAAK,GAAGF,EAAE,CAAC,GACzBI,IAAK,KAAK,IAAIF,EAAK,IAAIA,EAAK,SAASF,EAAE,IAAIA,EAAE,OAAO;GAC1D,EAAID,EAAI,SAAS,KAAK;IAAE,GAAGG;IAAM,GAAGC;IAAI,SAASC,IAAKD;GAAG;EAC3D,OACE,EAAI,KAAKH,CAAC;CAEd;CACA,OAAOD;AACT;AASA,SAAgBM,EACd,GACA,GACA,GACA,IAA4B,CAAC,GACpB;CACT,IAAMC,IAAIC,EAAK,WAAW;CAC1B,OACEC,KAAKC,EAAK,IAAIH,KACdE,KAAKC,EAAK,IAAIA,EAAK,QAAQH,KAC3BI,KAAKD,EAAK,IAAIH,KACdI,KAAKD,EAAK,IAAIA,EAAK,SAASH;AAEhC;AAaA,SAAgBK,EAAa,GAAW,GAAW,GAAwB;CACzE,IAAM,EAAE,SAAM,GAAGC,GAAI,GAAGC,MAAOC,EAAeL,CAAI,GAC5CM,IAAQC,EAAK;CACnB,IAAID,EAAM,WAAW,GAAG,OAAO;CAE/B,IAAME,IAAOF,EAAMA,EAAM,SAAS;CAClC,IAAIL,IAAIG,IAAKE,EAAM,EAAE,CAAC,IAAI,OAAOA,EAAM,EAAE,CAAC,MAAM,EAAE,EAAE,YAAYA,EAAM,EAAE,CAAC;CACzE,IAAIL,KAAKG,IAAKI,EAAK,IAAI,OAAOA,EAAK;CAEnC,IAAIC,IAAOD;CACX,KAAK,IAAME,KAAaJ,GACtB,IAAIL,IAAIG,IAAKM,EAAU,IAAI;EAAE,IAAOA;EAAW;CAAO;CAMxD,IAAID,EAAK,MAAM,WAAW,GAAG,OAAOA,EAAK;CACzC,IAAMjB,IAAQH,EAAeoB,EAAK,KAAK,GACjCE,IAASnB,EAAM,KAAK,GAAG,MAAMoB,CAAC,CAAC,CAAC,MAAM,GAAG,MAAMpB,EAAMqB,EAAE,CAAC,IAAIrB,EAAMsB,EAAE,CAAC,CAAC;CAE5E,KAAK,IAAMF,KAAKD,GAAQ;EACtB,IAAMpB,IAAIC,EAAMoB;EAChB,IAAI,OAAKT,IAAKZ,EAAE,IAAIA,EAAE,UAAU,IAGhC,OAAOA,EAAE,QAAQ,KAAM,IAAIA,EAAE,SAASA,EAAE;CAC1C;CACA,IAAMwB,IAAWvB,EAAMmB,EAAOA,EAAO,SAAS;CAC9C,OAAOI,EAAS,QAAQ,KAAM,IAAIA,EAAS,WAAWA,EAAS;AACjE"}

package/dist/features/text/renderLabel.js

@@ -0,0 +1,14 @@
+//#region src/features/text/renderLabel.ts
+function e(e, n, r, i, a = {}) {
+	let { align: o = "center", fontSize: s = 13, renderText: c, width: l, height: u, padX: d = 4, padY: f = 1, cornerRadius: p = 3 } = a;
+	e.save(), e.font = `${s}px sans-serif`, e.textBaseline = "top";
+	let m = l ?? e.measureText(n).width, h = u ?? s, g = m + d * 2, _ = h + f * 2, v = o === "center" ? r - g / 2 : r - d;
+	e.fillStyle = "rgba(0, 0, 0, 0.75)", e.beginPath(), e.roundRect(v, i - f, g, _, p), e.fill(), e.textAlign = o === "center" ? "center" : "left", (c ?? t)(e, n, r, i), e.restore();
+}
+var t = (e, t, n, r) => {
+	e.fillStyle = "#FFFFFF", e.fillText(t, n, r);
+};
+//#endregion
+export { t as defaultLabelTextRenderer, e as renderLabel };
+
+//# sourceMappingURL=renderLabel.js.map

package/dist/features/text/renderLabel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderLabel.js","names":["renderLabel","options","ctx","fontSize","contentW","width","text","contentH","height","w","padX","h","padY","rx","align","x","y","cornerRadius","renderText","defaultLabelTextRenderer"],"sources":["../../../src/features/text/renderLabel.ts"],"sourcesContent":["import type { TextRenderer } from '@weasel-js/text';\n\n\n/** Visual options for `renderLabel`. */\nexport interface LabelOptions {\n  align?: 'center' | 'left';\n  fontSize?: number;\n  renderText?: TextRenderer;\n  /** Override the pill width (content width, excluding padding). */\n  width?: number;\n  /** Override the pill height (content height, excluding padding). */\n  height?: number;\n  /** Horizontal padding inside the pill. Default 4 (screen-pixel default). */\n  padX?: number;\n  /** Vertical padding inside the pill. Default 1 (screen-pixel default). */\n  padY?: number;\n  /** Corner radius of the pill background. Default 3 (screen-pixel default). */\n  cornerRadius?: number;\n}\n\n/** Render a text label with a 75%-opaque black pill background and white text. */\nexport function renderLabel(\n  ctx: CanvasRenderingContext2D,\n  text: string,\n  x: number,\n  y: number,\n  options: LabelOptions = {},\n): void {\n  const {\n    align = 'center',\n    fontSize = 13,\n    renderText,\n    width,\n    height,\n    padX = 4,\n    padY = 1,\n    cornerRadius = 3,\n  } = options;\n\n  ctx.save();\n  ctx.font = `${fontSize}px sans-serif`;\n  ctx.textBaseline = 'top';\n  const contentW = width ?? ctx.measureText(text).width;\n  const contentH = height ?? fontSize;\n  const w = contentW + padX * 2;\n  const h = contentH + padY * 2;\n  const rx = align === 'center' ? x - w / 2 : x - padX;\n\n  ctx.fillStyle = 'rgba(0, 0, 0, 0.75)';\n  ctx.beginPath();\n  ctx.roundRect(rx, y - padY, w, h, cornerRadius);\n  ctx.fill();\n\n  ctx.textAlign = align === 'center' ? 'center' : 'left';\n  const tx = align === 'center' ? x : x;\n  (renderText ?? defaultLabelTextRenderer)(ctx, text, tx, y);\n  ctx.restore();\n}\n\n/** Default `TextRenderer` used by `renderLabel`: white fill, no styling. */\nexport const defaultLabelTextRenderer: TextRenderer = (ctx, text, x, y) => {\n  ctx.fillStyle = '#FFFFFF';\n  ctx.fillText(text, x, y);\n};\n"],"mappings":";AAqBA,SAAgBA,EACd,GACA,GACA,GACA,GACA,IAAwB,CAAC,GACnB;CACN,IAAM,EACJ,WAAQ,UACR,cAAW,IACX,eACA,UACA,WACA,UAAO,GACP,UAAO,GACP,kBAAe,MACbC;CAIJ,AAFAC,EAAI,KAAK,GACT,EAAI,OAAO,GAAGC,EAAS,gBACvB,EAAI,eAAe;CACnB,IAAMC,IAAWC,KAASH,EAAI,YAAYI,CAAI,CAAC,CAAC,OAC1CC,IAAWC,KAAUL,GACrBM,IAAIL,IAAWM,IAAO,GACtBC,IAAIJ,IAAWK,IAAO,GACtBC,IAAKC,MAAU,WAAWC,IAAIN,IAAI,IAAIM,IAAIL;CAUhD,AARA,EAAI,YAAY,uBAChBR,EAAI,UAAU,GACdA,EAAI,UAAUW,GAAIG,IAAIJ,GAAMH,GAAGE,GAAGM,CAAY,GAC9Cf,EAAI,KAAK,GAET,EAAI,YAAYY,MAAU,WAAW,WAAW,SAE/CI,KAAcC,EAAA,CAA0BjB,GAAKI,GADdS,GACwBC,CAAC,GACzDd,EAAI,QAAQ;AACd;AAGA,IAAaiB,KAA0C,GAAK,GAAM,GAAG,MAAM;CAEzE,AADA,EAAI,YAAY,WAChBjB,EAAI,SAASI,GAAMS,GAAGC,CAAC;AACzB"}

package/dist/features/text/runs/effectiveRangeStyle.js

@@ -0,0 +1,66 @@
+import { MIXED as e } from "../../../core/mixed.js";
+import { nodeHasFlag as t } from "./flagRange.js";
+import { isBoldWeight as n, numericWeight as r, resolveTextStyle as i } from "@weasel-js/text";
+//#region src/features/text/runs/effectiveRangeStyle.ts
+var a = [
+	"italic",
+	"underline",
+	"strikethrough",
+	"overline"
+];
+function o(t, i) {
+	let a = r(i?.fontWeight ?? 400), o = t?.fontWeight;
+	if (o === e) return {
+		fontWeight: e,
+		bold: e
+	};
+	if (o !== void 0) return {
+		fontWeight: o,
+		bold: n(o)
+	};
+	let s = t?.bold;
+	if (s === e) return a === 700 ? {
+		fontWeight: 700,
+		bold: !0
+	} : {
+		fontWeight: e,
+		bold: n(a) ? !0 : e
+	};
+	let c = s === !0 ? 700 : a;
+	return {
+		fontWeight: c,
+		bold: n(c)
+	};
+}
+var s = [
+	"fontFamily",
+	"fontSize",
+	"letterSpacing",
+	"fill",
+	"script",
+	"baselineShift",
+	"fontScale",
+	"textTransform",
+	"fontVariantCaps"
+];
+function c(e, n, r) {
+	let c = i(n, r), l = n ?? {}, u = {
+		fontFamily: c.fontFamily,
+		fontSize: c.fontSize,
+		letterSpacing: c.letterSpacing,
+		textTransform: c.textTransform,
+		fontVariantCaps: c.fontVariantCaps
+	};
+	c.fill !== null && (u.fill = c.fill), Object.assign(u, o(e, n));
+	for (let n of a) {
+		let r = t(l, n), i = e?.[n];
+		u[n] = r || i === void 0 ? r : i;
+	}
+	if (e === null) return u;
+	for (let t of s) e[t] !== void 0 && (u[t] = e[t]);
+	return u;
+}
+//#endregion
+export { c as effectiveRangeStyle, o as rangeWeight };
+
+//# sourceMappingURL=effectiveRangeStyle.js.map

package/dist/features/text/runs/effectiveRangeStyle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"effectiveRangeStyle.js","names":["FLAGS","rangeWeight","node","numericWeight","style","own","range","MIXED","isBoldWeight","flag","weight","OVERRIDES","effectiveRangeStyle","resolved","resolveTextStyle","paint","out","key","on","nodeHasFlag","run"],"sources":["../../../../src/features/text/runs/effectiveRangeStyle.ts"],"sourcesContent":["import { isBoldWeight, numericWeight, resolveTextStyle } from '@weasel-js/text';\nimport type { TextPaint, TextStyle } from '@weasel-js/text';\nimport { nodeHasFlag } from './flagRange';\nimport { MIXED } from './rangeStyle';\nimport type { Mixed, RangeStyle } from './rangeStyle';\n\nconst FLAGS = ['italic', 'underline', 'strikethrough', 'overline'] as const;\n\n/**\n * The weight a range renders at, and whether that reads as bold, resolved as\n * `resolveRuns` resolves a run: its own `fontWeight`, else 700 for `bold`,\n * else the node's weight.\n */\nexport function rangeWeight(\n  range: RangeStyle | null,\n  style: TextStyle | undefined,\n): { fontWeight: number | Mixed; bold: boolean | Mixed } {\n  const node = numericWeight(style?.fontWeight ?? 400);\n  const own = range?.fontWeight;\n  if (own === MIXED) return { fontWeight: MIXED, bold: MIXED };\n  if (own !== undefined) return { fontWeight: own, bold: isBoldWeight(own) };\n  const flag = range?.bold;\n  if (flag === MIXED) {\n    // Flagged runs draw at 700, the rest at the node's weight.\n    if (node === 700) return { fontWeight: 700, bold: true };\n    return { fontWeight: MIXED, bold: isBoldWeight(node) ? true : MIXED };\n  }\n  const weight = flag === true ? 700 : node;\n  return { fontWeight: weight, bold: isBoldWeight(weight) };\n}\n\n/** Keys a run overrides outright. `script` and the two primitives it presets\n *  have no node-level counterpart, so they only ever come from the range. */\nconst OVERRIDES = [\n  'fontFamily', 'fontSize', 'letterSpacing', 'fill', 'script', 'baselineShift', 'fontScale',\n  'textTransform', 'fontVariantCaps',\n] as const;\n\n/**\n * What is actually rendering across a range: `range` (from `styleAtRange`,\n * or `useTextEdit`'s `rangeStyle`) resolved against the node's own `style`\n * and `paint`, as the canvas resolves runs. `null` reads the node alone.\n *\n * Flags are additive — a run can turn one on, never off — so a node flag\n * makes the flag `true` across the range, `MIXED` runs included. Every other\n * key is the run's value where the range sets one, otherwise the node's.\n * The node level is resolved first, so the result has a value for every\n * key but the run-only ones, and for `fill` unless the node is unfilled.\n * Bold is read off the weight that renders (see {@link rangeWeight}), since\n * a run's own `fontWeight` can take a bold node's text back to regular.\n */\nexport function effectiveRangeStyle(\n  range: RangeStyle | null,\n  style: TextStyle | undefined,\n  paint?: TextPaint,\n): RangeStyle {\n  const resolved = resolveTextStyle(style, paint);\n  const node = style ?? {};\n  const out: RangeStyle = {\n    fontFamily: resolved.fontFamily,\n    fontSize: resolved.fontSize,\n    letterSpacing: resolved.letterSpacing,\n    textTransform: resolved.textTransform,\n    fontVariantCaps: resolved.fontVariantCaps,\n  };\n  if (resolved.fill !== null) out.fill = resolved.fill;\n  Object.assign(out, rangeWeight(range, style));\n  for (const key of FLAGS) {\n    const on = nodeHasFlag(node, key);\n    const run = range?.[key];\n    out[key] = on || run === undefined ? on : run;\n  }\n  if (range === null) return out;\n  for (const key of OVERRIDES) {\n    if (range[key] !== undefined) (out as Record<string, unknown>)[key] = range[key];\n  }\n  return out;\n}\n"],"mappings":";;;;AAMA,IAAMA,IAAQ;CAAC;CAAU;CAAa;CAAiB;AAAU;AAOjE,SAAgBC,EACd,GACA,GACuD;CACvD,IAAMC,IAAOC,EAAcC,GAAO,cAAc,GAAG,GAC7CC,IAAMC,GAAO;CACnB,IAAID,MAAQE,GAAO,OAAO;EAAE,YAAYA;EAAO,MAAMA;CAAM;CAC3D,IAAIF,MAAQ,KAAA,GAAW,OAAO;EAAE,YAAYA;EAAK,MAAMG,EAAaH,CAAG;CAAE;CACzE,IAAMI,IAAOH,GAAO;CACpB,IAAIG,MAASF,GAGX,OADIL,MAAS,MAAY;EAAE,YAAY;EAAK,MAAM;CAAK,IAChD;EAAE,YAAYK;EAAO,MAAMC,EAAaN,CAAI,IAAI,KAAOK;CAAM;CAEtE,IAAMG,IAASD,MAAS,KAAO,MAAMP;CACrC,OAAO;EAAE,YAAYQ;EAAQ,MAAMF,EAAaE,CAAM;CAAE;AAC1D;AAIA,IAAMC,IAAY;CAChB;CAAc;CAAY;CAAiB;CAAQ;CAAU;CAAiB;CAC9E;CAAiB;AACnB;AAeA,SAAgBC,EACd,GACA,GACA,GACY;CACZ,IAAMC,IAAWC,EAAiBV,GAAOW,CAAK,GACxCb,IAAOE,KAAS,CAAC,GACjBY,IAAkB;EACtB,YAAYH,EAAS;EACrB,UAAUA,EAAS;EACnB,eAAeA,EAAS;EACxB,eAAeA,EAAS;EACxB,iBAAiBA,EAAS;CAC5B;CAEA,AADIA,EAAS,SAAS,SAAM,EAAI,OAAOA,EAAS,OAChD,OAAO,OAAOG,GAAKf,EAAYK,GAAOF,CAAK,CAAC;CAC5C,KAAK,IAAMa,KAAOjB,GAAO;EACvB,IAAMkB,IAAKC,EAAYjB,GAAMe,CAAG,GAC1BG,IAAMd,IAAQW;EACpB,EAAIA,KAAOC,KAAME,MAAQ,KAAA,IAAYF,IAAKE;CAC5C;CACA,IAAId,MAAU,MAAM,OAAOU;CAC3B,KAAK,IAAMC,KAAON,GAChB,AAAIL,EAAMW,OAAS,KAAA,MAAW,EAAiCA,KAAOX,EAAMW;CAE9E,OAAOD;AACT"}