rapier-markdown-kit 1.2.20 → 1.2.22

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/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/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.20",
+  "version": "1.2.22",
   "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",