postext 0.1.11 → 0.1.13

package/dist/knuthPlass.js

@@ -0,0 +1,653 @@
+/**
+ * Knuth-Plass optimal paragraph line-breaking algorithm.
+ *
+ * Replaces the greedy first-fit line breaker with a dynamic-programming
+ * approach that minimizes total demerits across all lines of a paragraph,
+ * producing more even word-spacing and fewer "loose" lines.
+ */
+import { createBoundingBox } from './vdt';
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+const KP_INFINITY = 10000;
+const HYPHEN_PENALTY = 50;
+const DEFAULT_CONSECUTIVE_HYPHEN_DEMERIT = 3000;
+const DEFAULT_FITNESS_CLASS_DEMERIT = 100;
+const BADNESS_CAP = 10000;
+const MAX_STRETCH = Number.MAX_SAFE_INTEGER;
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function classifyFitness(r) {
+    if (r < -0.5)
+        return 0; // tight
+    if (r < 0.5)
+        return 1; // normal
+    if (r < 1.0)
+        return 2; // loose
+    return 3; // very loose
+}
+function computeBadness(r) {
+    const absR = Math.abs(r);
+    const b = Math.round(100 * absR * absR * absR);
+    return Math.min(b, BADNESS_CAP);
+}
+// ---------------------------------------------------------------------------
+// Core DP: compute optimal breakpoints
+// ---------------------------------------------------------------------------
+export function computeBreakpoints(items, options) {
+    const { lineWidth, consecutiveHyphenDemerit = DEFAULT_CONSECUTIVE_HYPHEN_DEMERIT, fitnessClassDemerit = DEFAULT_FITNESS_CLASS_DEMERIT, } = options;
+    // Running totals up to current item
+    let sumWidth = 0;
+    let sumStretch = 0;
+    let sumShrink = 0;
+    // Prefix sums: sumWidthAt[i] = sum of widths of items 0..i-1
+    // We build these incrementally and store for the range computations.
+    const sumWidthAt = [0];
+    const sumStretchAt = [0];
+    const sumShrinkAt = [0];
+    for (const item of items) {
+        if (item.type === 'box') {
+            sumWidth += item.width;
+        }
+        else if (item.type === 'glue') {
+            sumWidth += item.width;
+            sumStretch += item.stretch;
+            sumShrink += item.shrink;
+        }
+        // Penalties don't contribute to running width/stretch/shrink
+        sumWidthAt.push(sumWidth);
+        sumStretchAt.push(sumStretch);
+        sumShrinkAt.push(sumShrink);
+    }
+    // Seed active node list with a "start of paragraph" sentinel
+    let activeNodes = [{
+            position: -1,
+            line: 0,
+            fitnessClass: 1,
+            totalWidth: 0,
+            totalStretch: 0,
+            totalShrink: 0,
+            totalDemerits: 0,
+            previous: null,
+        }];
+    for (let i = 0; i < items.length; i++) {
+        const item = items[i];
+        // Determine if this position is a legal breakpoint
+        let isLegalBreak = false;
+        if (item.type === 'glue') {
+            // Glue breaks if preceded by a box
+            if (i > 0 && items[i - 1].type === 'box') {
+                isLegalBreak = true;
+            }
+        }
+        else if (item.type === 'penalty') {
+            if (item.penalty < KP_INFINITY) {
+                isLegalBreak = true;
+            }
+        }
+        if (!isLegalBreak)
+            continue;
+        // Width contribution of breaking at this item
+        const breakWidth = item.type === 'penalty' ? item.width : 0;
+        const isFlagged = item.type === 'penalty' && item.flagged;
+        // For glue breakpoints, the line content goes up to (but excluding) this glue.
+        // For penalty breakpoints, the line content goes up to this penalty.
+        // The content width from after active node a to break at i:
+        //   If glue: sumWidthAt[i] - a.totalWidth  (excludes glue itself)
+        //   If penalty: sumWidthAt[i] - a.totalWidth  (sumWidthAt doesn't include penalty width)
+        // Plus breakWidth for penalties.
+        // Compute the content width from the items between a.position and i.
+        // After the break at active node a.position:
+        //   - If a.position was a glue break, the next line starts at the item AFTER the glue
+        //   - If a.position was a penalty break, the next line starts at the item AFTER the penalty
+        //   - For the sentinel (-1), the line starts at item 0
+        // Total width from start to just before item i (excluding this glue/penalty's own width):
+        //   For a glue at i: line content = sumWidthAt[i] (which includes all box+glue widths before i)
+        //     but we need to subtract the width of glues/boxes after the previous break.
+        //     Actually sumWidthAt[i] already accounts for that.
+        //   We subtract a.totalWidth which is sumWidthAt at the point right after a's break.
+        const newNodes = [];
+        const toDeactivate = new Set();
+        for (let ai = 0; ai < activeNodes.length; ai++) {
+            const a = activeNodes[ai];
+            // Line content width: width of boxes and glues from after a's break to this break.
+            // For glue break: content is items from (a.position+1) to (i-1) inclusive + breakWidth
+            //   = sumWidthAt[i] - a.totalWidth
+            // For penalty break: content is items from (a.position+1) to (i-1) inclusive + penalty.width
+            //   = sumWidthAt[i] - a.totalWidth + breakWidth
+            // Note: sumWidthAt[i] does NOT include item i if it's a penalty.
+            // sumWidthAt[i] includes item i's width only for box/glue through the push.
+            // Wait — re-examine: sumWidthAt[i] is the prefix sum BEFORE item i is processed.
+            // Actually, sumWidthAt has length items.length + 1. sumWidthAt[0] = 0, sumWidthAt[k+1] includes item k.
+            // So sumWidthAt[i] includes items 0..i-1, and sumWidthAt[i+1] includes items 0..i.
+            // For a glue break at position i:
+            //   The line goes from after a's break to just before this glue.
+            //   Content width = sumWidthAt[i] - a.totalWidth
+            //   (sumWidthAt[i] includes items 0..i-1, which covers everything up to but not including the glue)
+            //
+            // For a penalty break at position i:
+            //   The line includes everything up to but not including the penalty, plus breakWidth
+            //   Content width = sumWidthAt[i] - a.totalWidth + breakWidth
+            const contentWidth = sumWidthAt[i] - a.totalWidth + breakWidth;
+            const available = lineWidth(a.line);
+            const slack = available - contentWidth;
+            // Stretch/shrink from the items on this line
+            const lineStretch = sumStretchAt[i] - a.totalStretch;
+            const lineShrink = sumShrinkAt[i] - a.totalShrink;
+            let r;
+            if (slack >= 0) {
+                r = lineStretch > 0 ? slack / lineStretch : KP_INFINITY;
+            }
+            else {
+                r = lineShrink > 0 ? slack / lineShrink : -KP_INFINITY;
+            }
+            // Deactivate nodes that are too far behind (line too wide, can't shrink enough)
+            if (r < -1) {
+                toDeactivate.add(ai);
+                continue;
+            }
+            // Feasibility: don't allow extreme stretching
+            // We allow r up to a generous threshold; the demerits will naturally penalize loose lines
+            if (r > KP_INFINITY) {
+                // Infeasible — too few items to fill the line
+                continue;
+            }
+            const badness = computeBadness(r);
+            const pen = item.type === 'penalty' ? item.penalty : 0;
+            let d;
+            if (pen >= 0) {
+                d = (1 + badness + pen) * (1 + badness + pen);
+            }
+            else if (pen > -KP_INFINITY) {
+                d = (1 + badness) * (1 + badness) - pen * pen;
+            }
+            else {
+                d = (1 + badness) * (1 + badness);
+            }
+            // Consecutive hyphen demerit
+            const prevIsFlagged = a.position >= 0 &&
+                items[a.position].type === 'penalty' &&
+                items[a.position].flagged;
+            if (isFlagged && prevIsFlagged) {
+                d += consecutiveHyphenDemerit;
+            }
+            // Fitness class demerit
+            const fc = classifyFitness(r);
+            if (Math.abs(fc - a.fitnessClass) > 1) {
+                d += fitnessClassDemerit;
+            }
+            const totalDemerits = a.totalDemerits + d;
+            // The total width/stretch/shrink after this break:
+            // After a glue break: the glue is consumed. Next line starts at item i+1.
+            //   totalWidth = sumWidthAt[i+1] (includes the glue's width — but we DON'T want it on the next line)
+            //   Actually, for the "totalWidth" tracked in active nodes, it represents the cumulative
+            //   width at the START of the next line. After a glue break at i, the next line starts at i+1.
+            //   So totalWidth should be sumWidthAt[i+1], which includes the glue.
+            //   When computing content width for the next line: sumWidthAt[j] - totalWidth
+            //   This correctly excludes the consumed glue.
+            //
+            // After a penalty break: the penalty is not consumed as content on the next line.
+            //   totalWidth = sumWidthAt[i+1] (which for penalties is same as sumWidthAt[i] since penalties
+            //   don't add to sumWidth). Wait — let me re-check: penalties don't contribute to sumWidth,
+            //   so sumWidthAt[i+1] == sumWidthAt[i] for a penalty at position i.
+            //   But the next line starts at i+1. So totalWidth = sumWidthAt[i+1].
+            const newTotalWidth = sumWidthAt[i + 1];
+            const newTotalStretch = sumStretchAt[i + 1];
+            const newTotalShrink = sumShrinkAt[i + 1];
+            newNodes.push({
+                position: i,
+                line: a.line + 1,
+                fitnessClass: fc,
+                totalWidth: newTotalWidth,
+                totalStretch: newTotalStretch,
+                totalShrink: newTotalShrink,
+                totalDemerits: totalDemerits,
+                previous: a,
+            });
+        }
+        // Remove deactivated nodes
+        if (toDeactivate.size > 0) {
+            activeNodes = activeNodes.filter((_, idx) => !toDeactivate.has(idx));
+        }
+        // Deduplicate new nodes by (line, fitnessClass): keep best demerits.
+        // Different breakpoint positions must NOT be merged — only nodes at the
+        // same position (which all newNodes share) can be compared.
+        const deduped = [];
+        for (const node of newNodes) {
+            const key = node.line * 4 + node.fitnessClass;
+            let found = false;
+            for (let di = 0; di < deduped.length; di++) {
+                const existing = deduped[di];
+                if (existing.line * 4 + existing.fitnessClass === key) {
+                    if (node.totalDemerits < existing.totalDemerits) {
+                        deduped[di] = node;
+                    }
+                    found = true;
+                    break;
+                }
+            }
+            if (!found) {
+                deduped.push(node);
+            }
+        }
+        // Append all deduplicated nodes to the active set
+        for (const node of deduped) {
+            activeNodes.push(node);
+        }
+        // Forced breaks: when penalty = -INFINITY, remove all active nodes that
+        // are NOT at this position. The break is mandatory — no line can skip it.
+        if (item.type === 'penalty' && item.penalty <= -KP_INFINITY) {
+            activeNodes = activeNodes.filter((a) => a.position === i);
+        }
+        // Emergency fallback: if active set is empty, force a break here
+        if (activeNodes.length === 0) {
+            activeNodes.push({
+                position: i,
+                line: 1, // We lost track — start fresh
+                fitnessClass: 1,
+                totalWidth: sumWidthAt[i + 1],
+                totalStretch: sumStretchAt[i + 1],
+                totalShrink: sumShrinkAt[i + 1],
+                totalDemerits: 0,
+                previous: null,
+            });
+        }
+    }
+    // Find best final node: only consider nodes at the last breakpoint position
+    // (the forced penalty at the end of the paragraph).
+    const lastBreakPosition = items.length - 1;
+    let best = null;
+    for (const a of activeNodes) {
+        if (a.position !== lastBreakPosition)
+            continue;
+        if (best === null || a.totalDemerits < best.totalDemerits) {
+            best = a;
+        }
+    }
+    // Fallback: if no node reached the final position, take any node with the
+    // highest position (nearest to the end).
+    if (!best) {
+        for (const a of activeNodes) {
+            if (a.position < 0)
+                continue;
+            if (best === null || a.position > best.position ||
+                (a.position === best.position && a.totalDemerits < best.totalDemerits)) {
+                best = a;
+            }
+        }
+    }
+    if (!best)
+        return [];
+    // Traceback
+    const breaks = [];
+    let node = best;
+    while (node !== null && node.position >= 0) {
+        breaks.push(node.position);
+        node = node.previous;
+    }
+    breaks.reverse();
+    return breaks;
+}
+// ---------------------------------------------------------------------------
+// Adapter: pretext segments → KPItems
+// ---------------------------------------------------------------------------
+const SOFT_HYPHEN = '\u00AD';
+export function pretextSegmentsToItems(prepared, normalSpaceWidth, maxStretchRatio, minShrinkRatio) {
+    const items = [];
+    const segments = prepared.segments;
+    const widths = prepared.widths;
+    const kinds = prepared.kinds;
+    const discretionaryHyphenWidth = prepared.discretionaryHyphenWidth;
+    const stretchPerSpace = normalSpaceWidth * (maxStretchRatio - 1);
+    const shrinkPerSpace = normalSpaceWidth * (1 - minShrinkRatio);
+    for (let i = 0; i < segments.length; i++) {
+        const kind = kinds[i];
+        const w = widths[i];
+        switch (kind) {
+            case 'text':
+                items.push({ type: 'box', width: w, sourceIndex: i });
+                break;
+            case 'space':
+            case 'glue':
+                items.push({
+                    type: 'glue',
+                    width: w,
+                    stretch: stretchPerSpace,
+                    shrink: shrinkPerSpace,
+                    sourceIndex: i,
+                });
+                break;
+            case 'soft-hyphen':
+                items.push({
+                    type: 'penalty',
+                    width: discretionaryHyphenWidth,
+                    penalty: HYPHEN_PENALTY,
+                    flagged: true,
+                    sourceIndex: i,
+                });
+                break;
+            case 'hard-break':
+                items.push({
+                    type: 'penalty',
+                    width: 0,
+                    penalty: -KP_INFINITY,
+                    flagged: false,
+                    sourceIndex: i,
+                });
+                break;
+            case 'zero-width-break':
+                items.push({
+                    type: 'penalty',
+                    width: 0,
+                    penalty: 0,
+                    flagged: false,
+                    sourceIndex: i,
+                });
+                break;
+            case 'preserved-space':
+            case 'tab':
+                items.push({ type: 'box', width: w, sourceIndex: i });
+                break;
+            default:
+                items.push({ type: 'box', width: w, sourceIndex: i });
+                break;
+        }
+    }
+    // Final-line glue (infinite stretch) + forced break
+    items.push({
+        type: 'glue',
+        width: 0,
+        stretch: MAX_STRETCH,
+        shrink: 0,
+        sourceIndex: -1,
+    });
+    items.push({
+        type: 'penalty',
+        width: 0,
+        penalty: -KP_INFINITY,
+        flagged: false,
+        sourceIndex: -1,
+    });
+    return items;
+}
+export function richTokensToItems(tokens, normalSpaceWidth, maxStretchRatio, minShrinkRatio) {
+    const items = [];
+    const stretchPerSpace = normalSpaceWidth * (maxStretchRatio - 1);
+    const shrinkPerSpace = normalSpaceWidth * (1 - minShrinkRatio);
+    for (let t = 0; t < tokens.length; t++) {
+        const token = tokens[t];
+        const meta = {
+            bold: token.bold,
+            italic: token.italic,
+            originalTokenIndex: t,
+        };
+        if (token.kind === 'space') {
+            items.push({
+                type: 'glue',
+                width: token.width,
+                stretch: stretchPerSpace,
+                shrink: shrinkPerSpace,
+                sourceIndex: t,
+                meta: { ...meta },
+            });
+            continue;
+        }
+        // Text token — may have soft-hyphen break points
+        if (token.breakPoints && token.breakPoints.length > 0) {
+            const hyphenW = token.hyphenWidth ?? 0;
+            let prevCharIndex = 0;
+            let prevWidth = 0;
+            for (let bp = 0; bp < token.breakPoints.length; bp++) {
+                const breakPoint = token.breakPoints[bp];
+                const fragmentWidth = breakPoint.widthBefore - prevWidth;
+                // Box for the fragment before this break point
+                items.push({
+                    type: 'box',
+                    width: fragmentWidth,
+                    sourceIndex: t,
+                    meta: { ...meta, subStart: prevCharIndex, subEnd: breakPoint.charIndex },
+                });
+                // Penalty at the soft hyphen
+                items.push({
+                    type: 'penalty',
+                    width: hyphenW,
+                    penalty: HYPHEN_PENALTY,
+                    flagged: true,
+                    sourceIndex: t,
+                    meta: { ...meta },
+                });
+                prevCharIndex = breakPoint.charIndex;
+                prevWidth = breakPoint.widthBefore;
+            }
+            // Final fragment after last break point
+            items.push({
+                type: 'box',
+                width: token.width - prevWidth,
+                sourceIndex: t,
+                meta: { ...meta, subStart: prevCharIndex, subEnd: token.text.length },
+            });
+        }
+        else {
+            // Simple text token without break points
+            items.push({
+                type: 'box',
+                width: token.width,
+                sourceIndex: t,
+                meta: { ...meta, subStart: 0, subEnd: token.text.length },
+            });
+        }
+    }
+    // Final-line glue + forced break
+    items.push({
+        type: 'glue',
+        width: 0,
+        stretch: MAX_STRETCH,
+        shrink: 0,
+        sourceIndex: -1,
+    });
+    items.push({
+        type: 'penalty',
+        width: 0,
+        penalty: -KP_INFINITY,
+        flagged: false,
+        sourceIndex: -1,
+    });
+    return items;
+}
+// ---------------------------------------------------------------------------
+// Reconstruction: breakpoints → VDTLine[] (pretext path)
+// ---------------------------------------------------------------------------
+function cleanSoftHyphens(text) {
+    return text.replace(/\u00AD/g, '');
+}
+export function reconstructPretextLines(items, breaks, prepared, lineHeightPx, lineWidthFn, lineIndentFn, normalSpaceWidth, textAlign) {
+    const segments = prepared.segments;
+    const widths = prepared.widths;
+    const discretionaryHyphenWidth = prepared.discretionaryHyphenWidth;
+    const lines = [];
+    let lineStart = 0; // item index where current line content starts
+    for (let li = 0; li < breaks.length; li++) {
+        const breakAt = breaks[li];
+        const isLastLine = li === breaks.length - 1;
+        const lineIndent = lineIndentFn(li);
+        const lineMaxWidth = lineWidthFn(li);
+        // Determine if this break is at a penalty (hyphenation)
+        const breakItem = items[breakAt];
+        const hyphenated = breakItem.type === 'penalty' && breakItem.flagged;
+        // Collect segments for this line: items from lineStart to breakAt
+        // For glue breaks: line content is items lineStart..breakAt-1 (exclude the breaking glue)
+        // For penalty breaks: line content is items lineStart..breakAt-1 (exclude the penalty itself)
+        const contentEnd = breakItem.type === 'glue' ? breakAt : breakAt;
+        const lineSegments = [];
+        const textParts = [];
+        for (let j = lineStart; j < contentEnd; j++) {
+            const it = items[j];
+            if (it.sourceIndex < 0)
+                continue; // skip synthetic items
+            if (it.type === 'box') {
+                const seg = segments[it.sourceIndex];
+                const w = widths[it.sourceIndex];
+                if (seg === SOFT_HYPHEN)
+                    continue;
+                const cleanText = cleanSoftHyphens(seg);
+                lineSegments.push({ kind: 'text', text: cleanText, width: w });
+                textParts.push(cleanText);
+            }
+            else if (it.type === 'glue') {
+                const seg = segments[it.sourceIndex];
+                const w = widths[it.sourceIndex];
+                lineSegments.push({ kind: 'space', text: seg, width: w });
+                textParts.push(seg);
+            }
+            // Penalties within the line are skipped (they're just potential break points)
+        }
+        // Trim trailing spaces
+        while (lineSegments.length > 0 && lineSegments[lineSegments.length - 1].kind === 'space') {
+            lineSegments.pop();
+            textParts.pop();
+        }
+        // If hyphenated, append '-' to the last text segment
+        if (hyphenated && lineSegments.length > 0) {
+            const lastIdx = lineSegments.length - 1;
+            const last = lineSegments[lastIdx];
+            if (last.kind === 'text') {
+                lineSegments[lastIdx] = {
+                    kind: 'text',
+                    text: last.text + '-',
+                    width: last.width + discretionaryHyphenWidth,
+                };
+                textParts[textParts.length - 1] = last.text + '-';
+            }
+        }
+        const lineText = textParts.join('');
+        const contentWidth = lineSegments.reduce((s, seg) => s + seg.width, 0);
+        // Compute justifiedSpaceRatio
+        let justifiedSpaceRatio;
+        if (textAlign === 'justify' && !isLastLine && normalSpaceWidth > 0) {
+            let wordWidth = 0;
+            let spaceCount = 0;
+            for (const seg of lineSegments) {
+                if (seg.kind === 'space')
+                    spaceCount++;
+                else
+                    wordWidth += seg.width;
+            }
+            if (spaceCount > 0) {
+                const justifiedSpaceWidth = (lineMaxWidth - wordWidth) / spaceCount;
+                justifiedSpaceRatio = justifiedSpaceWidth / normalSpaceWidth;
+            }
+        }
+        lines.push({
+            text: lineText,
+            bbox: createBoundingBox(lineIndent, li * lineHeightPx, contentWidth, lineHeightPx),
+            baseline: li * lineHeightPx + lineHeightPx * 0.8,
+            hyphenated,
+            segments: lineSegments,
+            isLastLine,
+            ...(justifiedSpaceRatio !== undefined ? { justifiedSpaceRatio } : {}),
+        });
+        // Next line starts after the break
+        lineStart = breakAt + 1;
+    }
+    return lines;
+}
+// ---------------------------------------------------------------------------
+// Reconstruction: breakpoints → VDTLine[] (rich text path)
+// ---------------------------------------------------------------------------
+export function reconstructRichLines(items, breaks, tokens, lineHeightPx, lineWidthFn, lineIndentFn, normalSpaceWidth, textAlign) {
+    const lines = [];
+    let lineStart = 0;
+    for (let li = 0; li < breaks.length; li++) {
+        const breakAt = breaks[li];
+        const isLastLine = li === breaks.length - 1;
+        const lineIndent = lineIndentFn(li);
+        const lineMaxWidth = lineWidthFn(li);
+        const breakItem = items[breakAt];
+        const hyphenated = breakItem.type === 'penalty' && breakItem.flagged;
+        const lineSegments = [];
+        const textParts = [];
+        for (let j = lineStart; j < breakAt; j++) {
+            const it = items[j];
+            if (it.sourceIndex < 0)
+                continue;
+            const meta = it.meta;
+            if (it.type === 'box' && meta) {
+                const token = tokens[meta.originalTokenIndex];
+                const subText = meta.subStart !== undefined && meta.subEnd !== undefined
+                    ? token.text.slice(meta.subStart, meta.subEnd)
+                    : token.text;
+                const cleanText = cleanSoftHyphens(subText);
+                lineSegments.push({
+                    kind: 'text',
+                    text: cleanText,
+                    width: it.width,
+                    bold: meta.bold || undefined,
+                    italic: meta.italic || undefined,
+                });
+                textParts.push(cleanText);
+            }
+            else if (it.type === 'glue' && meta) {
+                const token = tokens[meta.originalTokenIndex];
+                lineSegments.push({
+                    kind: 'space',
+                    text: token.text,
+                    width: it.width,
+                });
+                textParts.push(token.text);
+            }
+        }
+        // Trim trailing spaces
+        while (lineSegments.length > 0 && lineSegments[lineSegments.length - 1].kind === 'space') {
+            lineSegments.pop();
+            textParts.pop();
+        }
+        // If hyphenated, append '-' to the last text segment
+        if (hyphenated && lineSegments.length > 0) {
+            const breakMeta = breakItem.meta;
+            const hyphenW = breakMeta
+                ? (tokens[breakMeta.originalTokenIndex]?.hyphenWidth ?? 0)
+                : 0;
+            const lastIdx = lineSegments.length - 1;
+            const last = lineSegments[lastIdx];
+            if (last.kind === 'text') {
+                lineSegments[lastIdx] = {
+                    ...last,
+                    text: last.text + '-',
+                    width: last.width + hyphenW,
+                };
+                textParts[textParts.length - 1] = last.text + '-';
+            }
+        }
+        const lineText = textParts.join('');
+        const contentWidth = lineSegments.reduce((s, seg) => s + seg.width, 0);
+        // Compute justifiedSpaceRatio
+        let justifiedSpaceRatio;
+        if (textAlign === 'justify' && !isLastLine && normalSpaceWidth > 0) {
+            let wordWidth = 0;
+            let spaceCount = 0;
+            for (const seg of lineSegments) {
+                if (seg.kind === 'space')
+                    spaceCount++;
+                else
+                    wordWidth += seg.width;
+            }
+            if (spaceCount > 0) {
+                const justifiedSpaceWidth = (lineMaxWidth - wordWidth) / spaceCount;
+                justifiedSpaceRatio = justifiedSpaceWidth / normalSpaceWidth;
+            }
+        }
+        lines.push({
+            text: lineText,
+            bbox: createBoundingBox(lineIndent, li * lineHeightPx, contentWidth, lineHeightPx),
+            baseline: li * lineHeightPx + lineHeightPx * 0.8,
+            hyphenated,
+            segments: lineSegments,
+            isLastLine,
+            ...(justifiedSpaceRatio !== undefined ? { justifiedSpaceRatio } : {}),
+        });
+        lineStart = breakAt + 1;
+    }
+    return lines;
+}
+//# sourceMappingURL=knuthPlass.js.map