rapier-markdown-kit 1.1.101 → 1.1.104

package/dist/spec/document-fonts.mjs

@@ -3,7 +3,7 @@
 import {markdownParser, installMarkdownImages, normalizeLabel} from './md-assets.mjs';
 import {splitOpeningFrontmatter} from './frontmatter.mjs';
 import {readDocumentSettings, documentFont} from './document-settings.mjs';
-import {normalizeFontFamily, fontFamilyCss, FONT_STACKS} from './md-marks.mjs';
+import {normalizeFontFamily, fontFamilyCss, FONT_STACKS, typography} from './md-marks.mjs';
 
 // Unquoted CSS generic families require no portable asset. Quoted names remain custom.
 export const CSS_GENERIC_FONT_FAMILIES = Object.freeze(['serif', 'sans-serif', 'monospace', 'cursive', 'fantasy', 'system-ui',
@@ -188,6 +188,13 @@ function htmlFontFamilies(html, md) {
 	for (const tag of html.matchAll(/<[A-Za-z][A-Za-z0-9:-]*(?:"[^"]*"|'[^']*'|[^'">])*>/g)) {
 		for (const attr of tag[0].matchAll(/\s(data-md-font|style)\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>]+))/gi)) {
 			const value = decode(attr[2] ?? attr[3] ?? attr[4]), names = [];
+			if (/^<span(?=[\s>])/i.test(tag[0])) {
+				// Raw or unpaired spans use the same admission as paired typography. A CSS
+				// resource expression or authored data-* hook cannot request a font asset.
+				const family = attr[1].toLowerCase() === 'style' ? typography.parseStyle(value).family : null;
+				if (family?.custom) families.add(family.name);
+				continue;
+			}
 			if (attr[1].toLowerCase() === 'data-md-font') names.push(value);
 			else for (const declared of value.matchAll(/(?:^|;)\s*font-family\s*:\s*((?:"(?:\\.|[^"])*"|'(?:\\.|[^'])*'|[^;])*)/gi)) {
 				const match = /^\s*(?:"((?:\\.|[^"])*)"|'((?:\\.|[^'])*)'|([^,!]+))/.exec(declared[1]);
@@ -230,9 +237,11 @@ export function documentFontUsage(markdown, parser, defaultFont) {
 			for (const child of token.children || []) {
 				if (child.type === 'html_inline') html += child.content;
 				if (['text', 'text_special', 'emoji', 'image', 'code_inline'].includes(child.type)) text += child.content;
-				const marked = child.type === 'rapier_font_open' ? normalizeFontFamily(child.attrGet('data-md-font')) : null;
-				if (marked) { stack.push(marked); continue; }
-				if (child.type === 'rapier_font_close') { if (stack.length > 1) stack.pop(); continue; }
+				const typed = child.meta?.typography;
+				if (typed && child.nesting === 1) {
+					stack.push(typed.style.family ? typed.style.family.custom ? typed.style.family.name : null : stack.at(-1)); continue;
+				}
+				if (typed && child.nesting === -1) { if (stack.length > 1) stack.pop(); continue; }
 				if (child.type === 'code_inline') add(mono, child.content);
 				else if (['text', 'text_special', 'emoji', 'image'].includes(child.type)) add(stack.at(-1), child.content);
 			}

package/dist/spec/md-assets.mjs

@@ -73,6 +73,128 @@ function parserFor(factory = configured || globalThis.markdownit) {
 export {parserFor as markdownParser};
 export const markdownBodyOffset = source => splitSource ? splitSource(source).bodyOffset : 0;
 
+// markdown-it's block state builds five tables with one entry per line of its whole input, and its rules index
+// them by line. A long body gets the parser's one block pass with tables that hold a run of lines instead: a read
+// past the lines they hold fills them further from the parser's own line scan, and they are emptied between
+// top-level blocks. No line is parsed twice, so every token and `env` are the ones a whole-input state yields.
+const BLOCK_WINDOW = 1024, TABLE_STEP = 128, WINDOW_END = Symbol('block window end');
+const LINE_TABLES = ['bMarks', 'eMarks', 'tShift', 'sCount', 'bsCount'];
+const lineIndex = key => typeof key === 'string' && /^(?:0|[1-9]\d*)$/.test(key);
+// An array reaches its prototype only for an index it does not hold. One prototype serves every pass, so the
+// parser's table reads see one more array shape, not one per pass.
+let unheldLine = null;
+const unheldLines = new Proxy(Array.prototype, {
+  get: (target, key, table) => unheldLine && lineIndex(key) ? unheldLine(table, Number(key)) : Reflect.get(target, key, table),
+  set: (target, key, value, table) => unheldLine && lineIndex(key) ? unheldLine(table, Number(key), true, value) : Reflect.set(target, key, value, table),
+});
+
+// The parser's block pass over source.slice(bodyOffset). `visit` receives top-level blocks as they finish:
+// `tokens` with line numbers counted from `firstLine`, and lineStart(line), the source offset where one of those
+// lines begins (undefined when the source ends before it). `env` is the whole pass's. The tables hold at most
+// the lines between two visits: BLOCK_WINDOW of them, or as many as one block's rules read.
+export function eachBlockWindow(source, bodyOffset, parser, env, visit, keepNul = false) {
+  const lineEnds = source.slice(bodyOffset).replace(/\r\n?/g, '\n'), body = keepNul ? lineEnds : lineEnds.replace(/\0/g, '\ufffd');
+  // The body is the source with every CRLF one unit shorter: count the pairs before a body offset, from the last
+  // offset asked.
+  let pair = source.indexOf('\r\n', bodyOffset), shift = bodyOffset;
+  const sourceOffset = at => {
+    while (pair >= 0 && at + shift > pair) { shift++; pair = source.indexOf('\r\n', pair + 2); }
+    for (let last; shift > bodyOffset && at + shift - 1 <= (last = source.lastIndexOf('\r\n', (pair < 0 ? source.length : pair) - 1)); pair = last) shift--;
+    return at + shift;
+  };
+  const tokens = [];
+  let origin = 0, first = 0, state;
+  // A line begins after the newline that ends the line before it. No rule writes eMarks.
+  const report = () => visit({tokens, firstLine: first, lineStart: line => {
+    if (!line) return sourceOffset(origin);
+    const end = Object.hasOwn(state.eMarks, line - 1) ? state.eMarks[line - 1] : body.length;
+    return end < body.length ? sourceOffset(end + 1) : undefined;
+  }});
+  let lines = 0;
+  for (let at = 0; at < body.length; at++) if (body.charCodeAt(at) === 10) lines++;
+  if (lines <= BLOCK_WINDOW) {
+    state = new parser.block.State(body, parser, env, tokens);
+    parser.block.tokenize(state, state.line, state.lineMax);
+    return report();
+  }
+  // The parser's own count of a last line that no newline ends: it does not count one of only spaces.
+  state = new parser.block.State(body.slice(body.lastIndexOf('\n') + 1), parser, env, tokens);
+  lines += state.lineMax;
+  state.src = body;
+  const tables = new WeakMap();
+  for (const name of LINE_TABLES) { state[name].length = 0; tables.set(Object.setPrototypeOf(state[name], unheldLines), name); }
+  let frontier = 0, ended = false, betweenBlocks = false;
+  // A rule may be reading a table when it grows, so the five arrays are replaced whole; an array a rule still
+  // holds is left empty, and `answer` reads and writes the state's current one in its place.
+  const fill = line => {
+    while (!ended && line >= state.bMarks.length) {
+      const held = state.bMarks.length;
+      let until = frontier;
+      for (let more = held ? Math.max(TABLE_STEP, held - BLOCK_WINDOW) : BLOCK_WINDOW; more && until < body.length; more--) {
+        const end = body.indexOf('\n', until);
+        until = end < 0 ? body.length : end + 1;
+      }
+      const scanned = new parser.block.State(body.slice(frontier, until), parser, env, []);
+      ended = until === body.length;
+      // The scan's last entry stands for the end of its input, which is the body's end only for the last scan.
+      const added = ended ? scanned.lineMax + 1 : scanned.lineMax;
+      for (const name of LINE_TABLES) {
+        const old = state[name], next = scanned[name], offset = name === 'bMarks' || name === 'eMarks' ? frontier : 0, table = [];
+        for (let at = 0; at < held; at++) table.push(old[at]);
+        for (let at = 0; at < added; at++) table.push(next[at] + offset);
+        old.length = 0;
+        tables.set(table, name);
+        state[name] = Object.setPrototypeOf(table, unheldLines);
+      }
+      frontier = until;
+    }
+  };
+  const answer = (table, line, write, value) => {
+    const name = tables.get(table);
+    if (line >= state[name].length) {
+      if (betweenBlocks) throw WINDOW_END;
+      fill(line);
+    }
+    const current = state[name], held = Object.hasOwn(current, line);
+    if (!write) return held ? current[line] : undefined;
+    if (held) current[line] = value;
+    else Object.defineProperty(current, line, {value, writable: true, enumerable: true, configurable: true});
+    return true;
+  };
+  // The top-level loop calls this between two blocks with the line it stands on. There every token is a finished
+  // block and no rule is running, so the pass can leave the tokenizer and enter it again at that line.
+  const skipEmptyLines = state.skipEmptyLines;
+  state.skipEmptyLines = function (line) {
+    if (this.level || line !== this.line || !line) return skipEmptyLines.call(this, line);
+    if (line >= BLOCK_WINDOW) throw WINDOW_END;
+    betweenBlocks = true;
+    line = skipEmptyLines.call(this, line);
+    betweenBlocks = false;
+    return line;
+  };
+  for (;;) {
+    // Between top-level blocks the parser's loop only steps over empty lines, so a run of them is never tabled.
+    for (let at = origin; at < body.length; at++) {
+      const code = body.charCodeAt(at);
+      if (code === 10) { origin = at + 1; first++; }
+      else if (!parser.utils.isSpace(code)) break;
+    }
+    frontier = origin; ended = false; betweenBlocks = false;
+    state.line = 0; state.lineMax = lines - first;
+    const outer = unheldLine;
+    unheldLine = answer;
+    let finished = true;
+    try { parser.block.tokenize(state, 0, state.lineMax); }
+    catch (error) { if (error !== WINDOW_END) throw error; finished = false; }
+    finally { unheldLine = outer; }
+    report();
+    if (finished) return;
+    tokens.length = 0;
+    origin = state.eMarks[state.line - 1] + 1; first += state.line;
+    for (const name of LINE_TABLES) state[name].length = 0;
+  }
+}
+
 export function dataImage(url) {
   if (typeof url !== 'string' || url.length > IMAGE_LIMITS.sourceChars) return null;
   const prepared = preparedDefinitions.find(row => row.image.url === url)?.image;
@@ -94,36 +216,33 @@ export function parseAssets(source, factory = configured || globalThis.markdowni
   if (prior) return prior.index;
   const definition = !bodyOffset && preparedDefinitions.find(row => row.source === source && row.factory === factory);
   if (definition) return definition.index;
-  const parser = parserFor(factory), env = {}, tokens = [];
-  const starts = [bodyOffset];
-  for (let at = bodyOffset; at < source.length; at++) {
-    if (source[at] === '\r') { if (source[at + 1] === '\n') at++; starts.push(at + 1); }
-    else if (source[at] === '\n') starts.push(at + 1);
-  }
-  parser.block.parse(source.slice(bodyOffset).replace(/\r\n?/g, '\n').replace(/\0/g, '\ufffd'), parser, env, tokens);
-  const references = env.references || Object.create(null), assets = new Map(), blocks = [], seen = new Set(), duplicateLabels = new Set();
-  for (const token of tokens) {
-    if (token.type !== 'reference_definition' || !token.map) continue;
-    const id = token.meta.label, definition = token.meta.mdImageDefinition, first = !seen.has(id);
-    if (!first) duplicateLabels.add(id);
-    seen.add(id);
-    const info = dataImage(definition?.href);
-    if (!info) continue;
-    const start = starts[token.map[0]], stop = starts[token.map[1]] ?? source.length;
-    let end = stop;
-    if (source[end - 1] === '\n') end--;
-    if (source[end - 1] === '\r') end--;
-    // Repeated definitions are source, not additional image owners.
-    const raw = source.slice(start, end), found = raw.indexOf(definition.href);
-    const repeated = found >= 0 ? raw.indexOf(definition.href, found + 1) : -1;
-    const labelContainsUrl = definition.href.length <= id.length && id.includes(parser.utils.normalizeReference(definition.href));
-    const urlStart = found >= 0 && repeated < 0 && !labelContainsUrl ? start + found : null;
-    const row = {id, label: id, source: raw, url: definition.href, title: definition.title || '', start, end,
-      ...info, urlStart, urlEnd: urlStart == null ? null : urlStart + definition.href.length,
-      payloadStart: urlStart == null ? null : urlStart + info.payloadStart, payloadEnd: urlStart == null ? null : urlStart + definition.href.length, status: 'unverified', active: first, topLevel: token.level === 0};
-    blocks.push(row);
-    if (first) assets.set(id, row);
-  }
+  const parser = parserFor(factory), env = {};
+  const assets = new Map(), blocks = [], seen = new Set(), duplicateLabels = new Set();
+  eachBlockWindow(source, bodyOffset, parser, env, ({tokens, lineStart}) => {
+    for (const token of tokens) {
+      if (token.type !== 'reference_definition' || !token.map) continue;
+      const id = token.meta.label, definition = token.meta.mdImageDefinition, first = !seen.has(id);
+      if (!first) duplicateLabels.add(id);
+      seen.add(id);
+      const info = dataImage(definition?.href);
+      if (!info) continue;
+      const start = lineStart(token.map[0]), stop = lineStart(token.map[1]) ?? source.length;
+      let end = stop;
+      if (source[end - 1] === '\n') end--;
+      if (source[end - 1] === '\r') end--;
+      // Repeated definitions are source, not additional image owners.
+      const raw = source.slice(start, end), found = raw.indexOf(definition.href);
+      const repeated = found >= 0 ? raw.indexOf(definition.href, found + 1) : -1;
+      const labelContainsUrl = definition.href.length <= id.length && id.includes(parser.utils.normalizeReference(definition.href));
+      const urlStart = found >= 0 && repeated < 0 && !labelContainsUrl ? start + found : null;
+      const row = {id, label: id, source: raw, url: definition.href, title: definition.title || '', start, end,
+        ...info, urlStart, urlEnd: urlStart == null ? null : urlStart + definition.href.length,
+        payloadStart: urlStart == null ? null : urlStart + info.payloadStart, payloadEnd: urlStart == null ? null : urlStart + definition.href.length, status: 'unverified', active: first, topLevel: token.level === 0};
+      blocks.push(row);
+      if (first) assets.set(id, row);
+    }
+  });
+  const references = env.references || Object.create(null);
   if (assets.size > IMAGE_LIMITS.assets) for (const asset of assets.values()) asset.status = 'asset_count_limit';
   let appendixStart = source.length;
   for (let index = blocks.length - 1; index >= 0; index--) {

package/dist/spec/md-layout.mjs

@@ -103,14 +103,16 @@ export const parseLayoutAttribute = value => parseLayout(decodeLayoutAttribute(v
 export function textStyle(value, {portable = false, pointSize, indentOffset = 0} = {}) {
   if (!validLayout(value)) return '';
   const property = {first: 'text-indent', indent: 'margin-inline-start'};
-  return (portable ? ['first', 'indent'] : ['first', 'indent', 'marker'])
+  const css = (portable ? ['first', 'indent'] : ['first', 'indent', 'marker'])
     .filter(key => has(value, key) || key === 'indent' && indentOffset).map(key => {
       const level = (value[key] || 0) + (key === 'indent' ? indentOffset : 0);
       const measure = decimal(Number((level * 2).toFixed(6)));
       return (portable ? property[key] : '--md-' + key) + ':' + (portable ?
         pointSize ? decimal(Math.round(level * pointSize * 40) / 20) + 'pt' : measure + 'em' :
         'calc(' + measure + ' * var(--md-text-body))');
-    }).join(';');
+    });
+  if (portable && value.hyphens === 'auto') css.push('hyphens:auto');
+  return css.join(';');
 }
 
 // Raw HTML tables carry ordinary paragraph CSS. Read the browser's parsed declarations on the same
@@ -127,6 +129,7 @@ export function textLayout(style, {listMarker = false, pointSize, offset = 0} =
     // rather than each intermediate declaration, is the measurement the writer must keep.
     if (Number.isFinite(level) && level) value[key] = level;
   }
+  if (!listMarker && style?.getPropertyValue('hyphens').trim() === 'auto') value.hyphens = 'auto';
   return value;
 }
 

package/dist/spec/md-marks.mjs

@@ -1,5 +1,6 @@
 // SPDX-License-Identifier: MIT
-// The one owner of colour, font, ink and page-break markers.
+// The one owner of inline typography, authored colour/font comments, ink and page breaks.
+import {markdownSourcePositions} from './md-source.mjs';
 
 // The exported page retains this reader alone. The editor uses the same closure, then adds its writers and scans.
 const inkReader = () => {
@@ -84,7 +85,7 @@ export function formatColorOpen(hex) {
 }
 
 export function formatColorRun(hex, content) {
-	return formatColorOpen(hex) + content + COLOR_CLOSE;
+	return typography.wrap({color: hex}, content);
 }
 
 // Relocated into the parse Worker by .toString() (engine.js _buildParseWorkerSource): read only parameters, TEXT_COLOR_NAMES and COLOR_CLOSE.
@@ -165,7 +166,7 @@ export function formatFontOpen(family) {
 }
 
 export function formatFontRun(family, content) {
-	return formatFontOpen(family) + content + FONT_CLOSE;
+	return typography.wrap({family}, content);
 }
 
 export function matchFontOpen(text) {
@@ -209,6 +210,220 @@ export function hasFontMarker(source) {
 	return scanFontMarkers(source).length > 0;
 }
 
+// One typed interpretation for source, DOM and native-file adapters. The worker carries this
+// exact factory and its explicit grammar inputs; no DOM, CSS evaluator or resource loader.
+export function createTypography({normalizeFontFamily, fontFamilyCss, parseColorOpen, parseFontOpen, FONT_STACKS}) {
+	const LIMIT = 4096, DEPTH = 64;
+	const generics = {serif: 'serif', 'sans-serif': 'sans', monospace: 'mono', cursive: 'hand',
+		fantasy: 'fantasy', 'system-ui': 'system', 'ui-serif': 'ui-serif', 'ui-sans-serif': 'ui-sans-serif',
+		'ui-monospace': 'ui-monospace', 'ui-rounded': 'ui-rounded', emoji: 'emoji', math: 'math', fangsong: 'fangsong'};
+	const escape = value => String(value).replace(/&/g, '&amp;').replace(/"/g, '&quot;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+	function size(value) {
+		if (typeof value !== 'string' || value.length > 48) return null;
+		const match = /^(\d+(?:\.\d{0,12})?|\.\d{1,12})\s*(pt|px)$/i.exec(value.trim());
+		if (!match) return null;
+		const number = Number(match[1]), unit = match[2].toLowerCase(), points = number * (unit === 'px' ? .75 : 1);
+		if (!(points > 0 && points <= 1638)) return null;
+		const [integer, fraction = ''] = match[1].split('.'), tail = fraction.replace(/0+$/, '');
+		return Object.freeze({css: (integer.replace(/^0+/, '') || '0') + (tail ? '.' + tail : '') + unit,
+			unit, value: number, points, halfPoints: points * 2});
+	}
+	function color(value) {
+		if (typeof value !== 'string') return null;
+		if (/^#[0-9a-f]{6}$/i.test(value.trim())) return value.trim().toLowerCase();
+		// CSSOM serializes admitted hex to opaque rgb(). Native HTML import uses this same boundary.
+		const rgb = /^rgba?\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*(?:,\s*1\s*)?\)$/i.exec(value.trim());
+		return rgb && rgb.slice(1).every(channel => Number(channel) <= 255)
+			? '#' + rgb.slice(1).map(channel => Number(channel).toString(16).padStart(2, '0')).join('') : null;
+	}
+	function familyCss(value) {
+		if (typeof value !== 'string' || value.length > 2048) return null;
+		const css = value.trim();
+		const stackKey = text => text.replace(/'/g, '"').replace(/"([\w-]+)"/g, '$1').replace(/\s*,\s*/g, ',');
+		for (const [name] of Object.entries(FONT_STACKS)) if ((!/^["']/.test(css) || css.includes(',')) && stackKey(css) === stackKey(fontFamilyCss(name)))
+			return Object.freeze({name, css: fontFamilyCss(name), custom: false});
+		if (Object.hasOwn(generics, css.toLowerCase())) return Object.freeze({name: generics[css.toLowerCase()], css: css.toLowerCase(), custom: false});
+		let name = css;
+		if (css[0] === '"' || css[0] === "'") {
+			if (css.at(-1) !== css[0]) return null;
+			name = '';
+			for (let at = 1; at < css.length - 1; at++) {
+				if (css[at] === css[0] || /[\r\n\f]/.test(css[at])) return null;
+				if (css[at] !== '\\') { name += css[at]; continue; }
+				const escaped = /^\\(?:([0-9a-f]{1,6})(?:\r\n|[ \t\r\n\f])?|([^\r\n\f]))/i.exec(css.slice(at));
+				if (!escaped || at + escaped[0].length > css.length - 1) return null;
+				const code = escaped[1] ? parseInt(escaped[1], 16) : 0;
+				name += escaped[1] ? code && code <= 0x10ffff && !(code >= 0xd800 && code <= 0xdfff) ? String.fromCodePoint(code) : '\ufffd' : escaped[2];
+				at += escaped[0].length - 1;
+			}
+		} else if (!/^[\p{L}_-][\p{L}\p{N}_ -]*$/u.test(css) || /^(?:inherit|initial|unset|revert|revert-layer)$/i.test(css)) return null;
+		name = normalizeFontFamily(name);
+		// These five names are the existing family-choice aliases, not custom font identities.
+		if (name && Object.hasOwn(FONT_STACKS, name.toLowerCase())) return null;
+		return name ? Object.freeze({name, css: '"' + name.replace(/[\\"]/g, '\\$&') + '"', custom: true}) : null;
+	}
+	function family(value) {
+		if (value && typeof value === 'object') {
+			const parsed = familyCss(value.css);
+			return parsed && parsed.name === value.name && parsed.custom === value.custom ? parsed : null;
+		}
+		const name = normalizeFontFamily(value);
+		return name ? familyCss(fontFamilyCss(name)) : null;
+	}
+	function normalize(value, removals = false) {
+		if (!value || typeof value !== 'object' || Array.isArray(value)) throw new TypeError('Typography requires size, color or family.');
+		const result = {};
+		for (const key of Object.keys(value)) {
+			if (!['size', 'color', 'family'].includes(key)) throw new TypeError('Unknown typography property: ' + key);
+			if (value[key] === null && removals) { result[key] = null; continue; }
+			const parsed = key === 'size' ? size(value[key])?.css : key === 'color' ? color(value[key]) : family(value[key]);
+			if (!parsed) throw new TypeError('Invalid typography ' + key + '.');
+			result[key] = parsed;
+		}
+		return Object.freeze(result);
+	}
+	// Rendering drops unsupported declarations; rich editing admits only wholly owned
+	// spans so unrelated HTML and rejected attributes keep their exact-source editor.
+	function parseStyle(value, editable = false) {
+		if (typeof value !== 'string' || value.length > LIMIT) return editable ? null : Object.freeze({});
+		const parts = []; let quote = '', start = 0;
+		for (let at = 0; at <= value.length; at++) {
+			const ch = value[at];
+			if (quote) { if (ch === '\\') at++; else if (ch === quote) quote = ''; }
+			else if (ch === '"' || ch === "'") quote = ch;
+			else if (ch === ';' || at === value.length) { parts.push(value.slice(start, at)); start = at + 1; }
+		}
+		if (quote || parts.length > 32) return editable ? null : Object.freeze({});
+		const result = {};
+		for (const part of parts) {
+			if (!part.trim()) continue;
+			const colon = part.indexOf(':'); if (colon < 0) { if (editable) return null; continue; }
+			const key = part.slice(0, colon).trim().toLowerCase(), raw = part.slice(colon + 1).trim();
+			const parsed = key === 'font-size' ? size(raw)?.css : key === 'color' ? color(raw) : key === 'font-family' ? familyCss(raw) : null;
+			if (parsed) result[key === 'font-size' ? 'size' : key === 'font-family' ? 'family' : 'color'] = parsed;
+			else if (editable) return null;
+		}
+		return Object.freeze(result);
+	}
+	function style(value) {
+		const held = normalize(value), parts = [];
+		if (held.size) parts.push('font-size:' + held.size);
+		if (held.color) parts.push('color:' + held.color);
+		if (held.family) parts.push('font-family:' + held.family.css);
+		return parts.join(';');
+	}
+	const open = value => { const css = style(value); return css ? '<span style="' + escape(css) + '">' : ''; };
+	const wrap = (value, content) => {
+		const start = open(value);
+		if (!start || !content) return content;
+		// Importers can supply a styled break by itself, or before/after words. Keep
+		// those exact line-edge bytes outside the new span so its opener has words.
+		const prefix = /^(?:[ \t]*(?:\r\n|\r(?!\n)|\n))+/.exec(content)?.[0] || '';
+		let body = content.slice(prefix.length);
+		const suffix = /(?:[ \t]*(?:\r\n|\r(?!\n)|\n))+[ \t]*$/.exec(body)?.[0] || '';
+		body = body.slice(0, body.length - suffix.length);
+		if (!body) return content;
+		// Soft/hard line breaks can belong to one Markdown paragraph. A blank line or
+		// an opener on a line of its own would instead change the block grammar.
+		if (/^\s*\n|\n[ \t]*\n/.test(body.replace(/\r\n?/g, '\n')))
+			throw new TypeError('Typography wraps one inline paragraph at a time.');
+		return prefix + start + body + '</span>' + suffix;
+	};
+	function parseOpen(source, decode = value => value, editable = false) {
+		if (typeof source !== 'string' || source.length > LIMIT + 1024 || !/^<span(?=[\s>])/i.test(source) || !source.endsWith('>') || /\/\s*>$/.test(source)) return null;
+		const attrs = /\s+([^\s=<>/"']+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s=<>`"']+)))?/y;
+		let at = 5, css = null;
+		while (at < source.length - 1) {
+			if (/^\s*>$/.test(source.slice(at))) break;
+			attrs.lastIndex = at; const match = attrs.exec(source);
+			if (!match) return null;
+			at = attrs.lastIndex;
+			if (match[1].toLowerCase() !== 'style') { if (editable) return null; continue; }
+			if (css !== null) return null;
+			css = decode(match[2] ?? match[3] ?? match[4] ?? '');
+		}
+		const facts = parseStyle(css, editable);
+		return facts && Object.keys(facts).length ? facts : null;
+	}
+	function nodeStyle(node) {
+		const result = {...parseStyle(node?.getAttribute?.('style') || '')};
+		const authoredSize = size(node?.getAttribute?.('data-md-size'));
+		const authoredColor = color(node?.getAttribute?.('data-md-color'));
+		const authoredFamily = normalizeFontFamily(node?.getAttribute?.('data-md-font'));
+		if (authoredSize) result.size = authoredSize.css;
+		if (authoredColor) result.color = authoredColor;
+		if (authoredFamily && !result.family) result.family = family(authoredFamily);
+		return Object.freeze(result);
+	}
+	function runs(root) {
+		let text = ''; const paint = [], leaves = [];
+		const visit = (node, inherited, blocked) => {
+			if (node.nodeType === 3) {
+				const value = String(node.nodeValue || '').replace(/\u2060/g, '\n'), start = text.length;
+				text += value;
+				for (let index = 0; index < value.length; index++) paint.push(inherited);
+				if (value) leaves.push({start, end: text.length, blocked});
+				return;
+			}
+			if (node.nodeType !== 1 && node !== root) return;
+			const own = nodeStyle(node), next = {...inherited, ...own};
+			const literal = blocked || /^(?:CODE|PRE|KBD|SAMP|MATH)$/.test(node.tagName) ||
+				node.classList?.contains('math-rendered') || node.classList?.contains('math-placeholder');
+			for (const child of node.childNodes || []) visit(child, next, !!literal);
+		};
+		visit(root, {}, false);
+		return {text, paint, leaves};
+	}
+	function install(md) {
+		if (md.__rapierTypography) return md;
+		md.__rapierTypography = true;
+		md.core.ruler.after('linkify', 'rapier-typography', state => {
+			for (const block of state.tokens) {
+				if (block.type !== 'inline' || !block.children) continue;
+				const stack = []; let depth = 0, overflow = 0;
+				for (const token of block.children) {
+					if (token.type !== 'html_inline') { depth += token.nesting || 0; continue; }
+					const source = token.content, htmlClose = /^<\/span\s*>$/i.test(source);
+					const kind = htmlClose || /^<span(?=[\s>])/i.test(source) ? 'span'
+						: source === '<!--/c-->' || parseColorOpen(source) ? 'color'
+						: source === '<!--/f-->' || parseFontOpen(source) ? 'font' : '';
+					if (!kind) continue;
+					const close = htmlClose || source === '<!--/c-->' || source === '<!--/f-->';
+					if (overflow) { overflow += close ? -1 : 1; continue; }
+					if (!close) {
+						// Authored comment marks retain their original first-opener rule. Ordinary
+						// canonical spans nest; a repeated old opener remains an inert stray.
+						if (kind !== 'span' && stack.some(held => held.kind === kind)) continue;
+						if (stack.length === DEPTH) { overflow = 1; continue; }
+						const facts = kind === 'span' ? parseOpen(source, value => md.utils.unescapeAll(value.replace(/\\/g, '\\\\')))
+							: kind === 'color' ? normalize({color: parseColorOpen(source)}) : normalize({family: parseFontOpen(source)});
+						stack.push({token, kind, facts, depth, source}); continue;
+					}
+					const held = stack.at(-1);
+					if (!held || held.kind !== kind) continue;
+					stack.pop();
+					if (!held.facts || depth !== held.depth) continue;
+					const type = kind === 'span' ? 'typography' : kind, opener = held.token;
+					opener.type = 'rapier_' + type + '_open'; opener.tag = 'span'; opener.nesting = 1; opener.content = '';
+					(opener.meta ||= {}).typography = Object.freeze({style: held.facts, open: held.source, close: source});
+					opener.attrSet('style', style(held.facts));
+					if (held.facts.color) opener.attrSet('data-md-color', held.facts.color);
+					if (held.facts.size) opener.attrSet('data-md-size', held.facts.size);
+					if (held.facts.family) opener.attrSet('data-md-font', held.facts.family.name);
+					if (kind === 'font') { opener.attrSet('data-md-font-open', encodeURIComponent(held.source)); opener.meta.mdFont = {source: held.source, family: held.facts.family.name}; }
+					token.type = 'rapier_' + type + '_close'; token.tag = 'span'; token.nesting = -1; token.content = '';
+					(token.meta ||= {}).typography = opener.meta.typography;
+				}
+			}
+		});
+		return md;
+	}
+	return Object.freeze({size, color, family, familyCss, normalize, parseStyle, style, open, wrap, parseOpen, nodeStyle, runs, install});
+}
+
+export const typography = createTypography({normalizeFontFamily, fontFamilyCss, parseColorOpen, parseFontOpen, FONT_STACKS});
+export function typographySourceRanges(source, parser) { return markdownSourcePositions(source, parser).typography; }
+
 const INK_CLOSE = '<!--/ink-->';
 export { INK_KINDS, INK_CLOSE, INK_PATH_MAX, INK_INT_MAX, INK_OPEN_PATTERN };
 

package/dist/spec/md-source.mjs

@@ -0,0 +1,122 @@
+// SPDX-License-Identifier: MIT
+import {splitOpeningFrontmatter} from './frontmatter.mjs';
+
+// The standard parser owns literal regions and comment boundaries. Offsets are original UTF-16,
+// including BOM/CRLF and list/quote prefixes. A private parser view observes rules; it changes no
+// live rule or token. Call once per source, then ask isText(position) or isComment(start, end).
+export function markdownSourcePositions(source, parser) {
+  if (typeof source !== 'string' || !parser) throw new TypeError('Source positions require text and its Markdown parser');
+  const {body, bodyOffset} = splitOpeningFrontmatter(source), lines = [bodyOffset];
+  for (const row of body.matchAll(/\r\n?|\n/g)) lines.push(bodyOffset + row.index + row[0].length);
+  const lineAt = line => lines[line] ?? source.length;
+  const literal = [], comments = new Map(), observed = new WeakMap(), typography = [], openedStyles = new Map();
+  const add = (start, end) => { if (end > start) literal.push({start, end}); };
+  if (bodyOffset) add(0, bodyOffset);
+  const owner = Object.create(parser), inline = Object.create(parser.inline), ruler = Object.create(parser.inline.ruler);
+  owner.inline = inline; inline.ruler = ruler;
+  ruler.getRules = chain => parser.inline.ruler.getRules(chain).map(rule => (state, silent) => {
+    const start = state.pos, first = state.tokens.length;
+    const matched = rule(state, silent), token = state.tokens.at(-1);
+    // A pending text token may flush before this token. Never overwrite a nested rule's span
+    // with its enclosing link's range.
+    if (matched && !silent && state.tokens.length > first && !observed.has(token) &&
+        ['code_inline', 'html_inline', 'image', 'footnote_ref'].includes(token?.type)) {
+      observed.set(token, {start, end: state.pos, source: state.src,
+        comment: token.type === 'html_inline' && token.content.startsWith('<!--'),
+        footnote: token.type === 'footnote_ref' && state.src.startsWith('^[', start)
+          ? state.env.footnotes?.list?.[token.meta.id] : null});
+    }
+    return matched;
+  });
+  const tokens = owner.parse(body, {});
+  const readInline = (children, content, rawOffset) => {
+    for (const child of children || []) {
+      const span = observed.get(child);
+      if (!span || span.source !== content) continue;
+      // Inline footnotes are moved to a generated footer without line maps. Their parser-owned
+      // child tokens still stand inside the original ^[...] carrier, not in that footer.
+      if (span.footnote?.tokens) {
+        readInline(span.footnote.tokens, span.footnote.content, pos => rawOffset(span.start + 2 + pos));
+      } else if (child.type !== 'footnote_ref') {
+        const start = rawOffset(span.start), end = rawOffset(span.end);
+        const style = child.meta?.typography;
+        if (style && child.nesting === 1) openedStyles.set(style, {start, innerStart: end, style: style.style});
+        else if (style && child.nesting === -1 && openedStyles.has(style)) {
+          typography.push({...openedStyles.get(style), innerEnd: start, end});
+          openedStyles.delete(style);
+        }
+        if (span.comment) comments.set(start, end);
+        else add(start, end);
+      }
+    }
+  };
+  let table = null;
+  for (const token of tokens) {
+    if (token.type === 'tr_open' && token.map) {
+      // GFM unescapes a pipe before parsing a cell. Preserve that one-character projection and
+      // consume cells in order, so repeated cells and backticks across a separator never alias.
+      const start = lineAt(token.map[0]), end = lineAt(token.map[0] + 1), offsets = [];
+      let text = '';
+      for (let at = start; at < end; at++) {
+        if (source[at] === '\\' && source[at + 1] === '|') at++;
+        offsets.push(at); text += source[at] === '\0' ? '\ufffd' : source[at];
+      }
+      offsets.push(end); table = {text, offsets, at: 0};
+    }
+    if (token.type === 'tr_close') table = null;
+    if (token.map && ['fence', 'code_block', 'html_block', 'reference_definition'].includes(token.type)) {
+      const start = lineAt(token.map[0]), end = lineAt(token.map[1]);
+      add(start, end);
+      // A comment-carrier block can contain several adjacent comments. Keep each carrier,
+      // including a closer surviving damage to its opener. Never promote nested comments or
+      // comment-shaped text in a raw tagged HTML block (pre, script, div, ...).
+      if (token.type === 'html_block' && /^\s*<!--/.test(token.content)) {
+        let at = source.indexOf('<!--', start);
+        while (at >= start && at < end) {
+          const close = source.indexOf('-->', at + 4);
+          const stop = close >= 0 && close + 3 <= end ? close + 3 : end;
+          comments.set(at, stop);
+          at = source.indexOf('<!--', stop);
+        }
+      }
+      continue;
+    }
+    if (token.type !== 'inline' || !token.content) continue;
+    let rawOffset;
+    if (token.map) {
+      const offsets = [], starts = [], rows = token.content.split('\n');
+      let local = 0;
+      for (let i = 0; i < rows.length; i++) {
+        const start = lineAt(token.map[0] + i), end = lineAt(token.map[0] + i + 1);
+        const at = source.slice(start, end).replace(/\0/g, '\ufffd').indexOf(rows[i]);
+        if (at < 0) throw new Error('Markdown inline source mapping failed');
+        starts.push(local); offsets.push(start + at); local += rows[i].length + 1;
+      }
+      rawOffset = pos => {
+        let row = starts.length - 1;
+        while (row > 0 && starts[row] > pos) row--;
+        return offsets[row] + pos - starts[row];
+      };
+    } else if (table) {
+      const at = table.text.indexOf(token.content, table.at);
+      if (at < 0) throw new Error('Markdown table source mapping failed');
+      table.at = at + token.content.length;
+      rawOffset = pos => table.offsets[at + pos];
+    } else continue;
+    readInline(token.children, token.content, rawOffset);
+  }
+  literal.sort((a, b) => a.start - b.start || b.end - a.end);
+  const merged = [];
+  for (const range of literal) {
+    const last = merged.at(-1);
+    if (last && range.start <= last.end) last.end = Math.max(last.end, range.end);
+    else merged.push({...range});
+  }
+  const isText = position => {
+    if (comments.has(position)) return false;
+    let low = 0, high = merged.length;
+    while (low < high) { const mid = (low + high) >> 1; if (merged[mid].end <= position) low = mid + 1; else high = mid; }
+    return low < merged.length && merged[low].start <= position;
+  };
+  return {isText, isComment: (start, end) => comments.get(start) === end, typography: typography.sort((a, b) => a.start - b.start)};
+}