@weasel-js/core 1.7.0 → 1.7.2

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

@@ -0,0 +1,53 @@
+import { applyStyleToRange as e } from "./rangeStyle.js";
+import { isBoldWeight as t } from "@weasel-js/text";
+//#region src/features/text/runs/flagRange.ts
+function n(e, n) {
+	switch (n) {
+		case "bold": return e.fontWeight !== void 0 && t(e.fontWeight);
+		case "italic": return e.fontStyle === "italic";
+		case "underline": return e.underline === !0;
+		case "strikethrough": return e.strikethrough === !0;
+		case "overline": return e.overline === !0;
+	}
+}
+function r(e) {
+	return n(e, "bold") ? {
+		bold: !1,
+		fontWeight: 400
+	} : { bold: !1 };
+}
+function i(e, t) {
+	let n = { ...e };
+	switch (t) {
+		case "italic":
+			n.fontStyle = "normal";
+			break;
+		case "underline":
+			delete n.underline;
+			break;
+		case "strikethrough":
+			delete n.strikethrough;
+			break;
+		case "overline": delete n.overline;
+	}
+	return n;
+}
+function a(t, a, o, s, c, l) {
+	if (l || !n(a, c)) return {
+		runs: e(t, o, s, { [c]: l }),
+		style: a
+	};
+	if (c === "bold") return {
+		runs: e(t, o, s, r(a)),
+		style: a
+	};
+	let u = t.reduce((e, t) => e + t.text.length, 0), d = Math.max(0, o), f = Math.min(u, s), p = e(t, 0, u, { [c]: !0 });
+	return d < f && (p = e(p, d, f, { [c]: !1 })), {
+		runs: p,
+		style: i(a, c)
+	};
+}
+//#endregion
+export { n as nodeHasFlag, a as setFlagOverRange, r as unboldPatch };
+
+//# sourceMappingURL=flagRange.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"flagRange.js","names":["nodeHasFlag","key","style","isBoldWeight","unboldPatch","clearNodeFlag","next","setFlagOverRange","value","applyStyleToRange","runs","start","end","total","n","r","lo","hi"],"sources":["../../../../src/features/text/runs/flagRange.ts"],"sourcesContent":["/**\n * Turning a run-level flag **off** inside a node that sets it.\n *\n * Run flags are additive over the node's `TextStyle` — a run turns `bold` /\n * `italic` / `underline` / `strikethrough` on, never off (see the contract at\n * the top of `rangeStyle.ts`). So \"select a word inside an underlined node and\n * hit U\" is unrepresentable by the stored shape, and the character bar can\n * only refuse.\n *\n * This resolves it by rewriting rather than by widening the model: clear the\n * flag on the node, and set it on every run *outside* the range. The rendered\n * result is identical and the edit becomes expressible, with `StyledRun`\n * unchanged — so nothing a document can already contain changes meaning, which\n * matters while the flags are heading for a persisted format.\n *\n * The alternative was a tri-state run flag (`true` / `false` / inherit). It\n * cannot cover `italic`: that is a boolean on a run but `fontStyle` on the\n * node, so a run's `false` has no node-level boolean to override.\n *\n * `bold` needs neither: a run carries a numeric `fontWeight`, which overrides\n * the node's outright, so lowering bold writes a regular weight over the\n * range and leaves the node and the rest of the text alone.\n */\n\nimport { isBoldWeight } from '@weasel-js/text';\nimport type { StyledRun } from '@weasel-js/text';\nimport type { TextStyle } from '@weasel-js/text';\nimport { applyStyleToRange } from './rangeStyle';\nimport type { RunStylePatch } from './rangeStyle';\n\n/** The additive run flags. */\nexport type FlagKey = 'bold' | 'italic' | 'underline' | 'strikethrough' | 'overline';\n\n/** The result of toggling a style flag over a text range: the rewritten runs\n *  and node style, and whether the change could be made at all. */\nexport interface SetFlagResult {\n  runs: StyledRun[];\n  style: TextStyle;\n}\n\n/** Does the node style carry this flag? */\nexport function nodeHasFlag(style: TextStyle, key: FlagKey): boolean {\n  switch (key) {\n    case 'bold': return style.fontWeight !== undefined && isBoldWeight(style.fontWeight);\n    case 'italic': return style.fontStyle === 'italic';\n    case 'underline': return style.underline === true;\n    case 'strikethrough': return style.strikethrough === true;\n    case 'overline': return style.overline === true;\n  }\n}\n\n/** The patch that takes bold off a range: the flag, and — in a node that is\n *  itself bold — a regular weight to override the node's. */\nexport function unboldPatch(style: TextStyle): RunStylePatch {\n  return nodeHasFlag(style, 'bold') ? { bold: false, fontWeight: 400 } : { bold: false };\n}\n\n/** The node style with `key` cleared. */\nfunction clearNodeFlag(style: TextStyle, key: Exclude<FlagKey, 'bold'>): TextStyle {\n  const next = { ...style };\n  switch (key) {\n    case 'italic': next.fontStyle = 'normal'; break;\n    case 'underline': delete next.underline; break;\n    case 'strikethrough': delete next.strikethrough; break;\n    case 'overline': delete next.overline; break;\n  }\n  return next;\n}\n\n/**\n * Set `key` to `value` over `[start, end)`.\n *\n * Turning a flag **on**, or off in a node that doesn't set it, is the ordinary\n * additive write and leaves `style` alone. Turning it off in a node that *does*\n * set it takes the rewrite: the node flag is cleared and the flag is written\n * onto the complement of the range. Bold is the exception, written as a\n * weight over the range alone (see {@link unboldPatch}).\n *\n * `runs` is normalized on every path, so the complement collapses back to one\n * run when the range is empty and the whole array coalesces as usual.\n */\nexport function setFlagOverRange(\n  runs: readonly StyledRun[],\n  style: TextStyle,\n  start: number,\n  end: number,\n  key: FlagKey,\n  value: boolean,\n): SetFlagResult {\n  if (value || !nodeHasFlag(style, key)) {\n    return { runs: applyStyleToRange(runs, start, end, { [key]: value }), style };\n  }\n\n  if (key === 'bold') {\n    return { runs: applyStyleToRange(runs, start, end, unboldPatch(style)), style };\n  }\n\n  const total = runs.reduce((n, r) => n + r.text.length, 0);\n  const lo = Math.max(0, start);\n  const hi = Math.min(total, end);\n\n  // Raise the flag on everything, then lower it over the range. Doing it in\n  // that order rather than patching the two complement spans keeps one code\n  // path for a range at either edge, where one span is empty.\n  let next = applyStyleToRange(runs, 0, total, { [key]: true });\n  if (lo < hi) next = applyStyleToRange(next, lo, hi, { [key]: false });\n\n  return { runs: next, style: clearNodeFlag(style, key) };\n}\n"],"mappings":";;;AAyCA,SAAgBA,EAAY,GAAkB,GAAuB;CACnE,QAAQC,GAAR;EACE,KAAK,QAAQ,OAAOC,EAAM,eAAe,KAAA,KAAaC,EAAaD,EAAM,UAAU;EACnF,KAAK,UAAU,OAAOA,EAAM,cAAc;EAC1C,KAAK,aAAa,OAAOA,EAAM,cAAc;EAC7C,KAAK,iBAAiB,OAAOA,EAAM,kBAAkB;EACrD,KAAK,YAAY,OAAOA,EAAM,aAAa;CAC7C;AACF;AAIA,SAAgBE,EAAY,GAAiC;CAC3D,OAAOJ,EAAYE,GAAO,MAAM,IAAI;EAAE,MAAM;EAAO,YAAY;CAAI,IAAI,EAAE,MAAM,GAAM;AACvF;AAGA,SAASG,EAAc,GAAkB,GAA0C;CACjF,IAAMC,IAAO,EAAE,GAAGJ,EAAM;CACxB,QAAQD,GAAR;EACE,KAAK;GAAU,EAAK,YAAY;GAAU;EAC1C,KAAK;GAAa,OAAOK,EAAK;GAAW;EACzC,KAAK;GAAiB,OAAOA,EAAK;GAAe;EACjD,KAAK,YAAY,OAAOA,EAAK;CAC/B;CACA,OAAOA;AACT;AAcA,SAAgBC,EACd,GACA,GACA,GACA,GACA,GACA,GACe;CACf,IAAIC,KAAS,CAACR,EAAYE,GAAOD,CAAG,GAClC,OAAO;EAAE,MAAMQ,EAAkBC,GAAMC,GAAOC,GAAK,GAAGX,IAAMO,EAAM,CAAC;EAAG;CAAM;CAG9E,IAAIP,MAAQ,QACV,OAAO;EAAE,MAAMQ,EAAkBC,GAAMC,GAAOC,GAAKR,EAAYF,CAAK,CAAC;EAAG;CAAM;CAGhF,IAAMW,IAAQH,EAAK,QAAQ,GAAG,MAAMI,IAAIC,EAAE,KAAK,QAAQ,CAAC,GAClDC,IAAK,KAAK,IAAI,GAAGL,CAAK,GACtBM,IAAK,KAAK,IAAIJ,GAAOD,CAAG,GAK1BN,IAAOG,EAAkBC,GAAM,GAAGG,GAAO,GAAGZ,IAAM,GAAK,CAAC;CAG5D,OAFIe,IAAKC,MAAI,IAAOR,EAAkBH,GAAMU,GAAIC,GAAI,GAAGhB,IAAM,GAAM,CAAC,IAE7D;EAAE,MAAMK;EAAM,OAAOD,EAAcH,GAAOD,CAAG;CAAE;AACxD"}

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

