rapier-markdown-kit 1.2.8 → 1.2.9

package/dist/layout/preparation.mjs

@@ -3,11 +3,6 @@ import {clearCache, setLocale} from '../agent/vendor/pretext/layout.js';
 import {prepareRichInline} from '../agent/vendor/pretext/rich-inline.js';
 import {prepareParagraphCandidateSteps, createParagraphObserver} from './prepared-paragraph.mjs';
 
-// One metric authority for this loaded vendor graph. Document/face/paragraph identities are
-// weak; a width is never part of source preparation. A separate captured fitting operation
-// completes its requested interval facts before its immutable plan is ready. A font-string
-// cache must be retired when the actual face changes, even if a replacement kept its family
-// and all its CSS descriptors.
 const documents = new WeakMap(), faces = new WeakMap(), paragraphs = new WeakMap();
 let faceId = 0, generation = 0, language;
 const descriptors = ['family', 'style', 'weight', 'stretch', 'unicodeRange', 'status',
@@ -17,8 +12,10 @@ const finite = value => typeof value === 'number' && Number.isFinite(value);
 
 function clearMetrics() { clearCache(); return ++generation; }
 
+let turn = null;
 export function captureFontAuthority(document = globalThis.document) {
   if (!document || typeof document !== 'object') return generation;
+  if (turn?.document === document && turn.generation === generation) return generation;
   const previous = documents.get(document), declared = previous?.declared || new Set();
   const entries = [];
   try {
@@ -34,12 +31,13 @@ export function captureFontAuthority(document = globalThis.document) {
     documents.set(document, {signature, declared});
     clearMetrics();
   }
+  if (!turn) queueMicrotask(() => { turn = null; });
+  turn = {document, generation};
   return generation;
 }
 
-// Several hosts can observe the same FontFaceSet event. Its observed identity retires metrics
-// once. A non-DOM host has no observable face set and explicitly announces its own replacement.
 export function invalidateRichMetrics(document = globalThis.document) {
+  turn = null;
   return document ? captureFontAuthority(document) : clearMetrics();
 }
 
@@ -51,25 +49,27 @@ function familyName(value) {
     .toLowerCase();
 }
 
-// A CSS family with no declared FontFace can intentionally resolve through its fallback list.
-// For declared custom faces, a FontFaceSet.check() alone is insufficient: it can report true
-// after a failed face has fallen back. Keep that failure and same-name replacement observable.
 export function fontReady(document, font, text = ' ') {
   if (!document) return true;
   if (!document.fonts || document.fonts.status === 'loading') return false;
   try {
-    if (document.fonts.check(font, text || ' ') !== true) return false;
-    const family = /(?:\d*\.)?\d+px(?:\s*\/\s*[^\s]+)?\s+(.+)$/.exec(font)?.[1];
-    if (!family) return false;
-    const names = new Set((family.match(/"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|[^,]+/g) || []).map(familyName));
-    const present = new Set();
-    for (const face of document.fonts) {
-      const family = familyName(face.family); present.add(family);
-      if (names.has(family) && face.status !== 'loaded') return false;
+    const parts = /^(?:(normal|italic|oblique(?:\s+-?[\d.]+deg)?)\s+)?(?:(\d+)\s+)?(?:\d*\.)?\d+px(?:\s*\/\s*[^\s]+)?\s+(.+)$/.exec(font);
+    if (!parts) return false;
+    const style = parts[1] || 'normal', weight = Number(parts[2] || 400);
+    const names = (parts[3].match(/"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|[^,]+/g) || []).map(familyName);
+    const declared = documents.get(document)?.declared || new Set(), faces = [...document.fonts];
+    for (const name of names) {
+      const own = faces.filter(face => familyName(face.family) === name);
+      if (!own.length) return !declared.has(name);
+      const fitting = own.filter(face => {
+        const [low, high = low] = String(face.weight).split(/\s+/).map(Number);
+        return (face.style === 'normal') === (style === 'normal') && !(weight < low) && !(weight > high);
+      });
+      const pool = fitting.length ? fitting : own;
+      if (pool.some(face => face.status === 'loading')) return false;
+      if (pool.some(face => face.status === 'loaded')) return true;
+      if (pool.some(face => face.status === 'unloaded')) { document.fonts.load(font, text || ' ').catch(() => {}); return false; }
     }
-    // A deleted declared face is unavailable even when check() now succeeds with a fallback.
-    // Its expected name belongs to this document lifetime, not an individual projection root.
-    for (const family of documents.get(document)?.declared || []) if (names.has(family) && !present.has(family)) return false;
     return true;
   } catch (_) { return false; }
 }
@@ -81,17 +81,11 @@ function validLanguage(value) {
 }
 
 function supportedDocument(document) {
-  if (!document) return true; // A declared non-DOM Canvas host owns its chosen fonts/profile.
+  if (!document) return true;
   const agent = document.defaultView?.navigator?.userAgent ?? globalThis.navigator?.userAgent ?? '';
   return /(?:^|\s)(?:HeadlessChrome|Chrome|Chromium)\/\d+/.test(agent) && !/\bCriOS\//.test(agent);
 }
 
-// The pinned API accepts font shorthand, letter spacing, content language and two break modes.
-// Canvas supplies its default shaping. It has no public feature/variation/kerning controls or
-// paragraph-direction input; these styles retain the native selectable paragraph instead.
-// `nowrap` here is for an atomic item; the paragraph itself still needs normal or pre-wrap.
-// The app's inherited `pretty` is its existing greedy picture-flow policy, not an implementation
-// of native pretty optimization. A host's explicit request for that optimization stays native.
 export function supportsRichStyle(style, contentLanguage = '') {
   if (!style || !validLanguage(contentLanguage)) return false;
   const oneOf = (key, values) => style[key] == null || style[key] === '' || values.includes(style[key]);
@@ -158,8 +152,6 @@ function finish(work) {
 }
 
 function* prepareSteps(items, options, document) {
-  // FontFaceSet.check depends on the font and the used character set. Check each shaped
-  // font once across its runs; the scope is the sole font-readiness authority.
   const usedFonts = new Map();
   for (const item of items) if (item.text !== undefined) usedFonts.set(item.font, (usedFonts.get(item.font) || '') + item.text);
   for (const [font, text] of usedFonts) {
@@ -167,8 +159,6 @@ function* prepareSteps(items, options, document) {
     yield;
   }
   try {
-    // Locale selects content language for this preparation only. Existing handles already own
-    // their measured language; switching paragraphs must not invalidate those handles.
     if (language !== options.language) { setLocale(options.language); language = options.language; }
     if (options.paragraphBreaks && (options.paragraphBreaks[0] !== 0 || options.paragraphBreaks.at(-1) !== items.length ||
         options.paragraphBreaks.some((value, index, all) => !Number.isInteger(value) || value < 0 || value > items.length || index > 0 && value < all[index - 1]))) return null;
@@ -177,8 +167,6 @@ function* prepareSteps(items, options, document) {
       const work = prepareParagraphCandidateSteps(items, {...options, document});
       try {
         for (;;) {
-          // Another consumer may have selected a different content language between
-          // frames. Every resumed step uses this request's original language again.
           if (language !== options.language) { setLocale(options.language); language = options.language; }
           const step = work.next();
           if (step.done) { handle = step.value; break; }
@@ -200,8 +188,6 @@ export function prepareRichParagraph(items, options = {}) {
   return source && settings ? finish(prepareSteps(source, settings, document)) : null;
 }
 
-// This metadata is Rapier's original input snapshot, never a reconstruction of opaque vendor
-// fields. It exists only while its handle does and is used for exact source containment.
 export function paragraphItems(handle) { return paragraphs.get(handle)?.items ?? null; }
 
 export function createPreparationScope(document = globalThis.document) {
@@ -230,8 +216,6 @@ export function createPreparationScope(document = globalThis.document) {
       tickets.set(owner, ticket);
       try {
         for (;;) {
-          // A forgotten/replaced source request or changed face cannot publish a result
-          // after suspension. Until completion, no ready handle is installed for its owner.
           if (tickets.get(owner) !== ticket || captureFontAuthority(document) !== birth) return null;
           const step = work.next();
           if (step.done) {
@@ -249,8 +233,6 @@ export function createPreparationScope(document = globalThis.document) {
     let slotFor = null, readKnown = null, staged = false, active = false;
     try {
       if (!supportedDocument(document) || !owner || typeof owner !== 'object' && typeof owner !== 'function') return null;
-      // Preparation, fitting and forgetting share one outstanding request for this owner.
-      // Replacing a fit keeps its immutable source geometry, but retires the old plan work.
       tickets.delete(owner);
       const birth = captureFontAuthority(document), source = paragraphs.get(handle);
       if (owners.get(owner) !== handle || !source || source.generation !== birth ||
@@ -270,17 +252,12 @@ export function createPreparationScope(document = globalThis.document) {
             !Number.isInteger(from) || from < -1 || !Number.isInteger(to) || to < -1) return -2;
         const cuts = handle.segments[segment]?.words[word]?.breaks;
         if (!cuts || from >= cuts.length || to >= cuts.length || from < 0 && to < 0 || from >= 0 && to >= 0 && from >= to) return -2;
-        if (from >= 0 && to >= 0) return -1; // Exact interior facts remain transient.
+        if (from >= 0 && to >= 0) return -1;
         const cut = cuts[from < 0 ? to : from];
         if (!Number.isInteger(cut.slot) || cut.slot < 0 || cut.slot >= handle.cutCount) return -2;
-        // Slots come only from the captured geometry's final legal cuts. A request
-        // can select coordinates, but cannot supply a cache key or a metric buffer.
         return cut.slot * 2 + (from < 0 ? 0 : 1);
       };
       readKnown = request => {
-        // This callback belongs only to active numerical work. A warm edge reads an
-        // exact scalar without a generator crossing, FontFaceSet scan or observation.
-        // Current source/font authority is checked at each actual resume and finish.
         if (!active || tickets.get(owner) !== ticket || generation !== birth) return undefined;
         const slot = slotFor(request?.segment, request?.word, request?.from, request?.to);
         if (slot < 0 || tickets.get(owner) !== ticket || generation !== birth) return undefined;
@@ -298,7 +275,6 @@ export function createPreparationScope(document = globalThis.document) {
         const step = work.next(answer);
         answer = undefined;
         if (step.done) {
-          // A host measurement or another synchronous caller may replace this owner too.
           if (!currentFit()) return null;
           const plan = step.value;
           if (!plan || !Array.isArray(plan.lines)) return null;
@@ -306,9 +282,6 @@ export function createPreparationScope(document = globalThis.document) {
           Object.freeze(plan.lines);
           Object.freeze(plan);
           if (!currentFit()) return null;
-          // The private buffer holds at most two exact numbers per legal cut. It
-          // never escapes and is never written after publication. A later fit must
-          // copy it before staging a miss; cancellation cannot poison this snapshot.
           if (staged) source.edges = facts;
           return plan;
         }
@@ -322,8 +295,6 @@ export function createPreparationScope(document = globalThis.document) {
           if (answer !== undefined && !Number.isNaN(answer)) continue;
         }
         selectLanguage();
-        // No observer exists for a plan proved from whole-word facts. Its temporary
-        // vendor metric objects are owned only by this operation, never by the handle.
         observe ??= createParagraphObserver(source.items, handle, source.options.language);
         answer = observe({segment, word, from, to});
         if (!finite(answer) || answer < 0) return null;
@@ -357,13 +328,9 @@ export function createPreparationScope(document = globalThis.document) {
     current,
     invalidateFonts: () => invalidateRichMetrics(document),
     forget: owner => { owners.delete(owner); tickets.delete(owner); },
-    // The existing document/style owner calls this when replacing or retiring its content,
-    // not for width reflow. Upstream caches outlive handles, so dropping a WeakMap is not enough.
     retire({documentChanged = false} = {}) {
       owners = new WeakMap();
       tickets = new WeakMap();
-      // Disposing a projection must not erase a still-live peer's missing custom-family
-      // authority. Only the host's whole-document identity transition resets that history.
       if (documentChanged && document) documents.delete(document);
       const before = generation;
       captureFontAuthority(document);

package/dist/layout/prepared-paragraph.mjs

@@ -5,10 +5,6 @@ import {getEngineProfile, getPreparationLanguage, getFontMeasurement, parseFontS
   getTextWidth, getEmojiCorrection, textMayContainEmoji, measureWithLetterSpacing} from '../agent/vendor/pretext/measurement.js';
 import {KIND_BITS, TEXT, SPACE, SOFT_HYPHEN, ZERO_WIDTH_BREAK, ZERO_WIDTH_GLUE, OBJECT, SPACED, UNBROKEN} from '../agent/vendor/pretext/analysis.js';
 
-// The sole pin-specific bridge to bac1774c0f8b7a92e44b9da43b6d5443d55d0d9b.
-// Preparation seals source, whole-word geometry and legal edges. A separate captured fit
-// observes only requested edge intervals before sealing its plan. Neither phase exports a
-// vendor handle, a mutable metric object or a function that can measure after readiness.
 const opening = /^[\p{Ps}\p{Pi}\p{Pf}"']+/u;
 const closing = /[\p{Pe}\p{Pi}\p{Pf}"'.,;:!?]+$/u;
 const empty = values => values == null || !values.some(value => value !== null && value !== 0);
@@ -28,8 +24,6 @@ function sourceMeasurer(items, text, offsets, language) {
   const metrics = [];
   return (start, end, suffix = '') => {
     if (start >= end) return 0;
-    // The last positive overlap owns the suffix. Duplicate offsets from empty runs
-    // must not move it into an empty run or the next font.
     let lo = 0, hi = items.length;
     while (lo < hi) {
       const mid = lo + hi >>> 1;
@@ -51,16 +45,12 @@ function sourceMeasurer(items, text, offsets, language) {
         ? measureWithLetterSpacing(body, item.letterSpacing, metric.emoji, metric.font)
         : getTextWidth(body, metric.font, metric.emoji);
       if (measured === null) return NaN;
-      // Keep the original per-run shaping and left-to-right addition order.
       width += measured + (item.break === 'never' ? item.extraWidth : 0);
     }
     return width;
   };
 }
 
-// Only the preparation scope calls this, while its source/font ticket is live. The
-// short-lived observer owns the vendor metrics and context rows; the sealed geometry
-// retains only immutable coordinates, corrections and its resolved shaping language.
 export function createParagraphObserver(items, geometry) {
   const measure = sourceMeasurer(items, geometry.text, geometry.offsets, geometry.language);
   const rows = new Map();
@@ -73,8 +63,6 @@ export function createParagraphObserver(items, geometry) {
       for (let at = start.contextAfter; at < contexts.length; at++) correction += contexts[at].delta;
       return measure(start.offset, word.end) + correction + start.startExtra;
     }
-    // For a fixed start the fitter visits increasing ends. Extend that row's exact
-    // left-to-right sum; no total-minus-prefix arithmetic changes its rounding.
     let row = rows.get(start);
     if (!row || end.offset < row.end) rows.set(start, row = {at: start.contextInside, sum: 0, end: start.offset});
     while (row.at < contexts.length && contexts[row.at].end <= end.offset) row.sum += contexts[row.at++].delta;
@@ -99,8 +87,6 @@ export function* prepareParagraphCandidateSteps(items, options) {
     if (!source.some(item => item.text)) continue;
     const flow = prepareRichInlineSegments(source, {whiteSpace: 'normal', wordBreak: options.wordBreak});
     const data = flow.data, flags = data.segmentFlags, units = [];
-    // These are object-edge contracts that this text-only projection cannot paint. Refuse
-    // before making a plan, rather than dropping an advance or inventing a native equivalent.
     if (!empty(data.items?.insideExtras) || !empty(data.items?.fillExtras) || !empty(data.items?.openingEdges)) return null;
     for (let index = 0; index < flags.length; index++) {
       const kind = flags[index] & KIND_BITS;
@@ -138,8 +124,6 @@ export function* prepareParagraphCandidateSteps(items, options) {
     finish();
     yield;
 
-    // Native language data contributes only legal source positions. Every advance,
-    // including the displayed discretionary glyph, still comes from Pretext below.
     const automatic = paragraphHyphens(chunk.words, text, items, offsets, options.language, options.document);
     if (!automatic) return null;
     for (const word of chunk.words) for (const offset of automatic.get(word) || []) {
@@ -147,8 +131,6 @@ export function* prepareParagraphCandidateSteps(items, options) {
     }
     yield;
 
-    // Whole words and optical edges use the same font/language/letter-spacing cache
-    // as ordinary wrapping. Discretionary edges belong to the captured fit phase.
     let measuredWords = 0;
     for (const word of chunk.words) {
       if (word.protected) word.breaks = [];
@@ -157,11 +139,6 @@ export function* prepareParagraphCandidateSteps(items, options) {
       const contexts = [];
       let measuredEdges = 0;
       if (joined) {
-        // A joined word and its cut edges are separate shaping observations. Retain the
-        // engine's contextual advances (including positive following-space kerning and
-        // punctuation trims) when replacing the sum of pieces with the joined advance.
-        // A leading combining-only segment already belongs to that joined observation;
-        // its mark-context correction must not be added a second time.
         for (let at = word.first; at <= word.last; at++) {
           const unit = units[at];
           if (unit.kind !== TEXT || /^\p{M}+$/u.test(text.slice(unit.start, unit.end))) continue;
@@ -174,8 +151,6 @@ export function* prepareParagraphCandidateSteps(items, options) {
       let autoBefore = word.first - 1, autoAfter = word.first, contextAfter = 0, contextInside = 0, prefixContext = 0;
       for (const cut of word.breaks) {
         if (cut.kind === 'soft' || cut.kind === 'auto') {
-          // The projection's explicit glyph policy: the text font's hyphen-minus.
-          // Its whole shaped prefix is measured below; no fallback-family search.
           cut.glyph = '-';
         }
         let before = cut.at, after = cut.at + 1;

package/dist/layout/typography.mjs

@@ -2,7 +2,6 @@
 import {createPreparationScope, supportsRichStyle, captureFontAuthority} from './preparation.mjs';
 import {createParagraphFitter} from './paragraph-fit.mjs';
 
-// Layout projections keep the original text in place. The factory also runs in an exported page.
 export function createTypography() {
   const fitter = createParagraphFitter();
   const mark = 'data-rapier-typography', boundary = mark + '-break', hang = mark + '-hang';
@@ -11,7 +10,7 @@ export function createTypography() {
   const exclude = 'code,kbd,samp,math,script,style,.math-rendered,[hidden]';
   const candidates = 'p[data-md-hyphens="auto"],p[data-md-lines],p[data-md-hanging="on"],p[' + mark + ']';
   const properties = ['--md-drop-cap-font', '--md-hang-start'];
-  const states = new WeakMap(), documents = new WeakMap(), live = new Set();
+  const states = new WeakMap(), documents = new WeakMap(), live = new Set(), refused = new WeakMap();
   function scope(document) {
     let value = documents.get(document);
     if (!value) { value = createPreparationScope(document); documents.set(document, value); }
@@ -36,6 +35,9 @@ export function createTypography() {
     return end > start ? {start, end, text: text.slice(start, end)} : null;
   }
 
+  const flowFloat = '.rapier-flow-float';
+  const own = paragraph => [paragraph, ...[...paragraph.querySelectorAll('*')].filter(element => !element.closest(flowFloat))];
+
   function paragraphs(root, selector = candidates) {
     return [...(root?.matches?.(selector) ? [root] : []), ...(root?.querySelectorAll?.(selector) || [])];
   }
@@ -63,7 +65,6 @@ export function createTypography() {
     return item ? {node: item.node, offset: Math.max(0, Math.min(item.node.length, offset - item.start))} : null;
   }
 
-  // This data-only guard is safe on an active edit surface, including during composition.
   function protectInitial(root) {
     for (const paragraph of paragraphs(root, 'p[data-md-lines],p[data-md-hanging="on"],p[' + protectedInitial + ']')) {
       const initial = initialRange(paragraph), letter = initial && [...segment(initial.text)].at(-1);
@@ -94,7 +95,6 @@ export function createTypography() {
     return paragraph.hasAttribute('data-md-lines') ? Math.max(parseFloat(style.lineHeight) || 0, parseFloat(style.fontSize) * 1.7) : Infinity;
   }
 
-  // Returns a textContent coordinate, independent of markup, selected fonts or a floated initial.
   function firstLineEnd(paragraph) {
     if (!paragraph?.isConnected || !paragraph.getClientRects?.().length) return null;
     const view = paragraph.ownerDocument.defaultView;
@@ -141,8 +141,6 @@ export function createTypography() {
     if (anchor.node.isConnected && focus.node.isConnected) saved.selection.setBaseAndExtent(anchor.node, anchor.offset, focus.node, focus.offset);
   }
 
-  // A native initial cannot span inline element boundaries. Move only its opening punctuation
-  // into the letter's text node; the paragraph's text and all original elements stay in place.
   function unifyInitial(paragraph, state, initial, letterStart) {
     const items = runs(paragraph), at = point(items, letterStart);
     if (!at || at.node.parentElement?.closest(exclude)) return;
@@ -172,15 +170,14 @@ export function createTypography() {
       if (cursor !== move.next || text !== move.after) return;
       restore.push({move, pieces});
     }
-    // A changed projection belongs to its current writer; restoration never replaces newer text.
     for (const {move, pieces} of restore) { move.node.data = move.before; for (const piece of pieces.slice(1)) piece.remove(); }
   }
 
-  function clear(root, {forget = true} = {}) {
+  function clear(root, {forget = true, keepSelection = true} = {}) {
     const list = paragraphs(root, 'p[' + mark + '],p[' + protectedInitial + ']');
     for (const paragraph of list) {
       if (!paragraph.hasAttribute(mark)) { paragraph.removeAttribute(protectedInitial); continue; }
-      const selected = selectionBefore(paragraph);
+      const selected = keepSelection ? selectionBefore(paragraph) : null;
       const state = states.get(paragraph);
       state?.work?.return();
       state?.fitWork?.return();
@@ -204,9 +201,6 @@ export function createTypography() {
     }
   }
 
-  // Native clipboard HTML must see the original inline tree. Clear the selected
-  // projection before the browser/host captures its Range, retaining current metrics.
-  // The host schedules ordinary refinement again after the synchronous clipboard event.
   function clearSelection(root) {
     const selection=(root?.ownerDocument || root)?.getSelection?.();
     if (!selection?.rangeCount || selection.isCollapsed) return 0;
@@ -220,15 +214,12 @@ export function createTypography() {
     return selected.length;
   }
 
-  // Optical alignment uses the available margin; paint containment and narrow pages must not
-  // clip a large quoted initial. Offscreen measurement stages have no viewport clipping edge.
   function hangingEdge(paragraph, style, box) {
     const view = paragraph.ownerDocument.defaultView, rtl = style.direction === 'rtl';
     if (style.visibility !== 'visible' || box.right <= 0 || box.left >= view.innerWidth) return null;
     let edge = rtl ? view.innerWidth : 0;
     if (view.matchMedia('print').matches) {
       const content = paragraph.closest('.md-render')?.getBoundingClientRect();
-      // The PDF painter clips at the content area even when a physical page margin exists.
       if (content?.width > 0) edge = rtl ? Math.min(edge, content.right) : Math.max(edge, content.left);
     }
     for (let element = paragraph; element; element = element.parentElement) {
@@ -302,8 +293,6 @@ export function createTypography() {
     for (const element of parents) {
       const computed = element === paragraph ? baseStyle : view.getComputedStyle(element);
       const s = Object.fromEntries([...shaping, ...admission].map(name => [name, computed[name]]));
-      // The fit's own CSS suppresses native rewrapping. Source attributes and ancestor
-      // whitespace remain in the key; clearing reads the current unprojected styles anew.
       if (prior?.plan) for (const name of ['whiteSpace', 'hyphens', 'hangingPunctuation', 'textWrapStyle'])
         s[name] = prior.saved.styles.get(element)?.[name] ?? s[name];
       const before = view.getComputedStyle(element, '::before').content, after = view.getComputedStyle(element, '::after').content;
@@ -331,7 +320,8 @@ export function createTypography() {
           ['white-space','text-wrap','hyphens','hanging-punctuation','word-spacing'].some(name => element.style.getPropertyPriority(name))) return null;
       const s = inspection.styles.get(element), atom = element !== paragraph && (/^(CODE|KBD|SAMP)$/.test(element.tagName) || s.whiteSpace === 'nowrap');
       if (s.hyphenateCharacter && s.hyphenateCharacter !== 'auto') return null;
-      if (!supportsRichStyle({...s, hyphens:'manual', hangingPunctuation:'none', whiteSpace: atom ? 'nowrap' : s.whiteSpace}, language) ||
+      if (!supportsRichStyle({...s, hyphens:'manual', hangingPunctuation:'none', whiteSpace: atom ? 'nowrap' : s.whiteSpace,
+          lineBreak: s.lineBreak === 'after-white-space' ? 'auto' : s.lineBreak}, language) ||
           !atom && s.whiteSpace !== 'normal') return null;
       const extras = ['paddingLeft','paddingRight','borderLeftWidth','borderRightWidth','marginLeft','marginRight']
         .reduce((sum,name) => sum + Math.abs(parseFloat(s[name]) || 0),0);
@@ -383,6 +373,56 @@ export function createTypography() {
     return {width,indent,left:hanging?Math.max(0,left-clipLeft):0,right:hanging?Math.max(0,clipRight-right):0};
   }
 
+  function excluded(shape, a, b) {
+    const {points, box} = shape;
+    if (!points.length) return b > 0 && a < box.height ? [0, box.width] : null;
+    let low = Infinity, high = -Infinity;
+    for (let index = 0; index < points.length; index++) {
+      const [x1, y1] = points[index], [x2, y2] = points[(index + 1) % points.length];
+      const top = Math.min(y1, y2), bottom = Math.max(y1, y2);
+      if (bottom <= a || top >= b) continue;
+      for (const y of [Math.max(a, top), Math.min(b, bottom)]) {
+        const x = y1 === y2 ? null : x1 + (x2 - x1) * (y - y1) / (y2 - y1);
+        if (x == null) { low = Math.min(low, x1, x2); high = Math.max(high, x1, x2); }
+        else { low = Math.min(low, x); high = Math.max(high, x); }
+      }
+    }
+    return high > low ? [low, high] : null;
+  }
+
+  function floatMeasures(paragraph, style, box, width) {
+    const view = paragraph.ownerDocument.defaultView;
+    const floats = [...paragraph.children].filter(element => element.matches(flowFloat) && view.getComputedStyle(element).cssFloat !== 'none');
+    if (!floats.length) return null;
+    const lineHeight = parseFloat(style.lineHeight);
+    if (!(lineHeight > 0)) return {refuse: true};
+    const top = box.top + (parseFloat(style.borderTopWidth) || 0) + (parseFloat(style.paddingTop) || 0);
+    const left = box.left + (parseFloat(style.borderLeftWidth) || 0) + (parseFloat(style.paddingLeft) || 0);
+    const right = box.right - (parseFloat(style.borderRightWidth) || 0) - (parseFloat(style.paddingRight) || 0);
+    const shapes = floats.map(element => {
+      const computed = view.getComputedStyle(element), bounds = element.getBoundingClientRect();
+      const points = [...computed.shapeOutside.matchAll(/(-?[\d.]+)px\s+(-?[\d.]+)px/g)].map(match => [+match[1], +match[2]]);
+      return {side: computed.cssFloat, box: bounds, points, top: bounds.top - (parseFloat(computed.marginTop) || 0),
+        bottom: bounds.bottom + (parseFloat(computed.marginBottom) || 0)};
+    });
+    const bottom = Math.max(...shapes.map(shape => shape.bottom)), widths = [];
+    for (let line = 0; top + line * lineHeight < bottom && line < 512; line++) {
+      const a = top + line * lineHeight, b = a + lineHeight;
+      let start = 0, end = 0;
+      for (const shape of shapes) {
+        if (b <= shape.top || a >= shape.bottom) continue;
+        const span = excluded(shape, a - shape.box.top, b - shape.box.top);
+        if (!span) continue;
+        if (shape.side === 'left') start = Math.max(start, shape.box.left + span[1] - left);
+        else end = Math.max(end, right - (shape.box.left + span[0]));
+      }
+      widths.push(start || end ? Math.floor((width - start - end - 1) * 64) / 64 : width);
+    }
+    while (widths.length && widths.at(-1) === width) widths.pop();
+    return {widths, lineHeight, key: shapes.map(shape => [shape.side, shape.box.left - left, shape.box.top - top, shape.box.width,
+      shape.box.height, shape.points.join(' ')].join(':')).join('|')};
+  }
+
   const topology = plan => plan && plan.lines.map(line => [line.start,line.end,line.next,line.kind,line.glyph].join(':')).join('|');
   function updateProjection(projection, plan) {
     for (const {node,property,line,sign} of projection.bindings) {
@@ -415,8 +455,6 @@ export function createTypography() {
       if (first.opening && line.start === first.start) operations.push({start:first.start,end:first.openEnd,opening:true,line:lineIndex});
       if (last.closing && line.end === last.end) operations.push({start:last.closeStart,end:last.end,closing:true,line:lineIndex});
     }
-    // Sweep interval endpoints once. Each original text node is split from right to left;
-    // links, comments, IDs and inline ancestors never move or get reconstructed.
     const events = new Map();
     const event = offset => { let value = events.get(offset); if (!value) { value={start:[],end:[]}; events.set(offset,value); } return value; };
     for (const op of operations) { event(op.start).start.push(op); event(op.end).end.push(op); }
@@ -435,8 +473,6 @@ export function createTypography() {
         pieces.push({item,start,end,operations:[...active]}); start=end;
       }
     }
-    // Validate every zero-source insertion before the first write, so a refused source
-    // coordinate cannot leave a partially projected paragraph behind.
     const sourceEnds = new Set(pieces.map(piece => piece.end));
     if (inserts.some(insert => !sourceEnds.has(insert.offset))) return false;
     const ends = new Map();
@@ -472,7 +508,21 @@ export function createTypography() {
     paragraph.setAttribute(fitMark,'');return projection;
   }
 
-  function apply(root, {all=false}={}) {
+  function laidAsPlanned(paragraph, job) {
+    const style = job.view.getComputedStyle(paragraph), box = paragraph.getBoundingClientRect();
+    const inner = box.height - (parseFloat(style.paddingTop) || 0) - (parseFloat(style.paddingBottom) || 0) -
+      (parseFloat(style.borderTopWidth) || 0) - (parseFloat(style.borderBottomWidth) || 0);
+    return Math.abs(inner - job.plan.lines.length * job.beside.lineHeight) < 1;
+  }
+
+  function editKey(paragraph, generation) {
+    const page = paragraph.ownerDocument.documentElement;
+    return [generation, paragraph.innerHTML, ...[...paragraph.attributes].map(item => item.name + '=' + item.value),
+      ...[...page.attributes].map(item => item.name + '=' + item.value), paragraph.ownerDocument.body?.className,
+      paragraph.ownerDocument.defaultView.innerWidth].join('\u0000');
+  }
+
+  function apply(root, {all=false, editing=false}={}) {
     const started = performance.now();
     const generation = captureFontAuthority(root?.ownerDocument || globalThis.document);
     for (const paragraph of live) {
@@ -481,55 +531,63 @@ export function createTypography() {
     }
     const jobs=[];let pending=false,changed=0,released=0,preparedCount=0;
     for (const paragraph of paragraphs(root)) {
-      if (paragraph.closest('table,pre,code,h1,h2,h3,h4,h5,h6,.block-edit') ||
-          paragraph.isContentEditable && !paragraph.closest('.block-read')) {clear(paragraph);continue;}
+      if (paragraph.closest('table,pre,code,h1,h2,h3,h4,h5,h6')) {clear(paragraph);continue;}
+      if (paragraph.closest('.block-edit')) {
+        if (!editing) continue;
+        if (paragraph.getAttribute('data-md-align')!=='justify' || paragraph.getAttribute('data-md-hyphens')!=='auto') {
+          if (paragraph.hasAttribute(mark)) clear(paragraph);
+          protectInitial(paragraph);continue;
+        }
+      }
+      else if (paragraph.isContentEditable && !paragraph.closest('.block-read')) {clear(paragraph);continue;}
       if (!paragraph.isConnected || !all && paragraph.checkVisibility && !paragraph.checkVisibility({contentVisibilityAuto:true})) continue;
       const view=paragraph.ownerDocument.defaultView;
       if (!view || !paragraph.getClientRects().length) continue;
+      if (editing && states.get(paragraph)?.editKey===editKey(paragraph,generation)) continue;
       const style=view.getComputedStyle(paragraph),box=paragraph.getBoundingClientRect(),prior=states.get(paragraph);
       if (!all && (box.bottom < -100 || box.top > view.innerHeight+100)) continue;
       const hanging=paragraph.getAttribute('data-md-hanging')==='on',size=dimensions(paragraph,style,box,hanging);
       if (!(size.width>0)) continue;
-      const parents=prior?.parents || [paragraph,...paragraph.querySelectorAll('*')];
+      const beside=floatMeasures(paragraph,style,box,size.width);
+      if (beside?.refuse) {clear(paragraph);continue;}
+      if (beside?.widths.some(width=>!(width>0))) {clear(paragraph);continue;}
+      if (beside) size.widths=beside.widths;
+      const parents=prior?.parents || own(paragraph);
       const inspection=inspect(paragraph,parents,prior,style);
       const reusable=prior?.html===paragraph.innerHTML && prior.key===inspection.key && (!prior.geometry || scope(paragraph.ownerDocument).current(prior.geometry));
-      const sizeKey=[size.width,size.indent,size.left,size.right].join('|');
+      const sizeKey=[size.width,size.indent,size.left,size.right,beside?.key||''].join('|');
+      if (refused.get(paragraph)===sizeKey+'\u0000'+paragraph.textContent) {if (paragraph.hasAttribute(mark)) clear(paragraph);continue;}
       if (reusable && !prior.pending && prior.sizeKey===sizeKey) continue;
-      // Preparation survives reflow; a suspended fit belongs to its captured width,
-      // indent and margins. Cancel only that plan when dimensions have changed.
       const fitWork=reusable && prior.sizeKey===sizeKey?prior.fitWork:null;
       if (prior?.fitWork && prior.fitWork!==fitWork) {prior.fitWork.return();prior.fitWork=null;}
       if (!all && jobs.length===4) {if (!reusable) clear(paragraph);pending=true;continue;}
-      jobs.push({paragraph,view,style,inspection,size,sizeKey,hanging,selected:selectionBefore(paragraph),
+      jobs.push({paragraph,view,style,inspection,size,sizeKey,hanging,beside,selected:selectionBefore(paragraph),
         cap:paragraph.hasAttribute('data-md-lines'),justified:paragraph.getAttribute('data-md-align')==='justify' && paragraph.getAttribute('data-md-hyphens')==='auto',
         saved:reusable?prior.saved:null,geometry:reusable?prior.geometry:null,prepared:reusable?prior.prepared:null,
         work:reusable?prior.work:null,fitWork,
         prior,reusable,needsClear:paragraph.hasAttribute(mark)});
     }
-    // Remove obsolete source/style projections before yielding. Unprepared paragraphs
-    // use native layout until their turn; no stale font plan remains on the page.
-    for (const job of jobs) if (job.needsClear && !job.saved) clear(job.paragraph);
+    if (editing && jobs.some(job=>job.selected && !job.reusable)) root.ownerDocument.getSelection()?.removeAllRanges();
+    for (const job of jobs) if (job.needsClear && !job.saved) clear(job.paragraph,{keepSelection:!editing});
     function stateFor(job) {
       return {properties:new Map(),moves:[],saved:job.saved,geometry:job.geometry,prepared:job.prepared,plan:job.plan,
         work:job.work,fitWork:job.fitWork,parents:job.inspection.parents,key:job.inspection.key,generation:job.inspection.generation,sizeKey:job.sizeKey};
     }
     function suspend(job) {
       const state=stateFor(job);
-      // A reusable projection may remain readable while a new width is being fitted.
-      // Retain its restoration custody until it is updated or explicitly cleared.
       if (job.reusable && job.prior) for (const name of ['properties','moves','projection','plan']) state[name]=job.prior[name];
       state.pending=true;state.html=job.paragraph.innerHTML;
       states.set(job.paragraph,state);live.add(job.paragraph);job.paragraph.setAttribute(mark,'');pending=true;
     }
-    // Both preparation and fitting yield through the same captured source/font owner.
-    // Native text remains readable until its plan is ready. Each continuation
-    // rereads the current source/style/font and width; it cannot publish a suspended plan.
-    // A single native shaping call can exceed this allowance, so this is not a deadline.
     for (let jobIndex = 0; jobIndex < jobs.length; jobIndex++) {
       if (!all && jobIndex && performance.now() - started >= 8) {pending=true;break;}
       const job = jobs[jobIndex];
       if (!job.saved && job.justified) {
-        if (job.needsClear) job.inspection=inspect(job.paragraph,[job.paragraph,...job.paragraph.querySelectorAll('*')],null,job.view.getComputedStyle(job.paragraph));
+        if (job.needsClear) {
+          const elements=own(job.paragraph),parents=job.inspection.parents;
+          if (!editing || !job.prior?.saved || elements.length!==parents.length || elements.some((element,index)=>element!==parents[index]))
+            job.inspection=inspect(job.paragraph,elements,null,job.view.getComputedStyle(job.paragraph));
+        }
         job.saved=snapshot(job.paragraph,job.inspection);
         if (job.saved) {
           job.work=scope(job.paragraph.ownerDocument).prepareSteps(job.paragraph,job.saved.inline,{policy:'paragraph',language:job.saved.language,
@@ -557,7 +615,7 @@ export function createTypography() {
         if (job.fitWork) {suspend(job);continue;}
       }
       job.projection=job.reusable && job.plan && job.prior?.projection?.topology===topology(job.plan) ? job.prior.projection : null;
-      if (job.needsClear && job.saved && !job.projection) clear(job.paragraph,{forget:false});
+      if (job.needsClear && job.saved && !job.projection) clear(job.paragraph,{forget:false,keepSelection:!editing});
       const {paragraph,view,hanging,cap,justified}=job;
       if (!cap && !hanging && !justified) {restoreSelection(paragraph,job.selected);continue;}
       const state=stateFor(job);
@@ -571,10 +629,14 @@ export function createTypography() {
       }
       if (job.projection) {updateProjection(job.projection,job.plan);state.projection=job.projection;}
       else if (job.plan) state.projection=project(paragraph,job.saved,job.geometry,job.plan);
+      if (state.projection && job.beside && !laidAsPlanned(paragraph,job)) {
+        refused.set(paragraph,job.sizeKey+'\u0000'+paragraph.textContent);clear(paragraph);restoreSelection(paragraph,job.selected);continue;
+      }
       if (state.projection) released+=job.plan.lines.filter(line=>line.kind!=='end').length;
       else if (hanging) hangPunctuation(paragraph,state,job.style,hangingEdge(paragraph,job.style,paragraph.getBoundingClientRect()));
       state.html=paragraph.innerHTML;
       restoreSelection(paragraph,job.selected);changed++;
+      if (editing) state.editKey=editKey(paragraph,generation);
     }
     return {changed,released,pending,prepared:preparedCount};
   }