@stll/folio-core 0.62.0 → 0.63.1

package/dist/layout-engine/measure/crossRunWords.js

@@ -1,9 +1,10 @@
 import { sliceText } from "../../utils/sliceText.js";
 import { splitTrailingToken } from "../../utils/trailingText.js";
+import { automaticRunGap } from "./automaticTextSpacing.js";
 import { resolveEffectiveLineBreakPolicy } from "./effectiveLineBreakPolicy.js";
 import "./lineBreakProvider.js";
 import { findHyphenationBreaks, findWordBreaks } from "./lineBreaks.js";
-import { trimTrailingSpacesAndTabs } from "./lineFitting.js";
+import { trimLineEndWhitespace } from "./lineFitting.js";
 import { measureTextWidth } from "./measureProvider.js";
 import { isSpaceOrTab, isTextRun, runToFontStyle } from "./paragraphMeasureShared.js";
 //#region src/layout-engine/measure/crossRunWords.ts
@@ -33,7 +34,8 @@ function computeTrailingGlueWidths(block) {
 			attrs: block.attrs,
 			run: nextRun
 		}).provider).at(0);
-		widths[index] = measureTextWidth(firstBreak === void 0 ? text : trimTrailingSpacesAndTabs(text.slice(0, firstBreak)), style) + (firstBreak === void 0 ? widths[index + 1] ?? 0 : 0);
+		const leading = firstBreak === void 0 ? text : trimLineEndWhitespace(text.slice(0, firstBreak));
+		widths[index] = automaticRunGap(runs[index], nextRun) + measureTextWidth(leading, style) + (firstBreak === void 0 ? widths[index + 1] ?? 0 : 0);
 	}
 	return widths;
 }
@@ -95,7 +97,8 @@ function computeProtectedCrossRunGlueWidths(block) {
 		}
 		if (unseparatedFollowingText || separator.length === 0 || followingWord.length === 0) continue;
 		const boundary = token.length + separator.length;
-		if (!findWordBreaks(token + separator + followingWord, policy).includes(boundary)) widths[index] = glueWidth;
+		const probe = token + separator + followingWord;
+		if (!findWordBreaks(probe, policy).includes(boundary)) widths[index] = glueWidth;
 	}
 	return widths;
 }
@@ -130,10 +133,11 @@ function collectCrossRunWord({ block, startRunIndex, startChar }) {
 			attrs: block.attrs,
 			run
 		}).provider).at(0);
-		const segmentText = trimTrailingSpacesAndTabs(firstBreak === void 0 ? boundedRemainder : boundedRemainder.slice(0, firstBreak));
+		const segmentText = trimLineEndWhitespace(firstBreak === void 0 ? boundedRemainder : boundedRemainder.slice(0, firstBreak));
 		if (segmentText.length === 0) break;
 		if (segmentText.length > remainingBudget) return;
 		const style = runToFontStyle(run);
