@zzclub/pipeline 0.1.0

package/dist/node_modules/@chenglou/pretext/dist/measurement.d.ts

@@ -0,0 +1,28 @@
+export type SegmentMetrics = {
+    width: number;
+    containsCJK: boolean;
+    emojiCount?: number;
+    breakableFitAdvances?: number[] | null;
+};
+export type EngineProfile = {
+    lineFitEpsilon: number;
+    carryCJKAfterClosingQuote: boolean;
+    preferPrefixWidthsForBreakableRuns: boolean;
+    preferEarlySoftHyphenBreak: boolean;
+};
+export type BreakableFitMode = 'sum-graphemes' | 'segment-prefixes' | 'pair-context';
+export declare function getMeasureContext(): CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D;
+export declare function getSegmentMetricCache(font: string): Map<string, SegmentMetrics>;
+export declare function getSegmentMetrics(seg: string, cache: Map<string, SegmentMetrics>): SegmentMetrics;
+export declare function getEngineProfile(): EngineProfile;
+export declare function parseFontSize(font: string): number;
+export declare function textMayContainEmoji(text: string): boolean;
+export declare function getCorrectedSegmentWidth(seg: string, metrics: SegmentMetrics, emojiCorrection: number): number;
+export declare function getSegmentGraphemeWidths(seg: string, cache: Map<string, SegmentMetrics>, emojiCorrection: number): number[] | null;
+export declare function getSegmentBreakableFitAdvances(seg: string, metrics: SegmentMetrics, cache: Map<string, SegmentMetrics>, emojiCorrection: number, mode: BreakableFitMode): number[] | null;
+export declare function getFontMeasurementState(font: string, needsEmojiCorrection: boolean): {
+    cache: Map<string, SegmentMetrics>;
+    fontSize: number;
+    emojiCorrection: number;
+};
+export declare function clearMeasurementCaches(): void;

package/dist/node_modules/@chenglou/pretext/dist/measurement.js

