@stll/folio-core 0.0.1-placeholder.0 → 0.1.1

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

@@ -0,0 +1,23 @@
+import { FontMetrics, FontStyle, RunMeasurement, TextMeasurement } from "./measureTypes.js";
+
+//#region src/layout-engine/measure/measureProvider.d.ts
+/**
+ * Swappable text-measurement backend. A canvas implementation is installed at
+ * the composition roots; a Rust/WASM or headless provider can be installed via
+ * `setMeasureProvider` without the layout engine importing canvas directly.
+ */
+type MeasureProvider = {
+  getFontMetrics: (style: FontStyle) => FontMetrics;
+  measureTextWidth: (text: string, style: FontStyle) => number;
+  measureText: (text: string, style: FontStyle) => TextMeasurement;
+  measureRun: (text: string, style: FontStyle) => RunMeasurement;
+};
+declare const getMeasureProvider: () => MeasureProvider;
+declare const setMeasureProvider: (provider: MeasureProvider) => void;
+declare const resetMeasureProvider: () => void;
+declare const getFontMetrics: (style: FontStyle) => FontMetrics;
+declare const measureTextWidth: (text: string, style: FontStyle) => number;
+declare const measureText: (text: string, style: FontStyle) => TextMeasurement;
+declare const measureRun: (text: string, style: FontStyle) => RunMeasurement;
+//#endregion
+export { MeasureProvider, getFontMetrics, getMeasureProvider, measureRun, measureText, measureTextWidth, resetMeasureProvider, setMeasureProvider };

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

@@ -0,0 +1,35 @@
+import { panic } from "better-result";
+//#region src/layout-engine/measure/measureProvider.ts
+/**
+* Swappable text-measurement seam.
+*
+* Holds the provider interface, the active-provider registry, and the four
+* public delegators the layout engine measures through. This module is pure:
+* it never imports the canvas backend, so the engine's import graph stays
+* canvas-free. The default provider throws — a composition root must install a
+* concrete backend first (the React editor and the bun test preload call
+* `installCanvasMeasureProvider()`).
+*/
+const throwingMeasureProvider = {
+	getFontMetrics: () => noProvider(),
+	measureTextWidth: () => noProvider(),
+	measureText: () => noProvider(),
+	measureRun: () => noProvider()
+};
+function noProvider() {
+	panic("No MeasureProvider installed — install canvasMeasureProvider (the React editor and the test preload do this).");
+}
+let activeMeasureProvider = throwingMeasureProvider;
+const getMeasureProvider = () => activeMeasureProvider;
+const setMeasureProvider = (provider) => {
+	activeMeasureProvider = provider;
+};
+const resetMeasureProvider = () => {
+	activeMeasureProvider = throwingMeasureProvider;
+};
+const getFontMetrics = (style) => activeMeasureProvider.getFontMetrics(style);
+const measureTextWidth = (text, style) => activeMeasureProvider.measureTextWidth(text, style);
+const measureText = (text, style) => activeMeasureProvider.measureText(text, style);
+const measureRun = (text, style) => activeMeasureProvider.measureRun(text, style);
+//#endregion
+export { getFontMetrics, getMeasureProvider, measureRun, measureText, measureTextWidth, resetMeasureProvider, setMeasureProvider };

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