@@ -0,0 +1,135 @@
+import { MIXED as e } from "../../../core/mixed.js";
+//#region src/features/text/runs/rangeStyle.ts
+var t = [
+	"bold",
+	"fontWeight",
+	"italic",
+	"underline",
+	"strikethrough",
+	"overline",
+	"fontFamily",
+	"fontSize",
+	"letterSpacing",
+	"fill",
+	"stroke",
+	"script",
+	"baselineShift",
+	"fontScale",
+	"textTransform",
+	"fontVariantCaps"
+], n = /* @__PURE__ */ new Set([
+	"bold",
+	"italic",
+	"underline",
+	"strikethrough",
+	"overline"
+]);
+function r(e) {
+	return typeof e == "object" && !!e && !Array.isArray(e);
+}
+function i(e, t) {
+	if (Object.is(e, t)) return !0;
+	if (Array.isArray(e) && Array.isArray(t)) return e.length === t.length && e.every((e, n) => i(e, t[n]));
+	if (r(e) && r(t)) {
+		let n = Object.keys(e);
+		return n.length === Object.keys(t).length && n.every((n) => n in t && i(e[n], t[n]));
+	}
+	return !1;
+}
+function a(e, t) {
+	let r = e[t];
+	return n.has(t) ? r ?? !1 : r;
+}
+var o = /* @__PURE__ */ new Set(["fill", "stroke"]);
+function s(e, t, n) {
+	return o.has(e) ? i(t, n) : Object.is(t, n);
+}
+function c(e, n) {
+	return t.every((t) => s(t, a(e, t), a(n, t)));
+}
+function l(e) {
+	let t = 0;
+	for (let n of e) t += n.text.length;
+	return t;
+}
+function u(n, r, i) {
+	let o = Math.max(0, r), c = i;
+	if (!(o < c)) return {};
+	let l = /* @__PURE__ */ new Map(), u = /* @__PURE__ */ new Set(), d = !1, f = 0;
+	for (let e of n) {
+		let n = f + e.text.length, r = Math.max(f, o), i = Math.min(n, c);
+		if (f = n, r < i) {
+			for (let n of t) {
+				let t = a(e, n);
+				d ? !u.has(n) && !s(n, l.get(n), t) && u.add(n) : l.set(n, t);
+			}
+			d = !0;
+		}
+	}
+	if (!d) return {};
+	let p = {};
+	for (let n of t) if (u.has(n)) p[n] = e;
+	else {
+		let e = l.get(n);
+		e !== void 0 && (p[n] = e);
+	}
+	return p;
+}
+function d(e) {
+	return e.some((e) => t.some((t) => {
+		let n = e[t];
+		return n !== void 0 && n !== !1;
+	}));
+}
+function f(e) {
+	if ("bold" in e && !("fontWeight" in e)) return "fontWeight";
+	if (e.fontWeight !== void 0 && !("bold" in e)) return "bold";
+}
+function p(e, t) {
+	let n = { ...e }, r = f(t);
+	r !== void 0 && delete n[r];
+	for (let [e, r] of Object.entries(t)) r !== void 0 && (n[e] = r);
+	return n;
+}
+function m(e, n) {
+	let r = { ...e }, i = f(n);
+	i !== void 0 && delete r[i];
+	for (let e of t) {
+		if (!(e in n)) continue;
+		let t = n[e];
+		t === void 0 || t === !1 ? delete r[e] : r[e] = t;
+	}
+	return r;
+}
+function h(e) {
+	let t = [];
+	for (let n of e) {
+		if (n.text.length === 0) continue;
+		let e = t[t.length - 1];
+		e && c(e, n) ? e.text += n.text : t.push({ ...n });
+	}
+	return t;
+}
+function g(e, t, n, r) {
+	let i = Math.max(0, t), a = Math.min(l(e), n);
+	if (!(i < a)) return h(e);
+	let o = [], s = 0;
+	for (let t of e) {
+		let e = s + t.text.length, n = Math.max(s, i), c = Math.min(e, a);
+		n < c ? (s < n && o.push({
+			...t,
+			text: t.text.slice(0, n - s)
+		}), o.push(m({
+			...t,
+			text: t.text.slice(n - s, c - s)
+		}, r)), c < e && o.push({
+			...t,
+			text: t.text.slice(c - s)
+		})) : o.push({ ...t }), s = e;
+	}
+	return h(o);
+}
+//#endregion
+export { e as MIXED, g as applyStyleToRange, p as patchRangeStyle, d as runsCarryStyling, u as styleAtRange, f as supersededKey };
+
+//# sourceMappingURL=rangeStyle.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rangeStyle.js","names":["STYLE_KEYS","FLAG_KEYS","isPlainObject","v","deepEqual","a","b","item","i","keys","k","valueAt","value","run","key","STRUCTURAL_KEYS","sameValue","sameStyle","totalLength","n","runs","styleAtRange","lo","start","hi","end","first","mixed","seen","pos","runEnd","style","MIXED","runsCarryStyling","supersededKey","patch","patchRangeStyle","out","range","superseded","patchRun","next","coalesceRuns","prev","applyStyleToRange"],"sources":["../../../../src/features/text/runs/rangeStyle.ts"],"sourcesContent":["/**\n * Range-addressed styling over `StyledRun[]`. The panel addresses node paths;\n * a caret addresses a character range — these are the functions for the\n * second case. Pure and React-free so the semantics are unit-testable, the\n * same split `SelectionPanel` makes between `model.ts` and its component.\n *\n * Character offsets index the concatenated run text (`runsToPlainText`), and\n * a range is half-open: `[start, end)`. Ranges are clamped, never wrapped —\n * a negative `start` clamps to 0, an `end` past the text clamps to its\n * length, and a collapsed or inverted range (`start >= end`) is empty.\n * Offsets are UTF-16 code units, as everywhere else in this feature, so a\n * boundary can bisect a surrogate pair (`[1, 2)` over `'a👍b'` splits the\n * thumbs-up into lone surrogates). A caret-derived range never does this.\n *\n * **Run-level flags are additive over the node's `TextStyle`: a run can\n * turn `bold` / `italic` / `underline` / `strikethrough` on, never off.**\n * So a flag is stored only when true, and absent reads as `false`. A run\n * that must be lighter than a bold node says so with its own numeric\n * `fontWeight`, which `bold` is a preset over (see {@link supersededKey}).\n * For the boolean decorations there is no such primitive: both levels are\n * booleans, so a tri-state\n * (`true` / `false` / inherit) is expressible and we are collapsing it by\n * choice, to keep one canonical form per styling. Resolution must therefore\n * read decorations as `run.underline || style.underline` — a `??` would\n * make \"select a word in an underlined node, hit U to turn it off\" look\n * supported by the type while this file discards the `false` that expresses it.\n *\n * Copies here are shallow: a `fill` object is shared by reference between\n * the input runs, the patch, every run the patch touched, and the value\n * `styleAtRange` reports. Treat `fill` values as immutable.\n */\n\nimport { MIXED } from 'core/mixed';\nimport type { Mixed } from 'core/mixed';\nimport type { StyledRun } from '@weasel-js/text';\n\nexport { MIXED };\nexport type { Mixed };\n\n/** Every styleable key of a run, each either a concrete value or MIXED (the\n *  runs in the range disagree at that key). */\nexport type RangeStyle = {\n  [K in Exclude<keyof StyledRun, 'text'>]?: StyledRun[K] | Mixed;\n};\n\n/**\n * What `applyStyleToRange` writes. `text` is deliberately not part of it —\n * this is a styling operation, not an edit.\n */\nexport type RunStylePatch = Partial<Omit<StyledRun, 'text'>>;\n\n/** Every key of a run that carries styling — i.e. everything but `text`. */\nexport type StyleKey = Exclude<keyof StyledRun, 'text'>;\n\nconst STYLE_KEYS = [\n  'bold',\n  'fontWeight',\n  'italic',\n  'underline',\n  'strikethrough',\n  'overline',\n  'fontFamily',\n  'fontSize',\n  'letterSpacing',\n  'fill',\n  'stroke',\n  'script',\n  'baselineShift',\n  'fontScale',\n  'textTransform',\n  'fontVariantCaps',\n] as const satisfies readonly StyleKey[];\n\n// Every function here iterates STYLE_KEYS, so a key missing from the list is\n// invisible: `applyStyleToRange` would drop it when patching a run and\n// `sameStyle` would merge two runs that differ in it, silently discarding\n// one value. `satisfies` only checks the entries that ARE listed, so this\n// assertion checks the other direction — adding a key to `StyledRun`\n// without adding it here is a compile error.\ntype MissingStyleKey = Exclude<StyleKey, (typeof STYLE_KEYS)[number]>;\ntype AssertNoMissingStyleKey = [MissingStyleKey] extends [never] ? true : never;\nconst STYLE_KEYS_ARE_EXHAUSTIVE: AssertNoMissingStyleKey = true;\nvoid STYLE_KEYS_ARE_EXHAUSTIVE;\n\n/** The additive flags: absent and `false` mean the same thing, so both read as `false`. */\nconst FLAG_KEYS: ReadonlySet<StyleKey> = new Set<StyleKey>([\n  'bold',\n  'italic',\n  'underline',\n  'strikethrough',\n  'overline',\n]);\n\nfunction isPlainObject(v: unknown): v is Record<string, unknown> {\n  return typeof v === 'object' && v !== null && !Array.isArray(v);\n}\n\n/**\n * Structural equality over the JSON-ish values a run can hold. This assumes\n * `FillStyle` stays acyclic and plain — every member of the union is data\n * (`TextureHandle` is `{ id }`, so patterns compare by id, which is right).\n * A fill that grew a cyclic or class-valued field would recurse forever.\n */\nfunction deepEqual(a: unknown, b: unknown): boolean {\n  if (Object.is(a, b)) return true;\n  if (Array.isArray(a) && Array.isArray(b)) {\n    return a.length === b.length && a.every((item, i) => deepEqual(item, b[i]));\n  }\n  if (isPlainObject(a) && isPlainObject(b)) {\n    const keys = Object.keys(a);\n    if (keys.length !== Object.keys(b).length) return false;\n    return keys.every((k) => k in b && deepEqual(a[k], b[k]));\n  }\n  return false;\n}\n\n/** A run's value at `key`, with flags normalized so absent reads as `false`. */\nfunction valueAt(run: StyledRun, key: StyleKey): StyledRun[StyleKey] {\n  const value = run[key];\n  if (FLAG_KEYS.has(key)) return (value as boolean | undefined) ?? false;\n  return value;\n}\n\n/** The structural values. Everything else is a primitive, and\n *  `applyStyleToRange` spreads runs, so reference identity isn't reliable. */\nconst STRUCTURAL_KEYS: ReadonlySet<StyleKey> = new Set<StyleKey>(['fill', 'stroke']);\n\nfunction sameValue(key: StyleKey, a: unknown, b: unknown): boolean {\n  return STRUCTURAL_KEYS.has(key) ? deepEqual(a, b) : Object.is(a, b);\n}\n\n/** Do two runs carry the same styling (their `text` aside)? */\nfunction sameStyle(a: StyledRun, b: StyledRun): boolean {\n  return STYLE_KEYS.every((key) => sameValue(key, valueAt(a, key), valueAt(b, key)));\n}\n\n/** Total character length of a run array — the domain of its offsets. */\nfunction totalLength(runs: readonly StyledRun[]): number {\n  let n = 0;\n  for (const run of runs) n += run.text.length;\n  return n;\n}\n\n/**\n * The styling shared by every run overlapping `[start, end)`: a concrete\n * value where the range agrees, `MIXED` where it doesn't. Keys no run\n * in range sets are absent (they inherit the node's `TextStyle`) — except\n * the additive flags, which read as `false` rather than `undefined` since a\n * run cannot un-set them. An empty range reads as `{}`. A reported `fill`\n * is the run's own object, not a copy — treat it as immutable.\n */\nexport function styleAtRange(\n  runs: readonly StyledRun[],\n  start: number,\n  end: number,\n): RangeStyle {\n  const lo = Math.max(0, start);\n  const hi = end;\n  // Negated `<` rather than `>=` so a non-numeric offset reads as empty\n  // instead of matching every run.\n  if (!(lo < hi)) return {};\n\n  const first = new Map<StyleKey, unknown>();\n  const mixed = new Set<StyleKey>();\n  let seen = false;\n  let pos = 0;\n\n  for (const run of runs) {\n    const runEnd = pos + run.text.length;\n    const a = Math.max(pos, lo);\n    const b = Math.min(runEnd, hi);\n    pos = runEnd;\n    if (!(a < b)) continue;\n\n    for (const key of STYLE_KEYS) {\n      const value = valueAt(run, key);\n      if (!seen) first.set(key, value);\n      else if (!mixed.has(key) && !sameValue(key, first.get(key), value)) {\n        mixed.add(key);\n      }\n    }\n    seen = true;\n  }\n\n  if (!seen) return {};\n\n  const style: Record<string, unknown> = {};\n  for (const key of STYLE_KEYS) {\n    if (mixed.has(key)) style[key] = MIXED;\n    else {\n      const value = first.get(key);\n      if (value !== undefined) style[key] = value;\n    }\n  }\n  return style as RangeStyle;\n}\n\n/**\n * Does any run carry styling of its own? Per the additive-flags contract\n * above, absent and `false` are the same state — \"no run-level override\" —\n * so an array that is nothing but text reads as `false`, whether it came\n * from a plain-text edit or from styling that was toggled back off.\n *\n * This is how the commit path tells \"the edit produced run styling\" from\n * \"the edit produced text\", which is the question that decides whether a\n * node grows a `runs` array. Iterating `STYLE_KEYS` rather than the run's\n * own keys is what keeps it honest as `StyledRun` grows: a new styleable\n * key is a compile error at `STYLE_KEYS` until it's listed, and then this\n * sees it for free.\n */\nexport function runsCarryStyling(runs: readonly StyledRun[]): boolean {\n  return runs.some((run) =>\n    STYLE_KEYS.some((key) => {\n      const value = run[key];\n      return value !== undefined && value !== false;\n    }),\n  );\n}\n\n/**\n * The key a patch clears without naming it. `bold` is a preset over\n * `fontWeight`, and a run keeps at most one of the two: writing either drops\n * the other, so a Bold toggle is not hidden under a weight it cannot beat and\n * a picked weight is not shadowed by a stale flag. Naming both writes both.\n */\nexport function supersededKey(patch: RunStylePatch): 'bold' | 'fontWeight' | undefined {\n  if ('bold' in patch && !('fontWeight' in patch)) return 'fontWeight';\n  if (patch.fontWeight !== undefined && !('bold' in patch)) return 'bold';\n  return undefined;\n}\n\n/**\n * `range` with `patch` laid over it, keyed as a write of `patch` would leave\n * the runs — for showing styling armed for the next keystroke over the\n * styling at the caret. A key the patch leaves `undefined` keeps the range's\n * value; the key it supersedes is dropped.\n */\nexport function patchRangeStyle(range: RangeStyle, patch: RunStylePatch): RangeStyle {\n  const out: Record<string, unknown> = { ...range };\n  const superseded = supersededKey(patch);\n  if (superseded !== undefined) delete out[superseded];\n  for (const [key, value] of Object.entries(patch)) {\n    if (value !== undefined) out[key] = value;\n  }\n  return out as RangeStyle;\n}\n\n/** Apply `patch` to one run, deleting rather than storing \"no override\". */\nfunction patchRun(run: StyledRun, patch: RunStylePatch): StyledRun {\n  const next: StyledRun = { ...run };\n  const superseded = supersededKey(patch);\n  if (superseded !== undefined) delete next[superseded];\n  for (const key of STYLE_KEYS) {\n    if (!(key in patch)) continue;\n    const value = patch[key];\n    // Per the additive-flags contract at the top of the file, `false` is not\n    // a storable state — it means \"no run-level override\", same as\n    // `undefined`. Deleting keeps one canonical form (coalescing already\n    // treats absent and `false` as equal, so this isn't what makes runs\n    // merge — it's what keeps the stored shape from drifting).\n    if (value === undefined || value === false) delete next[key];\n    else (next as unknown as Record<string, unknown>)[key] = value;\n  }\n  return next;\n}\n\n/** Merge neighbors that ended up styled identically; drop empty runs. */\nfunction coalesceRuns(runs: readonly StyledRun[]): StyledRun[] {\n  const out: StyledRun[] = [];\n  for (const run of runs) {\n    if (run.text.length === 0) continue;\n    const prev = out[out.length - 1];\n    if (prev && sameStyle(prev, run)) prev.text += run.text;\n    else out.push({ ...run });\n  }\n  return out;\n}\n\n/**\n * Write `patch` over `[start, end)`, splitting runs at the boundaries and\n * coalescing neighbors that end up identical. A patch value of `undefined`\n * or `false` deletes the key instead of storing it — see the additive-flags\n * contract at the top of the file.\n *\n * Returns a new array of new runs; neither the input array nor its runs are\n * mutated (though a nested `fill` is shared by reference). Normalization —\n * merging identical neighbors, dropping empty runs — applies to the whole\n * array, not just the patched span, and to every call, including one whose\n * range is empty and so patches nothing.\n */\nexport function applyStyleToRange(\n  runs: readonly StyledRun[],\n  start: number,\n  end: number,\n  patch: RunStylePatch,\n): StyledRun[] {\n  const lo = Math.max(0, start);\n  const hi = Math.min(totalLength(runs), end);\n  // A collapsed caret is the common call, so it takes the same normalization\n  // as any other range rather than a laxer copy-only path.\n  if (!(lo < hi)) return coalesceRuns(runs);\n\n  const out: StyledRun[] = [];\n  let pos = 0;\n  for (const run of runs) {\n    const runEnd = pos + run.text.length;\n    const a = Math.max(pos, lo);\n    const b = Math.min(runEnd, hi);\n    if (a < b) {\n      if (pos < a) out.push({ ...run, text: run.text.slice(0, a - pos) });\n      out.push(patchRun({ ...run, text: run.text.slice(a - pos, b - pos) }, patch));\n      if (b < runEnd) out.push({ ...run, text: run.text.slice(b - pos) });\n    } else {\n      out.push({ ...run });\n    }\n    pos = runEnd;\n  }\n\n  return coalesceRuns(out);\n}\n"],"mappings":"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"}

