chat-layout 1.1.2 → 1.2.0-1

package/index.mjs

@@ -1,5 +1,3 @@
-import { layoutNextLine, layoutWithLines, measureLineStats, measureNaturalWidth, prepareWithSegments } from "@chenglou/pretext";
-import { layoutNextRichInlineLineRange, materializeRichInlineLineRange, measureRichInlineStats, prepareRichInline } from "@chenglou/pretext/rich-inline";
 //#region src/internal/node-registry.ts
 const registry = /* @__PURE__ */ new WeakMap();
 const revisions = /* @__PURE__ */ new WeakMap();
@@ -816,9 +814,117 @@ var Place = class extends Wrapper {
 		});
 	}
 };
-const INTRINSIC_MAX_WIDTH = Number.POSITIVE_INFINITY;
+//#endregion
+//#region src/nodes/shrinkwrap.ts
+const DEFAULT_TOLERANCE = .5;
+const HEIGHT_EPSILON = 1e-6;
+function withMaxWidth(constraints, maxWidth) {
+	return {
+		...constraints,
+		maxWidth
+	};
+}
+function computeShrinkwrapWidth(measure, lowerBound, upperBound, referenceHeight, tolerance = DEFAULT_TOLERANCE) {
+	const minWidth = Math.min(lowerBound, upperBound);
+	const maxWidth = Math.max(lowerBound, upperBound);
+	const effectiveTolerance = Math.max(tolerance, HEIGHT_EPSILON);
+	const lowerBoundBox = measure(minWidth);
+	if (lowerBoundBox.height <= referenceHeight + HEIGHT_EPSILON) return {
+		maxWidth: minWidth,
+		box: lowerBoundBox
+	};
+	let lo = minWidth;
+	let hi = maxWidth;
+	let hiBox = measure(maxWidth);
+	while (hi - lo > effectiveTolerance) {
+		const probeWidth = (lo + hi) / 2;
+		const probeBox = measure(probeWidth);
+		if (probeBox.height <= referenceHeight + HEIGHT_EPSILON) {
+			hi = probeWidth;
+			hiBox = probeBox;
+			continue;
+		}
+		lo = probeWidth;
+	}
+	return {
+		maxWidth: hi,
+		box: hiBox
+	};
+}
+/**
+* Shrinks a single child to the narrowest width that does not increase its reference height.
+*/
+var ShrinkWrap = class extends Wrapper {
+	constructor(inner, options = {}) {
+		super(inner);
+		this.options = options;
+	}
+	measure(ctx) {
+		const constraints = ctx.constraints;
+		const availableWidth = constraints?.maxWidth;
+		if (availableWidth == null) {
+			const childConstraints = constraints == null ? void 0 : { ...constraints };
+			const childBox = ctx.measureNode(this.inner, childConstraints);
+			this.#writeLayout(ctx, childBox, childConstraints);
+			return childBox;
+		}
+		const boundedConstraints = constraints == null ? { maxWidth: availableWidth } : constraints;
+		const referenceConstraints = { ...boundedConstraints };
+		const referenceBox = ctx.measureNode(this.inner, referenceConstraints);
+		let lowerBound = measureNodeMinContent(ctx, this.inner, boundedConstraints).width;
+		const preferredMinWidth = this.options.preferredMinWidth == null ? void 0 : Math.max(0, this.options.preferredMinWidth);
+		if (preferredMinWidth != null && preferredMinWidth <= availableWidth) lowerBound = Math.max(lowerBound, preferredMinWidth);
+		if (boundedConstraints.minWidth != null) lowerBound = Math.max(lowerBound, boundedConstraints.minWidth);
+		if (lowerBound >= availableWidth) {
+			this.#writeLayout(ctx, referenceBox, referenceConstraints);
+			return referenceBox;
+		}
+		const finalConstraints = withMaxWidth(boundedConstraints, computeShrinkwrapWidth((maxWidth) => ctx.measureNode(this.inner, withMaxWidth(boundedConstraints, maxWidth)), lowerBound, availableWidth, referenceBox.height, this.options.tolerance ?? DEFAULT_TOLERANCE).maxWidth);
+		const finalBox = ctx.measureNode(this.inner, finalConstraints);
+		this.#writeLayout(ctx, finalBox, finalConstraints);
+		return finalBox;
+	}
+	measureMinContent(ctx) {
+		return measureNodeMinContent(ctx, this.inner);
+	}
+	draw(ctx, x, y) {
+		const layoutResult = readLayoutResult(this, ctx);
+		if (!layoutResult) return this.inner.draw(ctx, x, y);
+		const childResult = getSingleChildLayout(layoutResult);
+		if (!childResult) return false;
+		return childResult.node.draw(withConstraints(ctx, childResult.constraints), x + childResult.rect.x, y + childResult.rect.y);
+	}
+	hittest(ctx, test) {
+		const layoutResult = readLayoutResult(this, ctx);
+		if (!layoutResult) return false;
+		const hit = findChildAtPoint(layoutResult.children, test.x, test.y, "rect");
+		if (!hit) return false;
+		return hit.child.node.hittest(withConstraints(ctx, hit.child.constraints), {
+			...test,
+			x: hit.localX,
+			y: hit.localY
+		});
+	}
+	#writeLayout(ctx, childBox, childConstraints) {
+		const childRect = createRect(0, 0, childBox.width, childBox.height);
+		writeLayoutResult(this, ctx, {
+			containerBox: childRect,
+			contentBox: childRect,
+			children: [{
+				node: this.inner,
+				rect: childRect,
+				contentBox: childRect,
+				constraints: childConstraints
+			}],
+			constraints: ctx.constraints
+		});
+	}
+};
+Number.POSITIVE_INFINITY;
 const MIN_CONTENT_WIDTH_EPSILON = .001;
 let sharedGraphemeSegmenter;
