rapier-markdown-kit 1.2.19 → 1.2.21

package/README.md

@@ -44,7 +44,7 @@ const edited = replaceLedgerText(base, 'Draft, revised\n', {actor: {kind: 'human
 console.log(merge(edited, base).text, authorship(edited).runs);
 ```
 
-TypeScript declarations ship for `markdown-it`, `will`, `rapier-ledger`, `ledger/carried` and `pdf`.
+TypeScript declarations ship for `markdown-it`, `parsed`, `will`, `rapier-ledger`, `ledger/carried` and `pdf`.
 
 ```js
 import {parseLayout} from 'rapier-markdown-kit/layout';   // the md-layout comment a picture carries
@@ -165,6 +165,7 @@ family name share the host's font namespace. Print retains its existing factory
 | Import | What it is |
 | --- | --- |
 | `rapier-markdown-kit/markdown-it` | `md.use(rapierMarkdown)`: the reference style's markup in markdown-it, in one line. |
+| `rapier-markdown-kit/parsed` | A frozen, serializable view of completed Markdown tokens, bound to source, revision and grammar. |
 | `rapier-markdown-kit/layout` | The `md-layout:v1` comment a picture carries: parse it, validate it, write it back. |
 | `rapier-markdown-kit/marks` | Unified typography values, span writer and parser installer; preserved color/font comments, ink and page breaks. |
 | `rapier-markdown-kit/model` | Occupancy profiles and the line planner: the wrapping itself. |
@@ -180,6 +181,51 @@ family name share the host's font namespace. Print retains its existing factory
 The canonical inline form is ordinary HTML inside Markdown. CSS support varies; the host's font metrics still
 determine line layout (below).
 
+## Read a parsed document
+
+`projectMarkdown` copies the tokens from your completed parse into JSON data. Pass the exact source and revision
+captured for that parse, and a grammar identity that includes its parser, plugins and options. The function does not
+parse again. Project before renderer hooks mutate the tokens; the resulting snapshot is detached from those later
+changes. Import this optional subpath only where you need it; the package's main entry does not import it.
+
+```js
+import MarkdownIt from 'markdown-it';
+import {rapierMarkdown} from 'rapier-markdown-kit/markdown-it';
+import {projectMarkdown, projectionMatches} from 'rapier-markdown-kit/parsed';
+
+const source = '# Plan\n\nShips **Friday**.\n';
+const revision = 7;
+const options = {html: true};
+const grammar = {id: 'my-app-markdown-1', options, plugins: ['rapierMarkdown']};
+const md = new MarkdownIt(options).use(rapierMarkdown);
+const env = {};
+const tokens = md.parse(source, env); // The same tokens can feed your renderer.
+const parsed = projectMarkdown({source, revision, grammar, tokens, env, complete: true});
+const json = JSON.stringify(parsed);
+console.log(projectionMatches(parsed, {source, revision, grammar})); // true
+```
+
+Change the grammar identity when its implementation changes. Grammar options must be JSON data; describe a custom
+rule or renderer by its identity, not by a function. If your parse excludes opening front matter, pass `bodyOffset`
+from that split and keep `source` as the full original document. Token line maps must remain relative to the parsed body.
+
+The source binding uses SHA-256 over its UTF-16LE code units, including BOM, original line endings and isolated
+surrogates. `span` ranges are half-open UTF-16 offsets into that source. A span with `scope: 'lines'` covers the token's
+source lines, including container prefixes and the final line ending. Inline delimiters and generated tokens without
+recorded ranges have `span: null`; `coverage` and `omissions` report these missing ranges. Never infer an exact inline
+edit boundary from a containing line span.
+
+Recorded `meta.mdLayoutSource` positions are translated from the parser's normalized body into the same original
+UTF-16 source coordinates and labeled `unit: 'utf16'`. Their marker text and any reason for an unmapped target remain
+with the layout record. Other JSON metadata retains the grammar's values; internal probe identities are not exported.
+
+The projection includes canonical token content, attributes, JSON metadata and reference, abbreviation and footnote
+definitions. It omits original source gaps, interpreted front matter, rendered HTML and geometry, decoded pictures,
+final heading IDs, and evaluated Will permissions. Non-JSON token metadata becomes `null` with a counted omission.
+Token strings remain document data for your existing renderer and sanitizer. `projectionMatches` checks currentness;
+it does not authenticate a projection received from another party or authorize an edit. Source transactions, Will,
+Undo and Save stay with their existing owners.
+
 ## Refined paragraphs
 
 The existing comment expresses the paragraph's intent without storing font-dependent line breaks:

package/dist/images/playback.mjs

@@ -1,5 +1,6 @@
 // SPDX-License-Identifier: MIT
 export function createMediaPlayback(win, inspectGIF) {
+  const FRAMES = 3600, LOOP_MS = 3600000;
   const active = new Map(), encode = bytes => bytes.toBase64();
   const bytes = async url => {
     const text = url.slice(url.indexOf(',') + 1), slice = 1 << 20;
@@ -14,7 +15,7 @@ export function createMediaPlayback(win, inspectGIF) {
   function raster(url, canvas, changed = () => {}, dimensions = null) {
     if (url.length > 24 * 1024 * 1024 || !/^data:image\/(gif|jxl);base64,/i.test(url) || (url.length - url.indexOf(',') - 1) % 4) throw new Error('Unsupported animation source');
     const type = url.slice(5, url.indexOf(';')).toLowerCase();
-    let data = null, info = null, size = null, decoder = null, timer = 0, closed = false, paused = true, ticket = 0, next = 0, loops = 0, duration = 0, single = false, held = false;
+    let data = null, info = null, size = null, decoder = null, timer = 0, closed = false, paused = true, ticket = 0, next = 0, loops = 0, duration = 0, single = false, held = false, due = 0;
     const state = {animated: true, status: 'loading', first: '', frames: 0};
     const admitted = (async () => {
       const buffer = await bytes(url); info = type === 'image/gif' ? inspectGIF(buffer) : null;
@@ -47,11 +48,12 @@ export function createMediaPlayback(win, inspectGIF) {
             state.status = 'playback-budget'; paused = true; changed(state); return;
           }
           active.set(canvas, size.width * size.height);
+          next = 0; duration = 0; due = 0;
           decoder = new win.ImageDecoder({data, type, preferAnimation: true});
           const current = decoder; await settle(current.tracks.ready);
           if (closed || paused || stamp !== ticket || decoder !== current) return;
           const track = current.tracks.selectedTrack;
-          if (!track || track.frameCount < 1 || track.frameCount > 240 || info && track.frameCount !== info.frames) throw new Error('Animation frame budget or container mismatch');
+          if (!track || track.frameCount < 1 || track.frameCount > FRAMES || info && track.frameCount !== info.frames) throw new Error('Animation frame budget or container mismatch');
           state.frames = track.frameCount; state.animated = track.animated;
         }
         const current = decoder, decoding = current.decode({frameIndex: next, completeFramesOnly: true});
@@ -62,13 +64,13 @@ export function createMediaPlayback(win, inspectGIF) {
         try {
           if (closed || paused || stamp !== ticket || decoder !== current) return;
           const w = frame.displayWidth, h = frame.displayHeight;
-          if (!result.complete || w !== size.width || h !== size.height || w * h * state.frames > 96000000) throw new Error('Decoded animation exceeds the image budget');
+          if (!result.complete || w !== size.width || h !== size.height) throw new Error('Decoded animation exceeds the image budget');
           if (canvas.width !== w) canvas.width = w;
           if (canvas.height !== h) canvas.height = h;
           const ctx = canvas.getContext('2d'); ctx.clearRect(0, 0, w, h); ctx.drawImage(frame, 0, 0);
           if (!state.first && next === 0) state.first = canvas.toDataURL('image/png');
           const delay = type !== 'image/gif' ? Math.max(8, frame.duration / 1000) : frame.duration > 10000 ? Math.max(20, frame.duration / 1000) : 100;
-          duration += delay; if (duration > 120000) throw new Error('Animation exceeds the duration budget');
+          duration += delay; if (duration > LOOP_MS) throw new Error('Animation exceeds the duration budget');
           state.status = 'ready'; state.frame = next; changed(state);
           if (single) {paused = true; closeDecoder(); return;}
           next++;
@@ -76,7 +78,8 @@ export function createMediaPlayback(win, inspectGIF) {
             next = 0; duration = 0; loops++;
             if (!state.animated || Number.isFinite(current.tracks.selectedTrack.repetitionCount) && loops > current.tracks.selectedTrack.repetitionCount) {paused = true; closeDecoder(); return;}
           }
-          timer = win.setTimeout(step, delay);
+          const now = win.performance.now(); due = due && now - due < 1000 ? due + delay : now + delay;
+          timer = win.setTimeout(step, Math.max(0, due - now));
         } finally {frame.close();}
       } catch (error) {
         if (closed || stamp !== ticket) return;
@@ -85,7 +88,7 @@ export function createMediaPlayback(win, inspectGIF) {
     }
     return {state, play() {if (!closed && paused && !['decode-failed', 'admission-failed'].includes(state.status)) {paused = false; void step();}},
       async first() {if (!state.first && !closed) {single = true; next = 0; paused = false; try {await step();} finally {single = false; paused = true; closeDecoder(); if (held) {held = false; this.suspend();}}} return state.first;},
-      pause() {paused = true; ticket++; win.clearTimeout(timer); timer = 0;},
+      pause() {paused = true; ticket++; win.clearTimeout(timer); timer = 0; due = 0;},
       suspend() {if (single) {held = true; return;} paused = true; closeDecoder(); canvas.width = canvas.height = 0; state.status = 'suspended'; changed(state);},
       close() {closed = true; paused = true; closeDecoder(); canvas.width = canvas.height = 0;},
       get paused() {return paused;}};

package/dist/kit/markdown-it.mjs

@@ -2,12 +2,14 @@
 import {parseLayout, imageStyle} from './layout.mjs';
 import {typography, isPageBreakBlock} from './marks.mjs';
 import {installMarkdownImages} from './assets.mjs';
+import {tuneMarkdownEngine} from '../spec/md-engine.mjs';
 
 const PAGE_BREAK = '<div class="rapier-page-break" data-md-break="page" role="separator" aria-label="Page break"></div>\n';
 
 export function rapierMarkdown(md) {
   if (md.__rapierMarkdownInstalled) return md;
   md.__rapierMarkdownInstalled = true;
+  tuneMarkdownEngine(md);
   typography.install(installMarkdownImages(md));
   md.renderer.rules.table_open = (tokens, index, options, env, renderer) =>
     '<div class="table-scroll-wrap">\n' + renderer.renderToken(tokens, index, options);
@@ -15,10 +17,13 @@ export function rapierMarkdown(md) {
     renderer.renderToken(tokens, index, options) + '</div>\n';
   md.core.ruler.after('inline', 'rapier-layout', state => {
     for (let i = 1; i < state.tokens.length; i++) {
-      const inline = state.tokens[i], owner = state.tokens[i - 1];
-      if (inline.type !== 'inline' || !['paragraph_open', 'heading_open'].includes(owner.type)) continue;
-      const children = inline.children, marker = children.at(-1);
-      const layout = marker?.type === 'html_inline' ? parseLayout(marker.content) : null;
+      const inline = state.tokens[i];
+      if (inline.type !== 'inline') continue;
+      const children = inline.children, marker = children[children.length - 1];
+      if (marker?.type !== 'html_inline') continue;
+      const owner = state.tokens[i - 1];
+      if (owner.type !== 'paragraph_open' && owner.type !== 'heading_open') continue;
+      const layout = parseLayout(marker.content);
       if (!layout) continue;
       children.pop();
       if (layout.align) owner.attrSet('data-md-align', layout.align);

package/dist/kit/parsed.d.mts

@@ -0,0 +1,78 @@
+// SPDX-License-Identifier: MIT
+export type Json = null | string | number | boolean | readonly Json[] | {readonly [key: string]: Json};
+export type Revision = string | number;
+export interface GrammarIdentity {
+  readonly id: string;
+  readonly options: {readonly [key: string]: Json};
+  readonly [key: string]: Json;
+}
+export interface Utf16Span { readonly start: number; readonly end: number; readonly unit: 'utf16'; }
+export interface TokenSpan extends Utf16Span { readonly scope: 'lines'; }
+export interface MarkdownTokenInput {
+  readonly type: string;
+  readonly tag?: string;
+  readonly nesting: -1 | 0 | 1;
+  readonly level?: number;
+  readonly block?: boolean;
+  readonly hidden?: boolean;
+  readonly content?: string;
+  readonly markup?: string;
+  readonly info?: string;
+  readonly attrs?: unknown;
+  readonly meta?: unknown;
+  readonly map?: readonly [number, number] | null;
+  readonly children?: readonly MarkdownTokenInput[] | null;
+}
+export interface ParsedMarkdown {
+  /** The exact full document, before normalization or front matter removal. */
+  readonly source: string;
+  readonly revision: Revision;
+  /** Includes every option or plugin setting that can change this parse's meaning. */
+  readonly grammar: GrammarIdentity;
+  readonly complete: true;
+  /** The shared front matter owner's body offset; zero if the parser read the full source.
+   * Token maps and recorded layout target offsets must be relative to that parsed body. */
+  readonly bodyOffset?: number;
+  readonly tokens: readonly MarkdownTokenInput[];
+  readonly env?: {
+    readonly references?: unknown;
+    readonly abbreviations?: unknown;
+    readonly footnotes?: {readonly list?: readonly {readonly label?: string; readonly count?: number}[]};
+  };
+}
+export interface ProjectedToken {
+  readonly type: string;
+  readonly tag: string;
+  readonly nesting: -1 | 0 | 1;
+  readonly level: number | null;
+  readonly block: boolean;
+  readonly hidden: boolean;
+  readonly content: string;
+  readonly markup: string;
+  readonly info: string;
+  readonly attrs: Json;
+  readonly meta: Json;
+  readonly span: TokenSpan | null;
+  readonly children: readonly ProjectedToken[] | null;
+}
+export interface MarkdownProjection {
+  readonly format: 'rapier-parsed/1';
+  readonly source: {
+    readonly revision: Revision;
+    readonly chars: number;
+    readonly hash: {readonly algorithm: 'sha256'; readonly encoding: 'utf16le'; readonly value: string};
+  };
+  readonly grammar: GrammarIdentity;
+  readonly body: Utf16Span;
+  readonly frontmatter: Utf16Span | null;
+  readonly tokens: readonly ProjectedToken[];
+  readonly definitions: Json;
+  readonly coverage: {readonly tokens: 'complete'; readonly tokenCount: number; readonly spans: 'complete' | 'partial'};
+  readonly omissions: readonly {readonly domain: string; readonly reason: string; readonly count?: number}[];
+}
+/** Project one completed parse. Does not parse again, normalize source, render or admit edits. */
+export function projectMarkdown(parsed: ParsedMarkdown): MarkdownProjection;
+/** Checks source, revision and grammar binding; does not authenticate an externally supplied projection. */
+export function projectionMatches(projection: MarkdownProjection, current: {
+  readonly source: string; readonly revision: Revision; readonly grammar: GrammarIdentity;
+}): boolean;

package/dist/kit/parsed.mjs

@@ -0,0 +1,157 @@
+// SPDX-License-Identifier: MIT
+import {sha256State} from './ledger/hash.mjs';
+import {splitOpeningFrontmatter} from '../spec/frontmatter.mjs';
+
+export function projectMarkdown(parsed) {
+  const {source, revision, grammar, tokens, env = {}, bodyOffset = 0, complete} = parsed || {};
+  requireSource(source, revision);
+  if (complete !== true || !Array.isArray(tokens)) throw new TypeError('A completed Markdown parse is required');
+  const front = splitOpeningFrontmatter(source);
+  if (!Number.isSafeInteger(bodyOffset) || bodyOffset < 0 || bodyOffset > source.length ||
+      bodyOffset !== 0 && bodyOffset !== front.bodyOffset) throw new TypeError('The parse must cover the document body');
+  const grammarCopy = copyGrammar(grammar), counts = new Map();
+  const omitted = (domain, reason) => {
+    const key = domain + ':' + reason;
+    const row = counts.get(key) || {domain, reason, count: 0};
+    row.count++; counts.set(key, row);
+  };
+  const lines = [bodyOffset], normalizedLines = [0];
+  let collapsed = 0;
+  for (const match of source.slice(bodyOffset).matchAll(/\r\n?|\n/g)) {
+    const end = match.index + match[0].length;
+    collapsed += match[0].length - 1;
+    lines.push(bodyOffset + end); normalizedLines.push(end - collapsed);
+  }
+  const originalOffset = offset => {
+    if (!Number.isSafeInteger(offset) || offset < 0 || offset > source.length - bodyOffset - collapsed)
+      throw new TypeError('A Markdown layout target has an invalid source offset');
+    let low = 0, high = normalizedLines.length;
+    while (low + 1 < high) {
+      const middle = (low + high) >>> 1;
+      if (normalizedLines[middle] <= offset) low = middle; else high = middle;
+    }
+    return lines[low] + offset - normalizedLines[low];
+  };
+  const metadata = token => {
+    const meta = copyJSON(token.meta ?? null, () => omitted('metadata', 'not-json'));
+    const target = meta?.mdLayoutSource;
+    if (!target) return meta;
+    const marker = target.marker ? Object.freeze({...target.marker, start: originalOffset(target.marker.start),
+      end: originalOffset(target.marker.end), unit: 'utf16'}) : null;
+    return Object.freeze({...meta, mdLayoutSource: Object.freeze({...target, start: originalOffset(target.start),
+      end: originalOffset(target.end), insert: target.insert == null ? null : originalOffset(target.insert), marker, unit: 'utf16'})});
+  };
+  const span = token => {
+    const map = token.map;
+    if (map == null) {
+      omitted('spans', token.block ? 'block-range-not-retained' : 'inline-range-not-retained');
+      return null;
+    }
+    if (!Array.isArray(map) || map.length !== 2 || map.some(at => !Number.isSafeInteger(at) || at < 0) ||
+        map[0] > map[1] || map[0] >= lines.length || map[1] > lines.length)
+      throw new TypeError('A Markdown token has an invalid line range');
+    if (map[0] === map[1]) { omitted('spans', token.block ? 'block-range-not-retained' : 'inline-range-not-retained'); return null; }
+    return Object.freeze({start: lines[map[0]], end: lines[map[1]] ?? source.length, unit: 'utf16', scope: 'lines'});
+  };
+  let count = 0;
+  const copyTokens = input => Object.freeze(input.map(token => {
+    if (!token || typeof token.type !== 'string' || ![-1, 0, 1].includes(token.nesting) ||
+        token.children != null && !Array.isArray(token.children)) throw new TypeError('Invalid Markdown token');
+    count++;
+    const scalar = key => {
+      if (token[key] == null) return '';
+      if (typeof token[key] !== 'string') throw new TypeError('Invalid Markdown token ' + key);
+      return token[key];
+    };
+    return Object.freeze({
+      type: token.type, tag: scalar('tag'), nesting: token.nesting,
+      level: Number.isSafeInteger(token.level) && token.level >= 0 ? token.level : null,
+      block: token.block === true, hidden: token.hidden === true,
+      content: scalar('content'), markup: scalar('markup'), info: scalar('info'),
+      attrs: copyJSON(token.attrs ?? null, () => omitted('attributes', 'not-json')),
+      meta: metadata(token),
+      span: span(token), children: token.children ? copyTokens(token.children) : null,
+    });
+  }));
+  const projected = copyTokens(tokens);
+  const definitions = copyJSON({
+    references: env.references || {}, abbreviations: env.abbreviations || {},
+    footnotes: (env.footnotes?.list || []).map(note => ({label: note.label ?? null, count: note.count ?? 0})),
+  }, () => omitted('definitions', 'not-json'));
+  const omissions = [
+    ...counts.values(),
+    {domain: 'source', reason: 'original-text-and-unrepresented-gaps-are-not-included'},
+    {domain: 'frontmatter', reason: 'metadata-is-not-interpreted'},
+    {domain: 'rendering', reason: 'html-dom-heading-ids-layout-and-decoded-assets-are-not-included'},
+    {domain: 'authority', reason: 'will-permissions-and-edit-admission-are-not-evaluated'},
+    {domain: 'environment', reason: 'only-reference-abbreviation-and-footnote-definitions-are-included'},
+  ];
+  return Object.freeze({
+    format: 'rapier-parsed/1',
+    source: Object.freeze({revision, chars: source.length,
+      hash: Object.freeze({algorithm: 'sha256', encoding: 'utf16le', value: sourceHash(source)})}),
+    grammar: grammarCopy,
+    body: Object.freeze({start: bodyOffset, end: source.length, unit: 'utf16'}),
+    frontmatter: bodyOffset ? Object.freeze({start: 0, end: bodyOffset, unit: 'utf16'}) : null,
+    tokens: projected, definitions,
+    coverage: Object.freeze({tokens: 'complete', tokenCount: count,
+      spans: counts.has('spans:block-range-not-retained') || counts.has('spans:inline-range-not-retained') ? 'partial' : 'complete'}),
+    omissions: Object.freeze(omissions.map(Object.freeze)),
+  });
+}
+
+export function projectionMatches(projection, {source, revision, grammar} = {}) {
+  requireSource(source, revision);
+  const expected = copyGrammar(grammar);
+  if (!(projection?.format === 'rapier-parsed/1' && projection.source?.revision === revision &&
+    projection.source.chars === source.length && projection.source.hash?.algorithm === 'sha256' &&
+    projection.source.hash.encoding === 'utf16le' && projection.source.hash.value === sourceHash(source))) return false;
+  try { return JSON.stringify(copyGrammar(projection.grammar)) === JSON.stringify(expected); }
+  catch (_) { return false; }
+}
+
+function requireSource(source, revision) {
+  if (typeof source !== 'string' || !(typeof revision === 'string' && revision.length ||
+      Number.isSafeInteger(revision) && revision >= 0)) throw new TypeError('Exact source and its revision are required');
+}
+
+function copyGrammar(grammar) {
+  const copy = copyJSON(grammar, () => { throw new TypeError('Grammar identity and options must be JSON data'); });
+  if (!copy || typeof copy.id !== 'string' || !copy.id || !copy.options ||
+      typeof copy.options !== 'object' || Array.isArray(copy.options))
+    throw new TypeError('A grammar identity and its options are required');
+  return copy;
+}
+
+function copyJSON(value, omit, ancestors = new Set()) {
+  if (typeof value === 'number' && Number.isFinite(value)) return value === 0 ? 0 : value;
+  if (value === null || typeof value === 'string' || typeof value === 'boolean') return value;
+  if (!value || typeof value !== 'object' || ancestors.has(value) ||
+      !Array.isArray(value) && ![Object.prototype, null].includes(Object.getPrototypeOf(value))) { omit(); return null; }
+  ancestors.add(value);
+  let result;
+  if (Array.isArray(value)) result = Array.from({length: value.length}, (_, index) => {
+    const property = Object.getOwnPropertyDescriptor(value, index);
+    if (!property || !Object.hasOwn(property, 'value')) { omit(); return null; }
+    return copyJSON(property.value, omit, ancestors);
+  });
+  else result = Object.fromEntries(Object.keys(value).sort().map(key => {
+    const property = Object.getOwnPropertyDescriptor(value, key);
+    if (!Object.hasOwn(property, 'value')) { omit(); return [key, null]; }
+    return [key, copyJSON(property.value, omit, ancestors)];
+  }));
+  ancestors.delete(value);
+  return Object.freeze(result);
+}
+
+function sourceHash(source) {
+  const hash = sha256State(), bytes = new Uint8Array(32768);
+  for (let at = 0; at < source.length;) {
+    let used = 0;
+    while (at < source.length && used < bytes.length) {
+      const code = source.charCodeAt(at++); bytes[used++] = code & 255; bytes[used++] = code >>> 8;
+    }
+    hash.update(bytes.subarray(0, used));
+  }
+  return hash.finish();
+}

package/dist/kit/render-markdown.mjs

@@ -90,9 +90,11 @@ function initMarkdownIt() {
 	md.renderer.rules.softbreak = () =>
 		sourceToken('\n', '\u2060', 'rapier-source-token--softbreak');
 	md.core.ruler.before('text_join', 'rapier_escape_token', state => {
-		for (const token of state.tokens) {
+		for (let at = 0; at < state.tokens.length; at++) {
+			const token = state.tokens[at];
 			if (token.type !== 'inline' || !token.children) continue;
-			for (const child of token.children) {
+			for (let next = 0; next < token.children.length; next++) {
+				const child = token.children[next];
 				if (child.type === 'text_special' && child.info === 'escape' && child.content.length === 1 && !/[\\*`[\]_]/.test(child.content)) child.type = 'rapier_escape';
 			}
 		}
@@ -251,7 +253,8 @@ function initMarkdownIt() {
 
 	md.core.ruler.push('rapier_setext_rule', function (state) {
 		let lines = null;
-		for (const token of state.tokens) {
+		for (let at = 0; at < state.tokens.length; at++) {
+			const token = state.tokens[at];
 			if (token.type !== 'heading_open') continue;
 			if (token.markup !== '=' && token.markup !== '-') continue;
 			if (!token.map) continue;
@@ -489,14 +492,14 @@ function _rapierInstallSemanticProbe(instance) {
 		const nextId = (targetEnv.__rapierInlineProbeSeq || 0) + 1;
 		targetEnv.__rapierInlineProbeSeq = nextId;
 		targetEnv.__rapierInlineProbeId = nextId;
-		try {
-			Object.defineProperty(outTokens, '_rapierInlineProbeId', { value: nextId, configurable: true });
-		} catch (_) { outTokens._rapierInlineProbeId = nextId; }
+		const candidateStart = targetEnv.__rapierInlineCandidates?.length || 0;
 		try {
 			const result = originalParse.call(this, source, parser, targetEnv, outTokens);
-			for (const token of outTokens) {
-				try { Object.defineProperty(token, '_rapierInlineProbeId', { value: nextId, configurable: true }); }
-				catch (_) { token._rapierInlineProbeId = nextId; }
+			if ((targetEnv.__rapierInlineCandidates?.length || 0) > candidateStart) {
+				Object.defineProperty(outTokens, '_rapierInlineProbeId', { value: nextId, configurable: true });
+				for (const token of outTokens) {
+					Object.defineProperty(token, '_rapierInlineProbeId', { value: nextId, configurable: true });
+				}
 			}
 			return result;
 		} finally { targetEnv.__rapierInlineProbeId = priorId; }
@@ -504,6 +507,8 @@ function _rapierInstallSemanticProbe(instance) {
 
 	instance.inline.ruler.before('escape', 'rapier_semantic_probe', function (state, silent) {
 		if (silent || !state || !state.env) return false;
+		const opener = state.src.charCodeAt(state.pos);
+		if (opener !== 0x5b && opener !== 0x21) return false;
 		const inlineId = Number(state.env.__rapierInlineProbeId || 0);
 		if (!inlineId) return false;
 		const src = state.src;
@@ -561,6 +566,8 @@ function _rapierInstallSemanticProbe(instance) {
 		if (src.charCodeAt(after) === 0x28) {
 			let destinationPos = after + 1;
 			while (destinationPos < max && /[ \t\n]/.test(src.charAt(destinationPos))) destinationPos++;
+			const first = src.charCodeAt(destinationPos);
+			if (first !== 0x23 && first !== 0x3c && first !== 0x5c && first !== 0x26) return false;
 			const destination = state.md.helpers.parseLinkDestination(src, destinationPos, max);
 			if (!destination || !destination.ok || !String(destination.str || '').startsWith('#')) return false;
 			const rawDestination = String(destination.str || '');

package/dist/kit/render-print.mjs

@@ -184,7 +184,8 @@ async function _rapierWritePrintPdf({root, css, fontCss = '', canonical, bom = f
 		[side, settings?.geometry ? settings.geometry[side] / 20 : (side === 'top' ? 12 : 14) * 72 / 25.4]));
 	const bodyWidth = Math.floor((width - margins.left - margins.right) * 4 / 3);
 	const bodyHeight = Math.floor((height - margins.top - margins.bottom) * 4 / 3);
-	if (bodyWidth < 1 || bodyHeight < 1 || bodyWidth * bodyHeight > 4 * 1024 * 1024) refuse('pdf_page_geometry_invalid');
+	if (bodyWidth < 1 || bodyHeight < 1) refuse('pdf_page_geometry_invalid');
+	const tiled = bodyWidth > CAPTURE_EDGE || bodyHeight > CAPTURE_EDGE || bodyWidth * bodyHeight > CAPTURE_PIXELS;
 	const frame = document.createElement('iframe');
 	let vectors, backdrop = null, nativeGlyphs, filmSession;
 	let rejectAbort;
@@ -319,7 +320,21 @@ async function _rapierWritePrintPdf({root, css, fontCss = '', canonical, bom = f
 			if (imageBytes > maxBytes) refuse('export_too_large');
 			pages.push({rgb: packed});
 		};
-		for (let first = 0; first < count;) {
+		const tileWidth = Math.min(bodyWidth, CAPTURE_EDGE), tileHeight = Math.min(bodyHeight, CAPTURE_EDGE, Math.floor(CAPTURE_PIXELS / tileWidth));
+		for (let index = 0; tiled && index < count; index++) {
+			const tiles = [];
+			for (let y = 0; y < bodyHeight; y += tileHeight) for (let x = 0; x < bodyWidth; x += tileWidth) {
+				check();
+				const width = Math.min(tileWidth, bodyWidth - x), height = Math.min(tileHeight, bodyHeight - y);
+				const shot = await step(filmSession.raster({x: index * bodyWidth + x, y, width, height}));
+				if (shot?.width !== width || shot?.height !== height || !(shot.rgb instanceof Uint8Array)) refuse('pdf_render_unavailable');
+				await pack(shot.rgb);
+				shot.rgb = null;
+				tiles.push({...pages.pop(), x, y, width, height});
+			}
+			pages.push({tiles});
+		}
+		for (let first = 0; !tiled && first < count;) {
 			check();
 			const span = Math.min(share, count - first);
 			try {
@@ -698,9 +713,10 @@ async function writeRasterPdf({pages, textPages, linkPages = [], vectorPages = [
 		const marked = [];
 		parentTree.push(marked);
 		const held = pages[index], flate = !!held?.rgb;
-		const picture = stream('/Type /XObject /Subtype /Image /Width ' + pixelWidth + ' /Height ' + pixelHeight + ' /ColorSpace /DeviceRGB /BitsPerComponent 8 /Filter /' + (flate ? 'FlateDecode' : 'DCTDecode'), flate ? held.rgb : held);
+		const tiles = held?.tiles || [{...(flate ? held : {jpeg: held}), x: 0, y: 0, width: pixelWidth, height: pixelHeight}];
+		const pictures = tiles.map((tile, at) => '/Im0_' + at + ' ' + stream('/Type /XObject /Subtype /Image /Width ' + tile.width + ' /Height ' + tile.height +
+			' /ColorSpace /DeviceRGB /BitsPerComponent 8 /Filter /' + (tile.rgb ? 'FlateDecode' : 'DCTDecode'), tile.rgb || tile.jpeg) + ' 0 R'), states = [];
 		pages[index] = null;
-		const pictures = ['/Im0 ' + picture + ' 0 R'], states = [];
 		const emit = (drawing, left, top, clipWidth, clipHeight) => {
 			let out = `q\n.75 0 0 -.75 ${decimal(left)} ${decimal(top)} cm\n0 0 ${clipWidth} ${clipHeight} re W n\n1 0 0 1 ${decimal(drawing.x)} 0 cm\n`;
 			out += [drawing.clip.x, drawing.clip.y, drawing.clip.width, drawing.clip.height].map(decimal).join(' ') + ' re W n\n';
@@ -728,7 +744,8 @@ async function writeRasterPdf({pages, textPages, linkPages = [], vectorPages = [
 		};
 		let commands = '';
 		for (const drawing of backdrop || []) commands += emit(drawing, 0, height, Math.round(width * 4 / 3), Math.round(height * 4 / 3));
-		commands += '/Artifact BMC\nq\n' + [decimal(pixelWidth * .75), 0, 0, decimal(pixelHeight * .75), decimal(margins.left), decimal(height - margins.top - pixelHeight * .75)].join(' ') + ' cm\n/Im0 Do\nQ\nEMC\n';
+		commands += '/Artifact BMC\n' + tiles.map((tile, at) => 'q\n' + [decimal(tile.width * .75), 0, 0, decimal(tile.height * .75), decimal(margins.left + tile.x * .75),
+			decimal(height - margins.top - (tile.y + tile.height) * .75)].join(' ') + ' cm\n/Im0_' + at + ' Do\nQ\n').join('') + 'EMC\n';
 		for (const drawing of vectorPages[index] || []) commands += emit(drawing, margins.left, height - margins.top, pixelWidth, pixelHeight);
 		const textAlphas = new Map();
 		for (const run of textPages[index]) {

package/dist/spec/document-settings.mjs

@@ -119,7 +119,16 @@ const PAPERS = Object.freeze({
 	a4: Object.freeze({name: 'a4', width: 11906, height: 16838, css: 'A4'}),
 	a5: Object.freeze({name: 'a5', width: 8391, height: 11906, css: 'A5'}),
 	legal: Object.freeze({name: 'legal', width: 12240, height: 20160, css: 'legal'}),
+	tabloid: Object.freeze({name: 'tabloid', width: 15840, height: 24480, css: '11in 17in'}),
+	a3: Object.freeze({name: 'a3', width: 16838, height: 23811, css: 'A3'}),
 });
+function paperOf(value) {
+	const name = String(value || '').toLowerCase(), named = Object.hasOwn(PAPERS, name) ? PAPERS[name] : null;
+	if (named) return named;
+	const pixels = /^(\d{3,5})x(\d{3,5})px$/.exec(name), width = Number(pixels?.[1]), height = Number(pixels?.[2]);
+	return pixels && width <= 10000 && height <= 10000 ? Object.freeze({name, width: width * 15, height: height * 15, css: width + 'px ' + height + 'px'}) : null;
+}
+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,
 	papersize: null, geometry: null, pagestyle: null, spacing: null,
@@ -334,7 +343,7 @@ export function readDocumentSettings(markdown) {
 	const monofont = documentFont(take('monofont'));
 	const defaultfont = documentFont(take('defaultfont'));
 	const linestretch = leading(take('linestretch'));
-	const papersize = PAPERS[String(take('papersize') || '').toLowerCase()] || null;
+	const papersize = paperOf(take('papersize'));
 	const geometry = take('geometry') != null ? marginOf(take('geometry')) : null;
 	const page = String(take('pagestyle') || '').toLowerCase();
 	return Object.freeze({
@@ -359,14 +368,14 @@ export function updateDocumentSettings(markdown, patch) {
 		text: (source[field.start - 1] === ':' ? ' ' : '') + text + (source[field.end] === '#' ? ' ' : '')});
 	for (const [key, supplied] of Object.entries(patch || {})) {
 		const font = ['mainfont', 'sansfont', 'monofont', 'defaultfont'].includes(key);
-		if (!font && !['fontsize', 'linestretch', 'spacing', 'geometry'].includes(key)) throw new TypeError('Unknown document setting: ' + key);
+		if (!font && !['fontsize', 'linestretch', 'spacing', 'geometry', 'papersize'].includes(key)) throw new TypeError('Unknown document setting: ' + key);
 		const matches = fields.filter(item => item.key === key);
 		if (matches.length > 1) throw new RangeError('Duplicate document setting: ' + key);
 		const field = matches[0];
-		const value = supplied === null ? null : font ? documentFont(supplied) : key === 'fontsize' ? fontSize(supplied) : key === 'spacing' ? normalizeDocumentSpacing(supplied) : key === 'geometry' ? marginOf(supplied) : leading(supplied);
+		const value = supplied === null ? null : font ? documentFont(supplied) : key === 'fontsize' ? fontSize(supplied) : key === 'spacing' ? normalizeDocumentSpacing(supplied) : key === 'geometry' ? marginOf(supplied) : key === 'papersize' ? paperOf(supplied) : leading(supplied);
 		if (supplied !== null && !value) throw new TypeError('Invalid document setting: ' + key);
-		const encoded = value === null ? '' : font ? JSON.stringify(value.family) : key === 'fontsize' ? value.step : key === 'spacing' ? JSON.stringify(value) : key === 'geometry' ? unquote(supplied).trim() : String(value.factor);
-		if (value !== null && before[key] && (font ? before[key].family === value.family : key === 'fontsize' ? same(before.fontsize.unit, value.unit) : key === 'spacing' ? JSON.stringify(before.spacing) === encoded : key === 'geometry' ? ['top', 'right', 'bottom', 'left'].every(side => before.geometry[side] === value[side]) : before.linestretch.factor === value.factor)) continue;
+		const encoded = value === null ? '' : font ? JSON.stringify(value.family) : key === 'fontsize' ? value.step : key === 'spacing' ? JSON.stringify(value) : key === 'geometry' ? unquote(supplied).trim() : key === 'papersize' ? value.name : String(value.factor);
+		if (value !== null && before[key] && (font ? before[key].family === value.family : key === 'fontsize' ? same(before.fontsize.unit, value.unit) : key === 'spacing' ? JSON.stringify(before.spacing) === encoded : key === 'geometry' ? ['top', 'right', 'bottom', 'left'].every(side => before.geometry[side] === value[side]) : key === 'papersize' ? before.papersize.name === value.name : before.linestretch.factor === value.factor)) continue;
 		if (key === 'fontsize' && value !== null && fontSize(encoded)?.unit !== value.unit) refuse(key);
 		if (!field) { if (value !== null) append.push(key + ': ' + encoded + eol); continue; }
 		if (field.opaque || field.invalid || field.multiline || field.block) refuse(key);

package/dist/spec/md-assets.mjs

@@ -23,6 +23,7 @@ export function installMarkdownImages(md) {
   const reference = md.block.ruler.__rules__.find(row => row.name === 'reference').fn;
   md.block.ruler.at('reference', (state, start, end, silent) => {
     if (silent) return reference(state, start, end, silent);
+    if (state.src.charCodeAt(state.bMarks[start] + state.tShift[start]) !== 0x5B) return false;
     const saved = state.env.references, local = Object.create(null);
     state.env.references = local;
     let accepted;
@@ -40,12 +41,12 @@ export function installMarkdownImages(md) {
   md.inline.ruler.at('image', (state, silent) => {
     const start = state.pos;
     if (state.src[start] !== '!' || state.src[start + 1] !== '[') return false;
-    const close = state.md.helpers.parseLinkLabel(state, start + 1, false);
     const before = state.tokens.length;
     if (!image(state, silent)) return false;
     if (!silent && state.tokens.length > before) {
       const token = state.tokens[state.tokens.length - 1], source = state.src.slice(start, state.pos);
       if (token.type === 'image') {
+        const close = state.md.helpers.parseLinkLabel(state, start + 1, false);
         let reference = null;
         if (close >= 0 && state.src[close + 1] !== '(') {
           const explicit = state.src[close + 1] === '[' ? state.src.slice(close + 2, state.pos - 1) : '';

package/dist/spec/md-engine.mjs

@@ -0,0 +1,90 @@
+// SPDX-License-Identifier: MIT
+
+const NEWLINES = /\r\n?/g, NULLS = /\0/g;
+
+function lineScanner(Base, Token) {
+  function StateBlock(src, md, env, tokens) {
+    this.bMarks = []; this.eMarks = []; this.tShift = []; this.sCount = []; this.bsCount = [];
+    this.blkIndent = 0; this.line = 0; this.lineMax = 0; this.tight = false; this.listIndent = -1;
+    this.parentType = 'root'; this.level = 0; this.Token = Token;
+    this.src = src; this.md = md; this.env = env; this.tokens = tokens;
+    const length = src.length;
+    for (let start = 0; start < length;) {
+      let at = start, indent = 0, offset = 0;
+      for (; at < length; at++) {
+        const code = src.charCodeAt(at);
+        if (code === 0x20) offset++;
+        else if (code === 0x09) offset += 4 - offset % 4;
+        else break;
+        indent++;
+      }
+      if (at === length) break;
+      let end = src.indexOf('\n', at);
+      if (end < 0) end = length;
+      this.bMarks.push(start); this.eMarks.push(end); this.tShift.push(indent); this.sCount.push(offset); this.bsCount.push(0);
+      start = end + 1;
+    }
+    this.bMarks.push(length); this.eMarks.push(length); this.tShift.push(0); this.sCount.push(0); this.bsCount.push(0);
+    this.lineMax = this.bMarks.length - 1;
+  }
+  StateBlock.prototype = Base.prototype;
+  return StateBlock;
+}
+
+function backticks(state, silent) {
+  const start = state.pos, src = state.src;
+  if (src.charCodeAt(start) !== 0x60) return false;
+  const max = state.posMax;
+  let pos = start + 1;
+  while (pos < max && src.charCodeAt(pos) === 0x60) pos++;
+  const marker = src.slice(start, pos), length = marker.length, runs = state.backticks;
+  const scanned = state.backticksScanned;
+  if (!scanned || pos < scanned || (runs[length] ?? -1) >= pos) {
+    let matchStart, matchEnd = pos;
+    while ((matchStart = src.indexOf('`', matchEnd)) !== -1 && matchStart < max) {
+      matchEnd = matchStart + 1;
+      while (src.charCodeAt(matchEnd) === 0x60) matchEnd++;
+      if (matchEnd > max) break;
+      const run = matchEnd - matchStart;
+      if (run === length) {
+        if (!silent) {
+          const token = state.push('code_inline', 'code', 0);
+          token.markup = marker;
+          let content = src.slice(pos, matchStart).replace(/\n/g, ' ');
+          if (content.startsWith(' ') && content.endsWith(' ') && /[^ ]/.test(content)) content = content.slice(1, -1);
+          token.content = content;
+        }
+        state.pos = matchEnd;
+        return true;
+      }
+      if (!(runs[run] >= matchStart)) runs[run] = matchStart;
+    }
+    if (matchStart === -1 && (!scanned || pos < scanned)) state.backticksScanned = pos;
+  }
+  if (!silent) state.pending += marker;
+  state.pos = pos;
+  return true;
+}
+
+const CLEAN_WEB_LINK = /^https?:\/\/([a-z0-9-]{1,63}(?:\.[a-z0-9-]{1,63})*)(?:\/[A-Za-z0-9\-._~/]*)?$/;
+function cleanWebLink(url) {
+  const match = CLEAN_WEB_LINK.exec(url);
+  return match !== null && match[1].length <= 255;
+}
+
+export function tuneMarkdownEngine(md) {
+  if (md.__rapierEngineTuned) return md;
+  md.__rapierEngineTuned = true;
+  md.core.ruler.at('normalize', state => {
+    let src = state.src;
+    if (src.indexOf('\r') >= 0) src = src.replace(NEWLINES, '\n');
+    if (src.indexOf('\0') >= 0) src = src.replace(NULLS, '�');
+    state.src = src;
+  });
+  const BaseBlock = md.block.State;
+  md.block.State = lineScanner(BaseBlock, new BaseBlock('', md, {}, []).Token);
+  md.inline.ruler.at('backticks', backticks);
+  const normalizeLink = md.normalizeLink;
+  md.normalizeLink = url => cleanWebLink(url) ? url : normalizeLink.call(md, url);
+  return md;
+}

package/dist/spec/md-marks.mjs

@@ -251,8 +251,9 @@ export function createTypography({normalizeFontFamily, fontFamilyCss, FONT_STACK
 		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;
+			for (let at = 0; at < state.tokens.length; at++) {
+				const block = state.tokens[at];
+				if (block.type !== 'inline' || !block.children || block.content.indexOf('<') < 0) continue;
 				const stack = []; let depth = 0, overflow = 0;
 				for (const token of block.children) {
 					if (token.type !== 'html_inline') { depth += token.nesting || 0; continue; }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rapier-markdown-kit",
-  "version": "1.2.19",
+  "version": "1.2.21",
   "description": "Read, render and write Self-contained Markdown: one .md file that carries its pictures, drawings and layout, and that any Markdown app can read. HTML renderer, stylesheet, text layout, Will/1 agent permissions, and an edit history with authorship and offline merge. MIT, no dependencies.",
   "keywords": [
     "markdown",
@@ -44,6 +44,10 @@
       "types": "./dist/kit/markdown-it.d.mts",
       "default": "./dist/kit/markdown-it.mjs"
     },
+    "./parsed": {
+      "types": "./dist/kit/parsed.d.mts",
+      "default": "./dist/kit/parsed.mjs"
+    },
     "./layout": "./dist/kit/layout.mjs",
     "./marks": "./dist/kit/marks.mjs",
     "./model": "./dist/kit/model.mjs",