@@ -0,0 +1,61 @@
+declare namespace measureTypes_d_exports {
+  export { FontMetrics, FontStyle, RunMeasurement, TextMeasurement };
+}
+/**
+ * Measurement data shapes.
+ *
+ * Pure type declarations shared by the provider seam (`measureProvider.ts`),
+ * the pure helpers (`measureHelpers.ts`), and the canvas implementation
+ * (`measureContainer.ts`). Types only — this module has no runtime and never
+ * pulls canvas/DOM into an importer's graph.
+ */
+/**
+ * Font styling properties for measurement
+ */
+type FontStyle = {
+  fontFamily?: string;
+  /**
+   * East-Asian font for CJK code points. When set, `measureTextWidth` /
+   * `measureRun` measure CJK code points with this font and the rest with
+   * `fontFamily`, matching the painter's per-script span split so wrapping
+   * and click positioning stay in sync.
+   */
+  eastAsiaFontFamily?: string;
+  fontSize?: number;
+  bold?: boolean;
+  italic?: boolean;
+  letterSpacing?: number;
+  textTransform?: "uppercase";
+  fontVariant?: "small-caps";
+  horizontalScale?: number;
+};
+/**
+ * Typography metrics for a font
+ */
+type FontMetrics = {
+  fontSize: number;
+  ascent: number;
+  descent: number;
+  lineHeight: number;
+  fontFamily: string; /** OS/2 single-line ratio for OOXML line spacing calculation */
+  singleLineRatio: number;
+};
+/**
+ * Result of measuring a text string
+ */
+type TextMeasurement = {
+  width: number;
+  height: number;
+  ascent: number;
+  descent: number;
+};
+/**
+ * Result of measuring a run of text
+ */
+type RunMeasurement = {
+  width: number;
+  charWidths: number[];
+  metrics: FontMetrics;
+};
+//#endregion
+export { FontMetrics, FontStyle, RunMeasurement, TextMeasurement, measureTypes_d_exports };

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

@@ -0,0 +1,54 @@
+import { MeasureWorkerRequest, MeasureWorkerResponse } from "./measureWorkerProtocol.js";
+
+//#region src/layout-engine/measure/measureWorker.d.ts
+/**
+ * Minimal duck-typed transport so tests can supply a fake instead of a
+ * real `Worker`. Mirrors the subset of `Worker` we use.
+ */
+type MeasureWorkerTransport = {
+  postMessage: (message: MeasureWorkerRequest) => void;
+  addEventListener: {
+    (type: "message", listener: (event: {
+      data: MeasureWorkerResponse;
+    }) => void): void;
+    (type: "error", listener: (event: unknown) => void): void;
+  };
+  terminate: () => void;
+};
+type TransportFactory = () => MeasureWorkerTransport;
+/**
+ * Test-only: inject a transport factory in place of the real `Worker`
+ * constructor. Pass `null` to restore production behaviour.
+ */
+declare function __setMeasureWorkerTransport(factory: TransportFactory | null): void;
+/**
+ * Enqueue a measurement for asynchronous pre-warming. Returns
+ * immediately. The caller has already filled the cache synchronously
+ * for the *current* probe; this prefetch is only useful for *future*
+ * probes (re-layouts triggered by font-ready, page-resize, or
+ * suggestion-mode toggles, which all re-measure the same runs).
+ *
+ * No-op when the feature flag is OFF, when the host lacks
+ * `OffscreenCanvas`/`Worker`, or when the proxy has been disabled by
+ * a previous error.
+ */
+declare function prefetchMeasurement(text: string, font: string, letterSpacing: number, horizontalScale: number, fontCacheKey: string, fontFingerprintWidth: number): void;
+declare function canPrefetchMeasurement(): boolean;
+/**
+ * Test-only: synchronously drain the pending queue. The caller is
+ * expected to have already attached its assertions to the cache or to
+ * the injected transport.
+ */
+declare function __flushMeasureQueueForTests(): void;
+/**
+ * Test-only: dispose the proxy. Safe to call when nothing is live.
+ */
+declare function __disposeMeasureProxyForTests(): void;
+/**
+ * Test-only: report whether the proxy considers itself alive. Useful
+ * for asserting that flag/feature-detection gating actually short-
+ * circuits worker construction.
+ */
+declare function __isMeasureProxyLiveForTests(): boolean;
+//#endregion
+export { MeasureWorkerTransport, __disposeMeasureProxyForTests, __flushMeasureQueueForTests, __isMeasureProxyLiveForTests, __setMeasureWorkerTransport, canPrefetchMeasurement, prefetchMeasurement };

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

