rapier-markdown-kit 1.2.33 → 1.2.40

package/dist/kit/render.mjs

@@ -212,14 +212,14 @@ function _rapierTemplatePage(canonical, settings, root, darkPaper = false) {
 		const image = paragraph.querySelector('img');
 		const layout = globalThis.RapierMarkdownLayout.parseLayoutAttribute(paragraph.getAttribute('data-md-layout'));
 		const source = image?.getAttribute('src') || '';
-		if (isPageBorderLayout(layout) && /^data:image\/(?:png|jpeg|webp|gif|svg\+xml|jxl);base64,[A-Za-z0-9+/=]+$/i.test(source)) { url = source; paragraph.remove(); break; }
+		if (isPageBorderLayout(layout) && globalThis.RapierImageAssets.dataImage(source)) { url = source; paragraph.remove(); break; }
 	}
 	if (!url) return null;
 	const width = paper.width / 15, height = paper.height / 15;
 	const margins = ['top', 'right', 'bottom', 'left'].map(side => (settings?.geometry?.[side] ?? 1440) / 15);
 	const padding = margins.map(value => value + 'px').join(' ');
 	const ground = 'background:var(--rapier-template-border) 0 0/100% 100% no-repeat';
-	const shown = darkPaper && url.startsWith('data:image/svg+xml;base64,') ? _rapierDarkPaperSvgUrl(url, '#fafafa') : url;
+	const shown = darkPaper && globalThis.RapierImageAssets.dataImage(url)?.codec === 'image/svg+xml' ? _rapierDarkPaperSvgUrl(url, '#fafafa') : url;
 	const css = ':root{--rapier-template-border:url("' + url + '")}\n'
 		+ '@media screen{' + (shown !== url ? ':root{--rapier-template-border:url("' + shown + '")}' : '') + '.rapier-template-border{display:none}body{background:var(--md-color-inset)}.rapier-page{box-sizing:border-box;width:min(100%,' + width + 'px);min-height:' + height + 'px;margin:0 auto;padding:' + padding
 		+ ';background:var(--rapier-template-border) 0 0/100% ' + height + 'px repeat-y,var(--md-color-bg);color:var(--md-color-text)}}\n'