+		width += automaticRunGap(segments.at(-1)?.run, run);
 		segments.push({
 			runIndex,
 			startChar: start,
@@ -165,6 +169,7 @@ function measureCrossRunPrefix(word, breakOffset) {
 	for (const segment of word.segments) {
 		const length = Math.min(remaining, segment.text.length);
 		if (length > 0) {
+			width += automaticRunGap(measuredSegments.at(-1)?.run, segment.run);
 			width += measureTextWidth(segment.text.slice(0, length), segment.style);
 			measuredSegments.push(segment);
 		}

package/dist/layout-engine/measure/effectiveLineBreakPolicy.d.ts

@@ -21,8 +21,8 @@ type ResolveEffectiveLineBreakPolicyOptions = {
   run: TextRun;
 };
 /** Resolve all authored line-breaking inputs used while measuring one text run. */
-declare const resolveEffectiveLineBreakPolicy: ({ attrs, run }: ResolveEffectiveLineBreakPolicyOptions) => EffectiveLineBreakPolicy;
+export declare const resolveEffectiveLineBreakPolicy: ({ attrs, run }: ResolveEffectiveLineBreakPolicyOptions) => EffectiveLineBreakPolicy;
 /** Cache fragments for every paragraph attribute consumed by the resolver. */
-declare const lineBreakPolicyCacheParts: (attrs: ParagraphAttrs) => readonly string[];
+export declare const lineBreakPolicyCacheParts: (attrs: ParagraphAttrs) => readonly string[];
 //#endregion
-export { lineBreakPolicyCacheParts, resolveEffectiveLineBreakPolicy };
+export {};

package/dist/layout-engine/measure/effectiveLineBreakPolicy.js

@@ -1,3 +1,4 @@
+import { isCjkFont } from "../../utils/fontResolver.js";
 import { hasCjk } from "../../utils/scriptSegments.js";
 //#region src/layout-engine/measure/effectiveLineBreakPolicy.ts
 const DEFAULT_HYPHENATION_ZONE_TWIPS = 360;
@@ -18,13 +19,14 @@ const resolveEffectiveLineBreakPolicy = ({ attrs, run }) => {
 			...automaticHyphenation?.doNotHyphenateCaps !== void 0 ? { doNotHyphenateCaps: automaticHyphenation.doNotHyphenateCaps } : {},
 			...run.allCaps === true ? { renderedAllCaps: true } : {}
 		},
-		hangingPunctuation: attrs?.overflowPunctuation !== false,
+		hangingPunctuation: attrs?.alignment === "justify" && attrs.overflowPunctuation !== false && attrs.defaultEastAsiaFontFamily !== void 0 && isCjkFont(attrs.defaultEastAsiaFontFamily),
 		automaticHyphenation: resolveAutomaticHyphenation(attrs)
 	};
 };
 /** Cache fragments for every paragraph attribute consumed by the resolver. */
 const lineBreakPolicyCacheParts = (attrs) => {
 	const parts = [];
+	if (attrs.defaultEastAsiaFontFamily !== void 0) parts.push(`default-east-asia-font:${attrs.defaultEastAsiaFontFamily}`);
 	if (attrs.kinsoku !== void 0) parts.push(`kinsoku:${attrs.kinsoku}`);
 	if (attrs.overflowPunctuation !== void 0) parts.push(`overflow-punct:${attrs.overflowPunctuation}`);
 	if (attrs.suppressAutoHyphens !== void 0) parts.push(`suppress-auto-hyphens:${attrs.suppressAutoHyphens}`);

package/dist/layout-engine/measure/featureFlags.d.ts

@@ -15,7 +15,7 @@
  * Flag bag shape. Adding a new flag means adding a key here and a `get*Flag`
  * accessor below.
  */
-type FolioMeasurementFeatureFlags = {
+export type FolioMeasurementFeatureFlags = {
   /**
    * Pre-warm the text-width cache from a Web Worker so cache misses during
    * the line-break binary search become cache hits on subsequent probes.
@@ -34,11 +34,10 @@ declare global {
  * comparison ensures truthy-but-not-true values (strings, numbers) cannot
  * accidentally enable the worker path.
  */
-declare function isWorkerFontMetricsEnabled(): boolean;
+export declare function isWorkerFontMetricsEnabled(): boolean;
 /**
  * Test-only helper to set the flag bag without polluting host state.
  * Production callers should set `globalThis.__folioFeatureFlags` directly.
  */
-declare function setFolioMeasurementFlags(flags: FolioMeasurementFeatureFlags | undefined): void;
-//#endregion
-export { FolioMeasurementFeatureFlags, isWorkerFontMetricsEnabled, setFolioMeasurementFlags };
+export declare function setFolioMeasurementFlags(flags: FolioMeasurementFeatureFlags | undefined): void;
+//#endregion

package/dist/layout-engine/measure/floatingLineClearance.d.ts

@@ -7,7 +7,7 @@ import { FloatingImageZone } from "./floatingZones.js";
  * Without this guard, a near-full-width float (e.g. floating table) produces
  * a ~2px segment that collapses every wrap line to one glyph per row.
  */
-declare const MIN_WRAP_SEGMENT_WIDTH = 24;
+export declare const MIN_WRAP_SEGMENT_WIDTH = 24;
 /**
  * Find the next vertical position at or below `startY` where the available
  * text width is at least `minWidth`. Used to skip lines past stacked floats
@@ -19,6 +19,5 @@ declare const MIN_WRAP_SEGMENT_WIDTH = 24;
  *
  * Coordinates are absolute (i.e., already include any paragraphYOffset).
  */
-declare function findClearLineY(startY: number, lineHeight: number, zones: FloatingImageZone[] | undefined, contentWidth: number, minWidth: number): number;
-//#endregion
-export { MIN_WRAP_SEGMENT_WIDTH, findClearLineY };
+export declare function findClearLineY(startY: number, lineHeight: number, zones: FloatingImageZone[] | undefined, contentWidth: number, minWidth: number): number;
+//#endregion

package/dist/layout-engine/measure/floatingTablePosition.d.ts

@@ -13,11 +13,11 @@ type FloatingTablePageXOptions = {
 /**
  * X of the table's left edge relative to the content-box left edge, px.
  */
-declare function resolveFloatingTableX(anchor: FloatingTablePosition, justification: TableBlock["justification"], tableWidth: number, contentWidth: number): number;
+export declare function resolveFloatingTableX(anchor: FloatingTablePosition, justification: TableBlock["justification"], tableWidth: number, contentWidth: number): number;
 /**
  * Absolute page X after resolving the selected anchor frame and constraining
  * the table to the physical page.
  */
-declare function resolveFloatingTablePageX({ anchor, justification, tableWidth, marginWidth, pageWidth, marginLeft, textFrameWidth, textFrameLeft }: FloatingTablePageXOptions): number;
+export declare function resolveFloatingTablePageX({ anchor, justification, tableWidth, marginWidth, pageWidth, marginLeft, textFrameWidth, textFrameLeft }: FloatingTablePageXOptions): number;
 //#endregion
-export { resolveFloatingTablePageX, resolveFloatingTableX };
+export {};

package/dist/layout-engine/measure/floatingZones.d.ts

@@ -9,13 +9,13 @@
  * of the upstream conversion; without it, body text after a wide float
  * collapses to ~1 glyph per line.
  */
-type WrapTextDirection = "bothSides" | "left" | "right" | "largest";
+export type WrapTextDirection = "bothSides" | "left" | "right" | "largest";
 /**
  * A single floating object's exclusion rectangle in content-area coordinates.
  * Produced from images and anchored text boxes; consumed by
  * `rectsToFloatingZones` to derive per-line wrap margins.
  */
-type FloatingExclusionRect = {
+export type FloatingExclusionRect = {
   /** Which side the object is on for simple one-sided wrapping. */
   side: "left" | "right";
   /** X position relative to the content area. */
@@ -36,7 +36,9 @@ type FloatingExclusionRect = {
  * becomes its own zone so lines at different Y positions get independently
  * correct widths.
  */
-type FloatingImageZone = {
+export type FloatingImageZone = {
+  /** The exclusion is produced by an anchored table rather than a drawing. */
+  source?: "floatingTable";
   /** Left margin reduction (pixels from left edge). */
   leftMargin: number;
   /** Right margin reduction (pixels from right edge). */
@@ -54,11 +56,11 @@ type FloatingImageZone = {
    */
   fullWidthBlock?: boolean;
 };
-type FloatingLineSegmentZone = {
+export type FloatingLineSegmentZone = {
   leftOffset: number;
   availableWidth: number;
 };
-type FloatingLineMargins = {
+export type FloatingLineMargins = {
   leftMargin: number;
   rightMargin: number;
   segments?: FloatingLineSegmentZone[];
@@ -78,7 +80,7 @@ type FloatingLineMargins = {
  *   - `largest`   → pick whichever side has more remaining room and reduce
  *                   the line to that single side (no split).
  */
-declare function rectsToFloatingZones(rects: FloatingExclusionRect[], contentWidth: number): FloatingImageZone[];
+export declare function rectsToFloatingZones(rects: FloatingExclusionRect[], contentWidth: number): FloatingImageZone[];
 /**
  * Effective horizontal text width for a line under the given margins.
  * When the zone provides split segments (centered both-sides wrap), each
@@ -86,12 +88,11 @@ declare function rectsToFloatingZones(rects: FloatingExclusionRect[], contentWid
  * overlapping vertically with the centered float still reduces the budget.
  * Otherwise falls back to `baseWidth - leftMargin - rightMargin`.
  */
-declare function getFloatingAvailableWidth(margins: FloatingLineMargins, baseWidth: number): number;
+export declare function getFloatingAvailableWidth(margins: FloatingLineMargins, baseWidth: number): number;
 /**
  * Calculate width reduction for a line based on floating object zones.
  * Returns the left and right margins (plus optional segments) that apply
  * at this vertical position.
  */
-declare function getFloatingMargins(lineY: number, lineHeight: number, zones: FloatingImageZone[] | undefined, paragraphYOffset: number): FloatingLineMargins;
-//#endregion
-export { FloatingExclusionRect, FloatingImageZone, FloatingLineMargins, FloatingLineSegmentZone, WrapTextDirection, getFloatingAvailableWidth, getFloatingMargins, rectsToFloatingZones };
+export declare function getFloatingMargins(lineY: number, lineHeight: number, zones: FloatingImageZone[] | undefined, paragraphYOffset: number): FloatingLineMargins;
+//#endregion

package/dist/layout-engine/measure/font-metrics.worker.d.ts

@@ -5,12 +5,11 @@ import { MeasureWorkerRequest, MeasureWorkerResponse } from "./measureWorkerProt
  * tests that toggle the global `OffscreenCanvas` between cases. The
  * worker itself never needs this — its lifetime is one tab.
  */
-declare function __resetWorkerCtxForTests(): void;
+export declare function __resetWorkerCtxForTests(): void;
 /**
  * Pure-function entry point. Exported so tests can exercise the worker
  * contract without spawning a real `Worker`. Production code only
  * reaches this via `postMessage`.
  */
-declare function handleMeasureRequest(req: MeasureWorkerRequest): MeasureWorkerResponse;
-//#endregion
-export { __resetWorkerCtxForTests, handleMeasureRequest };
+export declare function handleMeasureRequest(req: MeasureWorkerRequest): MeasureWorkerResponse;
+//#endregion

package/dist/layout-engine/measure/font-metrics.worker.js

@@ -17,7 +17,8 @@ import { TaggedError } from "better-result";
 * that touches `document`, `window`, or React. The protocol module is
 * deliberately dependency-free.
 */
-var WorkerInitError = class extends TaggedError("WorkerInitError") {};
+const WorkerInitErrorBase = TaggedError("WorkerInitError");
+var WorkerInitError = class extends WorkerInitErrorBase {};
 let ctx = null;
 let initError = null;
 const FONT_FINGERPRINT_EPSILON = .01;

package/dist/layout-engine/measure/hyperlinkInstance.d.ts

@@ -1,6 +1,5 @@
 import { HyperlinkInfo } from "../types.js";
 //#region src/layout-engine/measure/hyperlinkInstance.d.ts
-declare const setHyperlinkInstanceIndex: (hyperlink: HyperlinkInfo, instanceIndex: number) => void;
-declare const getHyperlinkInstanceIndex: (hyperlink: HyperlinkInfo) => number | undefined;
-//#endregion
-export { getHyperlinkInstanceIndex, setHyperlinkInstanceIndex };
+export declare const setHyperlinkInstanceIndex: (hyperlink: HyperlinkInfo, instanceIndex: number) => void;
+export declare const getHyperlinkInstanceIndex: (hyperlink: HyperlinkInfo) => number | undefined;
+//#endregion

package/dist/layout-engine/measure/hyphenationDictionaries.d.ts

@@ -1,33 +1,16 @@
+import { TaggedErrorClass } from "better-result";
 //#region src/layout-engine/measure/hyphenationDictionaries.d.ts
-/**
- * On-demand hyphenation dictionaries for automatic hyphenation.
- *
- * Each `hyphen` pattern set is tens to hundreds of kilobytes of source whose
- * evaluation builds a pattern trie, and most documents never enable
- * `w:autoHyphenation`. A dictionary is therefore imported only once measurement
- * asks to hyphenate a word in its language. Measurement is synchronous, so the
- * first request starts the import and hyphenates nothing. A layout run wrapped
- * in {@link collectRequestedHyphenationDictionaries} learns which dictionaries
- * it lacked, so its own editor can re-run layout on load or report the failure
- * (`controller/hyphenationReadiness`). Hosts that must lay out correctly on the
- * first pass (headless layout, tests) await `preloadHyphenationDictionaries`
- * (`./hyphenationPreload`) before measuring.
- *
- * This module sits on every editor's import graph, so it speaks in its own
- * settled-state union rather than `Result`, keeping the `Result` API out of
- * adapters' type checks; the preload boundary converts.
- */
-type HyphenateWord = (text: string) => string;
+export type HyphenateWord = (text: string) => string;
 declare const HYPHENATION_DICTIONARY_IDS: readonly ["cs", "en-gb", "en-us", "sk"];
-type HyphenationDictionaryId = (typeof HYPHENATION_DICTIONARY_IDS)[number];
-type HyphenationDictionaryLoaders = Readonly<Record<HyphenationDictionaryId, () => Promise<HyphenateWord>>>;
-declare const HyphenationDictionaryError_base: import("better-result").TaggedErrorClass<"HyphenationDictionaryError">;
-declare class HyphenationDictionaryError extends HyphenationDictionaryError_base<{
+export type HyphenationDictionaryId = (typeof HYPHENATION_DICTIONARY_IDS)[number];
+export type HyphenationDictionaryLoaders = Readonly<Record<HyphenationDictionaryId, () => Promise<HyphenateWord>>>;
+declare const HyphenationDictionaryErrorBase: TaggedErrorClass<"HyphenationDictionaryError">;
+export declare class HyphenationDictionaryError extends HyphenationDictionaryErrorBase<{
   message: string;
   dictionary: HyphenationDictionaryId;
   cause: unknown;
 }> {}
-type SettledHyphenationDictionary = Readonly<{
+export type SettledHyphenationDictionary = Readonly<{
   status: "loaded";
   hyphenate: HyphenateWord;
 }> | Readonly<{
@@ -41,34 +24,34 @@ type HyphenationDictionaryState = Readonly<{
   promise: Promise<SettledHyphenationDictionary>;
 }> | SettledHyphenationDictionary;
 /** Compare before and after a measurement to tell whether it lacked a dictionary. */
-declare const getHyphenationDictionaryMisses: () => number;
+export declare const getHyphenationDictionaryMisses: () => number;
 /** The dictionary that hyphenates text in `locale`, if one is bundled. */
-declare const hyphenationDictionaryFor: (locale: string | undefined) => HyphenationDictionaryId | undefined;
+export declare const hyphenationDictionaryFor: (locale: string | undefined) => HyphenationDictionaryId | undefined;
 /** Changes whenever a dictionary finishes loading, so measurement caches cannot go stale. */
-declare const getHyphenationDictionaryGeneration: () => number;
+export declare const getHyphenationDictionaryGeneration: () => number;
 /** Load `dictionary` once; later calls share the load or its settled outcome. */
-declare const requestHyphenationDictionary: (dictionary: HyphenationDictionaryId) => Promise<SettledHyphenationDictionary>;
+export declare const requestHyphenationDictionary: (dictionary: HyphenationDictionaryId) => Promise<SettledHyphenationDictionary>;
 /**
  * The loaded hyphenator for `dictionary`, or `undefined` while it is not
  * available. An unloaded dictionary starts loading, and a missing one is
  * recorded against the enclosing {@link collectRequestedHyphenationDictionaries}
  * run; the caller hyphenates nothing now.
  */
-declare const hyphenatorOrRequest: (dictionary: HyphenationDictionaryId) => HyphenateWord | undefined;
-type CollectedHyphenationDictionaries<T> = {
+export declare const hyphenatorOrRequest: (dictionary: HyphenationDictionaryId) => HyphenateWord | undefined;
+export type CollectedHyphenationDictionaries<T> = {
   result: T;
   /** Dictionaries the run needed and did not have: loading or failed. */
   missing: ReadonlySet<HyphenationDictionaryId>;
 };
 /** Run a synchronous layout pass and report the dictionaries it lacked. */
-declare const collectRequestedHyphenationDictionaries: <T>(run: () => T) => CollectedHyphenationDictionaries<T>;
+export declare const collectRequestedHyphenationDictionaries: <T>(run: () => T) => CollectedHyphenationDictionaries<T>;
 /**
  * Test seam: forget every dictionary so a test observes the unloaded path, and
  * optionally load through `loaders` (for example, ones that fail) until the
  * next reset.
  */
-declare const resetHyphenationDictionaries: (loaders?: HyphenationDictionaryLoaders) => void;
+export declare const resetHyphenationDictionaries: (loaders?: HyphenationDictionaryLoaders) => void;
 /** Test seam: which dictionaries have been requested or loaded. */
-declare const hyphenationDictionaryStatus: (dictionary: HyphenationDictionaryId) => HyphenationDictionaryState["status"];
+export declare const hyphenationDictionaryStatus: (dictionary: HyphenationDictionaryId) => HyphenationDictionaryState["status"];
 //#endregion
-export { CollectedHyphenationDictionaries, HyphenateWord, HyphenationDictionaryError, HyphenationDictionaryId, HyphenationDictionaryLoaders, SettledHyphenationDictionary, collectRequestedHyphenationDictionaries, getHyphenationDictionaryGeneration, getHyphenationDictionaryMisses, hyphenationDictionaryFor, hyphenationDictionaryStatus, hyphenatorOrRequest, requestHyphenationDictionary, resetHyphenationDictionaries };
+export {};

package/dist/layout-engine/measure/hyphenationDictionaries.js

@@ -26,13 +26,14 @@ const HYPHENATION_DICTIONARY_IDS = [
 	"sk"
 ];
 const HYPHENATION_DICTIONARY_LOADERS = {
-	cs: async () => (await import("hyphen/cs/index.js")).default.hyphenateSync,
-	"en-gb": async () => (await import("hyphen/en-gb/index.js")).default.hyphenateSync,
-	"en-us": async () => (await import("hyphen/en-us/index.js")).default.hyphenateSync,
-	sk: async () => (await import("hyphen/sk/index.js")).default.hyphenateSync
+	cs: async () => (await import("hyphen/cs")).default.hyphenateSync,
+	"en-gb": async () => (await import("hyphen/en-gb")).default.hyphenateSync,
+	"en-us": async () => (await import("hyphen/en-us")).default.hyphenateSync,
+	sk: async () => (await import("hyphen/sk")).default.hyphenateSync
 };
 let dictionaryLoaders = HYPHENATION_DICTIONARY_LOADERS;
-var HyphenationDictionaryError = class extends TaggedError("HyphenationDictionaryError") {};
+const HyphenationDictionaryErrorBase = TaggedError("HyphenationDictionaryError");
+var HyphenationDictionaryError = class extends HyphenationDictionaryErrorBase {};
 const createInitialStates = () => ({
 	cs: { status: "unloaded" },
 	"en-gb": { status: "unloaded" },

package/dist/layout-engine/measure/hyphenationPreload.d.ts

@@ -6,6 +6,5 @@ import { Result } from "better-result";
  * layout pass hyphenates on its first run. Locales without a dictionary are
  * ignored.
  */
-declare const preloadHyphenationDictionaries: (locales: Iterable<string>) => Promise<Result<void, HyphenationDictionaryError>>;
-//#endregion
-export { preloadHyphenationDictionaries };
+export declare const preloadHyphenationDictionaries: (locales: Iterable<string>) => Promise<Result<void, HyphenationDictionaryError>>;
+//#endregion

package/dist/layout-engine/measure/inlineObjectMetrics.d.ts

@@ -1,6 +1,5 @@
 import { ImageRun, MathRun } from "../types.js";
 //#region src/layout-engine/measure/inlineObjectMetrics.d.ts
-declare function rotatedBlockImageHeight(run: ImageRun): number;
-declare function estimateMathFootprintPx(run: MathRun): number;
-//#endregion
-export { estimateMathFootprintPx, rotatedBlockImageHeight };
+export declare function rotatedBlockImageHeight(run: ImageRun): number;
+export declare function estimateMathFootprintPx(run: MathRun): number;
+//#endregion

package/dist/layout-engine/measure/justification.d.ts

@@ -1,8 +1,8 @@
-import { ParagraphBlock } from "../types.js";
 import { FontStyle } from "./measureTypes.js";
+import { ParagraphBlock } from "../types.js";
 import { LineState } from "./paragraphMeasureShared.js";
 //#region src/layout-engine/measure/justification.d.ts
-declare function uppercaseLetterRatio(text: string): number;
+export declare function uppercaseLetterRatio(text: string): number;
 type JustifyFitStrategy = {
   type: "rounding";
 } | {
@@ -12,12 +12,12 @@ type JustifyFitStrategy = {
   type: "width";
   ratio: number;
 };
-type JustificationProfile = {
+export type JustificationProfile = {
   hasTabRuns: boolean;
   uppercaseRatio: number;
 };
-declare function resolveJustifyFitStrategy(block: ParagraphBlock, isFirstLine: boolean, profile: JustificationProfile): JustifyFitStrategy;
-declare function compressibleSpaceWidth(text: string, style: FontStyle): number;
+export declare function resolveJustifyFitStrategy(block: ParagraphBlock, isFirstLine: boolean, profile: JustificationProfile): JustifyFitStrategy;
+export declare function compressibleSpaceWidth(text: string, style: FontStyle): number;
 /**
  * Content being fitted onto a justified line: the line width with it added,
  * and the width of spaces inside it that stay on the line (an atomic field
@@ -27,6 +27,6 @@ type JustifyCandidate = {
   width: number;
   innerSpaceWidth: number;
 };
-declare function justifyFitTolerance(line: LineState, strategy: JustifyFitStrategy, candidateSpaceWidth: number, candidate?: JustifyCandidate): number;
+export declare function justifyFitTolerance(line: LineState, strategy: JustifyFitStrategy, candidateSpaceWidth: number, candidate?: JustifyCandidate): number;
 //#endregion
-export { JustificationProfile, compressibleSpaceWidth, justifyFitTolerance, resolveJustifyFitStrategy, uppercaseLetterRatio };
+export {};

package/dist/layout-engine/measure/lineBreakProvider.d.ts

@@ -7,7 +7,7 @@
  * default provider uses the platform's Unicode segmenter, then applies the
  * OOXML line-edge restrictions that are available in the flow model.
  */
-type LineBreakPolicy = {
+export type LineBreakPolicy = {
   /** BCP-47 language tag resolved from `w:lang` for this run. */
   locale?: string;
   /** Apply East Asian first/last-character restrictions (`w:kinsoku`). */
@@ -23,7 +23,7 @@ type LineBreakPolicy = {
   /** The run renders with the DOCX all-caps transform. */
   renderedAllCaps?: boolean;
 };
-type LineBreakProvider = {
+export type LineBreakProvider = {
   /** Legal soft-wrap offsets, in ascending UTF-16 order. */
   findBreaks: (text: string, policy?: LineBreakPolicy) => number[];
   /** Grapheme-safe emergency-wrap offsets, in ascending UTF-16 order. */
@@ -33,22 +33,27 @@ type LineBreakProvider = {
   /** Whether a trailing grapheme may overhang the line edge. */
   isHangingPunctuation?: (text: string, policy?: LineBreakPolicy) => boolean;
 };
-declare const MAX_HYPHENATION_WORD_LENGTH = 256;
-declare const isNonBreakingGlue: (character: string | undefined) => boolean;
+export declare const MAX_HYPHENATION_WORD_LENGTH = 256;
+export declare const isNonBreakingGlue: (character: string | undefined) => boolean;
 /**
  * Whether glue characters permit a line break between `previous` and `next`.
  * Only the character after the break matters here: glue characters are never
  * break opportunities themselves, so a break after one is never proposed.
  */
-declare const gluePermitsBreakBefore: (previous: string | undefined, next: string | undefined) => boolean;
-declare const defaultLineBreakProvider: LineBreakProvider;
-declare const getLineBreakProvider: () => LineBreakProvider;
+export declare const gluePermitsBreakBefore: (previous: string | undefined, next: string | undefined) => boolean;
+type LineBoundaryOptions = {
+  previous: string | undefined;
+  next: string | undefined;
+};
+export declare const unicodeLineBoundaryPermitsBreak: ({ previous, next }: LineBoundaryOptions) => boolean;
+export declare const defaultLineBreakProvider: LineBreakProvider;
+export declare const getLineBreakProvider: () => LineBreakProvider;
 /**
  * Changes whenever the active provider or a hyphenation dictionary changes, so
  * layout caches cannot go stale. Both counters only grow, so their sum does too.
  */
-declare const getLineBreakProviderGeneration: () => number;
-declare const setLineBreakProvider: (provider: LineBreakProvider) => void;
-declare const resetLineBreakProvider: () => void;
+export declare const getLineBreakProviderGeneration: () => number;
+export declare const setLineBreakProvider: (provider: LineBreakProvider) => void;
+export declare const resetLineBreakProvider: () => void;
 //#endregion
-export { LineBreakPolicy, LineBreakProvider, MAX_HYPHENATION_WORD_LENGTH, defaultLineBreakProvider, getLineBreakProvider, getLineBreakProviderGeneration, gluePermitsBreakBefore, isNonBreakingGlue, resetLineBreakProvider, setLineBreakProvider };
+export {};

package/dist/layout-engine/measure/lineBreakProvider.js

@@ -12,6 +12,11 @@ const SEGMENTER_CACHE_LIMIT = 16;
 const LINE_BREAK_LOCALE_CACHE_LIMIT = 16;
 const DEFAULT_SEGMENTER_KEY = "";
 const SOFT_HYPHEN = "­";
+const ZERO_WIDTH_SPACE = "​";
+const NEXT_LINE = "…";
+const FIRST_COMBINING_MARK_CODE_POINT = 768;
+const COMBINING_MARK = /^\p{Mark}$/u;
+const LETTER = /^\p{Letter}$/u;
 const MAX_HYPHENATION_WORD_LENGTH = 256;
 const wordSegmenters = /* @__PURE__ */ new Map();
 const graphemeSegmenters = /* @__PURE__ */ new Map();
@@ -49,7 +54,7 @@ const BREAK_AFTER_CHARACTER = /* @__PURE__ */ new Set([
 	"゠",
 	"﹣",
 	"－",
-	"​",
+	ZERO_WIDTH_SPACE,
 	"­"
 ]);
 const isGlueCodeUnit = (code) => code >= 160 && (code === 160 || code === 8199 || code === 8209 || code === 8239 || code === 8288 || code === 65279);
@@ -66,6 +71,12 @@ const gluePermitsBreakBefore = (previous, next) => {
 	if (isWordJoinerCodeUnit(next?.charCodeAt(0) ?? 0) || previous === void 0) return false;
 	return isBreakingWhitespace(previous) || BREAK_AFTER_CHARACTER.has(previous);
 };
+const unicodeLineBoundaryPermitsBreak = ({ previous, next }) => {
+	if (next === ZERO_WIDTH_SPACE) return false;
+	if ((previous === "្" || previous === "္") && next !== void 0 && LETTER.test(next)) return false;
+	if (next !== void 0 && next.charCodeAt(0) >= FIRST_COMBINING_MARK_CODE_POINT && COMBINING_MARK.test(next) && previous !== void 0 && previous !== ZERO_WIDTH_SPACE && previous !== NEXT_LINE && !BREAK_AFTER_CHARACTER.has(previous) && !isBreakingWhitespace(previous)) return false;
+	return true;
+};
 const DEFAULT_PROHIBITED_LINE_START = /* @__PURE__ */ new Set([
 	"!",
 	"%",
@@ -177,7 +188,10 @@ const allowsBreak = (text, index, policy, usesEastAsianRules, nextLineStart) =>
 };
 const pushBreak = (breaks, text, index, policy, usesEastAsianRules, nextLineStart) => {
 	if (index <= 0 || index > text.length || breaks.at(-1) === index) return;
-	if (isGlueCodeUnit(text.charCodeAt(index)) && !gluePermitsBreakBefore(previousCodePoint(text, index), text[index])) return;
+	if (text.charCodeAt(index) >= FIRST_COMBINING_MARK_CODE_POINT && !unicodeLineBoundaryPermitsBreak({
+		previous: previousCodePoint(text, index),
+		next: firstCodePoint(text, index)
+	}) || isGlueCodeUnit(text.charCodeAt(index)) && !gluePermitsBreakBefore(previousCodePoint(text, index), text[index])) return;
 	if (allowsBreak(text, index, policy, usesEastAsianRules, nextLineStart)) breaks.push(index);
 };
 const findSimpleGraphemeBreaks = (text) => {
@@ -197,7 +211,18 @@ const findUnicodeGraphemeBreaks = (text, policy) => {
 	const breaks = [];
 	for (const segment of getSegmenter(graphemeSegmenters, "grapheme", policy?.locale).segment(text)) {
 		const end = segment.index + segment.segment.length;
-		breaks.push(end);
+		let position = segment.index;
+		for (const character of segment.segment) {
+			position += character.length;
+			if (position < end && (isBreakingWhitespace(character) || BREAK_AFTER_CHARACTER.has(character)) && unicodeLineBoundaryPermitsBreak({
+				previous: character,
+				next: firstCodePoint(text, position)
+			})) breaks.push(position);
+		}
+		if (unicodeLineBoundaryPermitsBreak({
+			previous: previousCodePoint(text, end),
+			next: firstCodePoint(text, end)
+		})) breaks.push(end);
 	}
 	return breaks;
 };
@@ -328,4 +353,4 @@ const resetLineBreakProvider = () => {
 	lineBreakProviderGeneration += 1;
 };
 //#endregion
-export { MAX_HYPHENATION_WORD_LENGTH, defaultLineBreakProvider, getLineBreakProvider, getLineBreakProviderGeneration, gluePermitsBreakBefore, isNonBreakingGlue, resetLineBreakProvider, setLineBreakProvider };
+export { MAX_HYPHENATION_WORD_LENGTH, defaultLineBreakProvider, getLineBreakProvider, getLineBreakProviderGeneration, gluePermitsBreakBefore, isNonBreakingGlue, resetLineBreakProvider, setLineBreakProvider, unicodeLineBoundaryPermitsBreak };

package/dist/layout-engine/measure/lineBreaks.d.ts

@@ -5,15 +5,14 @@ import { LineBreakPolicy } from "./lineBreakProvider.js";
  * whitespace or hyphen; CJK text can break after every ideograph so a
  * partial line is filled instead of pushing the whole run to the next line.
  */
-declare const findWordBreaks: (text: string, policy?: LineBreakPolicy) => number[];
-declare const findGraphemeBreaks: (text: string, policy?: LineBreakPolicy) => number[];
-declare const findHyphenationBreaks: (text: string, policy?: LineBreakPolicy) => number[];
-declare const isHangingPunctuation: (text: string, policy?: LineBreakPolicy) => boolean;
-declare function isBreakChar(char: string | undefined): boolean;
+export declare const findWordBreaks: (text: string, policy?: LineBreakPolicy) => number[];
+export declare const findGraphemeBreaks: (text: string, policy?: LineBreakPolicy) => number[];
+export declare const findHyphenationBreaks: (text: string, policy?: LineBreakPolicy) => number[];
+export declare const isHangingPunctuation: (text: string, policy?: LineBreakPolicy) => boolean;
+export declare function isBreakChar(char: string | undefined): boolean;
 /**
  * Whether a line may break at a run boundary, between the last character of
  * one run and the first character of the text that follows it.
  */
-declare function isBreakBetween(previous: string | undefined, next: string | undefined): boolean;
-//#endregion
-export { findGraphemeBreaks, findHyphenationBreaks, findWordBreaks, isBreakBetween, isBreakChar, isHangingPunctuation };
+export declare function isBreakBetween(previous: string | undefined, next: string | undefined): boolean;
+//#endregion

package/dist/layout-engine/measure/lineBreaks.js

@@ -1,5 +1,5 @@
 import { isCjkCodePoint } from "../../utils/scriptSegments.js";
-import { defaultLineBreakProvider, getLineBreakProvider, gluePermitsBreakBefore, isNonBreakingGlue } from "./lineBreakProvider.js";
+import { defaultLineBreakProvider, getLineBreakProvider, gluePermitsBreakBefore, isNonBreakingGlue, unicodeLineBoundaryPermitsBreak } from "./lineBreakProvider.js";
 //#region src/layout-engine/measure/lineBreaks.ts
 /**
 * Indices in `text` where a line may end. Latin text breaks after
@@ -24,7 +24,10 @@ function isBreakChar(char) {
 * one run and the first character of the text that follows it.
 */
 function isBreakBetween(previous, next) {
-	return isBreakChar(previous) && gluePermitsBreakBefore(previous, next);
+	return isBreakChar(previous) && gluePermitsBreakBefore(previous, next) && unicodeLineBoundaryPermitsBreak({
+		previous,
+		next
+	});
 }
 //#endregion
 export { findGraphemeBreaks, findHyphenationBreaks, findWordBreaks, isBreakBetween, isBreakChar, isHangingPunctuation };