@@ -0,0 +1,249 @@
+import { getTextWidthCacheGeneration, setCachedTextWidth } from "./cache.js";
+import { isWorkerFontMetricsEnabled } from "./featureFlags.js";
+//#region src/layout-engine/measure/measureWorker.ts
+/**
+* Main-thread proxy for the off-main-thread font-measurement worker.
+*
+* Lifecycle:
+*   1. Caller enqueues a request via `prefetchMeasurement`.
+*   2. The proxy debounces and batches enqueued requests on a ~10 ms
+*      tick, deduping by cache key.
+*   3. The flushed batch is posted to the worker.
+*   4. The worker replies with widths; the proxy writes them into the
+*      main-thread LRU cache via `setCachedTextWidth`.
+*
+* The proxy is **never** on the critical path. `measureTextWidth` on
+* the main thread always returns synchronously from either the cache or
+* a direct canvas read. The worker only pre-warms entries so subsequent
+* re-layout passes (font-ready, page-resize, suggestion-mode toggles)
+* hit the cache instead of the main-thread canvas.
+*
+* Gating:
+*   - `isWorkerFontMetricsEnabled()` is checked on every enqueue. If
+*     the flag is OFF, the function is a no-op and no worker is ever
+*     constructed.
+*   - `OffscreenCanvas` and `Worker` are feature-detected at first
+*     enqueue. Missing either disables the proxy for the session.
+*   - Any worker construction or message-port error disables the proxy
+*     for the session; subsequent enqueues are no-ops.
+*
+* Tests inject a fake transport via `__setMeasureWorkerTransport`. In
+* production the transport is `null` and the real `Worker` is
+* constructed on demand.
+*/
+let injectedTransportFactory = null;
+/**
+* Test-only: inject a transport factory in place of the real `Worker`
+* constructor. Pass `null` to restore production behaviour.
+*/
+function __setMeasureWorkerTransport(factory) {
+	injectedTransportFactory = factory;
+	disposeProxy();
+	isDead = false;
+}
+/**
+* True when the host environment exposes both `Worker` and
+* `OffscreenCanvas`. Older Safari, jsdom, SSR, and bun:test (without a
+* DOM shim) all return `false` and route to the main-thread fallback.
+*
+* Detection is intentionally cheap and re-runnable — tests reset
+* globals between cases.
+*/
+function isWorkerMeasurementSupported() {
+	if (injectedTransportFactory !== null) return true;
+	return typeof Worker !== "undefined" && typeof OffscreenCanvas !== "undefined" && typeof URL !== "undefined";
+}
+let state = null;
+let isDead = false;
+/**
+* Dispose any live worker, reset queue. Idempotent. Called when the
+* worker reports an unrecoverable error or when tests swap transports.
+*/
+function disposeProxy(unrecoverable = false) {
+	if (state === null) {
+		if (unrecoverable) isDead = true;
+		return;
+	}
+	state.dead = true;
+	if (state.flushTimer !== null) clearTimeout(state.flushTimer);
+	try {
+		state.transport.terminate();
+	} catch {}
+	state = null;
+	if (unrecoverable) isDead = true;
+}
+function makeKey(text, fontCacheKey, letterSpacing) {
+	return `${text}|${fontCacheKey}|${letterSpacing}`;
+}
+function createTransport() {
+	if (injectedTransportFactory !== null) try {
+		return injectedTransportFactory();
+	} catch {
+		return null;
+	}
+	try {
+		return new Worker(new URL("font-metrics.worker.ts", import.meta.url), { type: "module" });
+	} catch {
+		return null;
+	}
+}
+function ensureProxy() {
+	if (isDead) return null;
+	if (state !== null) return state.dead ? null : state;
+	if (!isWorkerMeasurementSupported()) {
+		isDead = true;
+		return null;
+	}
+	const transport = createTransport();
+	if (transport === null) {
+		isDead = true;
+		return null;
+	}
+	const next = {
+		transport,
+		pending: /* @__PURE__ */ new Map(),
+		inFlightGenerations: /* @__PURE__ */ new Map(),
+		flushTimer: null,
+		nextRequestId: 0,
+		dead: false
+	};
+	transport.addEventListener("message", (event) => {
+		handleResponse(next, event.data);
+	});
+	transport.addEventListener("error", () => {
+		disposeProxy(true);
+	});
+	state = next;
+	return state;
+}
+/**
+* How long to wait before flushing the queue, in milliseconds. Short
+* enough to keep the worker warm and ahead of the binary-search probes,
+* long enough to amortise `postMessage` overhead across a typical
+* paragraph's worth of probes.
+*/
+const FLUSH_INTERVAL_MS = 10;
+/**
+* Cap on entries per round trip. Prevents one runaway paragraph (think
+* an unbroken 200 KB CDATA dump from a paste) from monopolising a
+* single message. Excess entries flush on the next tick.
+*/
+const MAX_BATCH_SIZE = 256;
+function scheduleFlush(current) {
+	if (current.flushTimer !== null) return;
+	current.flushTimer = setTimeout(() => {
+		current.flushTimer = null;
+		flush(current);
+	}, FLUSH_INTERVAL_MS);
+}
+function flush(current) {
+	if (current.pending.size === 0 || current.dead) return;
+	const cacheGeneration = getTextWidthCacheGeneration();
+	const entries = [];
+	for (const entry of current.pending.values()) {
+		if (entries.length >= MAX_BATCH_SIZE) break;
+		current.pending.delete(makeKey(entry.text, entry.fontCacheKey, entry.letterSpacing));
+		if (entry.cacheGeneration !== cacheGeneration) continue;
+		entries.push({
+			text: entry.text,
+			font: entry.font,
+			fontCacheKey: entry.fontCacheKey,
+			fontFingerprintWidth: entry.fontFingerprintWidth,
+			letterSpacing: entry.letterSpacing,
+			horizontalScale: entry.horizontalScale
+		});
+	}
+	if (entries.length === 0) {
+		if (current.pending.size > 0) scheduleFlush(current);
+		return;
+	}
+	const id = current.nextRequestId;
+	current.nextRequestId += 1;
+	current.inFlightGenerations.set(id, cacheGeneration);
+	try {
+		current.transport.postMessage({
+			type: "measure",
+			id,
+			entries
+		});
+	} catch {
+		current.inFlightGenerations.delete(id);
+		disposeProxy(true);
+		return;
+	}
+	if (current.pending.size > 0) scheduleFlush(current);
+}
+function handleResponse(current, message) {
+	if (state !== current || current.dead) return;
+	const requestGeneration = current.inFlightGenerations.get(message.id);
+	current.inFlightGenerations.delete(message.id);
+	if (requestGeneration === void 0) return;
+	if (!message.ok) {
+		disposeProxy(true);
+		return;
+	}
+	if (requestGeneration !== getTextWidthCacheGeneration()) return;
+	for (const entry of message.entries) setCachedTextWidth(entry.text, entry.fontCacheKey, entry.letterSpacing, entry.width);
+}
+/**
+* Enqueue a measurement for asynchronous pre-warming. Returns
+* immediately. The caller has already filled the cache synchronously
+* for the *current* probe; this prefetch is only useful for *future*
+* probes (re-layouts triggered by font-ready, page-resize, or
+* suggestion-mode toggles, which all re-measure the same runs).
+*
+* No-op when the feature flag is OFF, when the host lacks
+* `OffscreenCanvas`/`Worker`, or when the proxy has been disabled by
+* a previous error.
+*/
+function prefetchMeasurement(text, font, letterSpacing, horizontalScale, fontCacheKey, fontFingerprintWidth) {
+	if (!isWorkerFontMetricsEnabled()) return;
+	if (!text) return;
+	const current = ensureProxy();
+	if (current === null) return;
+	const key = makeKey(text, fontCacheKey, letterSpacing);
+	if (current.pending.has(key)) return;
+	current.pending.set(key, {
+		text,
+		font,
+		fontCacheKey,
+		fontFingerprintWidth,
+		letterSpacing,
+		horizontalScale,
+		cacheGeneration: getTextWidthCacheGeneration()
+	});
+	scheduleFlush(current);
+}
+function canPrefetchMeasurement() {
+	return isWorkerFontMetricsEnabled() && !isDead && isWorkerMeasurementSupported();
+}
+/**
+* Test-only: synchronously drain the pending queue. The caller is
+* expected to have already attached its assertions to the cache or to
+* the injected transport.
+*/
+function __flushMeasureQueueForTests() {
+	if (state === null) return;
+	if (state.flushTimer !== null) {
+		clearTimeout(state.flushTimer);
+		state.flushTimer = null;
+	}
+	flush(state);
+}
+/**
+* Test-only: dispose the proxy. Safe to call when nothing is live.
+*/
+function __disposeMeasureProxyForTests() {
+	disposeProxy();
+	isDead = false;
+}
+/**
+* Test-only: report whether the proxy considers itself alive. Useful
+* for asserting that flag/feature-detection gating actually short-
+* circuits worker construction.
+*/
+function __isMeasureProxyLiveForTests() {
+	return state !== null && !state.dead;
+}
+//#endregion
+export { __disposeMeasureProxyForTests, __flushMeasureQueueForTests, __isMeasureProxyLiveForTests, __setMeasureWorkerTransport, canPrefetchMeasurement, prefetchMeasurement };

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

