rapier-html 1.2.52 → 1.2.55

package/BUILD.json

@@ -1,10 +1,10 @@
 {
   "package": "rapier-html",
-  "version": "1.2.52",
+  "version": "1.2.55",
   "path": "dist/rapier.html",
-  "bytes": 6445804,
-  "sha256": "3c4983d36a53d73ff6e72cfd3b03bd819b7ffbc560c6ebdd2865e8013422a104",
-  "builtAt": "2026-10-31T05:43:35.807Z",
+  "bytes": 6613729,
+  "sha256": "66dd1e87abc3cd368fdd5481ce4ad8816ea5235fb08f1788fbfaa67ed111581f",
+  "builtAt": "2026-11-03T23:25:11.656Z",
   "node": "v22.23.4",
   "canonical": true,
   "packing": "zopfli",

package/README.md

@@ -2,11 +2,6 @@
 
 Turn Markdown into one offline HTML file that contains the full Rapier editor.
 
-<picture>
-  <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/jackskip22/rapier-plugins/main/assets/write-390-dark.png">
-  <img src="https://raw.githubusercontent.com/jackskip22/rapier-plugins/main/assets/write-390-light.png" alt="The Rapier editor on a phone: a launch plan with an agent's change marked" width="320">
-</picture>
-
 Try it: `npx rapier-html@1.2.52 notes.md`, then open `notes.rapier.html` in any browser.
 Install: `npm install rapier-html@1.2.52`.
 

package/dist/ledger/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/ledger/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/ledger/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 "./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};