+const fontShiftCache = /* @__PURE__ */ new Map();
+const ellipsisWidthCache = /* @__PURE__ */ new Map();
 function readLruValue$1(cache, key) {
 	const cached = cache.get(key);
 	if (cached == null) return;
@@ -836,11 +942,21 @@ function writeLruValue$1(cache, key, value, capacity) {
 	return value;
 }
 function measureFontShift(ctx) {
+	const font = ctx.graphics.font;
+	const cached = fontShiftCache.get(font);
+	if (cached != null) return cached;
 	const { fontBoundingBoxAscent: ascent = 0, fontBoundingBoxDescent: descent = 0 } = ctx.graphics.measureText("M");
-	return ascent - descent;
+	const shift = ascent - descent;
+	fontShiftCache.set(font, shift);
+	return shift;
 }
 function measureEllipsisWidth(ctx) {
-	return ctx.graphics.measureText("…").width;
+	const font = ctx.graphics.font;
+	const cached = ellipsisWidthCache.get(font);
+	if (cached != null) return cached;
+	const width = ctx.graphics.measureText("…").width;
+	ellipsisWidthCache.set(font, width);
+	return width;
 }
 function getGraphemeSegmenter() {
 	if (sharedGraphemeSegmenter !== void 0) return sharedGraphemeSegmenter;
@@ -923,79 +1039,1025 @@ function selectEllipsisUnitCounts({ position, prefixWidths, suffixWidths, unitCo
 		suffixCount
 	};
 }
-const LINE_START_CURSOR$1 = {
-	segmentIndex: 0,
-	graphemeIndex: 0
-};
-const preparedTextCache = /* @__PURE__ */ new Map();
-function getPreparedTextCacheKey(text, font, whiteSpace, wordBreak) {
-	return `${font}\u0000${whiteSpace}\u0000${wordBreak}\u0000${text}`;
+function resolveEllipsisSelection({ widths, ellipsisWidth, maxWidth, position }) {
+	if (ellipsisWidth > maxWidth) return;
+	const prefixWidths = buildPrefixWidths(widths);
+	const suffixWidths = buildSuffixWidths(widths);
+	const { prefixCount, suffixCount } = selectEllipsisUnitCounts({
+		position,
+		prefixWidths,
+		suffixWidths,
+		unitCount: widths.length,
+		availableWidth: Math.max(0, maxWidth - ellipsisWidth)
+	});
+	return {
+		prefixCount,
+		suffixCount,
+		width: position === "start" ? ellipsisWidth + (suffixWidths[suffixCount] ?? 0) : position === "middle" ? (prefixWidths[prefixCount] ?? 0) + ellipsisWidth + (suffixWidths[suffixCount] ?? 0) : (prefixWidths[prefixCount] ?? 0) + ellipsisWidth
+	};
 }
-function readPreparedText(text, font, whiteSpace, wordBreak) {
-	const key = getPreparedTextCacheKey(text, font, whiteSpace, wordBreak);
-	const cached = readLruValue$1(preparedTextCache, key);
+//#endregion
+//#region src/text/inline-engine.ts
+const LINE_FIT_EPSILON = .005;
+const PREPARED_INLINE_CACHE_CAPACITY = 512;
+const PREPARED_LINE_STATS_CACHE_CAPACITY = 16;
+const kinsokuStart = new Set([
+	"，",
+	"．",
+	"！",
+	"：",
+	"；",
+	"？",
+	"、",
+	"。",
+	"・",
+	"）",
+	"〕",
+	"〉",
+	"》",
+	"」",
+	"』",
+	"】",
+	"〗",
+	"〙",
+	"〛",
+	"ー",
+	"々",
+	"〻",
+	"ゝ",
+	"ゞ",
+	"ヽ",
+	"ヾ"
+]);
+const kinsokuEnd = new Set([
+	"\"",
+	"(",
+	"[",
+	"{",
+	"“",
+	"‘",
+	"«",
+	"‹",
+	"（",
+	"〔",
+	"〈",
+	"《",
+	"「",
+	"『",
+	"【",
+	"〖",
+	"〘",
+	"〚"
+]);
+const leftStickyPunctuation = new Set([
+	".",
+	",",
+	"!",
+	"?",
+	":",
+	";",
+	"،",
+	"؛",
+	"؟",
+	"।",
+	"॥",
+	"၊",
+	"။",
+	"၌",
+	"၍",
+	"၏",
+	")",
+	"]",
+	"}",
+	"%",
+	"\"",
+	"”",
+	"’",
+	"»",
+	"›",
+	"…"
+]);
+const keepAllGlueChars = new Set([
+	"\xA0",
+	" ",
+	"⁠",
+	""
+]);
+const closingQuoteChars = new Set([
+	"”",
+	"’",
+	"»",
+	"›",
+	"」",
+	"』",
+	"】"
+]);
+const cjkCodePointRanges = [
+	[19968, 40959],
+	[13312, 19903],
+	[131072, 173791],
+	[173824, 177983],
+	[177984, 178207],
+	[178208, 183983],
+	[183984, 191471],
+	[191472, 192093],
+	[194560, 195103],
+	[196608, 201551],
+	[201552, 205743],
+	[205744, 210041],
+	[63744, 64255],
+	[12288, 12351],
+	[12352, 12447],
+	[12448, 12543],
+	[44032, 55215],
+	[65280, 65519]
+];
+let sharedMeasureContext = null;
+let sharedWordSegmenter;
+const textWidthCache = /* @__PURE__ */ new Map();
+const preparedInlineCache = /* @__PURE__ */ new Map();
+function getMeasureContext() {
+	if (sharedMeasureContext != null) return sharedMeasureContext;
+	if (typeof OffscreenCanvas !== "undefined") {
+		const ctx = new OffscreenCanvas(1, 1).getContext("2d");
+		if (ctx != null) {
+			sharedMeasureContext = ctx;
+			return ctx;
+		}
+	}
+	if (typeof document !== "undefined") {
+		const ctx = document.createElement("canvas").getContext("2d");
+		if (ctx != null) {
+			sharedMeasureContext = ctx;
+			return ctx;
+		}
+	}
+	throw new Error("Text measurement requires OffscreenCanvas or a DOM canvas context.");
+}
+function getTextWidthCache(font) {
+	let cache = textWidthCache.get(font);
+	if (cache == null) {
+		cache = /* @__PURE__ */ new Map();
+		textWidthCache.set(font, cache);
+	}
+	return cache;
+}
+function measureTextWidth(font, text) {
+	const cache = getTextWidthCache(font);
+	const cached = cache.get(text);
 	if (cached != null) return cached;
-	return writeLruValue$1(preparedTextCache, key, prepareWithSegments(text, font, {
-		whiteSpace,
-		wordBreak
-	}), 512);
+	const ctx = getMeasureContext();
+	ctx.font = font;
+	const width = ctx.measureText(text).width;
+	cache.set(text, width);
+	return width;
+}
+function isCollapsibleWhitespace(text) {
+	return /^[ \t\n\f\r]+$/u.test(text);
+}
+function isPreservedWhitespaceGrapheme(text) {
+	return text === " " || text === "	";
+}
+function normalizePreWrapText(text) {
+	if (!/[\r\f]/.test(text)) return text.replace(/\r\n/g, "\n");
+	return text.replace(/\r\n/g, "\n").replace(/[\r\f]/g, "\n");
+}
+function getLastCodePoint(text) {
+	if (text.length === 0) return null;
+	const codePoints = Array.from(text);
+	return codePoints[codePoints.length - 1] ?? null;
+}
+function isCJKCodePoint(codePoint) {
+	for (const [start, end] of cjkCodePointRanges) if (codePoint >= start && codePoint <= end) return true;
+	return false;
+}
+function isCJK(text) {
+	for (const char of text) {
+		const codePoint = char.codePointAt(0);
+		if (codePoint != null && isCJKCodePoint(codePoint)) return true;
+	}
+	return false;
+}
+function endsWithClosingQuote(text) {
+	const last = getLastCodePoint(text);
+	return last != null && closingQuoteChars.has(last);
+}
+function endsWithKeepAllGlueText(text) {
+	const last = getLastCodePoint(text);
+	return last != null && keepAllGlueChars.has(last);
+}
+function endsWithLineStartProhibitedText(text) {
+	const last = getLastCodePoint(text);
+	return last != null && (kinsokuStart.has(last) || leftStickyPunctuation.has(last));
+}
+function canContinueKeepAllTextRun(text) {
+	return !endsWithLineStartProhibitedText(text) && !endsWithKeepAllGlueText(text);
+}
+function getSharedWordSegmenter() {
+	if (sharedWordSegmenter !== void 0) return sharedWordSegmenter;
+	sharedWordSegmenter = typeof Intl.Segmenter === "function" ? new Intl.Segmenter(void 0, { granularity: "word" }) : null;
+	return sharedWordSegmenter;
+}
+function joinAtomText(atoms, start = 0, end = atoms.length) {
+	let text = "";
+	for (let index = start; index < end; index += 1) {
+		const atom = atoms[index];
+		if (atom != null) text += atom.text;
+	}
+	return text;
+}
+function measureAtomSequenceWidth(atoms) {
+	if (atoms.length === 0) return 0;
+	let width = 0;
+	let currentFont = atoms[0].font;
+	let currentText = "";
+	for (const atom of atoms) {
+		if (atom.font !== currentFont && currentText.length > 0) {
+			width += measureTextWidth(currentFont, currentText);
+			currentFont = atom.font;
+			currentText = "";
+		}
+		currentText += atom.text;
+		width += atom.extraWidthAfter;
+	}
+	if (currentText.length > 0) width += measureTextWidth(currentFont, currentText);
+	return width;
+}
+function pushTextPartAtoms(target, text, font, itemIndex, atomicGroupId, extraWidth) {
+	const graphemes = splitGraphemes(text);
+	for (let index = 0; index < graphemes.length; index += 1) {
+		const grapheme = graphemes[index] ?? "";
+		target.push({
+			text: grapheme,
+			font,
+			itemIndex,
+			width: measureTextWidth(font, grapheme),
+			extraWidthAfter: index === graphemes.length - 1 ? extraWidth : 0,
+			kind: "text",
+			preservesLineEnd: false,
+			atomicGroupId
+		});
+	}
+}
+function buildCollapsedWhitespaceAtoms(items) {
+	const chunks = [[]];
+	const atoms = chunks[0];
+	let pendingSpace = null;
+	let lastVisible = null;
+	for (const item of items) {
+		const atomicGroupId = item.breakMode === "never" ? item.itemIndex + 1 : null;
+		const parts = item.text.match(/[ \t\n\f\r]+|[^ \t\n\f\r]+/gu) ?? [];
+		for (let partIndex = 0; partIndex < parts.length; partIndex += 1) {
+			const part = parts[partIndex] ?? "";
+			if (isCollapsibleWhitespace(part)) {
+				if (lastVisible != null) pendingSpace = {
+					font: lastVisible.font,
+					itemIndex: lastVisible.itemIndex,
+					atomicGroupId
+				};
+				continue;
+			}
+			if (pendingSpace != null) {
+				atoms.push({
+					text: " ",
+					font: pendingSpace.font,
+					itemIndex: pendingSpace.itemIndex,
+					width: measureTextWidth(pendingSpace.font, " "),
+					extraWidthAfter: 0,
+					kind: "space",
+					preservesLineEnd: false,
+					atomicGroupId: pendingSpace.atomicGroupId
+				});
+				pendingSpace = null;
+			}
+			pushTextPartAtoms(atoms, part, item.font, item.itemIndex, atomicGroupId, partIndex === parts.length - 1 ? item.extraWidth : 0);
+			lastVisible = {
+				font: item.font,
+				itemIndex: item.itemIndex,
+				atomicGroupId
+			};
+		}
+	}
+	return chunks;
+}
+function buildPreWrapAtoms(items) {
+	const chunks = [[]];
+	let currentChunk = chunks[0];
+	for (const item of items) {
+		const atomicGroupId = item.breakMode === "never" ? item.itemIndex + 1 : null;
+		const graphemes = splitGraphemes(normalizePreWrapText(item.text));
+		for (let index = 0; index < graphemes.length; index += 1) {
+			const grapheme = graphemes[index] ?? "";
+			if (grapheme === "\n") {
+				currentChunk = [];
+				chunks.push(currentChunk);
+				continue;
+			}
+			const isSpace = isPreservedWhitespaceGrapheme(grapheme);
+			currentChunk.push({
+				text: grapheme,
+				font: item.font,
+				itemIndex: item.itemIndex,
+				width: measureTextWidth(item.font, grapheme),
+				extraWidthAfter: index === graphemes.length - 1 ? item.extraWidth : 0,
+				kind: isSpace ? "space" : "text",
+				preservesLineEnd: isSpace,
+				atomicGroupId
+			});
+		}
+	}
+	return chunks;
+}
+function buildBaseCjkUnits(atoms) {
+	const units = [];
+	let current = [];
+	let currentContainsCJK = false;
+	let currentEndsWithClosingQuote = false;
+	let currentIsSingleKinsokuEnd = false;
+	const flushCurrent = () => {
+		if (current.length === 0) return;
+		units.push(current);
+		current = [];
+		currentContainsCJK = false;
+		currentEndsWithClosingQuote = false;
+		currentIsSingleKinsokuEnd = false;
+	};
+	for (const atom of atoms) {
+		const atomContainsCJK = isCJK(atom.text);
+		if (current.length === 0) {
+			current = [atom];
+			currentContainsCJK = atomContainsCJK;
+			currentEndsWithClosingQuote = endsWithClosingQuote(atom.text);
+			currentIsSingleKinsokuEnd = kinsokuEnd.has(atom.text);
+			continue;
+		}
+		if (currentIsSingleKinsokuEnd || kinsokuStart.has(atom.text) || leftStickyPunctuation.has(atom.text) || atomContainsCJK && currentEndsWithClosingQuote) {
+			current.push(atom);
+			currentContainsCJK = currentContainsCJK || atomContainsCJK;
+			currentEndsWithClosingQuote = leftStickyPunctuation.has(atom.text) ? currentEndsWithClosingQuote || endsWithClosingQuote(atom.text) : endsWithClosingQuote(atom.text);
+			currentIsSingleKinsokuEnd = false;
+			continue;
+		}
+		if (!currentContainsCJK && !atomContainsCJK) {
+			current.push(atom);
+			currentEndsWithClosingQuote = endsWithClosingQuote(atom.text);
+			currentIsSingleKinsokuEnd = false;
+			continue;
+		}
+		flushCurrent();
+		current = [atom];
+		currentContainsCJK = atomContainsCJK;
+		currentEndsWithClosingQuote = endsWithClosingQuote(atom.text);
+		currentIsSingleKinsokuEnd = kinsokuEnd.has(atom.text);
+	}
+	flushCurrent();
+	return units;
 }
-function readPreparedFirstLine(ctx, text, whiteSpace, wordBreak) {
-	const line = layoutNextLine(readPreparedText(text, ctx.graphics.font, whiteSpace, wordBreak), LINE_START_CURSOR$1, INTRINSIC_MAX_WIDTH);
-	if (line == null) return;
+function mergeKeepAllUnits(units) {
+	if (units.length <= 1) return units.slice();
+	const merged = [];
+	let current = units[0].slice();
+	let currentText = joinAtomText(current);
+	let currentContainsCJK = isCJK(currentText);
+	let currentCanContinue = canContinueKeepAllTextRun(currentText);
+	const flush = () => {
+		merged.push(current);
+	};
+	for (let index = 1; index < units.length; index += 1) {
+		const next = units[index];
+		const nextText = joinAtomText(next);
+		const nextContainsCJK = isCJK(nextText);
+		const nextCanContinue = canContinueKeepAllTextRun(nextText);
+		if (currentContainsCJK && currentCanContinue) {
+			current = [...current, ...next];
+			currentText += nextText;
+			currentContainsCJK = currentContainsCJK || nextContainsCJK;
+			currentCanContinue = nextCanContinue;
+			continue;
+		}
+		flush();
+		current = next.slice();
+		currentText = nextText;
+		currentContainsCJK = nextContainsCJK;
+		currentCanContinue = nextCanContinue;
+	}
+	flush();
+	return merged;
+}
+function splitAtomsByWordSegments(atoms) {
+	if (atoms.length <= 1) return atoms.length === 0 ? [] : [atoms.slice()];
+	const segmenter = getSharedWordSegmenter();
+	if (segmenter == null) return [atoms.slice()];
+	const text = joinAtomText(atoms);
+	const offsets = [0];
+	for (let index = 0; index < atoms.length; index += 1) offsets.push((offsets[index] ?? 0) + (atoms[index]?.text.length ?? 0));
+	const units = [];
+	let atomStart = 0;
+	let atomEnd = 0;
+	for (const segment of segmenter.segment(text)) {
+		const start = segment.index;
+		const end = start + segment.segment.length;
+		while ((offsets[atomStart] ?? 0) < start) atomStart += 1;
+		atomEnd = atomStart;
+		while ((offsets[atomEnd] ?? 0) < end) atomEnd += 1;
+		if (atomStart < atomEnd) units.push(atoms.slice(atomStart, atomEnd));
+		atomStart = atomEnd;
+	}
+	return units.length > 0 ? units : [atoms.slice()];
+}
+function makeTextUnit(atoms, atomic = false) {
+	const width = measureAtomSequenceWidth(atoms);
 	return {
-		text: line.text,
-		prepared: readPreparedText(line.text, ctx.graphics.font, whiteSpace, wordBreak)
+		kind: "text",
+		atoms,
+		width,
+		fitEndWidth: width,
+		paintEndWidth: width,
+		breakAfter: true,
+		breakable: !atomic && atoms.length > 1,
+		atomic
 	};
 }
-function measurePreparedMinContentWidth(prepared, overflowWrap = "break-word") {
-	let maxWidth = 0;
-	let maxAnyWidth = 0;
-	for (let index = 0; index < prepared.widths.length; index += 1) {
-		const segmentWidth = prepared.widths[index] ?? 0;
-		maxAnyWidth = Math.max(maxAnyWidth, segmentWidth);
-		const segment = prepared.segments[index];
-		if (segment != null && segment.trim().length > 0) {
-			const breakableWidths = prepared.breakableFitAdvances[index];
-			const minContentWidth = overflowWrap === "anywhere" && breakableWidths != null && breakableWidths.length > 0 ? breakableWidths.reduce((widest, width) => Math.max(widest, width), 0) : segmentWidth;
-			maxWidth = Math.max(maxWidth, minContentWidth);
+function makeSpaceUnit(atoms) {
+	const width = measureAtomSequenceWidth(atoms);
+	return {
+		kind: "space",
+		atoms,
+		width,
+		fitEndWidth: 0,
+		paintEndWidth: atoms.every((atom) => atom.preservesLineEnd) ? width : 0,
+		breakAfter: true,
+		breakable: atoms.length > 1,
+		atomic: false
+	};
+}
+function tokenizeChunkAtoms(chunkAtoms, wordBreak) {
+	const units = [];
+	let index = 0;
+	while (index < chunkAtoms.length) {
+		const atom = chunkAtoms[index];
+		if (atom.atomicGroupId != null) {
+			const start = index;
+			const atomicGroupId = atom.atomicGroupId;
+			while (index < chunkAtoms.length && chunkAtoms[index]?.atomicGroupId === atomicGroupId) index += 1;
+			units.push(makeTextUnit(chunkAtoms.slice(start, index), true));
+			continue;
 		}
+		if (atom.kind === "space") {
+			const start = index;
+			while (index < chunkAtoms.length && chunkAtoms[index]?.kind === "space" && chunkAtoms[index]?.atomicGroupId == null) index += 1;
+			units.push(makeSpaceUnit(chunkAtoms.slice(start, index)));
+			continue;
+		}
+		const start = index;
+		while (index < chunkAtoms.length && chunkAtoms[index]?.kind === "text" && chunkAtoms[index]?.atomicGroupId == null) index += 1;
+		const textRunAtoms = chunkAtoms.slice(start, index);
+		const runText = joinAtomText(textRunAtoms);
+		const rawUnits = isCJK(runText) ? buildBaseCjkUnits(textRunAtoms) : splitAtomsByWordSegments(textRunAtoms);
+		const normalizedUnits = wordBreak === "keep-all" && isCJK(runText) ? mergeKeepAllUnits(rawUnits) : rawUnits;
+		for (const unitAtoms of normalizedUnits) units.push(makeTextUnit(unitAtoms.slice(), false));
 	}
-	return maxWidth > 0 ? maxWidth : maxAnyWidth;
+	return units;
 }
-function getPreparedUnits(prepared) {
+function buildPreparedInlineLayout(items, whiteSpace, wordBreak) {
+	const atomChunks = whiteSpace === "pre-wrap" ? buildPreWrapAtoms(items) : buildCollapsedWhitespaceAtoms(items);
+	const chunks = [];
 	const units = [];
-	for (let index = 0; index < prepared.segments.length; index += 1) {
-		const segment = prepared.segments[index] ?? "";
-		const segmentWidth = prepared.widths[index] ?? 0;
-		const breakableWidths = prepared.breakableFitAdvances[index];
-		if (breakableWidths != null && segment.length > 0) {
-			const graphemes = splitGraphemes(segment);
-			if (graphemes.length === breakableWidths.length) {
-				for (let graphemeIndex = 0; graphemeIndex < graphemes.length; graphemeIndex += 1) units.push({
-					text: graphemes[graphemeIndex] ?? "",
-					width: breakableWidths[graphemeIndex] ?? 0
-				});
+	for (const atomChunk of atomChunks) {
+		const startUnit = units.length;
+		const chunkUnits = tokenizeChunkAtoms(atomChunk, wordBreak);
+		units.push(...chunkUnits);
+		chunks.push({
+			startUnit,
+			endUnit: units.length
+		});
+	}
+	return {
+		units,
+		chunks,
+		whiteSpace,
+		wordBreak,
+		lineStatsCache: /* @__PURE__ */ new Map(),
+		minContentWidthCache: /* @__PURE__ */ new Map()
+	};
+}
+function readNumberLruValue(cache, key) {
+	const cached = cache.get(key);
+	if (cached == null) return;
+	cache.delete(key);
+	cache.set(key, cached);
+	return cached;
+}
+function writeNumberLruValue(cache, key, value, capacity) {
+	if (cache.has(key)) cache.delete(key);
+	else if (cache.size >= capacity) {
+		const firstKey = cache.keys().next().value;
+		if (firstKey != null) cache.delete(firstKey);
+	}
+	cache.set(key, value);
+	return value;
+}
+function cloneCursor(cursor) {
+	return {
+		chunkIndex: cursor.chunkIndex,
+		unitIndex: cursor.unitIndex,
+		atomIndex: cursor.atomIndex
+	};
+}
+function cursorEquals(a, b) {
+	return a.chunkIndex === b.chunkIndex && a.unitIndex === b.unitIndex && a.atomIndex === b.atomIndex;
+}
+function fits(width, maxWidth) {
+	return width <= maxWidth + LINE_FIT_EPSILON;
+}
+function getVisibleEndAfterBreak(chunkIndex, unitIndex, unit) {
+	if (unit.kind === "space" && unit.paintEndWidth === 0) return {
+		chunkIndex,
+		unitIndex,
+		atomIndex: 0
+	};
+	return {
+		chunkIndex,
+		unitIndex: unitIndex + 1,
+		atomIndex: 0
+	};
+}
+function fitPartialUnit(unit, startAtomIndex, lineWidth, maxWidth) {
+	let width = 0;
+	let count = 0;
+	for (let index = startAtomIndex; index < unit.atoms.length; index += 1) {
+		const atom = unit.atoms[index];
+		const atomWidth = atom.width + atom.extraWidthAfter;
+		if (count > 0 && !fits(lineWidth + width + atomWidth, maxWidth)) break;
+		if (count === 0 || fits(lineWidth + width + atomWidth, maxWidth)) {
+			width += atomWidth;
+			count += 1;
+			continue;
+		}
+		break;
+	}
+	return {
+		count,
+		width
+	};
+}
+function stepChunkLine(prepared, chunkIndex, startUnitIndex, startAtomIndex, maxWidth) {
+	const chunk = prepared.chunks[chunkIndex];
+	if (chunk == null || startUnitIndex >= chunk.endUnit) return null;
+	const start = {
+		chunkIndex,
+		unitIndex: startUnitIndex,
+		atomIndex: startAtomIndex
+	};
+	let unitIndex = startUnitIndex;
+	let atomIndex = startAtomIndex;
+	let lineWidth = 0;
+	let hasContent = false;
+	let pendingBreak = null;
+	while (unitIndex < chunk.endUnit) {
+		const unit = prepared.units[unitIndex];
+		if (atomIndex > 0) {
+			const fitted = fitPartialUnit(unit, atomIndex, lineWidth, maxWidth);
+			if (fitted.count === 0) {
+				if (hasContent) return {
+					width: lineWidth,
+					start,
+					end: {
+						chunkIndex,
+						unitIndex,
+						atomIndex
+					},
+					next: {
+						chunkIndex,
+						unitIndex,
+						atomIndex
+					}
+				};
+				const atom = unit.atoms[atomIndex];
+				return {
+					width: atom.width + atom.extraWidthAfter,
+					start,
+					end: {
+						chunkIndex,
+						unitIndex,
+						atomIndex: atomIndex + 1
+					},
+					next: {
+						chunkIndex,
+						unitIndex,
+						atomIndex: atomIndex + 1
+					}
+				};
+			}
+			if (atomIndex + fitted.count >= unit.atoms.length) {
+				lineWidth += fitted.width;
+				hasContent = true;
+				atomIndex = 0;
+				unitIndex += 1;
+				pendingBreak = {
+					end: {
+						chunkIndex,
+						unitIndex,
+						atomIndex: 0
+					},
+					next: {
+						chunkIndex,
+						unitIndex,
+						atomIndex: 0
+					},
+					width: lineWidth
+				};
+				continue;
+			}
+			return {
+				width: lineWidth + fitted.width,
+				start,
+				end: {
+					chunkIndex,
+					unitIndex,
+					atomIndex: atomIndex + fitted.count
+				},
+				next: {
+					chunkIndex,
+					unitIndex,
+					atomIndex: atomIndex + fitted.count
+				}
+			};
+		}
+		if (!hasContent) {
+			if (fits(unit.width, maxWidth) || unit.atomic || !unit.breakable) {
+				lineWidth = unit.width;
+				hasContent = true;
+				const next = {
+					chunkIndex,
+					unitIndex: unitIndex + 1,
+					atomIndex: 0
+				};
+				pendingBreak = {
+					end: getVisibleEndAfterBreak(chunkIndex, unitIndex, unit),
+					next,
+					width: unit.paintEndWidth
+				};
+				unitIndex += 1;
+				continue;
+			}
+			const fitted = fitPartialUnit(unit, 0, 0, maxWidth);
+			if (fitted.count >= unit.atoms.length) {
+				lineWidth = fitted.width;
+				hasContent = true;
+				const next = {
+					chunkIndex,
+					unitIndex: unitIndex + 1,
+					atomIndex: 0
+				};
+				pendingBreak = {
+					end: next,
+					next,
+					width: lineWidth
+				};
+				unitIndex += 1;
 				continue;
 			}
+			return {
+				width: fitted.width,
+				start,
+				end: {
+					chunkIndex,
+					unitIndex,
+					atomIndex: fitted.count
+				},
+				next: {
+					chunkIndex,
+					unitIndex,
+					atomIndex: fitted.count
+				}
+			};
 		}
-		if (segment.length > 0 || segmentWidth > 0) units.push({
-			text: segment,
-			width: segmentWidth
-		});
+		if (fits(lineWidth + unit.width, maxWidth)) {
+			const nextWidth = lineWidth + unit.width;
+			lineWidth = nextWidth;
+			const next = {
+				chunkIndex,
+				unitIndex: unitIndex + 1,
+				atomIndex: 0
+			};
+			pendingBreak = {
+				end: getVisibleEndAfterBreak(chunkIndex, unitIndex, unit),
+				next,
+				width: nextWidth - unit.width + unit.paintEndWidth
+			};
+			unitIndex += 1;
+			continue;
+		}
+		if (fits(lineWidth + unit.fitEndWidth, maxWidth)) {
+			const next = {
+				chunkIndex,
+				unitIndex: unitIndex + 1,
+				atomIndex: 0
+			};
+			return {
+				width: lineWidth + unit.paintEndWidth,
+				start,
+				end: getVisibleEndAfterBreak(chunkIndex, unitIndex, unit),
+				next
+			};
+		}
+		if (pendingBreak != null) return {
+			width: pendingBreak.width,
+			start,
+			end: pendingBreak.end,
+			next: pendingBreak.next
+		};
+		return {
+			width: lineWidth,
+			start,
+			end: {
+				chunkIndex,
+				unitIndex,
+				atomIndex: 0
+			},
+			next: {
+				chunkIndex,
+				unitIndex,
+				atomIndex: 0
+			}
+		};
 	}
-	return units;
+	if (!hasContent) return null;
+	if (pendingBreak != null && pendingBreak.next.unitIndex === chunk.endUnit && pendingBreak.next.atomIndex === 0) return {
+		width: pendingBreak.width,
+		start,
+		end: pendingBreak.end,
+		next: pendingBreak.next
+	};
+	return {
+		width: lineWidth,
+		start,
+		end: {
+			chunkIndex,
+			unitIndex,
+			atomIndex: 0
+		},
+		next: {
+			chunkIndex,
+			unitIndex,
+			atomIndex: 0
+		}
+	};
 }
-function joinUnitText(units, start, end) {
-	if (start >= end) return "";
-	return units.slice(start, end).map((unit) => unit.text).join("");
+function getPreparedLineStart(prepared) {
+	for (let chunkIndex = 0; chunkIndex < prepared.chunks.length; chunkIndex += 1) {
+		const chunk = prepared.chunks[chunkIndex];
+		if (chunk.startUnit === chunk.endUnit) return {
+			chunkIndex,
+			unitIndex: chunk.startUnit,
+			atomIndex: 0
+		};
+		return {
+			chunkIndex,
+			unitIndex: chunk.startUnit,
+			atomIndex: 0
+		};
+	}
+}
+function layoutNextPreparedLine(prepared, start, maxWidth) {
+	const chunk = prepared.chunks[start.chunkIndex];
+	if (chunk == null) return null;
+	if (chunk.startUnit === chunk.endUnit) return cursorEquals(start, {
+		chunkIndex: start.chunkIndex,
+		unitIndex: chunk.endUnit,
+		atomIndex: 0
+	}) ? null : {
+		width: 0,
+		start: cloneCursor(start),
+		end: {
+			chunkIndex: start.chunkIndex,
+			unitIndex: chunk.endUnit,
+			atomIndex: 0
+		},
+		next: {
+			chunkIndex: start.chunkIndex,
+			unitIndex: chunk.endUnit,
+			atomIndex: 0
+		}
+	};
+	return stepChunkLine(prepared, start.chunkIndex, start.unitIndex, start.atomIndex, maxWidth);
+}
+function walkPreparedLineRanges(prepared, maxWidth, onLine) {
+	let lineCount = 0;
+	for (let chunkIndex = 0; chunkIndex < prepared.chunks.length; chunkIndex += 1) {
+		const chunk = prepared.chunks[chunkIndex];
+		if (chunk.startUnit === chunk.endUnit) {
+			const cursor = {
+				chunkIndex,
+				unitIndex: chunk.startUnit,
+				atomIndex: 0
+			};
+			if (onLine({
+				width: 0,
+				start: cursor,
+				end: cursor,
+				next: cursor
+			}) === false) {
+				lineCount += 1;
+				return lineCount;
+			}
+			lineCount += 1;
+			continue;
+		}
+		let cursor = {
+			chunkIndex,
+			unitIndex: chunk.startUnit,
+			atomIndex: 0
+		};
+		while (true) {
+			const line = layoutNextPreparedLine(prepared, cursor, maxWidth);
+			if (line == null) break;
+			if (onLine(line) === false) {
+				lineCount += 1;
+				return lineCount;
+			}
+			lineCount += 1;
+			if (cursorEquals(line.next, cursor)) break;
+			cursor = line.next;
+			if (cursor.unitIndex >= chunk.endUnit && cursor.atomIndex === 0) break;
+		}
+	}
+	return lineCount;
+}
+function forEachAtomFromCursorToEnd(prepared, start, cb) {
+	for (let chunkIndex = start.chunkIndex; chunkIndex < prepared.chunks.length; chunkIndex += 1) {
+		const chunk = prepared.chunks[chunkIndex];
+		if (chunk == null) continue;
+		forEachAtomInRange(prepared, chunkIndex === start.chunkIndex ? start : {
+			chunkIndex,
+			unitIndex: chunk.startUnit,
+			atomIndex: 0
+		}, {
+			chunkIndex,
+			unitIndex: chunk.endUnit,
+			atomIndex: 0
+		}, cb);
+	}
+}
+function measurePreparedLineStats(prepared, maxWidth) {
+	const cached = readNumberLruValue(prepared.lineStatsCache, maxWidth);
+	if (cached != null) return cached;
+	let lineCount = 0;
+	let maxLineWidth = 0;
+	walkPreparedLineRanges(prepared, maxWidth, (line) => {
+		lineCount += 1;
+		if (line.width > maxLineWidth) maxLineWidth = line.width;
+	});
+	return writeNumberLruValue(prepared.lineStatsCache, maxWidth, {
+		lineCount,
+		maxLineWidth
+	}, PREPARED_LINE_STATS_CACHE_CAPACITY);
+}
+function forEachAtomInRange(prepared, start, end, cb) {
+	if (start.chunkIndex !== end.chunkIndex) throw new Error("Atom range iteration only supports a single chunk.");
+	for (let unitIndex = start.unitIndex; unitIndex < end.unitIndex; unitIndex += 1) {
+		const unit = prepared.units[unitIndex];
+		const atomStart = unitIndex === start.unitIndex ? start.atomIndex : 0;
+		const atomEnd = unitIndex === end.unitIndex ? end.atomIndex : unit.atoms.length;
+		for (let atomIndex = atomStart; atomIndex < atomEnd; atomIndex += 1) {
+			const atom = unit.atoms[atomIndex];
+			if (atom != null) cb(atom);
+		}
+	}
+	if (end.unitIndex < prepared.units.length) {
+		const unit = prepared.units[end.unitIndex];
+		if (unit != null && start.unitIndex === end.unitIndex) for (let atomIndex = start.atomIndex; atomIndex < end.atomIndex; atomIndex += 1) {
+			const atom = unit.atoms[atomIndex];
+			if (atom != null) cb(atom);
+		}
+	}
+}
+function collectAtomsInRange(prepared, start, end) {
+	const atoms = [];
+	if (start.unitIndex === end.unitIndex) {
+		const unit = prepared.units[start.unitIndex];
+		if (unit == null) return atoms;
+		for (let atomIndex = start.atomIndex; atomIndex < end.atomIndex; atomIndex += 1) {
+			const atom = unit.atoms[atomIndex];
+			if (atom != null) atoms.push(atom);
+		}
+		return atoms;
+	}
+	if (prepared.chunks[start.chunkIndex] == null) return atoms;
+	for (let unitIndex = start.unitIndex; unitIndex < end.unitIndex; unitIndex += 1) {
+		const unit = prepared.units[unitIndex];
+		const atomStart = unitIndex === start.unitIndex ? start.atomIndex : 0;
+		for (let atomIndex = atomStart; atomIndex < unit.atoms.length; atomIndex += 1) {
+			const atom = unit.atoms[atomIndex];
+			if (atom != null) atoms.push(atom);
+		}
+	}
+	const endUnit = prepared.units[end.unitIndex];
+	if (endUnit != null) for (let atomIndex = 0; atomIndex < end.atomIndex; atomIndex += 1) {
+		const atom = endUnit.atoms[atomIndex];
+		if (atom != null) atoms.push(atom);
+	}
+	return atoms;
+}
+function collectLineAtoms(prepared, line) {
+	return {
+		atoms: collectAtomsInRange(prepared, line.start, line.end),
+		width: line.width
+	};
+}
+function materializePreparedLineText(prepared, line) {
+	return joinAtomText(collectLineAtoms(prepared, line).atoms);
+}
+function flattenPreparedLineAtoms(prepared, line) {
+	return collectLineAtoms(prepared, line).atoms;
+}
+function measurePreparedMinContentWidth$1(prepared, overflowWrap = "break-word") {
+	const cached = prepared.minContentWidthCache.get(overflowWrap);
+	if (cached != null) return cached;
+	let maxWidth = 0;
+	let maxAnyWidth = 0;
+	for (const unit of prepared.units) {
+		if (unit.width > maxAnyWidth) maxAnyWidth = unit.width;
+		if (unit.kind !== "text") continue;
+		const candidateWidth = overflowWrap === "anywhere" && unit.breakable ? unit.atoms.reduce((widest, atom) => Math.max(widest, atom.width + atom.extraWidthAfter), 0) : unit.width;
+		if (candidateWidth > maxWidth) maxWidth = candidateWidth;
+	}
+	const resolvedWidth = maxWidth > 0 ? maxWidth : maxAnyWidth;
+	prepared.minContentWidthCache.set(overflowWrap, resolvedWidth);
+	return resolvedWidth;
+}
+function measureAtomsWidth(atoms) {
+	let total = 0;
+	for (let index = 0; index < atoms.length; index += 1) {
+		const atom = atoms[index];
+		if (atom != null) total += atom.width + atom.extraWidthAfter;
+	}
+	return total;
+}
+function readPreparedInlineLayout(key, items, whiteSpace, wordBreak) {
+	const cached = readLruValue$1(preparedInlineCache, key);
+	if (cached != null) return cached;
+	return writeLruValue$1(preparedInlineCache, key, buildPreparedInlineLayout(items, whiteSpace, wordBreak), PREPARED_INLINE_CACHE_CAPACITY);
+}
+function getPlainPreparedKey(text, font, whiteSpace, wordBreak) {
+	return `plain\u0000${font}\u0000${whiteSpace}\u0000${wordBreak}\u0000${text}`;
+}
+function getRichPreparedKey(spans, defaultFont, whiteSpace, wordBreak) {
+	let key = "";
+	for (let index = 0; index < spans.length; index += 1) {
+		const span = spans[index];
+		if (index > 0) key += "
";
+		key += span.font ?? defaultFont;
+		key += "\0";
+		key += span.text;
+		key += "\0";
+		key += span.break ?? "";
+		key += "\0";
+		key += span.extraWidth ?? 0;
+	}
+	key += "";
+	key += whiteSpace;
+	key += "";
+	key += wordBreak;
+	return key;
+}
+function createPlainSourceItems(text, font) {
+	return [{
+		text,
+		font,
+		itemIndex: 0,
+		breakMode: "normal",
+		extraWidth: 0
+	}];
+}
+function createRichSourceItems(spans, defaultFont) {
+	return spans.map((span, index) => ({
+		text: span.text,
+		font: span.font ?? defaultFont,
+		itemIndex: index,
+		breakMode: span.break ?? "normal",
+		extraWidth: span.extraWidth ?? 0
+	}));
+}
+//#endregion
+//#region src/text/plain-core.ts
+function readPreparedText(text, font, whiteSpace, wordBreak) {
+	return readPreparedInlineLayout(getPlainPreparedKey(text, font, whiteSpace, wordBreak), createPlainSourceItems(text, font), whiteSpace, wordBreak);
+}
+function measurePreparedMinContentWidth(prepared, overflowWrap = "break-word") {
+	return measurePreparedMinContentWidth$1(prepared, overflowWrap);
 }
 //#endregion
 //#region src/text/plain.ts
-const LINE_START_CURSOR = {
-	segmentIndex: 0,
-	graphemeIndex: 0
-};
+function measureTextLayoutWidth(lines) {
+	let width = 0;
+	for (let index = 0; index < lines.length; index += 1) {
+		const line = lines[index];
+		if (line != null && line.width > width) width = line.width;
+	}
+	return width;
+}
 function clampMaxWidth(maxWidth) {
 	return Math.max(0, maxWidth);
 }
@@ -1014,22 +2076,33 @@ function createEllipsisOnlyLayout(ctx, maxWidth, shift) {
 		overflowed: true
 	};
 }
-function toTextBlockLayout(lines, shift) {
-	const mappedLines = lines.map((line) => ({
-		width: line.width,
-		text: line.text,
-		shift
-	}));
+function toTextBlockLayout(lines, prepared, shift) {
+	const mappedLines = [];
+	for (let index = 0; index < lines.length; index += 1) {
+		const line = lines[index];
+		mappedLines.push({
+			width: line.width,
+			text: materializePreparedLineText(prepared, line),
+			shift
+		});
+	}
 	return {
-		width: mappedLines.reduce((maxLineWidth, line) => Math.max(maxLineWidth, line.width), 0),
+		width: measureTextLayoutWidth(mappedLines),
 		lines: mappedLines
 	};
 }
-function layoutPreparedEllipsis(ctx, prepared, text, maxWidth, shift, position, forceEllipsis = false) {
-	const intrinsicWidth = measureNaturalWidth(prepared);
+function collectEllipsisLayout(ctx, atoms, maxWidth, shift, position, forceEllipsis = false) {
+	const widths = [];
+	let intrinsicWidth = 0;
+	for (let index = 0; index < atoms.length; index += 1) {
+		const atom = atoms[index];
+		const width = atom.width + atom.extraWidthAfter;
+		widths.push(width);
+		intrinsicWidth += width;
+	}
 	if (!forceEllipsis && intrinsicWidth <= maxWidth) return {
 		width: intrinsicWidth,
-		text,
+		text: atoms.map((atom) => atom.text).join(""),
 		shift,
 		overflowed: false
 	};
@@ -1040,65 +2113,120 @@ function layoutPreparedEllipsis(ctx, prepared, text, maxWidth, shift, position,
 		shift,
 		overflowed: true
 	};
-	const units = getPreparedUnits(prepared);
-	if (units.length === 0) return createEllipsisOnlyLayout(ctx, maxWidth, shift);
-	const availableWidth = Math.max(0, maxWidth - ellipsisWidth);
-	const prefixWidths = buildPrefixWidths(units.map((unit) => unit.width));
-	const suffixWidths = buildSuffixWidths(units.map((unit) => unit.width));
-	const { prefixCount, suffixCount } = selectEllipsisUnitCounts({
-		position,
-		prefixWidths,
-		suffixWidths,
-		unitCount: units.length,
-		availableWidth
+	if (atoms.length === 0) return createEllipsisOnlyLayout(ctx, maxWidth, shift);
+	const selection = resolveEllipsisSelection({
+		widths,
+		ellipsisWidth,
+		maxWidth,
+		position
 	});
-	const prefixWidth = prefixWidths[prefixCount] ?? 0;
-	const suffixWidth = suffixWidths[suffixCount] ?? 0;
-	const prefixText = joinUnitText(units, 0, prefixCount);
-	const suffixText = joinUnitText(units, units.length - suffixCount, units.length);
+	if (selection == null) return {
+		width: 0,
+		text: "",
+		shift,
+		overflowed: true
+	};
+	const { prefixCount, suffixCount, width } = selection;
+	const prefixText = atoms.slice(0, prefixCount).map((atom) => atom.text).join("");
+	const suffixText = atoms.slice(atoms.length - suffixCount).map((atom) => atom.text).join("");
 	return {
-		width: prefixWidth + ellipsisWidth + suffixWidth,
-		text: `${prefixText}…${suffixText}`,
+		width,
+		text: position === "start" ? `…${suffixText}` : position === "middle" ? `${prefixText}…${suffixText}` : `${prefixText}…`,
 		shift,
 		overflowed: true
 	};
 }
-function layoutForcedEllipsizedLine(ctx, text, maxWidth, shift, whiteSpace = "normal", wordBreak = "normal") {
-	if (text.length === 0) return createEllipsisOnlyLayout(ctx, maxWidth, shift);
-	return layoutPreparedEllipsis(ctx, readPreparedText(text, ctx.graphics.font, whiteSpace, wordBreak), text, maxWidth, shift, "end", true);
+function getFirstLineRange$1(prepared) {
+	const start = getPreparedLineStart(prepared);
+	if (start == null) return;
+	return layoutNextPreparedLine(prepared, start, Number.POSITIVE_INFINITY) ?? void 0;
+}
+function walkLines$1(prepared, maxWidth) {
+	const lines = [];
+	walkPreparedLineRanges(prepared, maxWidth, (line) => {
+		lines.push(line);
+	});
+	return lines;
+}
+function collectVisibleLines$1(prepared, maxWidth, maxLines) {
+	const lines = [];
+	let overflowed = false;
+	walkPreparedLineRanges(prepared, maxWidth, (line) => {
+		if (lines.length < maxLines) {
+			lines.push(line);
+			return true;
+		}
+		overflowed = true;
+		return false;
+	});
+	return {
+		lines,
+		overflowed
+	};
+}
+function collectEndEllipsisLayoutFromCursor(ctx, prepared, start, maxWidth, shift) {
+	const ellipsisWidth = measureEllipsisWidth(ctx);
+	if (ellipsisWidth > maxWidth) return {
+		width: 0,
+		text: "",
+		shift,
+		overflowed: true
+	};
+	const widths = [];
+	forEachAtomFromCursorToEnd(prepared, start, (atom) => {
+		widths.push(atom.width + atom.extraWidthAfter);
+	});
+	if (widths.length === 0) return createEllipsisOnlyLayout(ctx, maxWidth, shift);
+	const selection = resolveEllipsisSelection({
+		widths,
+		ellipsisWidth,
+		maxWidth,
+		position: "end"
+	});
+	if (selection == null) return {
+		width: 0,
+		text: "",
+		shift,
+		overflowed: true
+	};
+	const { prefixCount, width } = selection;
+	let text = "";
+	let atomIndex = 0;
+	forEachAtomFromCursorToEnd(prepared, start, (atom) => {
+		if (atomIndex < prefixCount) text += atom.text;
+		atomIndex += 1;
+	});
+	return {
+		width,
+		text: `${text}…`,
+		shift,
+		overflowed: true
+	};
 }
 function layoutFirstLineIntrinsic(ctx, text, whiteSpace = "normal", wordBreak = "normal") {
-	const firstLine = readPreparedFirstLine(ctx, text, whiteSpace, wordBreak);
-	if (firstLine == null) return {
+	const prepared = readPreparedText(text, ctx.graphics.font, whiteSpace, wordBreak);
+	const line = getFirstLineRange$1(prepared);
+	if (line == null) return {
 		width: 0,
 		text: "",
 		shift: 0
 	};
-	const shift = measureFontShift(ctx);
 	return {
-		width: measureNaturalWidth(firstLine.prepared),
-		text: firstLine.text,
-		shift
+		width: line.width,
+		text: materializePreparedLineText(prepared, line),
+		shift: measureFontShift(ctx)
 	};
 }
 function measureTextIntrinsic(ctx, text, whiteSpace = "normal", wordBreak = "normal") {
-	const { maxLineWidth: width, lineCount } = measureLineStats(readPreparedText(text, ctx.graphics.font, whiteSpace, wordBreak), INTRINSIC_MAX_WIDTH);
-	if (lineCount === 0) return {
-		width: 0,
-		lineCount: 0
-	};
+	const { maxLineWidth: width, lineCount } = measurePreparedLineStats(readPreparedText(text, ctx.graphics.font, whiteSpace, wordBreak), Number.POSITIVE_INFINITY);
 	return {
 		width,
 		lineCount
 	};
 }
 function layoutTextIntrinsic(ctx, text, whiteSpace = "normal", wordBreak = "normal") {
-	const intrinsic = layoutWithLines(readPreparedText(text, ctx.graphics.font, whiteSpace, wordBreak), INTRINSIC_MAX_WIDTH, 0);
-	if (intrinsic.lines.length === 0) return {
-		width: 0,
-		lines: []
-	};
-	return toTextBlockLayout(intrinsic.lines, measureFontShift(ctx));
+	const prepared = readPreparedText(text, ctx.graphics.font, whiteSpace, wordBreak);
+	return toTextBlockLayout(walkLines$1(prepared, Number.POSITIVE_INFINITY), prepared, measureFontShift(ctx));
 }
 function layoutFirstLine(ctx, text, maxWidth, whiteSpace = "normal", wordBreak = "normal") {
 	const clampedMaxWidth = clampMaxWidth(maxWidth);
@@ -1108,7 +2236,14 @@ function layoutFirstLine(ctx, text, maxWidth, whiteSpace = "normal", wordBreak =
 		text: "",
 		shift
 	};
-	const line = layoutNextLine(readPreparedText(text, ctx.graphics.font, whiteSpace, wordBreak), LINE_START_CURSOR, clampedMaxWidth);
+	const prepared = readPreparedText(text, ctx.graphics.font, whiteSpace, wordBreak);
+	const start = getPreparedLineStart(prepared);
+	if (start == null) return {
+		width: 0,
+		text: "",
+		shift
+	};
+	const line = layoutNextPreparedLine(prepared, start, clampedMaxWidth);
 	if (line == null) return {
 		width: 0,
 		text: "",
@@ -1116,19 +2251,12 @@ function layoutFirstLine(ctx, text, maxWidth, whiteSpace = "normal", wordBreak =
 	};
 	return {
 		width: line.width,
-		text: line.text,
+		text: materializePreparedLineText(prepared, line),
 		shift
 	};
 }
 function layoutEllipsizedFirstLine(ctx, text, maxWidth, ellipsisPosition = "end", whiteSpace = "normal", wordBreak = "normal") {
 	const clampedMaxWidth = clampMaxWidth(maxWidth);
-	const firstLine = readPreparedFirstLine(ctx, text, whiteSpace, wordBreak);
-	if (firstLine == null) return {
-		width: 0,
-		text: "",
-		shift: 0,
-		overflowed: false
-	};
 	const shift = measureFontShift(ctx);
 	if (clampedMaxWidth === 0) return {
 		width: 0,
@@ -1136,7 +2264,15 @@ function layoutEllipsizedFirstLine(ctx, text, maxWidth, ellipsisPosition = "end"
 		shift,
 		overflowed: true
 	};
-	return layoutPreparedEllipsis(ctx, firstLine.prepared, firstLine.text, clampedMaxWidth, shift, ellipsisPosition);
+	const prepared = readPreparedText(text, ctx.graphics.font, whiteSpace, wordBreak);
+	const intrinsicLine = getFirstLineRange$1(prepared);
+	if (intrinsicLine == null) return {
+		width: 0,
+		text: "",
+		shift: 0,
+		overflowed: false
+	};
+	return collectEllipsisLayout(ctx, flattenPreparedLineAtoms(prepared, intrinsicLine), clampedMaxWidth, shift, ellipsisPosition);
 }
 function measureText(ctx, text, maxWidth, whiteSpace = "normal", wordBreak = "normal") {
 	const clampedMaxWidth = clampMaxWidth(maxWidth);
@@ -1144,7 +2280,7 @@ function measureText(ctx, text, maxWidth, whiteSpace = "normal", wordBreak = "no
 		width: 0,
 		lineCount: 0
 	};
-	const { maxLineWidth: width, lineCount } = measureLineStats(readPreparedText(text, ctx.graphics.font, whiteSpace, wordBreak), clampedMaxWidth);
+	const { maxLineWidth: width, lineCount } = measurePreparedLineStats(readPreparedText(text, ctx.graphics.font, whiteSpace, wordBreak), clampedMaxWidth);
 	return {
 		width,
 		lineCount
@@ -1152,12 +2288,12 @@ function measureText(ctx, text, maxWidth, whiteSpace = "normal", wordBreak = "no
 }
 function measureTextMinContent(ctx, text, whiteSpace = "normal", wordBreak = "normal", overflowWrap = "break-word") {
 	const prepared = readPreparedText(text, ctx.graphics.font, whiteSpace, wordBreak);
-	if (prepared.widths.length === 0) return {
+	const width = measurePreparedMinContentWidth(prepared, overflowWrap);
+	if (width === 0) return {
 		width: 0,
 		lineCount: 0
 	};
-	const width = measurePreparedMinContentWidth(prepared, overflowWrap);
-	const { lineCount } = measureLineStats(prepared, Math.max(width, MIN_CONTENT_WIDTH_EPSILON));
+	const { lineCount } = measurePreparedLineStats(prepared, Math.max(width, MIN_CONTENT_WIDTH_EPSILON));
 	return {
 		width,
 		lineCount
@@ -1169,12 +2305,8 @@ function layoutText(ctx, text, maxWidth, whiteSpace = "normal", wordBreak = "nor
 		width: 0,
 		lines: []
 	};
-	const layout = layoutWithLines(readPreparedText(text, ctx.graphics.font, whiteSpace, wordBreak), clampedMaxWidth, 0);
-	if (layout.lines.length === 0) return {
-		width: 0,
-		lines: []
-	};
-	return toTextBlockLayout(layout.lines, measureFontShift(ctx));
+	const prepared = readPreparedText(text, ctx.graphics.font, whiteSpace, wordBreak);
+	return toTextBlockLayout(walkLines$1(prepared, clampedMaxWidth), prepared, measureFontShift(ctx));
 }
 function layoutTextWithOverflow(ctx, text, maxWidth, options = {}) {
 	const clampedMaxWidth = clampMaxWidth(maxWidth);
@@ -1182,46 +2314,61 @@ function layoutTextWithOverflow(ctx, text, maxWidth, options = {}) {
 	const wordBreak = options.wordBreak ?? "normal";
 	const overflow = options.overflow ?? "clip";
 	const normalizedMaxLines = normalizeMaxLines(options.maxLines);
-	const layout = layoutText(ctx, text, clampedMaxWidth, whiteSpace, wordBreak);
-	if (normalizedMaxLines == null || layout.lines.length <= normalizedMaxLines) return {
-		width: layout.width,
-		lines: layout.lines.map((line) => ({
-			...line,
+	const prepared = readPreparedText(text, ctx.graphics.font, whiteSpace, wordBreak);
+	const shift = measureFontShift(ctx);
+	if (normalizedMaxLines == null) {
+		const layout = toTextBlockLayout(walkLines$1(prepared, clampedMaxWidth), prepared, shift);
+		return {
+			width: layout.width,
+			lines: layout.lines.map((line) => ({
+				...line,
+				overflowed: false
+			})),
+			overflowed: false
+		};
+	}
+	const { lines: visibleRanges, overflowed } = collectVisibleLines$1(prepared, clampedMaxWidth, normalizedMaxLines);
+	if (!overflowed) {
+		const layout = toTextBlockLayout(visibleRanges, prepared, shift);
+		return {
+			width: layout.width,
+			lines: layout.lines.map((line) => ({
+				...line,
+				overflowed: false
+			})),
 			overflowed: false
-		})),
+		};
+	}
+	const visibleLines = visibleRanges.map((line) => ({
+		width: line.width,
+		text: materializePreparedLineText(prepared, line),
+		shift,
 		overflowed: false
-	};
-	const visibleLines = layout.lines.slice(0, normalizedMaxLines);
+	}));
 	if (overflow !== "ellipsis") return {
-		width: visibleLines.reduce((lineWidth, line) => Math.max(lineWidth, line.width), 0),
-		lines: visibleLines.map((line) => ({
-			...line,
-			overflowed: false
-		})),
+		width: measureTextLayoutWidth(visibleLines),
+		lines: visibleLines,
 		overflowed: true
 	};
-	const shift = visibleLines[visibleLines.length - 1]?.shift ?? measureFontShift(ctx);
-	const lastVisibleLine = visibleLines[visibleLines.length - 1];
-	const ellipsizedLastLine = lastVisibleLine == null || lastVisibleLine.text.length === 0 ? createEllipsisOnlyLayout(ctx, clampedMaxWidth, shift) : layoutForcedEllipsizedLine(ctx, lastVisibleLine.text, clampedMaxWidth, shift, whiteSpace, wordBreak);
-	const lines = [...visibleLines.slice(0, -1).map((line) => ({
-		...line,
-		overflowed: false
-	})), {
-		...ellipsizedLastLine,
-		shift
-	}];
+	const lastVisibleRange = visibleRanges[visibleRanges.length - 1];
+	const ellipsizedLastLine = lastVisibleRange == null ? createEllipsisOnlyLayout(ctx, clampedMaxWidth, shift) : collectEndEllipsisLayoutFromCursor(ctx, prepared, lastVisibleRange.start, clampedMaxWidth, shift);
+	const mergedLines = [...visibleLines.slice(0, -1), ellipsizedLastLine];
 	return {
-		width: lines.reduce((lineWidth, line) => Math.max(lineWidth, line.width), 0),
-		lines,
+		width: measureTextLayoutWidth(mergedLines),
+		lines: mergedLines,
 		overflowed: true
 	};
 }
 //#endregion
 //#region src/text/rich.ts
-const RICH_PREPARED_CACHE_CAPACITY = 256;
-const LEADING_COLLAPSIBLE_BOUNDARY_RE = /^[ \t\n\f\r]+/;
-const TRAILING_COLLAPSIBLE_BOUNDARY_RE = /[ \t\n\f\r]+$/;
-const richPreparedCache = /* @__PURE__ */ new Map();
+function measureRichBlockWidth(lines) {
+	let width = 0;
+	for (let index = 0; index < lines.length; index += 1) {
+		const line = lines[index];
+		if (line != null && line.width > width) width = line.width;
+	}
+	return width;
+}
 function withFont(ctx, font, cb) {
 	const previousFont = ctx.graphics.font;
 	ctx.graphics.font = font;
@@ -1231,177 +2378,108 @@ function withFont(ctx, font, cb) {
 		ctx.graphics.font = previousFont;
 	}
 }
-function getRichPreparedCacheKey(spans, defaultFont) {
-	return spans.map((span) => `${span.font ?? defaultFont}\u0000${span.text}\u0000${span.break ?? ""}\u0000${span.extraWidth ?? 0}`).join("
");
-}
-function readRichPrepared(spans, defaultFont) {
-	const key = getRichPreparedCacheKey(spans, defaultFont);
-	const cached = readLruValue$1(richPreparedCache, key);
-	if (cached != null) return cached;
-	const items = spans.map((span) => ({
-		text: span.text,
-		font: span.font ?? defaultFont,
-		break: span.break,
-		extraWidth: span.extraWidth
-	}));
-	const preparedItemIndexBySourceItemIndex = buildPreparedItemIndexBySourceItemIndex(spans);
-	return writeLruValue$1(richPreparedCache, key, {
-		prepared: prepareRichInline(items),
-		preparedItemIndexBySourceItemIndex
-	}, RICH_PREPARED_CACHE_CAPACITY);
-}
-function trimRichInlineBoundaryWhitespace(text) {
-	return text.replace(LEADING_COLLAPSIBLE_BOUNDARY_RE, "").replace(TRAILING_COLLAPSIBLE_BOUNDARY_RE, "");
-}
-function buildPreparedItemIndexBySourceItemIndex(spans) {
-	const preparedItemIndexBySourceItemIndex = Array.from({ length: spans.length });
-	let preparedItemIndex = 0;
-	for (let index = 0; index < spans.length; index += 1) {
-		if (trimRichInlineBoundaryWhitespace(spans[index].text).length === 0) continue;
-		preparedItemIndexBySourceItemIndex[index] = preparedItemIndex;
-		preparedItemIndex += 1;
-	}
-	return preparedItemIndexBySourceItemIndex;
-}
-function getRichFragmentStartCursor(prepared, fragment) {
-	const itemIndex = prepared.preparedItemIndexBySourceItemIndex[fragment.itemIndex];
-	if (itemIndex == null) return null;
-	return {
-		itemIndex,
-		segmentIndex: fragment.start.segmentIndex,
-		graphemeIndex: fragment.start.graphemeIndex
-	};
-}
-function splitOverflowingRichLineRange(prepared, lineRange, maxWidth) {
-	if (lineRange.width <= maxWidth || lineRange.fragments.length <= 1) return lineRange;
-	const trailingFragment = lineRange.fragments[lineRange.fragments.length - 1];
-	const splitCursor = getRichFragmentStartCursor(prepared, trailingFragment);
-	if (splitCursor == null) return lineRange;
-	const fragments = lineRange.fragments.slice(0, -1);
-	return {
-		fragments,
-		width: fragments.reduce((total, fragment) => total + fragment.gapBefore + fragment.occupiedWidth, 0),
-		end: splitCursor
-	};
-}
-function layoutNextConstrainedRichInlineLineRange(prepared, maxWidth, start) {
-	const lineRange = layoutNextRichInlineLineRange(prepared.prepared, maxWidth, start);
-	if (lineRange == null) return null;
-	return splitOverflowingRichLineRange(prepared, lineRange, maxWidth);
-}
-function walkConstrainedRichInlineLineRanges(prepared, maxWidth, onLine) {
-	let lineCount = 0;
-	let cursor;
-	while (true) {
-		const lineRange = layoutNextConstrainedRichInlineLineRange(prepared, maxWidth, cursor);
-		if (lineRange == null) return lineCount;
-		onLine(lineRange);
-		lineCount += 1;
-		cursor = lineRange.end;
-	}
-}
-function measureConstrainedRichInlineStats(prepared, maxWidth) {
-	let lineCount = 0;
-	let maxLineWidth = 0;
-	walkConstrainedRichInlineLineRanges(prepared, maxWidth, (lineRange) => {
-		lineCount += 1;
-		if (lineRange.width > maxLineWidth) maxLineWidth = lineRange.width;
-	});
-	return {
-		lineCount,
-		maxLineWidth
-	};
+function readRichPrepared(spans, defaultFont, whiteSpace, wordBreak) {
+	return readPreparedInlineLayout(getRichPreparedKey(spans, defaultFont, whiteSpace, wordBreak), createRichSourceItems(spans, defaultFont), whiteSpace, wordBreak);
 }
 function measureRichFragmentShift(ctx, font) {
 	return withFont(ctx, font, () => measureFontShift(ctx));
 }
-function materializeRichLine(ctx, spans, defaultFont, defaultColor, lineRange, overflowed) {
-	const richLine = materializeRichInlineLineRange(readRichPrepared(spans, defaultFont).prepared, lineRange);
-	const fragments = richLine.fragments.map((fragment) => {
-		const span = spans[fragment.itemIndex];
-		const font = span?.font ?? defaultFont;
+function materializeRichFragments(ctx, spans, defaultColor, atoms) {
+	const fragments = [];
+	let pendingGapBefore = 0;
+	for (const atom of atoms) {
+		const occupiedWidth = atom.width + atom.extraWidthAfter;
+		if (atom.kind === "space" && !atom.preservesLineEnd && atom.atomicGroupId == null) {
+			pendingGapBefore += occupiedWidth;
+			continue;
+		}
+		const span = spans[atom.itemIndex];
+		const font = span?.font ?? atom.font;
 		const color = span?.color ?? defaultColor;
-		return {
-			itemIndex: fragment.itemIndex,
-			text: fragment.text,
+		const previous = fragments[fragments.length - 1];
+		if (previous != null && previous.itemIndex === atom.itemIndex && previous.font === font && pendingGapBefore === 0) {
+			previous.text += atom.text;
+			previous.occupiedWidth += occupiedWidth;
+			continue;
+		}
+		fragments.push({
+			itemIndex: atom.itemIndex,
+			text: atom.text,
 			font,
 			color,
-			gapBefore: fragment.gapBefore,
-			occupiedWidth: fragment.occupiedWidth,
+			gapBefore: pendingGapBefore,
+			occupiedWidth,
 			shift: measureRichFragmentShift(ctx, font)
-		};
-	});
-	return {
-		width: richLine.width,
-		fragments,
-		overflowed
-	};
-}
-function flattenRichLineUnits(line) {
-	const units = [];
-	for (let fragmentIndex = 0; fragmentIndex < line.fragments.length; fragmentIndex += 1) {
-		const fragment = line.fragments[fragmentIndex];
-		const fragmentUnits = getPreparedUnits(readPreparedText(fragment.text, fragment.font, "normal", "normal"));
-		if (fragmentUnits.length === 0) continue;
-		const textWidth = fragmentUnits.reduce((total, unit) => total + unit.width, 0);
-		const trailingExtraWidth = Math.max(0, fragment.occupiedWidth - textWidth);
-		for (let unitIndex = 0; unitIndex < fragmentUnits.length; unitIndex += 1) {
-			const unit = fragmentUnits[unitIndex];
-			units.push({
-				fragmentIndex,
-				itemIndex: fragment.itemIndex,
-				text: unit.text,
-				width: unit.width + (unitIndex === fragmentUnits.length - 1 ? trailingExtraWidth : 0),
-				font: fragment.font,
-				color: fragment.color,
-				leadingGap: unitIndex === 0 ? fragment.gapBefore : 0
-			});
-		}
+		});
+		pendingGapBefore = 0;
 	}
-	return units;
-}
-function buildRichPrefixWidths(units) {
-	return buildPrefixWidths(units.map((unit) => unit.leadingGap + unit.width));
+	return fragments;
 }
-function buildRichSuffixWidths(units) {
-	const widths = [0];
-	let total = 0;
-	for (let index = units.length - 1; index >= 0; index -= 1) {
-		const unit = units[index];
-		total += unit.width;
-		if (widths.length > 1) total += unit.leadingGap;
-		widths.push(total);
+function appendRichFragment(ctx, spans, defaultColor, fragments, atom, pendingGapBefore) {
+	const occupiedWidth = atom.width + atom.extraWidthAfter;
+	if (atom.kind === "space" && !atom.preservesLineEnd && atom.atomicGroupId == null) return pendingGapBefore + occupiedWidth;
+	const span = spans[atom.itemIndex];
+	const font = span?.font ?? atom.font;
+	const color = span?.color ?? defaultColor;
+	const previous = fragments[fragments.length - 1];
+	if (previous != null && previous.itemIndex === atom.itemIndex && previous.font === font && pendingGapBefore === 0) {
+		previous.text += atom.text;
+		previous.occupiedWidth += occupiedWidth;
+		return 0;
 	}
-	return widths;
+	fragments.push({
+		itemIndex: atom.itemIndex,
+		text: atom.text,
+		font,
+		color,
+		gapBefore: pendingGapBefore,
+		occupiedWidth,
+		shift: measureRichFragmentShift(ctx, font)
+	});
+	return 0;
 }
-function materializeRichFragmentsFromUnits(units, start, end, suppressLeadingGap) {
+function materializeRichFragmentsInRange(ctx, spans, defaultColor, prepared, start, end) {
 	const fragments = [];
-	for (let index = start; index < end; index += 1) {
-		const unit = units[index];
-		const previous = fragments[fragments.length - 1];
-		const previousUnit = units[index - 1];
-		if (previous != null && previousUnit != null && previousUnit.fragmentIndex === unit.fragmentIndex) {
-			previous.text += unit.text;
-			previous.occupiedWidth += unit.width;
-			continue;
-		}
-		fragments.push({
-			itemIndex: unit.itemIndex,
-			text: unit.text,
-			font: unit.font,
-			color: unit.color,
-			gapBefore: fragments.length === 0 && suppressLeadingGap ? 0 : unit.leadingGap,
-			occupiedWidth: unit.width,
-			shift: 0
-		});
-	}
+	let pendingGapBefore = 0;
+	forEachAtomInRange(prepared, start, end, (atom) => {
+		pendingGapBefore = appendRichFragment(ctx, spans, defaultColor, fragments, atom, pendingGapBefore);
+	});
 	return fragments;
 }
-function measureRichFragmentsShift(ctx, fragments) {
-	return fragments.map((fragment) => ({
-		...fragment,
-		shift: measureRichFragmentShift(ctx, fragment.font)
-	}));
+function materializeRichLine(ctx, spans, defaultColor, prepared, line, overflowed) {
+	return {
+		width: line.width,
+		fragments: materializeRichFragmentsInRange(ctx, spans, defaultColor, prepared, line.start, line.end),
+		overflowed
+	};
+}
+function getFirstLineRange(prepared) {
+	const start = getPreparedLineStart(prepared);
+	if (start == null) return;
+	return layoutNextPreparedLine(prepared, start, Number.POSITIVE_INFINITY) ?? void 0;
+}
+function walkLines(prepared, maxWidth) {
+	const lines = [];
+	walkPreparedLineRanges(prepared, maxWidth, (line) => {
+		lines.push(line);
+	});
+	return lines;
+}
+function collectVisibleLines(prepared, maxWidth, maxLines) {
+	const lines = [];
+	let overflowed = false;
+	walkPreparedLineRanges(prepared, maxWidth, (line) => {
+		if (lines.length < maxLines) {
+			lines.push(line);
+			return true;
+		}
+		overflowed = true;
+		return false;
+	});
+	return {
+		lines,
+		overflowed
+	};
 }
 function createRichEllipsisFragment(ctx, font, color) {
 	return withFont(ctx, font, () => ({
@@ -1415,88 +2493,146 @@ function createRichEllipsisFragment(ctx, font, color) {
 	}));
 }
 function createRichEllipsisOnlyLayout(ctx, maxWidth, font, color) {
-	const ellipsis = createRichEllipsisFragment(ctx, font, color);
-	if (ellipsis.occupiedWidth > maxWidth) return {
+	const fragment = createRichEllipsisFragment(ctx, font, color);
+	if (fragment.occupiedWidth > maxWidth) return {
 		width: 0,
 		fragments: [],
 		overflowed: true
 	};
 	return {
-		width: ellipsis.occupiedWidth,
-		fragments: [ellipsis],
+		width: fragment.occupiedWidth,
+		fragments: [fragment],
 		overflowed: true
 	};
 }
-function layoutPreparedRichEllipsis(ctx, line, maxWidth, defaultFont, defaultColor, position) {
-	if (!line.overflowed && line.width <= maxWidth) return {
-		...line,
+function layoutRichEllipsisFromAtoms(ctx, spans, defaultFont, defaultColor, atoms, maxWidth, position, forceEllipsis = false) {
+	const intrinsicWidth = measureAtomsWidth(atoms);
+	if (!forceEllipsis && intrinsicWidth <= maxWidth) return {
+		width: intrinsicWidth,
+		fragments: materializeRichFragments(ctx, spans, defaultColor, atoms),
 		overflowed: false
 	};
-	const units = flattenRichLineUnits(line);
-	const fallbackFragment = line.fragments[0];
-	const ellipsisOnly = createRichEllipsisOnlyLayout(ctx, maxWidth, fallbackFragment?.font ?? defaultFont, fallbackFragment?.color ?? defaultColor);
-	if (ellipsisOnly.fragments.length === 0 || units.length === 0) return ellipsisOnly;
-	const ellipsisWidth = ellipsisOnly.width;
-	const availableWidth = Math.max(0, maxWidth - ellipsisWidth);
-	const prefixWidths = buildRichPrefixWidths(units);
-	const suffixWidths = buildRichSuffixWidths(units);
-	const { prefixCount, suffixCount } = selectEllipsisUnitCounts({
-		position,
-		prefixWidths,
-		suffixWidths,
-		unitCount: units.length,
-		availableWidth,
-		getMaxSuffixCount: position === "middle" ? (nextPrefixCount) => Math.max(0, units.length - nextPrefixCount - 1) : void 0
+	const ellipsisWidth = measureEllipsisWidth(ctx);
+	if (ellipsisWidth > maxWidth) return {
+		width: 0,
+		fragments: [],
+		overflowed: true
+	};
+	if (atoms.length === 0) return createRichEllipsisOnlyLayout(ctx, maxWidth, defaultFont, defaultColor);
+	const selection = resolveEllipsisSelection({
+		widths: atoms.map((atom) => atom.width + atom.extraWidthAfter),
+		ellipsisWidth,
+		maxWidth,
+		position
 	});
-	const prefixFragments = measureRichFragmentsShift(ctx, materializeRichFragmentsFromUnits(units, 0, prefixCount, false));
-	const suffixFragments = measureRichFragmentsShift(ctx, materializeRichFragmentsFromUnits(units, units.length - suffixCount, units.length, true));
-	const ellipsisSource = position === "start" ? suffixFragments[0] ?? line.fragments[0] : position === "middle" ? prefixFragments[prefixFragments.length - 1] ?? suffixFragments[0] ?? line.fragments[line.fragments.length - 1] : prefixFragments[prefixFragments.length - 1] ?? line.fragments[line.fragments.length - 1];
-	const ellipsis = createRichEllipsisFragment(ctx, ellipsisSource?.font ?? defaultFont, ellipsisSource?.color ?? defaultColor);
-	const fragments = position === "start" ? [ellipsis, ...suffixFragments] : position === "middle" ? [
-		...prefixFragments,
-		ellipsis,
-		...suffixFragments
-	] : [...prefixFragments, ellipsis];
+	if (selection == null) return {
+		width: 0,
+		fragments: [],
+		overflowed: true
+	};
+	const { prefixCount, suffixCount, width } = selection;
+	const prefixAtoms = atoms.slice(0, prefixCount);
+	const suffixAtoms = atoms.slice(atoms.length - suffixCount);
+	const ellipsisSource = position === "start" ? suffixAtoms[0] ?? atoms[0] : position === "middle" ? prefixAtoms[prefixAtoms.length - 1] ?? suffixAtoms[0] ?? atoms[atoms.length - 1] : prefixAtoms[prefixAtoms.length - 1] ?? atoms[atoms.length - 1];
+	const ellipsisSpan = ellipsisSource == null ? void 0 : spans[ellipsisSource.itemIndex];
+	const ellipsisFragment = createRichEllipsisFragment(ctx, ellipsisSpan?.font ?? ellipsisSource?.font ?? defaultFont, ellipsisSpan?.color ?? defaultColor);
+	const prefixFragments = materializeRichFragments(ctx, spans, defaultColor, prefixAtoms);
+	const suffixFragments = materializeRichFragments(ctx, spans, defaultColor, suffixAtoms);
 	return {
-		width: position === "start" ? ellipsis.occupiedWidth + (suffixWidths[suffixCount] ?? 0) : position === "middle" ? (prefixWidths[prefixCount] ?? 0) + ellipsis.occupiedWidth + (suffixWidths[suffixCount] ?? 0) : (prefixWidths[prefixCount] ?? 0) + ellipsis.occupiedWidth,
-		fragments,
+		width,
+		fragments: position === "start" ? [ellipsisFragment, ...suffixFragments] : position === "middle" ? [
+			...prefixFragments,
+			ellipsisFragment,
+			...suffixFragments
+		] : [...prefixFragments, ellipsisFragment],
 		overflowed: true
 	};
 }
-function layoutRichFirstLineIntrinsic(ctx, spans, defaultFont, defaultColor) {
-	if (spans.length === 0) return {
+function layoutRichEndEllipsisFromCursor(ctx, spans, defaultFont, defaultColor, prepared, start, maxWidth) {
+	const ellipsisWidth = measureEllipsisWidth(ctx);
+	if (ellipsisWidth > maxWidth) return {
 		width: 0,
 		fragments: [],
-		overflowed: false
+		overflowed: true
+	};
+	const widths = [];
+	forEachAtomFromCursorToEnd(prepared, start, (atom) => {
+		widths.push(atom.width + atom.extraWidthAfter);
+	});
+	if (widths.length === 0) return createRichEllipsisOnlyLayout(ctx, maxWidth, defaultFont, defaultColor);
+	const selection = resolveEllipsisSelection({
+		widths,
+		ellipsisWidth,
+		maxWidth,
+		position: "end"
+	});
+	if (selection == null) return {
+		width: 0,
+		fragments: [],
+		overflowed: true
+	};
+	const { prefixCount, width } = selection;
+	const fragments = [];
+	let atomIndex = 0;
+	let pendingGapBefore = 0;
+	let lastVisibleAtom;
+	let lastAtom;
+	forEachAtomFromCursorToEnd(prepared, start, (atom) => {
+		lastAtom = atom;
+		if (atomIndex < prefixCount) {
+			pendingGapBefore = appendRichFragment(ctx, spans, defaultColor, fragments, atom, pendingGapBefore);
+			lastVisibleAtom = atom;
+		}
+		atomIndex += 1;
+	});
+	const ellipsisSource = lastVisibleAtom ?? lastAtom;
+	const ellipsisSpan = ellipsisSource == null ? void 0 : spans[ellipsisSource.itemIndex];
+	fragments.push(createRichEllipsisFragment(ctx, ellipsisSpan?.font ?? ellipsisSource?.font ?? defaultFont, ellipsisSpan?.color ?? defaultColor));
+	return {
+		width,
+		fragments,
+		overflowed: true
 	};
-	const lineRange = layoutNextRichInlineLineRange(readRichPrepared(spans, defaultFont).prepared, INTRINSIC_MAX_WIDTH);
-	if (lineRange == null) return {
+}
+function layoutRichFirstLineIntrinsic(ctx, spans, defaultFont, defaultColor, whiteSpace = "normal", wordBreak = "normal") {
+	const prepared = readRichPrepared(spans, defaultFont, whiteSpace, wordBreak);
+	const line = getFirstLineRange(prepared);
+	if (line == null) return {
 		width: 0,
 		fragments: [],
 		overflowed: false
 	};
-	return materializeRichLine(ctx, spans, defaultFont, defaultColor, lineRange, false);
+	return materializeRichLine(ctx, spans, defaultColor, prepared, line, false);
 }
-function layoutRichFirstLine(ctx, spans, maxWidth, defaultFont, defaultColor) {
+function layoutRichFirstLine(ctx, spans, maxWidth, defaultFont, defaultColor, whiteSpace = "normal", wordBreak = "normal") {
 	const clampedMaxWidth = Math.max(0, maxWidth);
-	if (spans.length === 0 || clampedMaxWidth === 0) return {
+	if (clampedMaxWidth === 0 || spans.length === 0) return {
+		width: 0,
+		fragments: [],
+		overflowed: false
+	};
+	const prepared = readRichPrepared(spans, defaultFont, whiteSpace, wordBreak);
+	const start = getPreparedLineStart(prepared);
+	if (start == null) return {
 		width: 0,
 		fragments: [],
 		overflowed: false
 	};
-	const lineRange = layoutNextConstrainedRichInlineLineRange(readRichPrepared(spans, defaultFont), clampedMaxWidth);
-	if (lineRange == null) return {
+	const line = layoutNextPreparedLine(prepared, start, clampedMaxWidth);
+	if (line == null) return {
 		width: 0,
 		fragments: [],
 		overflowed: false
 	};
-	return materializeRichLine(ctx, spans, defaultFont, defaultColor, lineRange, false);
+	return materializeRichLine(ctx, spans, defaultColor, prepared, line, false);
 }
-function layoutRichEllipsizedFirstLine(ctx, spans, maxWidth, defaultFont, defaultColor, ellipsisPosition = "end") {
+function layoutRichEllipsizedFirstLine(ctx, spans, maxWidth, defaultFont, defaultColor, ellipsisPosition = "end", whiteSpace = "normal", wordBreak = "normal") {
 	const clampedMaxWidth = Math.max(0, maxWidth);
-	const intrinsicLine = layoutRichFirstLineIntrinsic(ctx, spans, defaultFont, defaultColor);
-	if (intrinsicLine.fragments.length === 0) return {
-		...intrinsicLine,
+	const prepared = readRichPrepared(spans, defaultFont, whiteSpace, wordBreak);
+	const intrinsicLine = getFirstLineRange(prepared);
+	if (intrinsicLine == null) return {
+		width: 0,
+		fragments: [],
 		overflowed: false
 	};
 	if (clampedMaxWidth === 0) return {
@@ -1504,103 +2640,110 @@ function layoutRichEllipsizedFirstLine(ctx, spans, maxWidth, defaultFont, defaul
 		fragments: [],
 		overflowed: true
 	};
-	return layoutPreparedRichEllipsis(ctx, intrinsicLine, clampedMaxWidth, defaultFont, defaultColor, ellipsisPosition);
+	return layoutRichEllipsisFromAtoms(ctx, spans, defaultFont, defaultColor, collectAtomsInRange(prepared, intrinsicLine.start, intrinsicLine.end), clampedMaxWidth, ellipsisPosition);
 }
-function measureRichText(_ctx, spans, maxWidth, defaultFont) {
-	if (spans.length === 0) return {
+function measureRichText(_ctx, spans, maxWidth, defaultFont, whiteSpace = "normal", wordBreak = "normal") {
+	if (spans.length === 0 || maxWidth <= 0) return {
 		width: 0,
 		lineCount: 0
 	};
-	const { maxLineWidth: width, lineCount } = measureConstrainedRichInlineStats(readRichPrepared(spans, defaultFont), maxWidth);
+	const { maxLineWidth: width, lineCount } = measurePreparedLineStats(readRichPrepared(spans, defaultFont, whiteSpace, wordBreak), maxWidth);
 	return {
 		width,
 		lineCount
 	};
 }
-function measureRichTextIntrinsic(_ctx, spans, defaultFont) {
+function measureRichTextIntrinsic(_ctx, spans, defaultFont, whiteSpace = "normal", wordBreak = "normal") {
 	if (spans.length === 0) return {
 		width: 0,
 		lineCount: 0
 	};
-	const { maxLineWidth: width, lineCount } = measureRichInlineStats(readRichPrepared(spans, defaultFont).prepared, INTRINSIC_MAX_WIDTH);
+	const { maxLineWidth: width, lineCount } = measurePreparedLineStats(readRichPrepared(spans, defaultFont, whiteSpace, wordBreak), Number.POSITIVE_INFINITY);
 	return {
 		width,
 		lineCount
 	};
 }
-function measureRichTextMinContent(_ctx, spans, defaultFont, overflowWrap = "break-word") {
+function measureRichTextMinContent(_ctx, spans, defaultFont, overflowWrap = "break-word", whiteSpace = "normal", wordBreak = "normal") {
 	if (spans.length === 0) return {
 		width: 0,
 		lineCount: 0
 	};
-	let maxWidth = 0;
-	for (const span of spans) {
-		if (span.text.trim().length === 0) continue;
-		const font = span.font ?? defaultFont;
-		const spanMinWidth = measurePreparedMinContentWidth(readPreparedText(span.text, font, "normal", "normal"), overflowWrap) + (span.extraWidth ?? 0);
-		if (spanMinWidth > maxWidth) maxWidth = spanMinWidth;
-	}
-	if (maxWidth === 0) return {
+	const prepared = readRichPrepared(spans, defaultFont, whiteSpace, wordBreak);
+	const width = measurePreparedMinContentWidth$1(prepared, overflowWrap);
+	if (width === 0) return {
 		width: 0,
 		lineCount: 0
 	};
-	const { lineCount } = measureConstrainedRichInlineStats(readRichPrepared(spans, defaultFont), Math.max(maxWidth, MIN_CONTENT_WIDTH_EPSILON));
+	const { lineCount } = measurePreparedLineStats(prepared, Math.max(width, MIN_CONTENT_WIDTH_EPSILON));
 	return {
-		width: maxWidth,
+		width,
 		lineCount
 	};
 }
-function layoutRichText(ctx, spans, maxWidth, defaultFont, defaultColor) {
-	if (spans.length === 0) return {
+function layoutRichText(ctx, spans, maxWidth, defaultFont, defaultColor, whiteSpace = "normal", wordBreak = "normal") {
+	if (spans.length === 0 || maxWidth <= 0) return {
 		width: 0,
 		lines: [],
 		overflowed: false
 	};
-	const prepared = readRichPrepared(spans, defaultFont);
-	const lineRanges = [];
-	walkConstrainedRichInlineLineRanges(prepared, maxWidth, (lineRange) => lineRanges.push(lineRange));
-	if (lineRanges.length === 0) return {
-		width: 0,
-		lines: [],
+	const prepared = readRichPrepared(spans, defaultFont, whiteSpace, wordBreak);
+	const lines = walkLines(prepared, maxWidth).map((line) => materializeRichLine(ctx, spans, defaultColor, prepared, line, false));
+	return {
+		width: measureRichBlockWidth(lines),
+		lines,
 		overflowed: false
 	};
-	const lines = lineRanges.map((lineRange) => materializeRichLine(ctx, spans, defaultFont, defaultColor, lineRange, false));
+}
+function layoutRichTextIntrinsic(ctx, spans, defaultFont, defaultColor, whiteSpace = "normal", wordBreak = "normal") {
+	const prepared = readRichPrepared(spans, defaultFont, whiteSpace, wordBreak);
+	const lines = walkLines(prepared, Number.POSITIVE_INFINITY).map((line) => materializeRichLine(ctx, spans, defaultColor, prepared, line, false));
 	return {
-		width: lines.reduce((maxLineWidth, line) => Math.max(maxLineWidth, line.width), 0),
+		width: measureRichBlockWidth(lines),
 		lines,
 		overflowed: false
 	};
 }
-function layoutRichTextIntrinsic(ctx, spans, defaultFont, defaultColor) {
-	return layoutRichText(ctx, spans, INTRINSIC_MAX_WIDTH, defaultFont, defaultColor);
-}
-function layoutRichTextWithOverflow(ctx, spans, maxWidth, defaultFont, defaultColor, maxLines, overflow = "clip") {
-	if (spans.length === 0) return {
+function layoutRichTextWithOverflow(ctx, spans, maxWidth, defaultFont, defaultColor, maxLines, overflow = "clip", whiteSpace = "normal", wordBreak = "normal") {
+	if (spans.length === 0 || maxWidth <= 0) return {
 		width: 0,
 		lines: [],
 		overflowed: false
 	};
 	const normalizedMaxLines = normalizeMaxLines(maxLines);
-	const layout = layoutRichText(ctx, spans, maxWidth, defaultFont, defaultColor);
-	if (normalizedMaxLines == null || layout.lines.length <= normalizedMaxLines) return layout;
-	const visibleLines = layout.lines.slice(0, normalizedMaxLines);
+	const prepared = readRichPrepared(spans, defaultFont, whiteSpace, wordBreak);
+	if (normalizedMaxLines == null) {
+		const lines = walkLines(prepared, maxWidth).map((line) => materializeRichLine(ctx, spans, defaultColor, prepared, line, false));
+		return {
+			width: measureRichBlockWidth(lines),
+			lines,
+			overflowed: false
+		};
+	}
+	const { lines: visibleRanges, overflowed } = collectVisibleLines(prepared, maxWidth, normalizedMaxLines);
+	if (!overflowed) {
+		const lines = visibleRanges.map((line) => materializeRichLine(ctx, spans, defaultColor, prepared, line, false));
+		return {
+			width: measureRichBlockWidth(lines),
+			lines,
+			overflowed: false
+		};
+	}
+	const visibleLines = visibleRanges.map((line) => materializeRichLine(ctx, spans, defaultColor, prepared, line, false));
 	if (overflow !== "ellipsis") return {
-		width: visibleLines.reduce((maxLineWidth, line) => Math.max(maxLineWidth, line.width), 0),
+		width: measureRichBlockWidth(visibleLines),
 		lines: visibleLines,
 		overflowed: true
 	};
-	const lastVisibleLine = visibleLines[visibleLines.length - 1];
-	const ellipsizedLastLine = lastVisibleLine == null ? {
+	const lastVisibleRange = visibleRanges[visibleRanges.length - 1];
+	const ellipsizedLastLine = lastVisibleRange == null ? {
 		width: 0,
 		fragments: [],
 		overflowed: true
-	} : layoutPreparedRichEllipsis(ctx, {
-		...lastVisibleLine,
-		overflowed: true
-	}, maxWidth, defaultFont, defaultColor, "end");
+	} : layoutRichEndEllipsisFromCursor(ctx, spans, defaultFont, defaultColor, prepared, lastVisibleRange.start, maxWidth);
 	const lines = [...visibleLines.slice(0, -1), ellipsizedLastLine];
 	return {
-		width: lines.reduce((maxLineWidth, line) => Math.max(maxLineWidth, line.width), 0),
+		width: measureRichBlockWidth(lines),
 		lines,
 		overflowed: true
 	};
@@ -1679,7 +2822,7 @@ function getSingleLineLayout(node, ctx, text, options) {
 }
 function getRichSingleLineLayout(node, ctx, spans, options) {
 	const maxWidth = normalizeTextMaxWidth(ctx.constraints?.maxWidth);
-	return readCachedTextLayout(node, ctx, getSingleLineLayoutKey(maxWidth), () => maxWidth == null ? layoutRichFirstLineIntrinsic(ctx, spans, options.font, options.color) : options.overflow === "ellipsis" ? layoutRichEllipsizedFirstLine(ctx, spans, maxWidth, options.font, options.color, options.ellipsisPosition ?? "end") : layoutRichFirstLine(ctx, spans, maxWidth, options.font, options.color));
+	return readCachedTextLayout(node, ctx, getSingleLineLayoutKey(maxWidth), () => maxWidth == null ? layoutRichFirstLineIntrinsic(ctx, spans, options.font, options.color, options.whiteSpace, options.wordBreak) : options.overflow === "ellipsis" ? layoutRichEllipsizedFirstLine(ctx, spans, maxWidth, options.font, options.color, options.ellipsisPosition ?? "end", options.whiteSpace, options.wordBreak) : layoutRichFirstLine(ctx, spans, maxWidth, options.font, options.color, options.whiteSpace, options.wordBreak));
 }
 function getMultiLineOverflowLayout(node, ctx, text, options) {
 	const maxWidth = normalizeTextMaxWidth(ctx.constraints?.maxWidth);
@@ -1712,7 +2855,7 @@ function getSingleLineMinContentLayout(node, ctx, text, options) {
 	});
 }
 function getRichSingleLineMinContentWidth(node, ctx, spans, options) {
-	return readCachedTextLayout(node, ctx, getSingleLineMinContentLayoutKey(), () => measureRichTextMinContent(ctx, spans, options.font, options.overflowWrap).width);
+	return readCachedTextLayout(node, ctx, getSingleLineMinContentLayoutKey(), () => measureRichTextMinContent(ctx, spans, options.font, options.overflowWrap, options.whiteSpace, options.wordBreak).width);
 }
 function drawRichLine(ctx, line, fallbackColor, x, y, lineHeight) {
 	let cursorX = x;
@@ -1734,19 +2877,19 @@ function getMultiLineMinContentLayout(node, ctx, text, whiteSpace, wordBreak, ov
 function getRichMultiLineMeasureLayout(node, ctx, spans, options) {
 	const maxWidth = normalizeTextMaxWidth(ctx.constraints?.maxWidth);
 	if (shouldReadConstrainedOverflowLayout(maxWidth, options)) return measureBlockLayout(getRichMultiLineOverflowLayout(node, ctx, spans, options));
-	return readCachedTextLayout(node, ctx, getRichMultiLineMeasureLayoutKey(maxWidth), () => maxWidth == null ? measureRichTextIntrinsic(ctx, spans, options.font) : measureRichText(ctx, spans, maxWidth, options.font));
+	return readCachedTextLayout(node, ctx, getRichMultiLineMeasureLayoutKey(maxWidth), () => maxWidth == null ? measureRichTextIntrinsic(ctx, spans, options.font, options.whiteSpace, options.wordBreak) : measureRichText(ctx, spans, maxWidth, options.font, options.whiteSpace, options.wordBreak));
 }
 function getRichMultiLineOverflowLayout(node, ctx, spans, options) {
 	const maxWidth = normalizeTextMaxWidth(ctx.constraints?.maxWidth);
-	return readCachedTextLayout(node, ctx, getRichMultiLineOverflowLayoutKey(maxWidth), () => layoutRichTextWithOverflow(ctx, spans, maxWidth ?? 0, options.font, options.color, options.maxLines, options.overflow));
+	return readCachedTextLayout(node, ctx, getRichMultiLineOverflowLayoutKey(maxWidth), () => layoutRichTextWithOverflow(ctx, spans, maxWidth ?? 0, options.font, options.color, options.maxLines, options.overflow, options.whiteSpace, options.wordBreak));
 }
 function getRichMultiLineDrawLayout(node, ctx, spans, options) {
 	const maxWidth = normalizeTextMaxWidth(ctx.constraints?.maxWidth);
 	if (shouldReadConstrainedOverflowLayout(maxWidth, options)) return getRichMultiLineOverflowLayout(node, ctx, spans, options);
-	return readCachedTextLayout(node, ctx, getRichMultiLineDrawLayoutKey(maxWidth), () => maxWidth == null ? layoutRichTextIntrinsic(ctx, spans, options.font, options.color) : layoutRichText(ctx, spans, maxWidth, options.font, options.color));
+	return readCachedTextLayout(node, ctx, getRichMultiLineDrawLayoutKey(maxWidth), () => maxWidth == null ? layoutRichTextIntrinsic(ctx, spans, options.font, options.color, options.whiteSpace, options.wordBreak) : layoutRichText(ctx, spans, maxWidth, options.font, options.color, options.whiteSpace, options.wordBreak));
 }
 function getRichMultiLineMinContentLayout(node, ctx, spans, options) {
-	return readCachedTextLayout(node, ctx, getRichMultiLineMinContentLayoutKey(), () => measureRichTextMinContent(ctx, spans, options.font, options.overflowWrap));
+	return readCachedTextLayout(node, ctx, getRichMultiLineMinContentLayoutKey(), () => measureRichTextMinContent(ctx, spans, options.font, options.overflowWrap, options.whiteSpace, options.wordBreak));
 }
 /**
 * Draws wrapped text using the configured line height and alignment.
@@ -3029,6 +4172,6 @@ var TimelineRenderer = class extends VirtualizedRenderer {
 	}
 };
 //#endregion
-export { BaseRenderer, ChatRenderer, DebugRenderer, Fixed, Flex, FlexItem, Group, ListState, MultilineText, PaddingBox, Place, Text, TimelineRenderer, VirtualizedRenderer, Wrapper, memoRenderItem, memoRenderItemBy };
+export { BaseRenderer, ChatRenderer, DebugRenderer, Fixed, Flex, FlexItem, Group, ListState, MultilineText, PaddingBox, Place, ShrinkWrap, Text, TimelineRenderer, VirtualizedRenderer, Wrapper, memoRenderItem, memoRenderItemBy };
 
 //# sourceMappingURL=index.mjs.map