@@ -0,0 +1,88 @@
+//#region src/layout-engine/measure/measureWorkerProtocol.d.ts
+/**
+ * Wire format shared between the main-thread proxy
+ * (`measureWorker.ts`) and the worker entry
+ * (`font-metrics.worker.ts`).
+ *
+ * The protocol is intentionally minimal: a batched request carrying an
+ * array of measurement inputs, and a matching response with widths in
+ * the same order. The worker is a pure function — no state, no cache.
+ * The main thread owns the LRU cache and is the sole authority on what
+ * is worth measuring.
+ *
+ * Keep this file tiny and dependency-free so it can be imported from
+ * both contexts.
+ */
+/**
+ * Single measurement request inside a batch. Mirrors the inputs that
+ * `measureTextWidth` already takes on the main thread.
+ *
+ * `font` is the already-built CSS font string (output of
+ * `buildFontString`) so the worker does not need to know about the font
+ * resolver or `FontStyle` shape.
+ *
+ * `horizontalScale` is the multiplier (1.0 = 100 %), so the worker can
+ * apply it after the canvas measurement and return the final width.
+ *
+ * `fontCacheKey` is the main-thread cache identity. It intentionally
+ * differs from `font` when scale metadata is appended.
+ *
+ * `fontFingerprintWidth` is the main-thread width for
+ * `WORKER_FONT_FINGERPRINT_TEXT` in the same `font`. The worker checks
+ * the same sentinel before measuring and skips entries whose font
+ * metrics do not match, which prevents worker fallback fonts from
+ * poisoning the main-thread cache.
+ */
+type MeasureRequestEntry = {
+  text: string;
+  font: string;
+  fontCacheKey: string;
+  fontFingerprintWidth: number;
+  letterSpacing: number;
+  horizontalScale: number;
+};
+declare const WORKER_FONT_FINGERPRINT_TEXT = "HAMBURGEFONTS ivwqy 0123456789";
+/**
+ * Count whole code points (not UTF-16 units) so letter spacing is applied once
+ * per rendered glyph — an astral character is one glyph spanning two units.
+ * Shared by the main thread (`measureContainer`) and the worker so their cached
+ * widths agree on astral text with letter spacing. Allocation-free.
+ */
+declare function countCodePoints(text: string): number;
+/**
+ * Worker → main response for a single entry. Echoes the input keys the
+ * proxy needs in order to look up the right cache slot.
+ */
+type MeasureResponseEntry = {
+  text: string;
+  fontCacheKey: string;
+  letterSpacing: number;
+  width: number;
+};
+/**
+ * `main → worker` message. `id` lets the proxy reject stale batches if
+ * the worker is replaced mid-flight.
+ */
+type MeasureWorkerRequest = {
+  type: "measure";
+  id: number;
+  entries: readonly MeasureRequestEntry[];
+};
+/**
+ * `worker → main` message. `ok: false` means the worker hit an
+ * unrecoverable error (e.g., no `OffscreenCanvas` after all); the proxy
+ * disables itself for the session.
+ */
+type MeasureWorkerResponse = {
+  type: "measure-result";
+  id: number;
+  ok: true;
+  entries: readonly MeasureResponseEntry[];
+} | {
+  type: "measure-result";
+  id: number;
+  ok: false;
+  error: string;
+};
+//#endregion
+export { MeasureRequestEntry, MeasureResponseEntry, MeasureWorkerRequest, MeasureWorkerResponse, WORKER_FONT_FINGERPRINT_TEXT, countCodePoints };

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

