rapier-markdown-kit 1.2.51 → 1.2.55

package/dist/kit/render-markdown.mjs

@@ -156,12 +156,16 @@ function initMarkdownIt() {
 	md.renderer.rules.softbreak = () =>
 		sourceToken('\n', '\u2060', 'rapier-source-token--softbreak');
 	md.core.ruler.before('text_join', 'rapier_escape_token', state => {
+		if (state.src.indexOf('\\') < 0) return;
 		for (let at = 0; at < state.tokens.length; at++) {
 			const token = state.tokens[at];
-			if (token.type !== 'inline' || !token.children) continue;
+			if (token.type !== 'inline' || !token.children || token.content.indexOf('\\') < 0) continue;
 			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';
+				if (child.type === 'text_special' && child.info === 'escape' && child.content.length === 1) {
+					const c = child.content.charCodeAt(0);
+					if (c !== 0x5c && c !== 0x2a && c !== 0x60 && c !== 0x5b && c !== 0x5d && c !== 0x5f) child.type = 'rapier_escape';
+				}
 			}
 		}
 	});
@@ -320,15 +324,27 @@ function initMarkdownIt() {
 	};
 
 	md.core.ruler.push('rapier_setext_rule', function (state) {
-		let lines = null;
+		let starts = null;
 		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;
-			if (lines === null) lines = state.src.split('\n');
-			const underline = lines[token.map[1] - 1];
-			if (typeof underline === 'string' && /^ {0,3}(?:=+|-+)[ \t]*$/.test(underline)) {
+			if (starts === null) {
+				starts = state._lineStarts;
+				if (!starts) {
+					starts = [0];
+					for (let i = state.src.indexOf('\n'); i >= 0; i = state.src.indexOf('\n', i + 1)) starts.push(i + 1);
+					state._lineStarts = starts;
+				}
+			}
+			const lineIdx = token.map[1] - 1;
+			if (lineIdx < 0 || lineIdx >= starts.length) continue;
+			const lineStart = starts[lineIdx];
+			const nextStart = starts[lineIdx + 1];
+			const lineEnd = nextStart !== undefined ? nextStart - 1 : state.src.length;
+			const underline = state.src.slice(lineStart, lineEnd);
+			if (/^ {0,3}(?:=+|-+)[ \t]*$/.test(underline)) {
 				token.attrSet('data-rapier-heading-rule', underline);
 			}
 		}
@@ -920,15 +936,15 @@ function _rapierInstallSemanticProbe(instance) {
 			return false;
 		}
 		const firstEnd = state.md.helpers.parseLinkLabel(state, labelStart, false);
-		if (firstEnd < 0) return false;
-		const firstLabel = src.slice(labelStart + 1, firstEnd);
+		if (firstEnd < 0 || firstEnd === labelStart + 1 && src.charCodeAt(firstEnd + 1) !== 0x5b && src.charCodeAt(firstEnd + 1) !== 0x28) return false;
 		const after = firstEnd + 1;
+		const afterCode = src.charCodeAt(after);
 
-		if (src.charCodeAt(after) === 0x5b) {
+		if (afterCode === 0x5b) {
 			const secondEnd = state.md.helpers.parseLinkLabel(state, after, false);
 			if (secondEnd < 0) return false;
 			const explicitLabel = src.slice(after + 1, secondEnd);
-			const rawKey = explicitLabel.length ? explicitLabel : firstLabel;
+			const rawKey = explicitLabel.length ? explicitLabel : src.slice(labelStart + 1, firstEnd);
 			record({
 				kind: image ? 'image-reference-use' : 'link-reference-use', rawKey,
 				localStart: pos, localEnd: secondEnd + 1,
@@ -938,9 +954,13 @@ function _rapierInstallSemanticProbe(instance) {
 			return false;
 		}
 
-		if (src.charCodeAt(after) === 0x28) {
+		if (afterCode === 0x28) {
 			let destinationPos = after + 1;
-			while (destinationPos < max && /[ \t\n]/.test(src.charAt(destinationPos))) destinationPos++;
+			while (destinationPos < max) {
+				const c = src.charCodeAt(destinationPos);
+				if (c === 0x20 || c === 0x09 || c === 0x0a) destinationPos++;
+				else break;
+			}
 			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);
@@ -957,9 +977,12 @@ function _rapierInstallSemanticProbe(instance) {
 			return false;
 		}
 
+		if (!image && !state.env.references) return false;
+		const firstLabel = src.slice(labelStart + 1, firstEnd);
+		if (!firstLabel) return false;
 		const normalize = state.md.utils && state.md.utils.normalizeReference;
 		const normalized = typeof normalize === 'function' ? normalize(firstLabel) : firstLabel.trim().replace(/\s+/g, ' ').toUpperCase();
-		if ((image || (state.env.references && state.env.references[normalized])) && firstLabel) {
+		if (image || (state.env.references && state.env.references[normalized])) {
 			record({
 				kind: image ? 'image-reference-use' : 'link-reference-use', rawKey: firstLabel,
 				localStart: pos, localEnd: firstEnd + 1,
@@ -971,6 +994,7 @@ function _rapierInstallSemanticProbe(instance) {
 
 	try {
 		instance.core.ruler.before('footnote_tail', 'rapier_footnote_definition_probe', function (state) {
+			if (!state.env?.footnotes) { state.env.__rapierFootnoteDefinitions = []; return; }
 			const out = [];
 			const tokens = state && Array.isArray(state.tokens) ? state.tokens : [];
 			const signatureFor = values => {

package/dist/kit/render-sanitize.mjs

@@ -121,7 +121,7 @@ function prepareMathSource(input, DOMParser) {
 	return sourceRoot ? root.outerHTML : root;
 }
 
-function createInertHtmlSanitizer({parseFragment, serialize, sanitizeHtml, safeRasterDataUrl, chromeOwnsId = id => /^rapier-(?!anchor-)/.test(id)}) {
+function createInertHtmlSanitizer({parseFragment, serialize, sanitizeHtml, safeRasterDataUrl, chromeOwnsId = id => /^(?:rapier-(?!anchor-)|Rapier[A-Z]|_rapier)/.test(id)}) {
 	if (![parseFragment, serialize, sanitizeHtml, safeRasterDataUrl, chromeOwnsId].every(port => typeof port === 'function'))
 		throw new TypeError('The inert HTML sanitizer requires every parser and filtering port');
 	const uri = /^(?:(?:(?:f|ht)tps?|mailto|tel|callto|sms|cid|xmpp|matrix):|[^a-z]|[a-z+.\-]+(?:[^a-z+.\-:]|$))/i;
@@ -184,7 +184,7 @@ function createInertHtmlSanitizer({parseFragment, serialize, sanitizeHtml, safeR
 					const key = name.toLowerCase();
 					const value = name === 'value' ? inputValue : inputValue.trim();
 					if (forbiddenAttributes.has(key) || key.startsWith('on')) continue;
-					if (key === 'id' && chromeOwnsId(value)) continue;
+					if ((key === 'id' || key === 'name') && chromeOwnsId(value)) continue;
 					if (/((--!?|])>)|<\/(style|script|title|xmp|textarea|noscript|iframe|noembed|noframes)/i.test(value)
 						|| key === 'attributename' && value.includes('href')) continue;
 					const data = /^data-[\-\w.\u00b7-\uffff]+$/.test(key), aria = /^aria-[\-\w]+$/.test(key);
@@ -372,7 +372,7 @@ function _rapierInstallDocumentSanitizeHooks() {
 			data.keepAttr = !!data.attrValue;
 			return;
 		}
-		if (String(data.attrName || '').toLowerCase() === 'id' && _rapierChromeOwnsId(value)) { data.keepAttr = false; return; }
+		if (/^(?:id|name)$/.test(String(data.attrName || '').toLowerCase()) && _rapierChromeOwnsId(value)) { data.keepAttr = false; return; }
 		if (_rapierRemoteContent.allowed || _rapierSanitizeRuntime.context === 'source') return;
 		const attribute = String(data.attrName || '').toLowerCase();
 		if (attribute === 'alt' || attribute === 'title') return;
@@ -502,7 +502,7 @@ function escapeRapierHtmlText(value) {
 
 function _rapierChromeOwnsId(id) {
 	if (!_rapierSanitizeRuntime.chromeIds) _rapierSanitizeRuntime.chromeIds = new Set(Array.from(typeof document?.querySelectorAll === 'function' ? document.querySelectorAll('[id]') : [], element => element.id));
-	return _rapierSanitizeRuntime.chromeIds.has(String(id)) || /^rapier-(?!anchor-)/.test(id);
+	return _rapierSanitizeRuntime.chromeIds.has(String(id)) || /^(?:rapier-(?!anchor-)|Rapier[A-Z]|_rapier)/.test(id);
 }
 
 const RAPIER_BIDI_CONTROL = /[\u061c\u200e\u200f\u202a-\u202e\u2066-\u2069]/;

package/dist/math/delimiters.mjs

@@ -1,32 +1,71 @@
 // SPDX-License-Identifier: MIT
+function countLines(source, from, to) {
+  let lines = 0;
+  for (let i = from; i < to; i++) {
+    const code = source.charCodeAt(i);
+    if (code === 0x0a || code === 0x0d) lines++;
+  }
+  return lines;
+}
+
 export function createMathMatcher(source, {singleDollar = false, brackets = true} = {}) {
   if (typeof source !== 'string') throw new TypeError('Math boundaries require source text.');
-  const markers = new Map(), next = Object.create(null);
-  let slashes = 0, line = 0;
-  for (let at = 0; at < source.length;) {
-    const char = source[at];
-    if (char === '\\') { slashes++; at++; continue; }
-    if (char === '\n' || char === '\r') line++;
-    if (char === '$') {
+  const len = source.length;
+  if (len === 0 || (source.indexOf('$') < 0 && (!brackets || source.indexOf('\\') < 0))) {
+    return () => null;
+  }
+  const markers = new Map(), list = [], next = Object.create(null);
+  if (!brackets) {
+    let line = 0, lastAt = 0;
+    for (let at = source.indexOf('$'); at >= 0; at = source.indexOf('$', at)) {
+      line += countLines(source, lastAt, at);
+      let slashes = 0;
+      for (let s = at - 1; s >= 0 && source.charCodeAt(s) === 0x5c; s--) slashes++;
       let end = at + 1;
-      while (source[end] === '$') end++;
+      while (end < len && source.charCodeAt(end) === 0x24) end++;
       const count = end - at;
-      if (!(slashes & 1) && (count === 2 || count === 1 && singleDollar))
-        markers.set(at, {at, marker: count === 2 ? '$$' : '$', line});
+      if (!(slashes & 1) && (count === 2 || count === 1 && singleDollar)) {
+        const entry = {at, marker: count === 2 ? '$$' : '$', line, close: undefined};
+        markers.set(at, entry);
+        list.push(entry);
+      }
+      lastAt = end;
       at = end;
-    } else {
-      if (brackets && slashes & 1 && '()[]'.includes(char))
-        markers.set(at - 1, {at: at - 1, marker: '\\' + char, line});
-      at++;
     }
-    slashes = 0;
+  } else {
+    let slashes = 0, line = 0;
+    for (let at = 0; at < len;) {
+      const code = source.charCodeAt(at);
+      if (code === 0x5c) { slashes++; at++; continue; }
+      if (code === 0x0a || code === 0x0d) line++;
+      if (code === 0x24) {
+        let end = at + 1;
+        while (end < len && source.charCodeAt(end) === 0x24) end++;
+        const count = end - at;
+        if (!(slashes & 1) && (count === 2 || count === 1 && singleDollar)) {
+          const entry = {at, marker: count === 2 ? '$$' : '$', line, close: undefined};
+          markers.set(at, entry);
+          list.push(entry);
+        }
+        at = end;
+      } else {
+        if (slashes & 1 && (code === 0x28 || code === 0x29 || code === 0x5b || code === 0x5d)) {
+          const entry = {at: at - 1, marker: '\\' + source[at], line, close: undefined};
+          markers.set(at - 1, entry);
+          list.push(entry);
+        }
+        at++;
+      }
+      slashes = 0;
+    }
   }
-  for (const entry of [...markers.values()].reverse()) {
+  for (let i = list.length - 1; i >= 0; i--) {
+    const entry = list[i];
     const closing = entry.marker === '\\(' ? '\\)' : entry.marker === '\\[' ? '\\]' : entry.marker;
     entry.close = next[closing];
     next[entry.marker] = entry;
   }
-  return function match(start, limit = source.length) {
+  return function match(start, limit = len) {
     const open = markers.get(start), close = open?.close;
     if (!close || open.marker === '\\)' || open.marker === '\\]' || close.at + close.marker.length > limit) return null;
     const bodyStart = start + open.marker.length, bodyEnd = close.at;

package/dist/math/markdown-rules.mjs

@@ -1,6 +1,19 @@
 // SPDX-License-Identifier: MIT
 import {createMathMatcher} from './delimiters.mjs';
 
+function isMathFenceInfo(info) {
+  if (!info || info.length < 4) return false;
+  let start = 0;
+  const len = info.length;
+  while (start < len && info.charCodeAt(start) <= 0x20) start++;
+  if (start + 4 > len) return false;
+  if ((info.charCodeAt(start) | 32) !== 0x6d ||
+      (info.charCodeAt(start + 1) | 32) !== 0x61 ||
+      (info.charCodeAt(start + 2) | 32) !== 0x74 ||
+      (info.charCodeAt(start + 3) | 32) !== 0x68) return false;
+  return start + 4 === len || info.charCodeAt(start + 4) <= 0x20;
+}
+
 export function installMathRules(md, {singleDollar = false, brackets = true, ruleName = 'rapier_math', inLink = false} = {}) {
   const authored = new WeakMap();
   md.core.ruler.before('normalize', ruleName + '_source', state => {
@@ -9,13 +22,13 @@ export function installMathRules(md, {singleDollar = false, brackets = true, rul
   md.core.ruler.after('block', ruleName + '_source_release', state => authored.delete(state.tokens));
   const tokenize = md.block.tokenize;
   md.block.tokenize = function(state, startLine, endLine) {
-    const first = state.tokens.length;
+    const first = Math.max(state.tokens.length, state._mathScanned || 0);
     try { return tokenize.call(this, state, startLine, endLine); }
     finally {
-      for (let index = first; index < state.tokens.length; index++) {
+      const len = state.tokens.length;
+      for (let index = first; index < len; index++) {
         const token = state.tokens[index];
-        if (token.type !== 'fence' || !token.map || token.meta?.mathSource !== undefined ||
-            String(token.info || '').trim().split(/\s+/)[0].toLowerCase() !== 'math') continue;
+        if (token.type !== 'fence' || !token.map || token.meta?.mathSource !== undefined || !isMathFenceInfo(token.info)) continue;
         const held = authored.get(state.tokens), source = held?.source ?? state.src;
         let value;
         if (!state.rapierSourceSlice && source === state.src) value = state.getLines(token.map[0], token.map[1], state.blkIndent, false);
@@ -42,6 +55,7 @@ export function installMathRules(md, {singleDollar = false, brackets = true, rul
         }
         token.meta = {...token.meta, mathSource: value};
       }
+      state._mathScanned = len;
     }
   };
   const renderText = md.renderer.renderInlineAsText;
@@ -62,7 +76,8 @@ export function installMathRules(md, {singleDollar = false, brackets = true, rul
   }
   md.inline.ruler.before('escape', ruleName, (state, silent) => {
     if (!inLink && state.linkLevel > 0) return false;
-    if (state.src[state.pos] !== '$' && state.src[state.pos] !== '\\') return false;
+    const ch = state.src.charCodeAt(state.pos);
+    if (ch !== 0x24 && (!brackets || ch !== 0x5c)) return false;
     const span = match(state, state.pos, state.posMax);
     if (!span) return false;
     if (!silent) {
@@ -77,7 +92,8 @@ export function installMathRules(md, {singleDollar = false, brackets = true, rul
   md.block.ruler.before('fence', ruleName, (state, startLine, endLine, silent) => {
     if (state.sCount[startLine] - state.blkIndent >= 4) return false;
     const start = state.bMarks[startLine] + state.tShift[startLine];
-    if (state.src.slice(start, start + 2) !== '$$' && (!brackets || state.src.slice(start, start + 2) !== '\\[')) return false;
+    const c0 = state.src.charCodeAt(start), c1 = state.src.charCodeAt(start + 1);
+    if (!(c0 === 0x24 && c1 === 0x24) && (!brackets || !(c0 === 0x5c && c1 === 0x5b))) return false;
     const span = match(state, start, state.eMarks[endLine - 1]);
     if (!span?.displayMode) return false;
     let last = startLine;

package/dist/spec/md-assets.mjs

@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: MIT
 // Pure text and markdown-it tokens: no DOM, no byte decoding, no globalThis.Rapier* (MIT kit; decoders stay in images/assets.mjs).
 import {isWordSidecarBlock} from './word-sidecar.mjs';
+import {tuneMarkdownEngine} from './md-engine.mjs';
 import {sourceFacts, sourceView, sourceEdit} from '../kit/ledger/source.mjs';
 
 export const IMAGE_LIMITS = Object.freeze({bytes: 16 * 1024 * 1024, sourceChars: 64 * 1024 * 1024, dimension: 16384, pixels: 24000000, assets: 1024});
@@ -66,27 +67,22 @@ function parserFor(factory = configured || globalThis.markdownit) {
   if (configured && factory === globalThis.markdownit) return configured;
   if (typeof factory !== 'function') return fail('markdown_parser_unavailable');
   let parser = parsers.get(factory);
-  if (!parser) { parser = installMarkdownImages(factory({html: true, maxNesting: 20})); parsers.set(factory, parser); }
+  if (!parser) { parser = installMarkdownImages(tuneMarkdownEngine(factory({html: true, maxNesting: 20}))); parsers.set(factory, parser); }
   return parser;
 }
 export {parserFor as markdownParser};
 export const markdownBodyOffset = source => splitSource ? splitSource(source).bodyOffset : 0;
 
-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);
-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),
-});
+const BLOCK_WINDOW = 1024, WINDOW_END = Symbol('block window end');
 
 export function eachBlockWindow(source, bodyOffset, parser, env, visit, keepNul = false) {
   for (const window of blockWindows(source, bodyOffset, parser, env, keepNul)) visit(window);
 }
 
 export function* blockWindows(source, bodyOffset, parser, env, keepNul = false) {
-  const lineEnds = source.slice(bodyOffset).replace(/\r\n?/g, '\n'), body = keepNul ? lineEnds : lineEnds.replace(/\0/g, '\ufffd');
+  const rawSlice = bodyOffset ? source.slice(bodyOffset) : source;
+  const lineEnds = rawSlice.indexOf('\r') >= 0 ? rawSlice.replace(/\r\n?/g, '\n') : rawSlice;
+  const body = keepNul || lineEnds.indexOf('\0') < 0 ? lineEnds : lineEnds.replace(/\0/g, '\ufffd');
   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); }
@@ -94,89 +90,52 @@ export function* blockWindows(source, bodyOffset, parser, env, keepNul = false)
     return at + shift;
   };
   const tokens = [];
-  let origin = 0, first = 0, state;
+  const state = new parser.block.State(body, parser, env, tokens);
+  state.rapierSourceSlice = (from, to) => source.slice(sourceOffset(from), sourceOffset(to));
+  const totalLines = state.lineMax;
+  let origin = 0, first = 0, windowStartLine = 0;
   const report = () => ({tokens, firstLine: first, lineStart: line => {
     if (!line) return sourceOffset(origin);
-    const end = Object.hasOwn(state.eMarks, line - 1) ? state.eMarks[line - 1] : body.length;
+    const absLine = first + line - 1;
+    const end = absLine >= 0 && absLine < totalLines ? state.eMarks[absLine] : body.length;
     return end < body.length ? sourceOffset(end + 1) : undefined;
   }});
-  let lines = 0;
-  for (let at = body.indexOf('\n'); at !== -1; at = body.indexOf('\n', at + 1)) lines++;
-  if (lines <= BLOCK_WINDOW) {
-    state = new parser.block.State(body, parser, env, tokens);
-    state.rapierSourceSlice = (from, to) => source.slice(sourceOffset(from), sourceOffset(to));
-    parser.block.tokenize(state, state.line, state.lineMax);
+  if (totalLines <= BLOCK_WINDOW) {
+    parser.block.tokenize(state, state.line, totalLines);
     yield report(); return;
   }
-  state = new parser.block.State(body.slice(body.lastIndexOf('\n') + 1), parser, env, tokens);
-  state.rapierSourceSlice = (from, to) => source.slice(sourceOffset(from), sourceOffset(to));
-  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;
-  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;
-      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;
-  };
   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 (;;) {
-    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;
+    if (this.level || line !== this.line || line === windowStartLine) return skipEmptyLines.call(this, line);
+    if (line - windowStartLine >= BLOCK_WINDOW) throw WINDOW_END;
+    const next = skipEmptyLines.call(this, line);
+    if (next - windowStartLine >= BLOCK_WINDOW) {
+      this.line = windowStartLine + BLOCK_WINDOW;
+      throw WINDOW_END;
     }
-    frontier = origin; ended = false; betweenBlocks = false;
-    state.line = 0; state.lineMax = lines - first; state.rapierFirstLine = first;
-    const outer = unheldLine;
-    unheldLine = answer;
+    return next;
+  };
+  for (let startLine = 0; startLine < totalLines;) {
+    startLine = skipEmptyLines.call(state, startLine);
+    if (startLine >= totalLines) break;
+    windowStartLine = startLine;
+    first = startLine;
+    origin = startLine === 0 ? 0 : state.eMarks[startLine - 1] + 1;
+    state.line = startLine;
+    state.rapierFirstLine = first;
     let finished = true;
-    try { parser.block.tokenize(state, 0, state.lineMax); }
+    try { parser.block.tokenize(state, startLine, totalLines); }
     catch (error) { if (error !== WINDOW_END) throw error; finished = false; }
-    finally { unheldLine = outer; }
+    if (first !== 0) {
+      for (let i = 0; i < tokens.length; i++) {
+        const m = tokens[i].map;
+        if (m) { m[0] -= first; m[1] -= first; }
+      }
+    }
     yield 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;
+    startLine = state.line;
   }
 }
 
@@ -184,7 +143,7 @@ const INVALID_PERCENT_PAYLOAD = /[^A-Za-z0-9._~:\/?@+$,;=%-]/;
 const isHexUnit = code => code >= 48 && code <= 57 || code >= 65 && code <= 70 || code >= 97 && code <= 102;
 let lastScan = null;
 export function dataImage(url) {
-  if (typeof url !== 'string' || url.length > IMAGE_LIMITS.sourceChars) return null;
+  if (typeof url !== 'string' || url.length < 15 || (url.charCodeAt(0) | 32) !== 0x64 || url.charCodeAt(4) !== 0x3a || url.length > IMAGE_LIMITS.sourceChars) return null;
   if (url.length > 4096) {
     if (lastScan?.url !== url) lastScan = {url, image: scanDataImage(url)};
     return lastScan.image && {...lastScan.image};