package/dist/features/text/textCommand.js

@@ -0,0 +1,59 @@
+import { fillInPoseFrame as e } from "../../core/fillInPoseFrame.js";
+import { resolveFillPattern as t } from "../patterns/resolveSpec.js";
+import { resolveAlign as n, resolveRuns as r, resolveTextStyle as i, textPoseLayoutInput as a } from "@weasel-js/text";
+//#region src/features/text/textCommand.ts
+function o(e, t, a, o, s, c, l, u, d, f = 1) {
+	let p = i(o, u, f);
+	return {
+		kind: "text",
+		x: e,
+		y: t,
+		runs: r(a, p, f),
+		align: n(p.align, p.direction),
+		justify: p.align === "justify",
+		maxWidth: s,
+		style: o ?? {},
+		height: c,
+		verticalAlign: l,
+		width: d
+	};
+}
+function s(e, t, n, r, i, a, s, c, l, u = 1) {
+	return o(e, t, [{ text: n }], r, i, a, s, c, l, u);
+}
+function c(e, t = 1) {
+	let { runs: n, opts: r } = a(e, t);
+	return {
+		kind: "text",
+		x: e.x,
+		y: e.y,
+		runs: l(n, e),
+		align: r.align,
+		justify: r.justify,
+		maxWidth: r.maxWidth,
+		width: r.alignWidth,
+		style: e.style ?? {},
+		height: e.height,
+		verticalAlign: e.verticalAlign
+	};
+}
+function l(n, r) {
+	return n.every((e) => u(e.fill) && u(e.stroke?.paint)) ? n : n.map((n) => {
+		let i = n.fill && t(e(n.fill, r)), a = n.stroke?.paint && t(e(n.stroke.paint, r));
+		return {
+			...n,
+			fill: i,
+			stroke: n.stroke && {
+				...n.stroke,
+				paint: a || void 0
+			}
+		};
+	});
+}
+function u(e) {
+	return e == null || (e.fill ?? "solid") === "solid";
+}
+//#endregion
+export { s as textCommand, c as textCommandFromPose, o as textCommandFromRuns };
+
+//# sourceMappingURL=textCommand.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"textCommand.js","names":["textCommandFromRuns","resolved","resolveTextStyle","style","paint","scale","resolveRuns","runs","resolveAlign","textCommand","x","y","maxWidth","height","verticalAlign","width","textCommandFromPose","textPoseLayoutInput","pose","runsInPoseFrame","opts","isSolid","r","fill","resolveFillPattern","fillInPoseFrame","box"],"sources":["../../../src/features/text/textCommand.ts"],"sourcesContent":["/**\n * Build a `TextDrawCommand`. `textCommandFromPose` is the command for a text\n * node — what `kit:text` and `createTextLayer` both emit. `textCommand` takes\n * a plain string and wraps it in one run; `textCommandFromRuns` takes the\n * styled runs directly, for text that has no pose. All three\n * resolve through `resolveTextStyle` + `resolveRuns`, so every emitter of a\n * text command derives `align` and per-run resolution the same way — a\n * caller that assembles the command by hand is one field away from a\n * silently different result.\n *\n * `paint` is the node's `data.fill` / `data.stroke`. A caller with no node —\n * a HUD widget, a debug overlay — states its color on the run instead.\n *\n * `scale` is the view scale a `{ px }` `fontSize` or `letterSpacing` resolves\n * against — for a world-space layer, the mean of `view.scale.x` and\n * `view.scale.y`. It has to be applied here and not at draw time, because a\n * screen-pixel size moves the glyph advances and so the wrap points.\n */\n\nimport type { DrawCommand, TextDrawCommand } from '../../renderer';\nimport type { TextPaint, TextPose, TextStyle } from '@weasel-js/text';\nimport { resolveAlign, resolveTextStyle, textPoseLayoutInput } from '@weasel-js/text';\nimport { resolveRuns } from '@weasel-js/text';\nimport type { StyledRun } from '@weasel-js/text';\nimport type { TextVerticalAlign, ResolvedRun } from '@weasel-js/text';\nimport type { FillStyle } from '@weasel-js/paint';\nimport { fillInPoseFrame, type FillPoseBox } from '../../core/fillInPoseFrame';\nimport { resolveFillPattern } from '../patterns/resolveSpec';\n\n/** Build a draw command from styled runs, for text with no pose. `style`\n *  supplies the defaults each run inherits; the rest match `textCommand`. */\nexport function textCommandFromRuns(\n  x: number,\n  y: number,\n  runs: readonly StyledRun[],\n  style?: TextStyle,\n  maxWidth?: number,\n  height?: number,\n  verticalAlign?: TextVerticalAlign,\n  paint?: TextPaint,\n  width?: number,\n  scale = 1,\n): DrawCommand {\n  const resolved = resolveTextStyle(style, paint, scale);\n  return {\n    kind: 'text',\n    x,\n    y,\n    runs: resolveRuns(runs, resolved, scale),\n    align: resolveAlign(resolved.align, resolved.direction),\n    justify: resolved.align === 'justify',\n    maxWidth,\n    style: style ?? {},\n    height,\n    verticalAlign,\n    width,\n  };\n}\n\n/** Build a draw command for a single unstyled string. Text is laid out with\n *  the registered font's metrics, wrapped at `maxWidth`, aligned across\n *  `width` (default `maxWidth`) and within `height` when `verticalAlign` is\n *  given. */\nexport function textCommand(\n  x: number,\n  y: number,\n  text: string,\n  style?: TextStyle,\n  maxWidth?: number,\n  height?: number,\n  verticalAlign?: TextVerticalAlign,\n  paint?: TextPaint,\n  width?: number,\n  scale = 1,\n): DrawCommand {\n  return textCommandFromRuns(\n    x, y, [{ text }], style, maxWidth, height, verticalAlign, paint, width, scale,\n  );\n}\n\n/**\n * The draw command for a text pose. Its wrap width, alignment box and runs\n * come from `textPoseLayoutInput`, so the renderer lays it out into exactly\n * the lines `layoutTextPose` reports for the same pose.\n *\n * Each run's paints are resolved against the pose box the way every other\n * node's are — a `'bounds'` paint mapped onto it, a pattern spec swapped for\n * its texture — since the renderer can do neither.\n */\nexport function textCommandFromPose(pose: TextPose, scale = 1): TextDrawCommand {\n  const { runs, opts } = textPoseLayoutInput(pose, scale);\n  return {\n    kind: 'text',\n    x: pose.x,\n    y: pose.y,\n    runs: runsInPoseFrame(runs, pose),\n    align: opts.align,\n    justify: opts.justify,\n    maxWidth: opts.maxWidth,\n    width: opts.alignWidth,\n    style: pose.style ?? {},\n    height: pose.height,\n    verticalAlign: pose.verticalAlign,\n  };\n}\n\nfunction runsInPoseFrame(runs: ResolvedRun[], box: FillPoseBox): ResolvedRun[] {\n  if (runs.every((r) => isSolid(r.fill) && isSolid(r.stroke?.paint))) return runs;\n  return runs.map((r) => {\n    const fill = r.fill && resolveFillPattern(fillInPoseFrame(r.fill, box));\n    const paint = r.stroke?.paint && resolveFillPattern(fillInPoseFrame(r.stroke.paint, box));\n    return { ...r, fill, stroke: r.stroke && { ...r.stroke, paint: paint || undefined } };\n  });\n}\n\nfunction isSolid(paint: FillStyle | null | undefined): boolean {\n  return paint == null || (paint.fill ?? 'solid') === 'solid';\n}\n"],"mappings":";;;;AA+BA,SAAgBA,EACd,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,IAAQ,GACK;CACb,IAAMC,IAAWC,EAAiBC,GAAOC,GAAOC,CAAK;CACrD,OAAO;EACL,MAAM;EACN;EACA;EACA,MAAMC,EAAYC,GAAMN,GAAUI,CAAK;EACvC,OAAOG,EAAaP,EAAS,OAAOA,EAAS,SAAS;EACtD,SAASA,EAAS,UAAU;EAC5B;EACA,OAAOE,KAAS,CAAC;EACjB;EACA;EACA;CACF;AACF;AAMA,SAAgBM,EACd,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,IAAQ,GACK;CACb,OAAOT,EACLU,GAAGC,GAAG,CAAC,EAAE,QAAK,CAAC,GAAGR,GAAOS,GAAUC,GAAQC,GAAeV,GAAOW,GAAOV,CAC1E;AACF;AAWA,SAAgBW,EAAoB,GAAgB,IAAQ,GAAoB;CAC9E,IAAM,EAAE,SAAM,YAASC,EAAoBC,GAAMb,CAAK;CACtD,OAAO;EACL,MAAM;EACN,GAAGa,EAAK;EACR,GAAGA,EAAK;EACR,MAAMC,EAAgBZ,GAAMW,CAAI;EAChC,OAAOE,EAAK;EACZ,SAASA,EAAK;EACd,UAAUA,EAAK;EACf,OAAOA,EAAK;EACZ,OAAOF,EAAK,SAAS,CAAC;EACtB,QAAQA,EAAK;EACb,eAAeA,EAAK;CACtB;AACF;AAEA,SAASC,EAAgB,GAAqB,GAAiC;CAE7E,OADIZ,EAAK,OAAO,MAAMc,EAAQC,EAAE,IAAI,KAAKD,EAAQC,EAAE,QAAQ,KAAK,CAAC,IAAUf,IACpEA,EAAK,KAAK,MAAM;EACrB,IAAMgB,IAAOD,EAAE,QAAQE,EAAmBC,EAAgBH,EAAE,MAAMI,CAAG,CAAC,GAChEtB,IAAQkB,EAAE,QAAQ,SAASE,EAAmBC,EAAgBH,EAAE,OAAO,OAAOI,CAAG,CAAC;EACxF,OAAO;GAAE,GAAGJ;GAAG;GAAM,QAAQA,EAAE,UAAU;IAAE,GAAGA,EAAE;IAAQ,OAAOlB,KAAS,KAAA;GAAU;EAAE;CACtF,CAAC;AACH;AAEA,SAASiB,EAAQ,GAA8C;CAC7D,OAAOjB,KAAS,SAASA,EAAM,QAAQ,aAAa;AACtD"}