@@ -0,0 +1,219 @@
+import { isCJK } from './analysis.js';
+let measureContext = null;
+const segmentMetricCaches = new Map();
+let cachedEngineProfile = null;
+// Safari's prefix-fit policy is useful for ordinary word-sized runs, but letting
+// it measure every growing prefix of a giant segment recreates a pathological
+// superlinear prepare-time path. Past this size, switch to the cheaper
+// pair-context model and keep the public behavior linear.
+const MAX_PREFIX_FIT_GRAPHEMES = 96;
+const emojiPresentationRe = /\p{Emoji_Presentation}/u;
+const maybeEmojiRe = /[\p{Emoji_Presentation}\p{Extended_Pictographic}\p{Regional_Indicator}\uFE0F\u20E3]/u;
+let sharedGraphemeSegmenter = null;
+const emojiCorrectionCache = new Map();
+export function getMeasureContext() {
+    if (measureContext !== null)
+        return measureContext;
+    if (typeof OffscreenCanvas !== 'undefined') {
+        measureContext = new OffscreenCanvas(1, 1).getContext('2d');
+        return measureContext;
+    }
+    if (typeof document !== 'undefined') {
+        measureContext = document.createElement('canvas').getContext('2d');
+        return measureContext;
+    }
+    throw new Error('Text measurement requires OffscreenCanvas or a DOM canvas context.');
+}
+export function getSegmentMetricCache(font) {
+    let cache = segmentMetricCaches.get(font);
+    if (!cache) {
+        cache = new Map();
+        segmentMetricCaches.set(font, cache);
+    }
+    return cache;
+}
+export function getSegmentMetrics(seg, cache) {
+    let metrics = cache.get(seg);
+    if (metrics === undefined) {
+        const ctx = getMeasureContext();
+        metrics = {
+            width: ctx.measureText(seg).width,
+            containsCJK: isCJK(seg),
+        };
+        cache.set(seg, metrics);
+    }
+    return metrics;
+}
+export function getEngineProfile() {
+    if (cachedEngineProfile !== null)
+        return cachedEngineProfile;
+    if (typeof navigator === 'undefined') {
+        cachedEngineProfile = {
+            lineFitEpsilon: 0.005,
+            carryCJKAfterClosingQuote: false,
+            preferPrefixWidthsForBreakableRuns: false,
+            preferEarlySoftHyphenBreak: false,
+        };
+        return cachedEngineProfile;
+    }
+    const ua = navigator.userAgent;
+    const vendor = navigator.vendor;
+    const isSafari = vendor === 'Apple Computer, Inc.' &&
+        ua.includes('Safari/') &&
+        !ua.includes('Chrome/') &&
+        !ua.includes('Chromium/') &&
+        !ua.includes('CriOS/') &&
+        !ua.includes('FxiOS/') &&
+        !ua.includes('EdgiOS/');
+    const isChromium = ua.includes('Chrome/') ||
+        ua.includes('Chromium/') ||
+        ua.includes('CriOS/') ||
+        ua.includes('Edg/');
+    cachedEngineProfile = {
+        lineFitEpsilon: isSafari ? 1 / 64 : 0.005,
+        carryCJKAfterClosingQuote: isChromium,
+        preferPrefixWidthsForBreakableRuns: isSafari,
+        preferEarlySoftHyphenBreak: isSafari,
+    };
+    return cachedEngineProfile;
+}
+export function parseFontSize(font) {
+    const m = font.match(/(\d+(?:\.\d+)?)\s*px/);
+    return m ? parseFloat(m[1]) : 16;
+}
+function getSharedGraphemeSegmenter() {
+    if (sharedGraphemeSegmenter === null) {
+        sharedGraphemeSegmenter = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
+    }
+    return sharedGraphemeSegmenter;
+}
+function isEmojiGrapheme(g) {
+    return emojiPresentationRe.test(g) || g.includes('\uFE0F');
+}
+export function textMayContainEmoji(text) {
+    return maybeEmojiRe.test(text);
+}
+function getEmojiCorrection(font, fontSize) {
+    let correction = emojiCorrectionCache.get(font);
+    if (correction !== undefined)
+        return correction;
+    const ctx = getMeasureContext();
+    ctx.font = font;
+    const canvasW = ctx.measureText('\u{1F600}').width;
+    correction = 0;
+    if (canvasW > fontSize + 0.5 &&
+        typeof document !== 'undefined' &&
+        document.body !== null) {
+        const span = document.createElement('span');
+        span.style.font = font;
+        span.style.display = 'inline-block';
+        span.style.visibility = 'hidden';
+        span.style.position = 'absolute';
+        span.textContent = '\u{1F600}';
+        document.body.appendChild(span);
+        const domW = span.getBoundingClientRect().width;
+        document.body.removeChild(span);
+        if (canvasW - domW > 0.5) {
+            correction = canvasW - domW;
+        }
+    }
+    emojiCorrectionCache.set(font, correction);
+    return correction;
+}
+function countEmojiGraphemes(text) {
+    let count = 0;
+    const graphemeSegmenter = getSharedGraphemeSegmenter();
+    for (const g of graphemeSegmenter.segment(text)) {
+        if (isEmojiGrapheme(g.segment))
+            count++;
+    }
+    return count;
+}
+function getEmojiCount(seg, metrics) {
+    if (metrics.emojiCount === undefined) {
+        metrics.emojiCount = countEmojiGraphemes(seg);
+    }
+    return metrics.emojiCount;
+}
+export function getCorrectedSegmentWidth(seg, metrics, emojiCorrection) {
+    if (emojiCorrection === 0)
+        return metrics.width;
+    return metrics.width - getEmojiCount(seg, metrics) * emojiCorrection;
+}
+export function getSegmentGraphemeWidths(seg, cache, emojiCorrection) {
+    const widths = [];
+    const graphemeSegmenter = getSharedGraphemeSegmenter();
+    for (const gs of graphemeSegmenter.segment(seg)) {
+        const graphemeMetrics = getSegmentMetrics(gs.segment, cache);
+        widths.push(getCorrectedSegmentWidth(gs.segment, graphemeMetrics, emojiCorrection));
+    }
+    return widths.length > 1 ? widths : null;
+}
+export function getSegmentBreakableFitAdvances(seg, metrics, cache, emojiCorrection, mode) {
+    if (metrics.breakableFitAdvances !== undefined)
+        return metrics.breakableFitAdvances;
+    const graphemeSegmenter = getSharedGraphemeSegmenter();
+    const graphemes = [];
+    for (const gs of graphemeSegmenter.segment(seg)) {
+        graphemes.push(gs.segment);
+    }
+    if (graphemes.length <= 1) {
+        metrics.breakableFitAdvances = null;
+        return metrics.breakableFitAdvances;
+    }
+    if (mode === 'sum-graphemes') {
+        const advances = [];
+        for (const grapheme of graphemes) {
+            const graphemeMetrics = getSegmentMetrics(grapheme, cache);
+            advances.push(getCorrectedSegmentWidth(grapheme, graphemeMetrics, emojiCorrection));
+        }
+        metrics.breakableFitAdvances = advances;
+        return metrics.breakableFitAdvances;
+    }
+    if (mode === 'pair-context' || graphemes.length > MAX_PREFIX_FIT_GRAPHEMES) {
+        const advances = [];
+        let previousGrapheme = null;
+        let previousWidth = 0;
+        for (const grapheme of graphemes) {
+            const graphemeMetrics = getSegmentMetrics(grapheme, cache);
+            const currentWidth = getCorrectedSegmentWidth(grapheme, graphemeMetrics, emojiCorrection);
+            if (previousGrapheme === null) {
+                advances.push(currentWidth);
+            }
+            else {
+                const pair = previousGrapheme + grapheme;
+                const pairMetrics = getSegmentMetrics(pair, cache);
+                advances.push(getCorrectedSegmentWidth(pair, pairMetrics, emojiCorrection) - previousWidth);
+            }
+            previousGrapheme = grapheme;
+            previousWidth = currentWidth;
+        }
+        metrics.breakableFitAdvances = advances;
+        return metrics.breakableFitAdvances;
+    }
+    const advances = [];
+    let prefix = '';
+    let prefixWidth = 0;
+    for (const grapheme of graphemes) {
+        prefix += grapheme;
+        const prefixMetrics = getSegmentMetrics(prefix, cache);
+        const nextPrefixWidth = getCorrectedSegmentWidth(prefix, prefixMetrics, emojiCorrection);
+        advances.push(nextPrefixWidth - prefixWidth);
+        prefixWidth = nextPrefixWidth;
+    }
+    metrics.breakableFitAdvances = advances;
+    return metrics.breakableFitAdvances;
+}
+export function getFontMeasurementState(font, needsEmojiCorrection) {
+    const ctx = getMeasureContext();
+    ctx.font = font;
+    const cache = getSegmentMetricCache(font);
+    const fontSize = parseFontSize(font);
+    const emojiCorrection = needsEmojiCorrection ? getEmojiCorrection(font, fontSize) : 0;
+    return { cache, fontSize, emojiCorrection };
+}
+export function clearMeasurementCaches() {
+    segmentMetricCaches.clear();
+    emojiCorrectionCache.clear();
+    sharedGraphemeSegmenter = null;
+}