@@ -235,7 +235,7 @@ function _rapierDarkPaperSvgUrl(url, paperInk) {
 	const ink = globalThis.RapierImageInspection?.inkForPaper;
 	if (typeof ink !== 'function') return url;
 	let text;
-	try { text = new TextDecoder('utf-8', {fatal: true}).decode(Uint8Array.from(atob(url.slice(26)), c => c.charCodeAt(0))); }
+	try { text = new TextDecoder('utf-8', {fatal: true}).decode(globalThis.RapierImageAssets.decodeDataImageBytes(url).bytes); }
 	catch (_) { return url; }
 	const inked = ink(text, {dark: true, paperInk});
 	if (inked === text) return url;
@@ -274,7 +274,7 @@ function* _rapierProjectStyledRootSteps(semanticRoot, options) {
 	for (const token of root.querySelectorAll('.rapier-source-token--softbreak')) { yield;
 		if (token.getAttribute('data-rapier-source') !== '%0A') token.replaceWith(...token.childNodes);
 		else if (token.previousSibling?.classList?.contains('callout__label')) token.remove();
-		else token.replaceWith(root.ownerDocument.createTextNode(' '));
+		else token.replaceWith(root.ownerDocument.createTextNode(token.closest('pre') ? '\n' : ' '));
 	}
 	const metadata = opts.metadata || {};
 
@@ -532,10 +532,10 @@ function _rapierAnnotateExportBoxPolygons(root) {
 	for (const image of root.querySelectorAll('img[data-rapier-image-layout]')) {
 		const layout = globalThis.RapierMarkdownLayout.parseLayoutAttribute(image.getAttribute('data-rapier-image-layout'));
 		if (layout?.wrap !== 'box' && layout?.wrap !== 'around') continue;
-		const match = /^data:image\/svg\+xml;base64,([A-Za-z0-9+/]+=*)$/.exec(image.getAttribute('src') || '');
-		if (!match) continue;
+		const url = image.getAttribute('src') || '';
+		if (globalThis.RapierImageAssets.dataImage(url)?.codec !== 'image/svg+xml') continue;
 		let text;
-		try { text = new TextDecoder('utf-8', { fatal: true }).decode(Uint8Array.from(atob(match[1]), c => c.charCodeAt(0))); }
+		try { text = new TextDecoder('utf-8', { fatal: true }).decode(globalThis.RapierImageAssets.decodeDataImageBytes(url).bytes); }
 		catch (_) { continue; }
 		let recipe;
 		try { recipe = _rapierDrawReadSVGRecipe(text); } catch (_) { continue; }
@@ -634,7 +634,7 @@ function _rapierSharedResolve(text, ids, images, definitions) {
 	let broken = false;
 	const src = value => {
 		const found = images.get(value);
-		if (typeof found !== 'string' || !/^data:image\/(?:png|jpeg|webp|gif|svg\+xml|jxl);base64,[A-Za-z0-9+/]+={0,2}$/i.test(found)) { broken = true; return null; }
+		if (!globalThis.RapierImageAssets.dataImage(found)) { broken = true; return null; }
 		return found;
 	};
 	const inline = new RegExp('(\\]\\([ \\t\\r\\n]*(?:<)?)#' + id + '(?=>?[ \\t\\r\\n]*\\)|>?[ \\t\\r\\n]+["\'(])', 'g');
@@ -896,7 +896,7 @@ async function _rapierRequireOfflinePageImages(root) {
 	}
 	if (!missing.length) return;
 	throw Object.assign(new Error('Web page not written; embed these pictures and try again. ' + missing.join('; ')),
-		{code: 'offline_image_unavailable'});
+		{code: 'offline_image_unavailable', missing});
 }
 
 function _rapierCssValueUrls(value) {
@@ -1741,7 +1741,7 @@ function _rapierArtifactLayoutScript(root, nonce = '', {pictures = true} = {}) {
     throw new Error('Offline typography requires the complete retained MIT layout factories');
   const modules = _rapierArtifactFactoryModules(dependencies, 'layout');
   const script = '/* Rapier export layout: SPDX-License-Identifier: MIT */\n' +
-    '/* Pretext bac1774c0f8b7a92e44b9da43b6d5443d55d0d9b (Unreleased)\n' + dependencies.license + '\n*/\n' +
+    '/* Pretext 1.0.0 + main 0d102a5cd933611e86a7e60bda7b4baa5995c6b0\n' + dependencies.license + '\n*/\n' +
     '(() => {\nconst modules = Object.create(null);\n' + modules +
     (wrapping ? '\n(' + _rapierProjectArtifactLayout.toString() +
     ')(document.querySelector("main.rapier-page"), modules["spec/md-layout.mjs"], modules["layout/model.mjs"], modules["layout/preparation.mjs"]);\n' : '') +

package/dist/kit/wiki.mjs

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: MIT
+export const WIKI_PREFIX = '?rapier-wiki=';
+export function wikiAddress(target) {
+  const at = target.indexOf('#'), path = at < 0 ? target : target.slice(0, at);
+  return WIKI_PREFIX + encodeURIComponent(path) + (at < 0 ? '' : '#' + encodeURIComponent(target.slice(at + 1)));
+}
+export function wikiTarget(address) {
+  if (typeof address !== 'string' || !address.startsWith(WIKI_PREFIX)) return null;
+  try { return decodeURIComponent(address.slice(WIKI_PREFIX.length).split('#')[0]); }
+  catch { return null; }
+}
+export function installWikiParser(md, render) {
+  md.inline.ruler.before('image', 'rapier_wiki', (state, silent) => {
+    if (!state.env?.rapierWikiLinks) return false;
+    const start = state.pos, embed = state.src[start] === '!';
+    const open = start + (embed ? 1 : 0);
+    if (state.linkLevel || state.src.slice(open, open + 2) !== '[[') return false;
+    const end = state.src.indexOf(']]', open + 2);
+    if (end < 0 || end + 2 > state.posMax || end - start > 4096) return false;
+    const body = state.src.slice(open + 2, end);
+    if (!body || /[\[\]\n\r\0]/.test(body)) return false;
+    const pipe = body.indexOf('|'), target = (pipe < 0 ? body : body.slice(0, pipe)).trim();
+    if (!target || /^(?:[a-z][a-z0-9+.-]*:|\/|\\)/i.test(target)) return false;
+    if (!silent) {
+      const token = state.push('rapier_wiki', '', 0);
+      token.content = state.src.slice(start, end + 2);
+      token.meta = {target, label: pipe < 0 ? target : body.slice(pipe + 1), embed};
+    }
+    state.pos = end + 2;
+    return true;
+  });
+  md.renderer.rules.rapier_wiki = (tokens, at, options, env) => render(tokens[at], env);
+}
+

package/dist/kit/will.d.mts

@@ -40,3 +40,6 @@ export function willMarkerOf(line: string): WillMarker | null;
 export function terminatorWidth(last: number, prior: number): number;
 /** The text without one trailing line terminator. */
 export function stripOneTerminator(text: string): string;
+/** Judges sequential UTF-16 source splices, including the resulting marker identities and protected text. */
+export function evaluateWill(beforeText: string, splices: {pos: number; removed: string; inserted: string}[]):
+  {outcome: 'applied'} | {outcome: 'invalid' | 'refused'; reason: string; rule: string; law?: WillLaw; region?: number};

package/dist/layout/hyphenation.mjs

@@ -1,9 +1,11 @@
 // SPDX-License-Identifier: MIT
 import {next, weight, exceptions, maximum} from '../agent/vendor/hyphen-en-us/patterns.js';
 
+export const hyphenMinimums = {left: 2, right: 3, word: 5};
+
 export function englishCuts(word) {
   if (!/^[A-Za-z]+$/.test(word)) return null;
-  if (word.length < 6) return [];
+  if (word.length < hyphenMinimums.word) return [];
   const cuts = [];
   let offset = 0, before = 0;
   for (const part of word.match(/[A-Z]+(?![a-z])|[A-Z]?[a-z]+/g)) {
@@ -11,11 +13,11 @@ export function englishCuts(word) {
     for (const at of partCuts(part)) cuts.push(offset+at);
     offset += part.length; before = part.length;
   }
-  return cuts.filter(at => at >= 3 && at <= word.length-3).sort((a, b) => a-b).filter((at, index, all) => at !== all[index-1]);
+  return cuts.filter(at => at >= hyphenMinimums.left && at <= word.length-hyphenMinimums.right).sort((a, b) => a-b).filter((at, index, all) => at !== all[index-1]);
 }
 
 function partCuts(word) {
-  if (word.length < 6) return [];
+  if (word.length < hyphenMinimums.word) return [];
   const lower = word.toLowerCase(), known = exceptions[lower];
   if (Array.isArray(known)) return known;
   const source = '.'+lower+'.', weights = new Uint8Array(source.length+1);
@@ -30,7 +32,7 @@ function partCuts(word) {
     }
   }
   const cuts = [];
-  for (let at = 3; at <= word.length-3; at++) if (weights[at+1]&1) cuts.push(at);
+  for (let at = hyphenMinimums.left; at <= word.length-hyphenMinimums.right; at++) if (weights[at+1]&1) cuts.push(at);
   return cuts;
 }
 

package/dist/layout/line-plan.mjs

@@ -55,9 +55,105 @@ function laterWholeWord(flow, cursor, line, items, bands, slot, next, materializ
   return false;
 }
 
+export function slotSequence(width, top, obstacles, lineHeight, minWidth, slotsForBand, direction = 'ltr', order = 'columns') {
+  const bottom = obstacles.length ? Math.max(...obstacles.map(item => item.y + item.height)) - top : 0, rows = [];
+  let y = 0;
+  while (y < bottom && rows.length < 768) {
+    const bands = slotsForBand(width, obstacles, top + y, lineHeight, Math.min(minWidth, width));
+    if (!bands) return null;
+    if (bands.length) { rows.push({y, bands}); y += lineHeight; continue; }
+    let next = Infinity;
+    for (const obstacle of obstacles) if (obstacle.x < width && obstacle.x + obstacle.width > 0 &&
+        obstacle.y < top + y + lineHeight && obstacle.y + obstacle.height > top + y) next = Math.min(next, obstacle.y + obstacle.height - top);
+    if (!Number.isFinite(next) || next <= y) return null;
+    y = next;
+  }
+  const multiple = rows.some(row => row.bands.length > 1);
+  if (!multiple) return {slots: rows.flatMap(row => row.bands.map(band => ({...band, y: row.y}))), end: y, multiple};
+  const free = row => row.bands.length === 1 && row.bands[0].x < .5 && row.bands[0].width > width - .5;
+  const slots = [];
+  let block = 0;
+  for (let at = 0; at < rows.length;) {
+    if (free(rows[at])) { slots.push({...rows[at].bands[0], y: rows[at].y}); at++; continue; }
+    let stop = at;
+    while (stop < rows.length && !free(rows[stop])) stop++;
+    block++;
+    const channels = [];
+    for (let index = at; index < stop; index++) for (const band of rows[index].bands) {
+      const owner = channels.find(channel => channel.row === index - 1 &&
+        Math.min(channel.last.x + channel.last.width, band.x + band.width) - Math.max(channel.last.x, band.x) > 0);
+      const slot = {...band, y: rows[index].y};
+      if (owner) { owner.slots.push(slot); owner.row = index; owner.last = slot; }
+      else channels.push({slots: [slot], row: index, last: slot, x: band.x});
+    }
+    channels.sort((a, b) => direction === 'rtl' ? b.x - a.x : a.x - b.x);
+    const gaps = rows.slice(at, stop).filter(row => row.bands.length > 1).map(row => row.bands[1].x - row.bands[0].x - row.bands[0].width).sort((a, b) => a - b);
+    const thin = gaps[gaps.length >> 1] < .15 * width;
+    if (!thin) channels.forEach((channel, index) => { for (const slot of channel.slots) { slot.block = block; slot.channel = index; } });
+    if (order === 'rows' || thin) slots.push(...channels.flatMap(channel => channel.slots).sort((a, b) => a.y - b.y || (direction === 'rtl' ? b.x - a.x : a.x - b.x)));
+    else for (const channel of channels) slots.push(...channel.slots);
+    at = stop;
+  }
+  return {slots, end: y, multiple};
+}
+
+function channelPlan(flow, width, lineHeight, sequence, layoutNextRichInlineLineRange, materializeRichInlineLineRange, items) {
+  const lines = [], slots = sequence.slots;
+  let cursor, previous = null;
+  const place = (band, later) => {
+    let range = layoutNextRichInlineLineRange(flow, band.width, cursor);
+    if (!range) return 'end';
+    if (!Number.isFinite(range.width) || range.width > width + .5) return 'fail';
+    if (range.width > band.width + .5) return 'skip';
+    let line = materializeRichInlineLineRange(flow, range);
+    if (!afterSource(lastSource(line), previous)) return 'fail';
+    if (laterWholeWord(flow, cursor, line, items, [band, ...later], 0, layoutNextRichInlineLineRange, materializeRichInlineLineRange)) return 'skip';
+    if (later.some(other => other.y === band.y) && insideChip(items, line)) {
+      const whole = beforeChip(flow, range, line, cursor, items, layoutNextRichInlineLineRange, materializeRichInlineLineRange);
+      if (whole) { range = whole.range; line = whole.line; }
+    }
+    if (!afterSource(lastSource(line), previous) || lines.length === 4096) return 'fail';
+    lines.push({...line, ...band});
+    previous = lastSource(line); cursor = range.end;
+    return 'placed';
+  };
+  const done = () => lines.length ? {lines, height: Math.max(lineHeight, ...lines.map(line => line.y + lineHeight))} : null;
+  for (let index = 0; index < slots.length; index++) {
+    const result = place(slots[index], [...slots.slice(index + 1, index + 9), {x: 0, width, y: sequence.end}]);
+    if (result === 'end') return done();
+    if (result === 'fail') return null;
+  }
+  for (let row = 0; row < 768; row++) {
+    const result = place({x: 0, width, y: sequence.end + row * lineHeight}, []);
+    if (result === 'end') return done();
+    if (result !== 'placed') return null;
+  }
+  return null;
+}
+
+export function columnsFilled(slots, placed) {
+  const total = new Map(), used = new Map(), reached = new Set();
+  for (const slot of slots) if (slot.block) total.set(slot.block + ':' + slot.channel, (total.get(slot.block + ':' + slot.channel) || 0) + 1);
+  for (const slot of placed) if (slot.block) { used.set(slot.block + ':' + slot.channel, (used.get(slot.block + ':' + slot.channel) || 0) + 1); reached.add(slot.block); }
+  for (const count of total.values()) if (count < 4) return false;
+  for (const block of reached) {
+    let last = -1;
+    for (const slot of slots) if (slot.block === block && slot.channel > last) last = slot.channel;
+    if ((used.get(block + ':' + last) || 0) < .6 * total.get(block + ':' + last)) return false;
+  }
+  return true;
+}
+
 export function linePlan(flow, width, top, obstacles, lineHeight, minWidth, direction, balance,
   slotsForBand, layoutNextRichInlineLineRange, materializeRichInlineLineRange, items = null) {
   if (!flow || balance) return null;
+  const sequence = obstacles.length ? slotSequence(width, top, obstacles, lineHeight, minWidth, slotsForBand, direction) : null;
+  if (sequence?.multiple) {
+    const columns = channelPlan(flow, width, lineHeight, sequence, layoutNextRichInlineLineRange, materializeRichInlineLineRange, items);
+    if (!columns || columnsFilled(sequence.slots, columns.lines)) return columns;
+    return channelPlan(flow, width, lineHeight, slotSequence(width, top, obstacles, lineHeight, minWidth, slotsForBand, direction, 'rows'),
+      layoutNextRichInlineLineRange, materializeRichInlineLineRange, items);
+  }
   const lines = [];
   let cursor, previous = null, y = 0, bottom = 0, rows = 0;
   for (let step = 0; step < 4096 && rows < 768; step++) {

package/dist/layout/model.mjs

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: MIT
 import {layoutNextRichInlineLineRange, materializeRichInlineLineRange} from '../agent/vendor/pretext/rich-inline.js';
 import {validLayout} from '../spec/md-layout.mjs';
-import {linePlan} from './line-plan.mjs';
+import {linePlan, slotSequence, columnsFilled} from './line-plan.mjs';
 import {captureFontAuthority, createPreparationScope, fontReady, invalidateRichMetrics, paragraphItems,
   prepareRichParagraph, supportsRichStyle} from './preparation.mjs';
 export {captureFontAuthority, createPreparationScope, invalidateRichMetrics, prepareRichParagraph, supportsRichStyle};
@@ -309,6 +309,7 @@ export function pictureSlices(profile, x, y, width, height, scale = 1) {
   return slices;
 }
 
+export {slotSequence, columnsFilled};
 export function slotsForBand(width, obstacles, top, height, minWidth = 40) {
   if (!finite(width) || width <= 0 || !finite(top) || !finite(height) || height <= 0 ||
       !finite(top + height) || !finite(minWidth) || minWidth <= 0 || !Array.isArray(obstacles)) return null;

package/dist/layout/paragraph-fit.mjs

@@ -22,7 +22,7 @@ export function createParagraphFitter() {
     return handle;
   }
 
-  function* solveSteps(handle, width, {indent = 0, left = 0, right = 0, widths = null, shrink = .4, stretch = .8} = {}, known) {
+  function* solveSteps(handle, width, {indent = 0, left = 0, right = 0, widths = null, shrink = .5, stretch = 1.2, hyphenCost = 8} = {}, known) {
     const prepared = indexes.get(handle);
     if (!prepared || ![width, indent, left, right].every(Number.isFinite) || width <= 0) return null;
     const measures = Array.isArray(widths) && widths.every(value => Number.isFinite(value) && value > 0) ? widths : [];
@@ -102,7 +102,7 @@ export function createParagraphFitter() {
           if (!Number.isFinite(natural)) continue;
           const count = lastWord - start.word, gapWidth = gaps[lastWord] - gaps[start.word];
           const opening = start.cut ? 0 : Math.min(Math.max(0, left), words[start.word].opening);
-          const closing = end.cut ? 0 : Math.min(Math.max(0, right), words[lastWord].closing);
+          const closing = end.cut ? Math.min(Math.max(0, right), end.cut.protrude || 0) : Math.min(Math.max(0, right), words[lastWord].closing);
           const priorDiscretionary = start.kind === 'soft' || start.kind === 'auto';
           if (final && priorDiscretionary) continue;
           for (let lineClass = 0; lineClass < classes; lineClass++) {
@@ -120,7 +120,7 @@ export function createParagraphFitter() {
             let local = 1 + 100 * Math.max(0, overflow / target) ** 2;
             if (final && startIndex) local += 100 * Math.max(0, .45 - natural / target) ** 2 + (count === 0 ? 25 : 0);
             else if (!final) local += (ratio < 0 ? 100 : 12.5) * ratio ** 2 + 2400 * (residual / target) ** 2;
-            if (discretionary) local += 12 + (priorDiscretionary ? 12 : 0);
+            if (discretionary) local += hyphenCost + (priorDiscretionary ? hyphenCost : 0);
             const set = !final && count && residual > 0 ? remaining / count : delta;
             const nextClass = Math.min(lineClass + 1, classes - 1);
             for (let active = available; active; active &= active - 1) {
@@ -153,7 +153,7 @@ export function createParagraphFitter() {
         const start = points[startIndex], end = points[endIndex], lastWord = end.cut ? end.word : end.word - 1;
         chosen.push({start: start.next, end: end.end, next: end.next, kind: end.kind, glyph: end.cut?.glyph || '',
           wordSpacing: spacing[best], opening: start.cut ? 0 : Math.min(Math.max(0, left), words[start.word].opening),
-          closing: end.cut ? 0 : Math.min(Math.max(0, right), words[lastWord].closing),
+          closing: end.cut ? Math.min(Math.max(0, right), end.cut.protrude || 0) : Math.min(Math.max(0, right), words[lastWord].closing),
           firstWord: start.word, lastWord, segment: segmentIndex});
         best = priorIndex; endIndex = startIndex;
       }

package/dist/layout/prepared-paragraph.mjs

@@ -2,9 +2,25 @@
 import {paragraphHyphens} from './hyphenation.mjs';
 import {prepareRichInlineSegments} from '../agent/vendor/pretext/rich-inline.js';
 import {getEngineProfile, getPreparationLanguage, getFontMeasurement, parseFontSize,
-  getTextWidth, getEmojiCorrection, textMayContainEmoji, measureWithLetterSpacing} from '../agent/vendor/pretext/measurement.js';
+  getTextWidth, getEmojiCorrection, textMayContainEmoji, getSegmentMetrics, getContext} 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';
 
+function measureWithLetterSpacing(text, letterSpacing, emojiCorrection, measurement) {
+  if (!measurement.state.takesLetterSpacing) return null;
+  const base = getTextWidth(text, measurement, emojiCorrection);
+  if (letterSpacing === 0) return base;
+  const corrected = getSegmentMetrics(text, measurement).width - base;
+  const context = getContext(measurement), previous = context.letterSpacing;
+  try {
+    context.letterSpacing = `${letterSpacing}px`;
+    if (Number.parseFloat(context.letterSpacing) !== letterSpacing) return null;
+    const width = context.measureText(text).width - corrected;
+    return Number.isFinite(width) ? width : null;
+  } finally {
+    context.letterSpacing = previous;
+  }
+}
+
 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);
@@ -141,7 +157,7 @@ export function* prepareParagraphCandidateSteps(items, options) {
       if (joined) {
         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;
+          if (unit.kind !== TEXT) continue;
           const delta = unit.width - measure(unit.start, unit.end);
           if (delta !== 0) contexts.push(Object.freeze({start: unit.start, end: unit.end, delta}));
           if (++measuredEdges % 8 === 0) yield;
@@ -152,6 +168,7 @@ export function* prepareParagraphCandidateSteps(items, options) {
       for (const cut of word.breaks) {
         if (cut.kind === 'soft' || cut.kind === 'auto') {
           cut.glyph = '-';
+          if (options.hanging && !word.protected) cut.protrude = parseFontSize(items[units[word.first].itemIndex].font) * .25;
         }
         let before = cut.at, after = cut.at + 1;
         if (cut.kind === 'auto') {

package/dist/layout/typography.mjs

@@ -464,6 +464,7 @@ export function createTypography() {
   function updateProjection(projection, plan) {
     for (const {node,property,line,sign} of projection.bindings) {
       const value = sign * plan.lines[line][property] + 'px';
+      if (node.hasAttribute(boundary)) { if (node.style.getPropertyValue('--md-fit-protrude') !== value) node.style.setProperty('--md-fit-protrude', value); continue; }
       const name = property === 'opening' ? 'marginInlineStart' : property === 'closing' ? 'marginInlineEnd' : 'wordSpacing';
       if (node.style[name] !== value) node.style[name] = value;
     }
@@ -487,7 +488,7 @@ export function createTypography() {
         add(line.end);
       }
       if (line.kind === 'space') operations.push({start:line.end,end:line.next,boundary:true});
-      else if (line.kind !== 'end') inserts.push({offset:line.end,glyph:line.glyph});
+      else if (line.kind !== 'end') inserts.push({offset:line.end,glyph:line.glyph,line:lineIndex,protrudes:line.closing>0});
       const first = words[line.firstWord], last = words[line.lastWord];
       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});
@@ -538,6 +539,7 @@ export function createTypography() {
       const at=ends.get(insert.offset);
       const marker=paragraph.ownerDocument.createElement('span');marker.setAttribute(boundary,insert.glyph?'hyphen':'');
       if (insert.glyph) marker.style.setProperty('--md-fit-hyphen',JSON.stringify(insert.glyph));
+      if (insert.protrudes) bindings.push({node:marker,property:'closing',line:insert.line,sign:-1});
       at.after(marker);
     }
     const projection = {bindings,topology:topology(plan)};
@@ -689,77 +691,69 @@ export function createTypography() {
     slotPlans.set(paragraph, {key, plan});
     return plan;
   }
-  function slotLines(paragraph, items, options, {width, top, obstacles, lineHeight, minWidth, slotsForBand, justify, hyphenate}) {
+  function slotLines(paragraph, items, options, {width, top, obstacles, lineHeight, minWidth, slotsForBand, slotSequence, columnsFilled, justify, hyphenate}) {
     if (!obstacles.length) return null;
     const doc = paragraph.ownerDocument, words = scope(doc);
     const source = items.map(item => ({...item, hyphenate}));
     const geometry = words.prepare(paragraph, source, {policy: 'paragraph', language: options.language, whiteSpace: 'normal',
       wordBreak: options.wordBreak, hanging: false, paragraphBreaks: [0, source.length]});
     if (!geometry) return null;
-    const sequence = [], bottom = Math.max(...obstacles.map(item => item.y + item.height)) - top;
-    let y = 0, rows = 0;
-    while (y < bottom && rows < 512 && sequence.length < 1024) {
-      const bands = slotsForBand(width, obstacles, top + y, lineHeight, Math.min(minWidth, width));
-      if (!bands) return null;
-      if (bands.length) {
-        for (const band of bands) sequence.push({x: band.x, y, width: band.width});
-        y += lineHeight; rows++; continue;
+    const build = order => {
+      const found = slotSequence(width, top, obstacles, lineHeight, minWidth, slotsForBand, 'ltr', order);
+      if (!found?.multiple) return null;
+      const sequence = found.slots, y = found.end;
+      const prepared = fitter.prepare(geometry);
+      let slots = sequence, plan = null;
+      for (let pass = 0; prepared && pass < 8; pass++) {
+        const measures = slots.map(slot => Math.floor(slot.width * 64) / 64);
+        if (!measures.length) return null;
+        plan = words.fit(paragraph, geometry, known => fitter.solveSteps(prepared, width, {widths: measures, shrink: justify ? undefined : 0}, known));
+        if (!plan) return null;
+        const wide = new Set();
+        plan.lines.forEach((line, index) => {
+          if (index >= slots.length || line.firstWord !== line.lastWord || line.kind === 'soft' || line.kind === 'auto') return;
+          const word = geometry.segments[line.segment].words[line.firstWord];
+          if (line.start === word.start && line.end === word.end && word.width > measures[index] + .5) wide.add(slots[index]);
+        });
+        if (!wide.size) break;
+        slots = slots.filter(slot => !wide.has(slot)); plan = null;
       }
-      let next = Infinity;
-      for (const obstacle of obstacles) if (obstacle.x < width && obstacle.x + obstacle.width > 0 &&
-          obstacle.y < top + y + lineHeight && obstacle.y + obstacle.height > top + y) next = Math.min(next, obstacle.y + obstacle.height - top);
-      if (!Number.isFinite(next) || next <= y) return null;
-      y = next;
-    }
-    const prepared = fitter.prepare(geometry);
-    let slots = sequence, plan = null;
-    for (let pass = 0; prepared && pass < 8; pass++) {
-      const measures = slots.map(slot => Math.floor(slot.width * 64) / 64);
-      if (!measures.length) return null;
-      plan = words.fit(paragraph, geometry, known => fitter.solveSteps(prepared, width, {widths: measures, shrink: justify ? undefined : 0}, known));
-      if (!plan) return null;
-      const wide = new Set();
-      plan.lines.forEach((line, index) => {
-        if (index >= slots.length || line.firstWord !== line.lastWord || line.kind === 'soft' || line.kind === 'auto') return;
-        const word = geometry.segments[line.segment].words[line.firstWord];
-        if (line.start === word.start && line.end === word.end && word.width > measures[index] + .5) wide.add(slots[index]);
-      });
-      if (!wide.size) break;
-      slots = slots.filter(slot => !wide.has(slot)); plan = null;
-    }
-    const perRow = new Map();
-    for (const slot of slots) perRow.set(slot.y, (perRow.get(slot.y) || 0) + 1);
-    if (!plan || ![...perRow.values()].some(count => count > 1)) return null;
-    const lines = [], text = geometry.text, offsets = geometry.offsets, space = /^[\t\n\f\r ]*$/;
-    for (let index = 0; index < plan.lines.length; index++) {
-      const line = plan.lines[index], slot = sequence[index] || {x: 0, y: y + (index - sequence.length) * lineHeight, width};
-      const spacing = justify ? line.wordSpacing : 0, fragments = [];
-      const segment = geometry.segments[line.segment].words.slice(line.firstWord, line.lastWord + 1);
-      let at = 0, previous = null;
-      while (at < source.length - 1 && offsets[at + 1] <= line.start) at++;
-      for (; at < source.length && offsets[at] < line.end; at++) {
-        let from = Math.max(line.start, offsets[at]), to = Math.min(line.end, offsets[at + 1]);
-        if (previous) while (from < to && /[\t\n\f\r ]/.test(text[from])) from++;
-        if (offsets[at + 1] < line.end) while (to > from && /[\t\n\f\r ]/.test(text[to - 1])) to--;
-        if (to <= from) continue;
-        const fragment = {itemIndex: at, sourceStart: from - offsets[at], sourceEnd: to - offsets[at], derive: true, occupiedWidth: 0, gapItemIndex: at, gapBefore: 0};
-        if (previous) {
-          fragment.gapItemIndex = previous.itemIndex;
-          if (previous.end < from) {
-            if (!space.test(text.slice(previous.end, from))) return null;
-            const before = segment.find(word => word.end === previous.end);
-            if (!before?.gap) return null;
-            fragment.gapBefore = before.gap.width + spacing;
-          } else fragment.gapBefore = 0;
+      const perRow = new Map();
+      for (const slot of slots) perRow.set(slot.y, (perRow.get(slot.y) || 0) + 1);
+      if (!plan || ![...perRow.values()].some(count => count > 1)) return null;
+      const lines = [], text = geometry.text, offsets = geometry.offsets, space = /^[\t\n\f\r ]*$/;
+      for (let index = 0; index < plan.lines.length; index++) {
+        const line = plan.lines[index], slot = sequence[index] || {x: 0, y: y + (index - sequence.length) * lineHeight, width};
+        const spacing = justify ? line.wordSpacing : 0, fragments = [];
+        const segment = geometry.segments[line.segment].words.slice(line.firstWord, line.lastWord + 1);
+        let at = 0, previous = null;
+        while (at < source.length - 1 && offsets[at + 1] <= line.start) at++;
+        for (; at < source.length && offsets[at] < line.end; at++) {
+          let from = Math.max(line.start, offsets[at]), to = Math.min(line.end, offsets[at + 1]);
+          if (previous) while (from < to && /[\t\n\f\r ]/.test(text[from])) from++;
+          if (offsets[at + 1] < line.end) while (to > from && /[\t\n\f\r ]/.test(text[to - 1])) to--;
+          if (to <= from) continue;
+          const fragment = {itemIndex: at, sourceStart: from - offsets[at], sourceEnd: to - offsets[at], derive: true, occupiedWidth: 0, gapItemIndex: at, gapBefore: 0};
+          if (previous) {
+            fragment.gapItemIndex = previous.itemIndex;
+            if (previous.end < from) {
+              if (!space.test(text.slice(previous.end, from))) return null;
+              const before = segment.find(word => word.end === previous.end);
+              if (!before?.gap) return null;
+              fragment.gapBefore = before.gap.width + spacing;
+            } else fragment.gapBefore = 0;
+          }
+          fragments.push(fragment); previous = {itemIndex: at, end: to};
         }
-        fragments.push(fragment); previous = {itemIndex: at, end: to};
+        if (!fragments.length) return null;
+        if (line.kind === 'soft' || line.kind === 'auto') fragments.at(-1).glyph = line.glyph || '-';
+        lines.push({x: slot.x, y: slot.y, width: slot.width, fragments, wordSpacing: spacing});
       }
-      if (!fragments.length) return null;
-      if (line.kind === 'soft' || line.kind === 'auto') fragments.at(-1).glyph = line.glyph || '-';
-      lines.push({x: slot.x, y: slot.y, width: slot.width, fragments, wordSpacing: spacing});
-    }
-    const last = lines.at(-1);
-    return {lines, height: last ? Math.max(lineHeight, last.y + lineHeight) : lineHeight};
+      return {plan: {lines, height: Math.max(lineHeight, ...lines.map(line => line.y + lineHeight))}, filled: columnsFilled(slots, slots.slice(0, plan.lines.length))};
+    };
+    const columns = build('columns');
+    if (!columns || columns.filled) return columns?.plan || null;
+    return build('rows')?.plan || columns.plan;
   }
 
   function retire(root, {documentChanged=false}={}) {

package/dist/spec/document-fonts.mjs

@@ -211,6 +211,7 @@ export function documentFontUsage(markdown, parser, defaultFont) {
 	const inherited = defaultFont === undefined ? settings.defaultfont : documentFont(defaultFont);
 	const main = family(settings.mainfont || inherited || settings.sansfont), sans = family(settings.sansfont || settings.mainfont || inherited), mono = family(settings.monofont);
 	const add = (name, text) => { if (name && !Object.hasOwn(FONT_STACKS, name.toLowerCase()) && text) use.set(name, (use.get(name) || '') + text + '\n'); };
+	if (!main && !sans && !mono && !source.includes('<')) return use;
 	const plain = html => md.utils.unescapeAll(String(html).replace(/<!--[^]*?-->/g, '').replace(/<(script|style)\b[^>]*>[^]*?<\/\1\s*>/gi, '').replace(/<[^>]*>/g, '').replace(/\\/g, '\\\\'));
 	let blockFamily = main;
 	for (const token of md.parse(splitOpeningFrontmatter(source).body, {})) {

package/dist/spec/document-settings.mjs

@@ -129,6 +129,7 @@ function paperOf(value) {
 	return pixels && width <= 10000 && height <= 10000 ? Object.freeze({name, width: width * 15, height: height * 15, css: width + 'px ' + height + 'px'}) : null;
 }
 export const pageSizeOf = settings => settings?.papersize || PAPERS.letter;
+export const paperForLanguage = language => /(?:^|[-_])(?:US|CA|MX|PH|CL|CO|VE|CR|GT)$/i.test(String(language || '')) ? PAPERS.letter : PAPERS.a4;
 export const PAGE_SIZES = Object.freeze(['letter', 'legal', 'tabloid', 'a3', 'a4', 'a5', '1080x1080px', '1080x1350px', '1920x1080px', '1200x630px']);
 const EMPTY = Object.freeze({
 	title: null, subtitle: null, lang: null, fontsize: null, mainfont: null, sansfont: null, monofont: null, defaultfont: null, linestretch: null,

package/dist/spec/html-blocks.mjs

@@ -425,7 +425,7 @@ export function mountHtmlBlocks(doc, options = {}) {
           const name = attr.name.toLowerCase(), value = attr.value;
           if (name.startsWith('on') || name.startsWith('data-rapier-') || ['nonce','srcdoc','is','autofocus','form','formaction','action','target','download','ping','xmlns:xlink'].includes(name)) el.removeAttribute(attr.name);
           if (['src','srcset','href'].includes(attr.localName.toLowerCase()) && !(name.endsWith('href') && /^#[A-Za-z][\w.-]*$/.test(value) ||
-              (name === 'src' && tag === 'img' || name.endsWith('href') && tag === 'image') && /^data:image\/(?:png|jpeg|webp|gif|jxl|svg\+xml);/i.test(value))) el.removeAttribute(attr.name);
+              (name === 'src' && tag === 'img' || name.endsWith('href') && tag === 'image') && /^data:image\/(?:(?:png|jpeg|webp|gif|jxl|svg\+xml);|svg\+xml,)/i.test(value))) el.removeAttribute(attr.name);
         }
         if (tag.startsWith('animate') || tag === 'set') {
           const attribute = (el.getAttribute('attributeName') || '').trim().toLowerCase().split(':').pop();
@@ -437,13 +437,16 @@ export function mountHtmlBlocks(doc, options = {}) {
           const name = tag === 'img' ? 'src' : el.hasAttribute('href') ? 'href' : 'xlink:href', original = el.getAttribute(name);
           if (original) {
             const match = /^data:(image\/(?:png|jpeg|webp|gif|jxl|svg\+xml));(?:charset=[^;,]+;)?base64,([A-Za-z0-9+/]+={0,2})$/i.exec(original);
-            if (!match || original.length > 24 * 1024 * 1024) throw new Error('Image requires a bounded base64 data URL');
-            const url = 'data:' + match[1].toLowerCase() + ';base64,' + match[2];
-            const bytes = Uint8Array.from(win.atob(match[2]), c => c.charCodeAt(0));
-            const info = match[1].toLowerCase() === 'image/gif' ? media.inspectGIF(bytes) : imageInfo(url) || admitted[url];
-            if (!info && match[1].toLowerCase() !== 'image/svg+xml') {el.removeAttribute(name); continue;}
+            const percent = /^data:image\/svg\+xml,/i.test(original);
+            if ((!match && !percent) || original.length > 24 * 1024 * 1024) throw new Error('Image requires a bounded base64 data URL');
+            const mime = percent ? 'image/svg+xml' : match[1].toLowerCase();
+            const url = percent ? original : 'data:' + mime + ';base64,' + match[2];
+            const bytes = percent ? new win.TextEncoder().encode(decodeURIComponent(original.slice(19)))
+              : Uint8Array.from(win.atob(match[2]), c => c.charCodeAt(0));
+            const info = mime === 'image/gif' ? media.inspectGIF(bytes) : imageInfo(url) || admitted[url];
+            if (!info && mime !== 'image/svg+xml') {el.removeAttribute(name); continue;}
             if (info) {pixels += info.width * info.height; if (pixels > 24000000) throw new Error('HTML image pixel budget'); admitted[url] = {width: info.width, height: info.height, animated: !!info.animated};}
-            if (match[1].toLowerCase() === 'image/svg+xml') {
+            if (mime === 'image/svg+xml') {
               const svgText = new win.TextDecoder('utf-8', {fatal: true}).decode(bytes);
               if (/<!\s*(?:DOCTYPE|ENTITY)\b/i.test(svgText)) throw new Error('SVG declarations are unsupported');
               const parsed = new win.DOMParser().parseFromString(svgText, 'image/svg+xml');