package/dist/features/text/textLayer.js

@@ -0,0 +1,35 @@
+import { textCommandFromPose as e } from "./textCommand.js";
+import { runsToPlainText as t } from "@weasel-js/text";
+//#region src/features/text/textLayer.ts
+function n(n) {
+	let { id: r = "text", label: i = "Text", getTexts: a, getPose: o, isHidden: s, clipToBounds: c = !1 } = n;
+	return {
+		id: r,
+		label: i,
+		draw: (n, r) => {
+			let i = (r.scale.x + r.scale.y) / 2, l = [];
+			for (let n of a()) {
+				if (s?.(n)) continue;
+				let r = o(n);
+				if (r.runs && r.runs.length > 0 && t(r.runs) !== r.text) throw Error("weasel createTextLayer: TextPose invariant violated — runsToPlainText(runs) !== text. Either omit `runs` or keep it synchronized with `text`.");
+				let a = e(r, i);
+				c ? l.push({
+					kind: "group",
+					clip: {
+						kind: "rect",
+						x: r.x,
+						y: r.y,
+						width: r.width,
+						height: r.height
+					},
+					children: [a]
+				}) : l.push(a);
+			}
+			return l;
+		}
+	};
+}
+//#endregion
+export { n as createTextLayer };
+
+//# sourceMappingURL=textLayer.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"textLayer.js","names":["createTextLayer","opts","scale","view","children","node","getTexts","isHidden","pose","getPose","runsToPlainText","textCmd","textCommandFromPose","clipToBounds"],"sources":["../../../src/features/text/textLayer.ts"],"sourcesContent":["/**\n * Text RenderLayer for text that is not in a scene: one `textCommandFromPose`\n * command per item, the same command the `kit:text` node painter emits, so an\n * item lays out — and wraps, or doesn't, per its style — as a node would.\n *\n * The GL renderer uses MSDF text. The resolved style's `fontFamily` must\n * be registered via `registerFont(family, variant, metricsUrl, atlasUrl)`\n * from the renderer module *before* the GL backend dispatches this layer.\n * Unregistered families render with a warning and no glyphs (see\n * `TextDrawCommand`'s contract).\n */\n\nimport { type DrawCommand } from '../../renderer';\nimport type { TextPose } from '@weasel-js/text';\n\nimport type { RenderLayer } from 'core/layers/render';\nimport { textCommandFromPose } from './textCommand';\nimport { runsToPlainText } from '@weasel-js/text';\n\n\n/** Options for `createTextLayer`. */\nexport interface CreateTextLayerOpts<T> {\n  id?: string;\n  label?: string;\n  getTexts: () => readonly T[];\n  getPose: (node: T) => TextPose;\n  /** Optional per-node hide hook (e.g., suppress while editing). */\n  isHidden?: (node: T) => boolean;\n  /** When `true`, each text command is wrapped in a clipped group so any\n   *  overflow beyond the pose's `(width × height)` is hidden. Default\n   *  `false` (legacy: text can spill outside the declared bounds). Opt-in\n   *  so existing consumers who rely on overflow keep working. */\n  clipToBounds?: boolean;\n}\n\n/** Build a `RenderLayer` that emits one `TextDrawCommand` per text node. */\nexport function createTextLayer<T>(opts: CreateTextLayerOpts<T>): RenderLayer<unknown> {\n  const { id = 'text', label = 'Text', getTexts, getPose, isHidden, clipToBounds = false } = opts;\n  return {\n    id,\n    label,\n    draw: (_data, view) => {\n      // A world-space layer, so a `{ px }` size in a pose's style resolves\n      // against the live camera. Radial in effect — one factor for both axes.\n      const scale = (view.scale.x + view.scale.y) / 2;\n      const children: DrawCommand[] = [];\n      for (const node of getTexts()) {\n        if (isHidden?.(node)) continue;\n        const pose = getPose(node);\n        if (pose.runs && pose.runs.length > 0 && runsToPlainText(pose.runs) !== pose.text) {\n          throw new Error(\n            `weasel createTextLayer: TextPose invariant violated — ` +\n            `runsToPlainText(runs) !== text. Either omit \\`runs\\` or keep it ` +\n            `synchronized with \\`text\\`.`,\n          );\n        }\n        const textCmd = textCommandFromPose(pose, scale);\n        if (clipToBounds) {\n          children.push({\n            kind: 'group',\n            clip: { kind: 'rect', x: pose.x, y: pose.y, width: pose.width, height: pose.height },\n            children: [textCmd],\n          });\n        } else {\n          children.push(textCmd);\n        }\n      }\n      // World-space commands; drawLayers wraps in viewToMat3 automatically.\n      return children;\n    },\n  };\n}\n"],"mappings":";;;AAoCA,SAAgBA,EAAmB,GAAoD;CACrF,IAAM,EAAE,QAAK,QAAQ,WAAQ,QAAQ,aAAU,YAAS,aAAU,kBAAe,OAAUC;CAC3F,OAAO;EACL;EACA;EACA,OAAO,GAAO,MAAS;GAGrB,IAAMC,KAASC,EAAK,MAAM,IAAIA,EAAK,MAAM,KAAK,GACxCC,IAA0B,CAAC;GACjC,KAAK,IAAMC,KAAQC,EAAS,GAAG;IAC7B,IAAIC,IAAWF,CAAI,GAAG;IACtB,IAAMG,IAAOC,EAAQJ,CAAI;IACzB,IAAIG,EAAK,QAAQA,EAAK,KAAK,SAAS,KAAKE,EAAgBF,EAAK,IAAI,MAAMA,EAAK,MAC3E,MAAU,MACR,+IAGF;IAEF,IAAMG,IAAUC,EAAoBJ,GAAMN,CAAK;IAC/C,AAAIW,IACFT,EAAS,KAAK;KACZ,MAAM;KACN,MAAM;MAAE,MAAM;MAAQ,GAAGI,EAAK;MAAG,GAAGA,EAAK;MAAG,OAAOA,EAAK;MAAO,QAAQA,EAAK;KAAO;KACnF,UAAU,CAACG,CAAO;IACpB,CAAC,IAEDP,EAAS,KAAKO,CAAO;GAEzB;GAEA,OAAOP;EACT;CACF;AACF"}