package/dist/node_modules/@chenglou/pretext/dist/rich-inline.d.ts

@@ -0,0 +1,51 @@
+import { type LayoutCursor } from './layout.js';
+declare const preparedRichInlineBrand: unique symbol;
+export type RichInlineItem = {
+    text: string;
+    font: string;
+    break?: 'normal' | 'never';
+    extraWidth?: number;
+};
+export type PreparedRichInline = {
+    readonly [preparedRichInlineBrand]: true;
+};
+export type RichInlineCursor = {
+    itemIndex: number;
+    segmentIndex: number;
+    graphemeIndex: number;
+};
+export type RichInlineFragment = {
+    itemIndex: number;
+    text: string;
+    gapBefore: number;
+    occupiedWidth: number;
+    start: LayoutCursor;
+    end: LayoutCursor;
+};
+export type RichInlineFragmentRange = {
+    itemIndex: number;
+    gapBefore: number;
+    occupiedWidth: number;
+    start: LayoutCursor;
+    end: LayoutCursor;
+};
+export type RichInlineLine = {
+    fragments: RichInlineFragment[];
+    width: number;
+    end: RichInlineCursor;
+};
+export type RichInlineLineRange = {
+    fragments: RichInlineFragmentRange[];
+    width: number;
+    end: RichInlineCursor;
+};
+export type RichInlineStats = {
+    lineCount: number;
+    maxLineWidth: number;
+};
+export declare function prepareRichInline(items: RichInlineItem[]): PreparedRichInline;
+export declare function layoutNextRichInlineLineRange(prepared: PreparedRichInline, maxWidth: number, start?: RichInlineCursor): RichInlineLineRange | null;
+export declare function materializeRichInlineLineRange(prepared: PreparedRichInline, line: RichInlineLineRange): RichInlineLine;
+export declare function walkRichInlineLineRanges(prepared: PreparedRichInline, maxWidth: number, onLine: (line: RichInlineLineRange) => void): number;
+export declare function measureRichInlineStats(prepared: PreparedRichInline, maxWidth: number): RichInlineStats;
+export {};