@@ -0,0 +1,20 @@
+//#region src/layout-engine/measure/measureWorkerProtocol.ts
+const WORKER_FONT_FINGERPRINT_TEXT = "HAMBURGEFONTS ivwqy 0123456789";
+/**
+* Count whole code points (not UTF-16 units) so letter spacing is applied once
+* per rendered glyph — an astral character is one glyph spanning two units.
+* Shared by the main thread (`measureContainer`) and the worker so their cached
+* widths agree on astral text with letter spacing. Allocation-free.
+*/
+function countCodePoints(text) {
+	let count = 0;
+	let i = 0;
+	while (i < text.length) {
+		const code = text.codePointAt(i);
+		i += code !== void 0 && code > 65535 ? 2 : 1;
+		count += 1;
+	}
+	return count;
+}
+//#endregion
+export { WORKER_FONT_FINGERPRINT_TEXT, countCodePoints };

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

@@ -0,0 +1,26 @@
+import { TableCell, TableCellMeasure } from "../types.js";
+import { FloatingImageZone } from "./floatingZones.js";
+
+//#region src/layout-engine/measure/tableCellFloating.d.ts
+type TableCellFloatingImage = {
+  src: string;
+  width: number;
+  height: number;
+  alt?: string;
+  transform?: string;
+  x: number;
+  y: number;
+  side: "left" | "right";
+  distTop: number;
+  distBottom: number;
+  distLeft: number;
+  distRight: number;
+  wrapText?: "bothSides" | "left" | "right" | "largest";
+  pmStart?: number;
+  pmEnd?: number;
+};
+declare function getTableCellContentWidth(cell: TableCell | undefined, cellMeasure: TableCellMeasure): number;
+declare function getTableCellFloatingImages(cell: TableCell, cellMeasure: TableCellMeasure, contentWidth: number): TableCellFloatingImage[];
+declare function buildTableCellFloatingZones(floatingImages: TableCellFloatingImage[], contentWidth: number): FloatingImageZone[];
+//#endregion
+export { TableCellFloatingImage, buildTableCellFloatingZones, getTableCellContentWidth, getTableCellFloatingImages };

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