package/dist/features/text/textToPath.js

@@ -0,0 +1,181 @@
+import { SYNTHETIC_ITALIC_RADIANS as e } from "../../renderer/syntheticItalic.js";
+import { poseRotationOf as t } from "../../core/geometry/poseRotation.js";
+import { loadFontOutlines as n, outlineStatus as r, resolveFontVariant as i } from "@weasel-js/font";
+import { PATH_L as a, PATH_M as o, PATH_Z as s, pathFromD as c, pathSignedArea as l, reversePath as u, rotateAboutPoint as d, transformPath as f } from "@weasel-js/geom";
+import { layoutRuns as p, textPoseLayoutInput as m, verticalAlignOffset as h } from "@weasel-js/text";
+//#region src/features/text/textToPath.ts
+var g = class extends Error {
+	reason;
+	family;
+	weight;
+	style;
+	constructor(e, t, n, r, i) {
+		super(`textToPath: "${t}" ${n}/${r} — ${i}`), this.name = "TextOutlinesError", this.reason = e, this.family = t, this.weight = n, this.style = r;
+	}
+};
+function _(e) {
+	let t = /* @__PURE__ */ new Map(), n = (e, n, r) => {
+		t.set(`${e}|${n}|${r}`, {
+			family: e,
+			weight: n,
+			style: r
+		});
+	};
+	for (let t of e) {
+		n(t.fontFamily, t.fontWeight, t.fontStyle);
+		let { family: e, weight: r, style: a } = i(t.fontFamily, t.fontWeight, t.fontStyle).resolved;
+		n(e, r, a);
+	}
+	return [...t.values()];
+}
+function v(e) {
+	let { fontFamily: t, fontWeight: a, fontStyle: o } = e, s = (e, n) => {
+		throw new g(e, t, a, o, n);
+	}, c = r(t, a, o);
+	(c === "idle" || c === "loading") && (n(t, {
+		weight: a,
+		style: o
+	}), s("outlines-loading", "its outlines have not loaded yet; await loadTextOutlines first."));
+	let l = i(t, a, o), { family: u, weight: d, style: f } = l.resolved;
+	if (l.synthetic.bold && s("synthetic-bold", `drawn as a faux bold of ${u} ${d}/${f}, which has no geometry to embolden. Register outlines for the real bold face.`), l.source === "outline") return;
+	let p = r(u, d, f);
+	p === null && s("no-outlines", `served by ${u} ${d}/${f}, which has no outlines registered. Call registerFontOutlines for it.`), (p === "idle" || p === "loading") && (n(u, {
+		weight: d,
+		style: f
+	}), s("outlines-loading", `the outlines of ${u} ${d}/${f} have not loaded yet; await loadTextOutlines first.`)), p === "failed" && s("outlines-failed", `the outlines registered for ${u} ${d}/${f} failed to load.`);
+}
+var y = 4096, b = /* @__PURE__ */ new Map();
+function x(e) {
+	let t = b.get(e);
+	return t || (t = c(e), l(t) < 0 && (t = u(t)), b.size >= y && b.clear(), b.set(e, t), t);
+}
+function S(e) {
+	let t = 0, n = 0;
+	for (let r of e) t += r.commands.length, n += r.coords.length;
+	let r = new Uint8Array(t), i = new Float32Array(n), a = 0, o = 0;
+	for (let t of e) r.set(t.commands, a), a += t.commands.length, i.set(t.coords, o), o += t.coords.length;
+	return {
+		kind: "polygon",
+		commands: r,
+		coords: i,
+		fillRule: "nonzero"
+	};
+}
+function C(e, t, n, r) {
+	return {
+		kind: "polygon",
+		commands: new Uint8Array([
+			o,
+			a,
+			a,
+			a,
+			s
+		]),
+		coords: new Float32Array([
+			e,
+			t,
+			n,
+			t,
+			n,
+			r,
+			e,
+			r
+		]),
+		fillRule: "nonzero"
+	};
+}
+function w(e, t) {
+	return JSON.stringify([e, t ?? null]);
+}
+function T(n, r, i) {
+	let a = {
+		x: r.x,
+		y: r.y,
+		width: r.width,
+		height: r.height,
+		text: n.text,
+		runs: n.runs,
+		style: n.style,
+		verticalAlign: n.verticalAlign,
+		fill: n.fill,
+		stroke: n.stroke
+	}, { runs: o, opts: s } = m(a, i.scale ?? 1);
+	for (let e of o) v(e);
+	let c = [], l = /* @__PURE__ */ new Map(), u = o.map((e) => {
+		let t = w(e.fill, e.stroke), n = l.get(t);
+		n === void 0 && (n = c.length, l.set(t, n), c.push(e.stroke === void 0 ? { fill: e.fill } : {
+			fill: e.fill,
+			stroke: e.stroke
+		}));
+		let { stroke: r, ...i } = e;
+		return {
+			...i,
+			fill: {
+				fill: "solid",
+				color: `#${n.toString(16).padStart(6, "0")}`
+			}
+		};
+	}), _ = (e) => e !== null && "color" in e ? parseInt(e.color.slice(1), 16) : 0, y = p(u, {
+		...s,
+		outlineMinSize: 0
+	});
+	for (let e of y.groups) if (e.source !== "outline" && e.quads.length > 0) throw new g("no-outlines", e.family, e.weight, e.style, "a fallback face serving some of the text's characters has no outlines registered.");
+	let b = r.x, T = r.y + h(n.verticalAlign, r.height, y.bounds.height), E = c.map(() => []);
+	for (let t of y.groups) {
+		let n = E[_(t.fill)], r = t.synthetic.italic ? Math.tan(e) : 0;
+		for (let e of t.glyphs) {
+			let t = e.scale, i = [
+				t,
+				0,
+				-r * t,
+				t,
+				e.x + b,
+				e.baselineY + T
+			];
+			n.push(f(x(e.d), i));
+		}
+	}
+	for (let e of y.decorations) E[_(e.fill)].push(C(e.x0 + b, e.y0 + T, e.x1 + b, e.y1 + T));
+	let D = t(r);
+	return {
+		paints: c,
+		paths: E.map((e) => {
+			let t = S(e);
+			return !D || t.commands.length === 0 ? t : f(t, d(D.cx, D.cy, D.rotation));
+		})
+	};
+}
+function E(e, t, n = {}) {
+	return S(T(e, t, n).paths);
+}
+function D(e, t, n = {}) {
+	let { paints: r, paths: i } = T(e, t, n), a = [];
+	return r.forEach((e, t) => {
+		i[t].commands.length > 0 && a.push({
+			...e,
+			path: i[t]
+		});
+	}), a;
+}
+async function O(e, t = {}) {
+	let r = {
+		x: 0,
+		y: 0,
+		width: 0,
+		height: 0,
+		text: e.text,
+		runs: e.runs,
+		style: e.style
+	}, { runs: i } = m(r, t.scale ?? 1);
+	await Promise.all(_(i).map((e) => n(e.family, {
+		weight: e.weight,
+		style: e.style
+	}))), await Promise.all(_(i).map((e) => n(e.family, {
+		weight: e.weight,
+		style: e.style
+	})));
+}
+//#endregion
+export { g as TextOutlinesError, O as loadTextOutlines, E as textToPath, D as textToPathsByPaint };
+
+//# sourceMappingURL=textToPath.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"textToPath.js","names":["TextOutlinesError","family","weight","style","detail","reason","facesOf","out","add","r","runs","resolveFontVariant","assertOutlinable","run","fail","fontFamily","fontWeight","fontStyle","requested","outlineStatus","loadFontOutlines","status","EM_CACHE_LIMIT","emCache","emGlyph","p","d","pathFromD","pathSignedArea","reversePath","concat","nc","nk","parts","commands","coords","ci","ki","ruleContour","PATH_M","PATH_L","PATH_Z","x0","y0","x1","y1","paintKey","fill","stroke","walkOutlines","textPose","pose","data","resolved","layoutOpts","textPoseLayoutInput","opts","paints","indexOf","key","i","_stroke","rest","groupOf","laid","layoutRuns","g","dx","dy","verticalAlignOffset","shear","SYNTHETIC_ITALIC_RADIANS","glyph","s","m","transformPath","rot","poseRotationOf","path","rotateAboutPoint","textToPath","textToPathsByPaint","paths","paint","loadTextOutlines","f"],"sources":["../../../src/features/text/textToPath.ts"],"sourcesContent":["/**\n * Text as path geometry: the glyph outlines a text node draws, placed in\n * world space and composed into one `Path`. What \"Create Outlines\" replaces a\n * text node with, and what a Boolean op reads when a text node is an operand.\n *\n * The walk is `layoutRuns`', so the glyphs land exactly where the renderer's\n * outline tier puts them — same pen positions, same baselines, same synthetic\n * italic shear — but with the tier forced on for every glyph whatever its\n * size, and with paint set aside: unfilled text has outlines too.\n * `textToPathsByPaint` is the same walk, split by the paint each glyph wears.\n */\n\nimport type { FillStyle, Stroke } from '@weasel-js/paint';\n\nimport {\n  loadFontOutlines, outlineStatus, resolveFontVariant, type FontStyle,\n} from '@weasel-js/font';\nimport {\n  layoutRuns, textPoseLayoutInput, verticalAlignOffset,\n  type ResolvedRun, type StyledRun, type TextPose, type TextStyle, type TextVerticalAlign,\n} from '@weasel-js/text';\nimport {\n  PATH_L, PATH_M, PATH_Z, pathFromD, pathSignedArea, reversePath, rotateAboutPoint,\n  transformPath, type Mat3, type PolygonPath,\n} from '@weasel-js/geom';\nimport { poseRotationOf } from 'core/geometry/poseRotation';\nimport type { PathInWorldPose } from 'features/paths/pathInWorld';\nimport { SYNTHETIC_ITALIC_RADIANS } from 'renderer/syntheticItalic';\n\n/** The fields of a text node's data that decide its glyph geometry, and the\n *  paint `textToPathsByPaint` splits it by. Paint never changes the geometry. */\nexport interface TextOutlineSource {\n  text: string;\n  runs?: readonly StyledRun[];\n  style?: TextStyle;\n  verticalAlign?: TextVerticalAlign;\n  /** The node's `data.fill`: `null` is no fill, absent the default black. */\n  fill?: FillStyle | null;\n  /** The node's `data.stroke`: absent or `null` is no stroke. */\n  stroke?: Stroke | null;\n}\n\n/** One paint's share of a text node's outlines — see {@link textToPathsByPaint}. */\nexport interface TextPaintPath {\n  /** The resolved fill these glyphs wear: the run's own, else the node's.\n   *  `null` for unfilled text, painted by its stroke alone. */\n  fill: FillStyle | null;\n  /** The resolved stroke — the run's own, else the node's — or absent. */\n  stroke?: Stroke;\n  /** World-space outlines, as {@link textToPath} builds them. */\n  path: PolygonPath;\n}\n\n/** A text node as {@link textToPath} reads it: its data and its pose. */\nexport interface TextNodeSource {\n  data: TextOutlineSource;\n  pose: PathInWorldPose;\n}\n\n/** Options for {@link textToPath}. */\nexport interface TextToPathOptions {\n  /** The view scale a `{ px }` `fontSize` or `letterSpacing` resolves\n   *  against, as for `textCommandFromPose`. Default 1. */\n  scale?: number;\n}\n\n/**\n * Why a text node has no outline geometry to give:\n *\n * - `'no-outlines'` — the face that serves it has no outlines registered\n *   (`registerFontOutlines`), so there is no geometry to read.\n * - `'outlines-loading'` — registered but not parsed yet. `loadTextOutlines`\n *   waits for it; the call has already started the load.\n * - `'outlines-failed'` — registered, and the bytes did not load or parse.\n * - `'synthetic-bold'` — the requested weight is faked from a lighter face.\n *   The renderer thickens the distance field for that, and a path has no\n *   field to thicken; emboldening geometry needs outline offsetting, which\n *   the kit does not have. Converting would silently lighten the text.\n */\nexport type TextOutlinesFailure =\n  | 'no-outlines'\n  | 'outlines-loading'\n  | 'outlines-failed'\n  | 'synthetic-bold';\n\n/** Thrown by {@link textToPath} when some run of the text has no outline\n *  geometry. Names the run's requested face. */\nexport class TextOutlinesError extends Error {\n  readonly reason: TextOutlinesFailure;\n  readonly family: string;\n  readonly weight: number;\n  readonly style: FontStyle;\n\n  constructor(reason: TextOutlinesFailure, family: string, weight: number, style: FontStyle, detail: string) {\n    super(`textToPath: \"${family}\" ${weight}/${style} — ${detail}`);\n    this.name = 'TextOutlinesError';\n    this.reason = reason;\n    this.family = family;\n    this.weight = weight;\n    this.style = style;\n  }\n}\n\n/** The face every run is set in, before and after variant resolution. */\nfunction facesOf(runs: readonly ResolvedRun[]): { family: string; weight: number; style: FontStyle }[] {\n  const out = new Map<string, { family: string; weight: number; style: FontStyle }>();\n  const add = (family: string, weight: number, style: FontStyle) => {\n    out.set(`${family}|${weight}|${style}`, { family, weight, style });\n  };\n  for (const r of runs) {\n    add(r.fontFamily, r.fontWeight, r.fontStyle);\n    const { family, weight, style } = resolveFontVariant(r.fontFamily, r.fontWeight, r.fontStyle).resolved;\n    add(family, weight, style);\n  }\n  return [...out.values()];\n}\n\nfunction assertOutlinable(run: ResolvedRun): void {\n  const { fontFamily, fontWeight, fontStyle } = run;\n  const fail = (reason: TextOutlinesFailure, detail: string): never => {\n    throw new TextOutlinesError(reason, fontFamily, fontWeight, fontStyle, detail);\n  };\n  const requested = outlineStatus(fontFamily, fontWeight, fontStyle);\n  if (requested === 'idle' || requested === 'loading') {\n    void loadFontOutlines(fontFamily, { weight: fontWeight, style: fontStyle });\n    fail('outlines-loading', 'its outlines have not loaded yet; await loadTextOutlines first.');\n  }\n  const r = resolveFontVariant(fontFamily, fontWeight, fontStyle);\n  const { family, weight, style } = r.resolved;\n  if (r.synthetic.bold) {\n    fail('synthetic-bold', `drawn as a faux bold of ${family} ${weight}/${style}, which has no ` +\n      'geometry to embolden. Register outlines for the real bold face.');\n  }\n  if (r.source === 'outline') return;\n  const status = outlineStatus(family, weight, style);\n  if (status === null) {\n    fail('no-outlines', `served by ${family} ${weight}/${style}, which has no outlines ` +\n      'registered. Call registerFontOutlines for it.');\n  }\n  if (status === 'idle' || status === 'loading') {\n    void loadFontOutlines(family, { weight, style });\n    fail('outlines-loading', `the outlines of ${family} ${weight}/${style} have not loaded yet; ` +\n      'await loadTextOutlines first.');\n  }\n  if (status === 'failed') {\n    fail('outlines-failed', `the outlines registered for ${family} ${weight}/${style} failed to load.`);\n  }\n}\n\n// Em-space glyph geometry, wound one way, keyed by the outline data itself so a\n// re-registered face cannot serve stale geometry. The cap bounds a document\n// that cycles through many faces.\nconst EM_CACHE_LIMIT = 4096;\nconst emCache = new Map<string, PolygonPath>();\n\n/** A glyph's em-space path, wound positive so glyphs from faces that disagree\n *  on winding — TrueType against CFF — still fill their overlaps under\n *  `'nonzero'`, and so do the decoration rules drawn across them. */\nfunction emGlyph(d: string): PolygonPath {\n  let p = emCache.get(d);\n  if (p) return p;\n  p = pathFromD(d);\n  if (pathSignedArea(p) < 0) p = reversePath(p);\n  if (emCache.size >= EM_CACHE_LIMIT) emCache.clear();\n  emCache.set(d, p);\n  return p;\n}\n\nfunction concat(parts: readonly PolygonPath[]): PolygonPath {\n  let nc = 0, nk = 0;\n  for (const p of parts) { nc += p.commands.length; nk += p.coords.length; }\n  const commands = new Uint8Array(nc);\n  const coords = new Float32Array(nk);\n  let ci = 0, ki = 0;\n  for (const p of parts) {\n    commands.set(p.commands, ci); ci += p.commands.length;\n    coords.set(p.coords, ki); ki += p.coords.length;\n  }\n  return { kind: 'polygon', commands, coords, fillRule: 'nonzero' };\n}\n\nfunction ruleContour(x0: number, y0: number, x1: number, y1: number): PolygonPath {\n  return {\n    kind: 'polygon',\n    commands: new Uint8Array([PATH_M, PATH_L, PATH_L, PATH_L, PATH_Z]),\n    coords: new Float32Array([x0, y0, x1, y0, x1, y1, x0, y1]),\n    fillRule: 'nonzero',\n  };\n}\n\n/** Paint identity for grouping. Paint is plain data, so structural equality\n *  is exact — a gradient set on two runs separately is still one paint. */\nfunction paintKey(fill: FillStyle | null, stroke: Stroke | undefined): string {\n  return JSON.stringify([fill, stroke ?? null]);\n}\n\n/**\n * The one glyph walk behind both entry points. Each resolved run is repainted\n * with an opaque solid whose color is its paint group's index, so the layout's\n * own groups and decoration rules come back labeled with it; nothing else in\n * the layout reads paint once `outlineMinSize` is 0, so the geometry is what\n * it would be with no paint at all.\n */\nfunction walkOutlines(\n  data: TextOutlineSource,\n  pose: PathInWorldPose,\n  opts: TextToPathOptions,\n): { paints: { fill: FillStyle | null; stroke?: Stroke }[]; paths: PolygonPath[] } {\n  const textPose: TextPose = {\n    x: pose.x, y: pose.y, width: pose.width, height: pose.height,\n    text: data.text,\n    runs: data.runs as StyledRun[] | undefined,\n    style: data.style,\n    verticalAlign: data.verticalAlign,\n    fill: data.fill,\n    stroke: data.stroke,\n  };\n  const { runs: resolved, opts: layoutOpts } = textPoseLayoutInput(textPose, opts.scale ?? 1);\n  for (const run of resolved) assertOutlinable(run);\n\n  const paints: { fill: FillStyle | null; stroke?: Stroke }[] = [];\n  const indexOf = new Map<string, number>();\n  const runs = resolved.map((run): ResolvedRun => {\n    const key = paintKey(run.fill, run.stroke);\n    let i = indexOf.get(key);\n    if (i === undefined) {\n      i = paints.length;\n      indexOf.set(key, i);\n      paints.push(run.stroke !== undefined ? { fill: run.fill, stroke: run.stroke } : { fill: run.fill });\n    }\n    const { stroke: _stroke, ...rest } = run;\n    return { ...rest, fill: { fill: 'solid', color: `#${i.toString(16).padStart(6, '0')}` } };\n  });\n  const groupOf = (fill: FillStyle | null): number =>\n    fill !== null && 'color' in fill ? parseInt(fill.color.slice(1), 16) : 0;\n\n  const laid = layoutRuns(runs, { ...layoutOpts, outlineMinSize: 0 });\n  // A code point the run's own face lacks escalates to a fallback face, which\n  // the per-run check above never saw.\n  for (const g of laid.groups) {\n    if (g.source !== 'outline' && g.quads.length > 0) {\n      throw new TextOutlinesError('no-outlines', g.family, g.weight, g.style,\n        'a fallback face serving some of the text\\'s characters has no outlines registered.');\n    }\n  }\n\n  const dx = pose.x;\n  const dy = pose.y + verticalAlignOffset(data.verticalAlign, pose.height, laid.bounds.height);\n  const parts: PolygonPath[][] = paints.map(() => []);\n  for (const g of laid.groups) {\n    const out = parts[groupOf(g.fill)]!;\n    const shear = g.synthetic.italic ? Math.tan(SYNTHETIC_ITALIC_RADIANS) : 0;\n    for (const glyph of g.glyphs) {\n      const s = glyph.scale;\n      // The renderer's placement (`mergeGlyphMeshes`): x = pen + (ex - ey·shear)·s.\n      const m: Mat3 = [s, 0, -shear * s, s, glyph.x + dx, glyph.baselineY + dy];\n      out.push(transformPath(emGlyph(glyph.d), m) as PolygonPath);\n    }\n  }\n  for (const r of laid.decorations) {\n    parts[groupOf(r.fill)]!.push(ruleContour(r.x0 + dx, r.y0 + dy, r.x1 + dx, r.y1 + dy));\n  }\n\n  const rot = poseRotationOf(pose);\n  const paths = parts.map((p) => {\n    const path = concat(p);\n    if (!rot || path.commands.length === 0) return path;\n    return transformPath(path, rotateAboutPoint(rot.cx, rot.cy, rot.rotation)) as PolygonPath;\n  });\n  return { paints, paths };\n}\n\n/**\n * The outline geometry of a text node, in world space: every glyph and every\n * underline, strikethrough and overline rule it draws, as one `'nonzero'`\n * compound path whose filled region is their union. Glyphs keep the font's\n * curves; overlapping contours are not merged — run the result through\n * `pathUnion` for that, at the cost of flattening the curves.\n *\n * `pose` is the node's box and rotation. Synthetic italic is sheared exactly\n * as the renderer shears it. Throws {@link TextOutlinesError} when any run's\n * face cannot supply outlines — never returns a partial or empty path for\n * that. Text with no ink (empty, or only spaces) returns an empty path.\n */\nexport function textToPath(\n  data: TextOutlineSource,\n  pose: PathInWorldPose,\n  opts: TextToPathOptions = {},\n): PolygonPath {\n  return concat(walkOutlines(data, pose, opts).paths);\n}\n\n/**\n * {@link textToPath}, split by paint: one path per distinct resolved fill and\n * stroke, each gathering the glyphs and decoration rules that wear it — a\n * rule takes the fill of the run it underlines. Groups come in the order\n * their paint first appears in the text; a paint whose runs put down no ink\n * has none. Together the paths cover exactly what `textToPath` covers.\n *\n * Paint resolves as the renderer resolves it: a run's `fill` / `stroke`, else\n * the node's `data.fill` / `data.stroke` from `data`, else the default black\n * fill and no stroke. Throws as `textToPath` does.\n */\nexport function textToPathsByPaint(\n  data: TextOutlineSource,\n  pose: PathInWorldPose,\n  opts: TextToPathOptions = {},\n): TextPaintPath[] {\n  const { paints, paths } = walkOutlines(data, pose, opts);\n  const out: TextPaintPath[] = [];\n  paints.forEach((paint, i) => {\n    if (paths[i]!.commands.length > 0) out.push({ ...paint, path: paths[i]! });\n  });\n  return out;\n}\n\n/**\n * Load the outlines of every face `data` is set in — the requested faces and\n * the ones they resolve to — so a following {@link textToPath} does not fail\n * with `'outlines-loading'`. Resolves once each has loaded or failed.\n */\nexport async function loadTextOutlines(\n  data: TextOutlineSource,\n  opts: TextToPathOptions = {},\n): Promise<void> {\n  const textPose: TextPose = {\n    x: 0, y: 0, width: 0, height: 0,\n    text: data.text,\n    runs: data.runs as StyledRun[] | undefined,\n    style: data.style,\n  };\n  const { runs } = textPoseLayoutInput(textPose, opts.scale ?? 1);\n  await Promise.all(facesOf(runs).map((f) => loadFontOutlines(f.family, { weight: f.weight, style: f.style })));\n  // An outline-only family resolves to its own face only once that face has\n  // parsed; before, it resolved to whatever stood in. Ask again.\n  await Promise.all(facesOf(runs).map((f) => loadFontOutlines(f.family, { weight: f.weight, style: f.style })));\n}\n\n"],"mappings":"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"}