package/dist/node_modules/@chenglou/pretext/dist/rich-inline.js

@@ -0,0 +1,401 @@
+import { materializeLineRange, measureNaturalWidth, prepareWithSegments, } from './layout.js';
+import { layoutNextLineRange as stepPreparedLineRange, stepPreparedLineGeometry, } from './line-break.js';
+const COLLAPSIBLE_BOUNDARY_RE = /[ \t\n\f\r]+/;
+const LEADING_COLLAPSIBLE_BOUNDARY_RE = /^[ \t\n\f\r]+/;
+const TRAILING_COLLAPSIBLE_BOUNDARY_RE = /[ \t\n\f\r]+$/;
+const EMPTY_LAYOUT_CURSOR = { segmentIndex: 0, graphemeIndex: 0 };
+const RICH_INLINE_START_CURSOR = {
+    itemIndex: 0,
+    segmentIndex: 0,
+    graphemeIndex: 0,
+};
+function getInternalPreparedRichInline(prepared) {
+    return prepared;
+}
+function cloneCursor(cursor) {
+    return {
+        segmentIndex: cursor.segmentIndex,
+        graphemeIndex: cursor.graphemeIndex,
+    };
+}
+function isLineStartCursor(cursor) {
+    return cursor.segmentIndex === 0 && cursor.graphemeIndex === 0;
+}
+function getCollapsedSpaceWidth(font, cache) {
+    const cached = cache.get(font);
+    if (cached !== undefined)
+        return cached;
+    const joinedWidth = measureNaturalWidth(prepareWithSegments('A A', font));
+    const compactWidth = measureNaturalWidth(prepareWithSegments('AA', font));
+    const collapsedWidth = Math.max(0, joinedWidth - compactWidth);
+    cache.set(font, collapsedWidth);
+    return collapsedWidth;
+}
+function prepareWholeItemLine(prepared) {
+    const line = stepPreparedLineRange(prepared, EMPTY_LAYOUT_CURSOR, Number.POSITIVE_INFINITY);
+    if (line === null)
+        return null;
+    return {
+        endGraphemeIndex: line.endGraphemeIndex,
+        endSegmentIndex: line.endSegmentIndex,
+        width: line.width,
+    };
+}
+function endsInsideFirstSegment(segmentIndex, graphemeIndex) {
+    return segmentIndex === 0 && graphemeIndex > 0;
+}
+export function prepareRichInline(items) {
+    const preparedItems = [];
+    const itemsBySourceItemIndex = Array.from({ length: items.length });
+    const collapsedSpaceWidthCache = new Map();
+    let pendingGapWidth = 0;
+    for (let index = 0; index < items.length; index++) {
+        const item = items[index];
+        const hasLeadingWhitespace = LEADING_COLLAPSIBLE_BOUNDARY_RE.test(item.text);
+        const hasTrailingWhitespace = TRAILING_COLLAPSIBLE_BOUNDARY_RE.test(item.text);
+        const trimmedText = item.text
+            .replace(LEADING_COLLAPSIBLE_BOUNDARY_RE, '')
+            .replace(TRAILING_COLLAPSIBLE_BOUNDARY_RE, '');
+        if (trimmedText.length === 0) {
+            if (COLLAPSIBLE_BOUNDARY_RE.test(item.text) && pendingGapWidth === 0) {
+                pendingGapWidth = getCollapsedSpaceWidth(item.font, collapsedSpaceWidthCache);
+            }
+            continue;
+        }
+        const gapBefore = pendingGapWidth > 0
+            ? pendingGapWidth
+            : hasLeadingWhitespace
+                ? getCollapsedSpaceWidth(item.font, collapsedSpaceWidthCache)
+                : 0;
+        const prepared = prepareWithSegments(trimmedText, item.font);
+        const wholeLine = prepareWholeItemLine(prepared);
+        if (wholeLine === null) {
+            pendingGapWidth = hasTrailingWhitespace ? getCollapsedSpaceWidth(item.font, collapsedSpaceWidthCache) : 0;
+            continue;
+        }
+        const preparedItem = {
+            break: item.break ?? 'normal',
+            endGraphemeIndex: wholeLine.endGraphemeIndex,
+            endSegmentIndex: wholeLine.endSegmentIndex,
+            extraWidth: item.extraWidth ?? 0,
+            gapBefore,
+            naturalWidth: wholeLine.width,
+            prepared,
+            sourceItemIndex: index,
+        };
+        preparedItems.push(preparedItem);
+        itemsBySourceItemIndex[index] = preparedItem;
+        pendingGapWidth = hasTrailingWhitespace ? getCollapsedSpaceWidth(item.font, collapsedSpaceWidthCache) : 0;
+    }
+    return {
+        items: preparedItems,
+        itemsBySourceItemIndex,
+    };
+}
+function stepRichInlineLine(flow, maxWidth, cursor, collectFragment) {
+    if (flow.items.length === 0 || cursor.itemIndex >= flow.items.length)
+        return null;
+    const safeWidth = Math.max(1, maxWidth);
+    let lineWidth = 0;
+    let remainingWidth = safeWidth;
+    let itemIndex = cursor.itemIndex;
+    const textCursor = {
+        segmentIndex: cursor.segmentIndex,
+        graphemeIndex: cursor.graphemeIndex,
+    };
+    lineLoop: while (itemIndex < flow.items.length) {
+        const item = flow.items[itemIndex];
+        if (!isLineStartCursor(textCursor) &&
+            textCursor.segmentIndex === item.endSegmentIndex &&
+            textCursor.graphemeIndex === item.endGraphemeIndex) {
+            itemIndex++;
+            textCursor.segmentIndex = 0;
+            textCursor.graphemeIndex = 0;
+            continue;
+        }
+        const gapBefore = lineWidth === 0 ? 0 : item.gapBefore;
+        const atItemStart = isLineStartCursor(textCursor);
+        if (item.break === 'never') {
+            if (!atItemStart) {
+                itemIndex++;
+                textCursor.segmentIndex = 0;
+                textCursor.graphemeIndex = 0;
+                continue;
+            }
+            const occupiedWidth = item.naturalWidth + item.extraWidth;
+            const totalWidth = gapBefore + occupiedWidth;
+            if (lineWidth > 0 && totalWidth > remainingWidth)
+                break lineLoop;
+            collectFragment?.(item, gapBefore, occupiedWidth, cloneCursor(EMPTY_LAYOUT_CURSOR), {
+                segmentIndex: item.endSegmentIndex,
+                graphemeIndex: item.endGraphemeIndex,
+            });
+            lineWidth += totalWidth;
+            remainingWidth = Math.max(0, safeWidth - lineWidth);
+            itemIndex++;
+            textCursor.segmentIndex = 0;
+            textCursor.graphemeIndex = 0;
+            continue;
+        }
+        const reservedWidth = gapBefore + item.extraWidth;
+        if (lineWidth > 0 && reservedWidth >= remainingWidth)
+            break lineLoop;
+        if (atItemStart) {
+            const totalWidth = reservedWidth + item.naturalWidth;
+            if (totalWidth <= remainingWidth) {
+                collectFragment?.(item, gapBefore, item.naturalWidth + item.extraWidth, cloneCursor(EMPTY_LAYOUT_CURSOR), {
+                    segmentIndex: item.endSegmentIndex,
+                    graphemeIndex: item.endGraphemeIndex,
+                });
+                lineWidth += totalWidth;
+                remainingWidth = Math.max(0, safeWidth - lineWidth);
+                itemIndex++;
+                textCursor.segmentIndex = 0;
+                textCursor.graphemeIndex = 0;
+                continue;
+            }
+        }
+        const availableWidth = Math.max(1, remainingWidth - reservedWidth);
+        const line = stepPreparedLineRange(item.prepared, textCursor, availableWidth);
+        if (line === null) {
+            itemIndex++;
+            textCursor.segmentIndex = 0;
+            textCursor.graphemeIndex = 0;
+            continue;
+        }
+        if (textCursor.segmentIndex === line.endSegmentIndex &&
+            textCursor.graphemeIndex === line.endGraphemeIndex) {
+            itemIndex++;
+            textCursor.segmentIndex = 0;
+            textCursor.graphemeIndex = 0;
+            continue;
+        }
+        // If the only thing we can fit after paying the boundary gap is a partial
+        // slice of the item's first segment, prefer wrapping before the item so we
+        // keep whole-word-style boundaries when they exist. But once the current
+        // line can consume a real breakable unit from the item, stay greedy and
+        // keep filling the line.
+        if (lineWidth > 0 &&
+            atItemStart &&
+            gapBefore > 0 &&
+            endsInsideFirstSegment(line.endSegmentIndex, line.endGraphemeIndex)) {
+            const freshLine = stepPreparedLineRange(item.prepared, EMPTY_LAYOUT_CURSOR, Math.max(1, safeWidth - item.extraWidth));
+            if (freshLine !== null &&
+                (freshLine.endSegmentIndex > line.endSegmentIndex ||
+                    (freshLine.endSegmentIndex === line.endSegmentIndex &&
+                        freshLine.endGraphemeIndex > line.endGraphemeIndex))) {
+                break lineLoop;
+            }
+        }
+        collectFragment?.(item, gapBefore, line.width + item.extraWidth, cloneCursor(textCursor), {
+            segmentIndex: line.endSegmentIndex,
+            graphemeIndex: line.endGraphemeIndex,
+        });
+        lineWidth += gapBefore + line.width + item.extraWidth;
+        remainingWidth = Math.max(0, safeWidth - lineWidth);
+        if (line.endSegmentIndex === item.endSegmentIndex &&
+            line.endGraphemeIndex === item.endGraphemeIndex) {
+            itemIndex++;
+            textCursor.segmentIndex = 0;
+            textCursor.graphemeIndex = 0;
+            continue;
+        }
+        textCursor.segmentIndex = line.endSegmentIndex;
+        textCursor.graphemeIndex = line.endGraphemeIndex;
+        break;
+    }
+    if (lineWidth === 0)
+        return null;
+    cursor.itemIndex = itemIndex;
+    cursor.segmentIndex = textCursor.segmentIndex;
+    cursor.graphemeIndex = textCursor.graphemeIndex;
+    return lineWidth;
+}
+function stepRichInlineLineStats(flow, maxWidth, cursor) {
+    if (flow.items.length === 0 || cursor.itemIndex >= flow.items.length)
+        return null;
+    const safeWidth = Math.max(1, maxWidth);
+    let lineWidth = 0;
+    let remainingWidth = safeWidth;
+    let itemIndex = cursor.itemIndex;
+    lineLoop: while (itemIndex < flow.items.length) {
+        const item = flow.items[itemIndex];
+        if (!isLineStartCursor(cursor) &&
+            cursor.segmentIndex === item.endSegmentIndex &&
+            cursor.graphemeIndex === item.endGraphemeIndex) {
+            itemIndex++;
+            cursor.segmentIndex = 0;
+            cursor.graphemeIndex = 0;
+            continue;
+        }
+        const gapBefore = lineWidth === 0 ? 0 : item.gapBefore;
+        const atItemStart = isLineStartCursor(cursor);
+        if (item.break === 'never') {
+            if (!atItemStart) {
+                itemIndex++;
+                cursor.segmentIndex = 0;
+                cursor.graphemeIndex = 0;
+                continue;
+            }
+            const occupiedWidth = item.naturalWidth + item.extraWidth;
+            const totalWidth = gapBefore + occupiedWidth;
+            if (lineWidth > 0 && totalWidth > remainingWidth)
+                break lineLoop;
+            lineWidth += totalWidth;
+            remainingWidth = Math.max(0, safeWidth - lineWidth);
+            itemIndex++;
+            cursor.segmentIndex = 0;
+            cursor.graphemeIndex = 0;
+            continue;
+        }
+        const reservedWidth = gapBefore + item.extraWidth;
+        if (lineWidth > 0 && reservedWidth >= remainingWidth)
+            break lineLoop;
+        if (atItemStart) {
+            const totalWidth = reservedWidth + item.naturalWidth;
+            if (totalWidth <= remainingWidth) {
+                lineWidth += totalWidth;
+                remainingWidth = Math.max(0, safeWidth - lineWidth);
+                itemIndex++;
+                cursor.segmentIndex = 0;
+                cursor.graphemeIndex = 0;
+                continue;
+            }
+        }
+        const availableWidth = Math.max(1, remainingWidth - reservedWidth);
+        const lineEnd = {
+            segmentIndex: cursor.segmentIndex,
+            graphemeIndex: cursor.graphemeIndex,
+        };
+        const lineWidthForItem = stepPreparedLineGeometry(item.prepared, lineEnd, availableWidth);
+        if (lineWidthForItem === null) {
+            itemIndex++;
+            cursor.segmentIndex = 0;
+            cursor.graphemeIndex = 0;
+            continue;
+        }
+        if (cursor.segmentIndex === lineEnd.segmentIndex && cursor.graphemeIndex === lineEnd.graphemeIndex) {
+            itemIndex++;
+            cursor.segmentIndex = 0;
+            cursor.graphemeIndex = 0;
+            continue;
+        }
+        if (lineWidth > 0 &&
+            atItemStart &&
+            gapBefore > 0 &&
+            endsInsideFirstSegment(lineEnd.segmentIndex, lineEnd.graphemeIndex)) {
+            const freshLineEnd = {
+                segmentIndex: 0,
+                graphemeIndex: 0,
+            };
+            const freshLineWidth = stepPreparedLineGeometry(item.prepared, freshLineEnd, Math.max(1, safeWidth - item.extraWidth));
+            if (freshLineWidth !== null &&
+                (freshLineEnd.segmentIndex > lineEnd.segmentIndex ||
+                    (freshLineEnd.segmentIndex === lineEnd.segmentIndex &&
+                        freshLineEnd.graphemeIndex > lineEnd.graphemeIndex))) {
+                break lineLoop;
+            }
+        }
+        lineWidth += gapBefore + lineWidthForItem + item.extraWidth;
+        remainingWidth = Math.max(0, safeWidth - lineWidth);
+        if (lineEnd.segmentIndex === item.endSegmentIndex && lineEnd.graphemeIndex === item.endGraphemeIndex) {
+            itemIndex++;
+            cursor.segmentIndex = 0;
+            cursor.graphemeIndex = 0;
+            continue;
+        }
+        cursor.segmentIndex = lineEnd.segmentIndex;
+        cursor.graphemeIndex = lineEnd.graphemeIndex;
+        break;
+    }
+    if (lineWidth === 0)
+        return null;
+    cursor.itemIndex = itemIndex;
+    return lineWidth;
+}
+export function layoutNextRichInlineLineRange(prepared, maxWidth, start = RICH_INLINE_START_CURSOR) {
+    const flow = getInternalPreparedRichInline(prepared);
+    const end = {
+        itemIndex: start.itemIndex,
+        segmentIndex: start.segmentIndex,
+        graphemeIndex: start.graphemeIndex,
+    };
+    const fragments = [];
+    const width = stepRichInlineLine(flow, maxWidth, end, (item, gapBefore, occupiedWidth, fragmentStart, fragmentEnd) => {
+        fragments.push({
+            itemIndex: item.sourceItemIndex,
+            gapBefore,
+            occupiedWidth,
+            start: fragmentStart,
+            end: fragmentEnd,
+        });
+    });
+    if (width === null)
+        return null;
+    return {
+        fragments,
+        width,
+        end,
+    };
+}
+function materializeFragmentText(item, fragment) {
+    const line = materializeLineRange(item.prepared, {
+        width: fragment.occupiedWidth - item.extraWidth,
+        start: fragment.start,
+        end: fragment.end,
+    });
+    return line.text;
+}
+// Bridge from cheap range walking to full fragment text. Lets callers do
+// shrinkwrap/virtualization/probing work first, then only pay for text on the
+// lines they actually render.
+export function materializeRichInlineLineRange(prepared, line) {
+    const flow = getInternalPreparedRichInline(prepared);
+    return {
+        fragments: line.fragments.map(fragment => {
+            const item = flow.itemsBySourceItemIndex[fragment.itemIndex];
+            if (item === undefined)
+                throw new Error('Missing rich-text inline item for fragment');
+            return {
+                ...fragment,
+                text: materializeFragmentText(item, fragment),
+            };
+        }),
+        width: line.width,
+        end: line.end,
+    };
+}
+export function walkRichInlineLineRanges(prepared, maxWidth, onLine) {
+    let lineCount = 0;
+    let cursor = RICH_INLINE_START_CURSOR;
+    while (true) {
+        const line = layoutNextRichInlineLineRange(prepared, maxWidth, cursor);
+        if (line === null)
+            return lineCount;
+        onLine(line);
+        lineCount++;
+        cursor = line.end;
+    }
+}
+export function measureRichInlineStats(prepared, maxWidth) {
+    const flow = getInternalPreparedRichInline(prepared);
+    let lineCount = 0;
+    let maxLineWidth = 0;
+    const cursor = {
+        itemIndex: 0,
+        segmentIndex: 0,
+        graphemeIndex: 0,
+    };
+    while (true) {
+        const lineWidth = stepRichInlineLineStats(flow, maxWidth, cursor);
+        if (lineWidth === null) {
+            return {
+                lineCount,
+                maxLineWidth,
+            };
+        }
+        lineCount++;
+        if (lineWidth > maxLineWidth)
+            maxLineWidth = lineWidth;
+    }
+}