@@ -0,0 +1,99 @@
+import { emuToPixels } from "../../utils/units.js";
+import { isFloatingImageRun } from "../types.js";
+import { clampFloatingWrapMargins } from "./clampFloatingWrapMargins.js";
+//#region src/layout-engine/measure/tableCellFloating.ts
+function getTableCellContentWidth(cell, cellMeasure) {
+	const padLeft = cell?.padding?.left ?? 7;
+	const padRight = cell?.padding?.right ?? 7;
+	return Math.max(0, cellMeasure.width - padLeft - padRight);
+}
+function getTableCellFloatingImages(cell, cellMeasure, contentWidth) {
+	const result = [];
+	let paragraphY = 0;
+	for (let blockIndex = 0; blockIndex < cell.blocks.length; blockIndex++) {
+		const block = cell.blocks[blockIndex];
+		if (block?.kind !== "paragraph") {
+			const blockMeasure = cellMeasure.blocks[blockIndex];
+			if (blockMeasure?.kind === "table") paragraphY += blockMeasure.totalHeight;
+			continue;
+		}
+		for (const run of block.runs) {
+			if (run.kind !== "image" || !isFloatingImageRun(run)) continue;
+			const position = run.position;
+			const distTop = run.distTop ?? 0;
+			const distBottom = run.distBottom ?? 0;
+			const distLeft = run.distLeft ?? 12;
+			const distRight = run.distRight ?? 12;
+			let side = "left";
+			let x = 0;
+			if (position?.horizontal) {
+				const horizontal = position.horizontal;
+				if (horizontal.align === "right") {
+					side = "right";
+					x = contentWidth - run.width;
+				} else if (horizontal.align === "left") x = 0;
+				else if (horizontal.align === "center") x = (contentWidth - run.width) / 2;
+				else if (horizontal.posOffset !== void 0) {
+					x = emuToPixels(horizontal.posOffset);
+					side = x > contentWidth / 2 ? "right" : "left";
+				}
+			} else if (run.cssFloat === "right") {
+				side = "right";
+				x = contentWidth - run.width;
+			}
+			let y = paragraphY;
+			if (position?.vertical) {
+				const vertical = position.vertical;
+				if (vertical.posOffset !== void 0) y = paragraphY + emuToPixels(vertical.posOffset);
+				else if (vertical.align === "top") y = 0;
+			}
+			x = Math.max(0, Math.min(x, contentWidth - run.width));
+			let wrapText = "bothSides";
+			if (run.cssFloat === "left") wrapText = "right";
+			else if (run.cssFloat === "right") wrapText = "left";
+			result.push({
+				src: run.src,
+				width: run.width,
+				height: run.height,
+				...run.alt !== void 0 ? { alt: run.alt } : {},
+				...run.transform !== void 0 ? { transform: run.transform } : {},
+				x,
+				y,
+				side,
+				distTop,
+				distBottom,
+				distLeft,
+				distRight,
+				wrapText,
+				...run.pmStart !== void 0 ? { pmStart: run.pmStart } : {},
+				...run.pmEnd !== void 0 ? { pmEnd: run.pmEnd } : {}
+			});
+		}
+		const blockMeasure = cellMeasure.blocks[blockIndex];
+		if (blockMeasure?.kind === "paragraph") paragraphY += blockMeasure.totalHeight;
+	}
+	return result;
+}
+function buildTableCellFloatingZones(floatingImages, contentWidth) {
+	return floatingImages.map((img) => {
+		const rectRight = img.x + img.width + img.distRight;
+		const rectTop = img.y - img.distTop;
+		const rectBottom = img.y + img.height + img.distBottom;
+		let leftMargin = 0;
+		let rightMargin = 0;
+		const wrapText = img.wrapText ?? "bothSides";
+		if (wrapText === "right") leftMargin = rectRight;
+		else if (wrapText === "left") rightMargin = contentWidth - (img.x - img.distLeft);
+		else if (img.side === "left") leftMargin = rectRight;
+		else rightMargin = contentWidth - (img.x - img.distLeft);
+		const clamped = clampFloatingWrapMargins(leftMargin, rightMargin, contentWidth);
+		return {
+			leftMargin: clamped.leftMargin,
+			rightMargin: clamped.rightMargin,
+			topY: rectTop,
+			bottomY: rectBottom
+		};
+	});
+}
+//#endregion
+export { buildTableCellFloatingZones, getTableCellContentWidth, getTableCellFloatingImages };