rapier-markdown-kit 1.1.102 → 1.2.3

package/dist/spec/md-assets.mjs

@@ -22,7 +22,7 @@ export function installMarkdownImages(md) {
   const normalize = md.normalizeLink;
   // An exact base64 data URL contains no URI escapes or host name to normalize.
   // Preserve its spelling and avoid allocating one URI-normalizer item per raster byte.
-  md.normalizeLink = url => /^data:image\/(?:jxl|png|jpeg|webp|svg\+xml);base64,[A-Za-z0-9+/]+={0,2}$/i.test(url) ? url : normalize(url);
+  md.normalizeLink = url => /^data:image\/(?:jxl|png|jpeg|webp|gif|svg\+xml);base64,[A-Za-z0-9+/]+={0,2}$/i.test(url) ? url : normalize(url);
   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);
@@ -73,11 +73,133 @@ function parserFor(factory = configured || globalThis.markdownit) {
 export {parserFor as markdownParser};
 export const markdownBodyOffset = source => splitSource ? splitSource(source).bodyOffset : 0;
 
+// markdown-it's block state builds five tables with one entry per line of its whole input, and its rules index
+// them by line. A long body gets the parser's one block pass with tables that hold a run of lines instead: a read
+// past the lines they hold fills them further from the parser's own line scan, and they are emptied between
+// top-level blocks. No line is parsed twice, so every token and `env` are the ones a whole-input state yields.
+const BLOCK_WINDOW = 1024, TABLE_STEP = 128, WINDOW_END = Symbol('block window end');
+const LINE_TABLES = ['bMarks', 'eMarks', 'tShift', 'sCount', 'bsCount'];
+const lineIndex = key => typeof key === 'string' && /^(?:0|[1-9]\d*)$/.test(key);
+// An array reaches its prototype only for an index it does not hold. One prototype serves every pass, so the
+// parser's table reads see one more array shape, not one per pass.
+let unheldLine = null;
+const unheldLines = new Proxy(Array.prototype, {
+  get: (target, key, table) => unheldLine && lineIndex(key) ? unheldLine(table, Number(key)) : Reflect.get(target, key, table),
+  set: (target, key, value, table) => unheldLine && lineIndex(key) ? unheldLine(table, Number(key), true, value) : Reflect.set(target, key, value, table),
+});
+
+// The parser's block pass over source.slice(bodyOffset). `visit` receives top-level blocks as they finish:
+// `tokens` with line numbers counted from `firstLine`, and lineStart(line), the source offset where one of those
+// lines begins (undefined when the source ends before it). `env` is the whole pass's. The tables hold at most
+// the lines between two visits: BLOCK_WINDOW of them, or as many as one block's rules read.
+export function eachBlockWindow(source, bodyOffset, parser, env, visit, keepNul = false) {
+  const lineEnds = source.slice(bodyOffset).replace(/\r\n?/g, '\n'), body = keepNul ? lineEnds : lineEnds.replace(/\0/g, '\ufffd');
+  // The body is the source with every CRLF one unit shorter: count the pairs before a body offset, from the last
+  // offset asked.
+  let pair = source.indexOf('\r\n', bodyOffset), shift = bodyOffset;
+  const sourceOffset = at => {
+    while (pair >= 0 && at + shift > pair) { shift++; pair = source.indexOf('\r\n', pair + 2); }
+    for (let last; shift > bodyOffset && at + shift - 1 <= (last = source.lastIndexOf('\r\n', (pair < 0 ? source.length : pair) - 1)); pair = last) shift--;
+    return at + shift;
+  };
+  const tokens = [];
+  let origin = 0, first = 0, state;
+  // A line begins after the newline that ends the line before it. No rule writes eMarks.
+  const report = () => visit({tokens, firstLine: first, lineStart: line => {
+    if (!line) return sourceOffset(origin);
+    const end = Object.hasOwn(state.eMarks, line - 1) ? state.eMarks[line - 1] : body.length;
+    return end < body.length ? sourceOffset(end + 1) : undefined;
+  }});
+  let lines = 0;
+  for (let at = 0; at < body.length; at++) if (body.charCodeAt(at) === 10) lines++;
+  if (lines <= BLOCK_WINDOW) {
+    state = new parser.block.State(body, parser, env, tokens);
+    parser.block.tokenize(state, state.line, state.lineMax);
+    return report();
+  }
+  // The parser's own count of a last line that no newline ends: it does not count one of only spaces.
+  state = new parser.block.State(body.slice(body.lastIndexOf('\n') + 1), parser, env, tokens);
+  lines += state.lineMax;
+  state.src = body;
+  const tables = new WeakMap();
+  for (const name of LINE_TABLES) { state[name].length = 0; tables.set(Object.setPrototypeOf(state[name], unheldLines), name); }
+  let frontier = 0, ended = false, betweenBlocks = false;
+  // A rule may be reading a table when it grows, so the five arrays are replaced whole; an array a rule still
+  // holds is left empty, and `answer` reads and writes the state's current one in its place.
+  const fill = line => {
+    while (!ended && line >= state.bMarks.length) {
+      const held = state.bMarks.length;
+      let until = frontier;
+      for (let more = held ? Math.max(TABLE_STEP, held - BLOCK_WINDOW) : BLOCK_WINDOW; more && until < body.length; more--) {
+        const end = body.indexOf('\n', until);
+        until = end < 0 ? body.length : end + 1;
+      }
+      const scanned = new parser.block.State(body.slice(frontier, until), parser, env, []);
+      ended = until === body.length;
+      // The scan's last entry stands for the end of its input, which is the body's end only for the last scan.
+      const added = ended ? scanned.lineMax + 1 : scanned.lineMax;
+      for (const name of LINE_TABLES) {
+        const old = state[name], next = scanned[name], offset = name === 'bMarks' || name === 'eMarks' ? frontier : 0, table = [];
+        for (let at = 0; at < held; at++) table.push(old[at]);
+        for (let at = 0; at < added; at++) table.push(next[at] + offset);
+        old.length = 0;
+        tables.set(table, name);
+        state[name] = Object.setPrototypeOf(table, unheldLines);
+      }
+      frontier = until;
+    }
+  };
+  const answer = (table, line, write, value) => {
+    const name = tables.get(table);
+    if (line >= state[name].length) {
+      if (betweenBlocks) throw WINDOW_END;
+      fill(line);
+    }
+    const current = state[name], held = Object.hasOwn(current, line);
+    if (!write) return held ? current[line] : undefined;
+    if (held) current[line] = value;
+    else Object.defineProperty(current, line, {value, writable: true, enumerable: true, configurable: true});
+    return true;
+  };
+  // The top-level loop calls this between two blocks with the line it stands on. There every token is a finished
+  // block and no rule is running, so the pass can leave the tokenizer and enter it again at that line.
+  const skipEmptyLines = state.skipEmptyLines;
+  state.skipEmptyLines = function (line) {
+    if (this.level || line !== this.line || !line) return skipEmptyLines.call(this, line);
+    if (line >= BLOCK_WINDOW) throw WINDOW_END;
+    betweenBlocks = true;
+    line = skipEmptyLines.call(this, line);
+    betweenBlocks = false;
+    return line;
+  };
+  for (;;) {
+    // Between top-level blocks the parser's loop only steps over empty lines, so a run of them is never tabled.
+    for (let at = origin; at < body.length; at++) {
+      const code = body.charCodeAt(at);
+      if (code === 10) { origin = at + 1; first++; }
+      else if (!parser.utils.isSpace(code)) break;
+    }
+    frontier = origin; ended = false; betweenBlocks = false;
+    state.line = 0; state.lineMax = lines - first;
+    const outer = unheldLine;
+    unheldLine = answer;
+    let finished = true;
+    try { parser.block.tokenize(state, 0, state.lineMax); }
+    catch (error) { if (error !== WINDOW_END) throw error; finished = false; }
+    finally { unheldLine = outer; }
+    report();
+    if (finished) return;
+    tokens.length = 0;
+    origin = state.eMarks[state.line - 1] + 1; first += state.line;
+    for (const name of LINE_TABLES) state[name].length = 0;
+  }
+}
+
 export function dataImage(url) {
   if (typeof url !== 'string' || url.length > IMAGE_LIMITS.sourceChars) return null;
   const prepared = preparedDefinitions.find(row => row.image.url === url)?.image;
   if (prepared) return {codec: prepared.codec, byteLength: prepared.byteLength, payloadStart: url.indexOf(',') + 1};
-  const match = /^data:(image\/(?:jxl|png|jpeg|webp|svg\+xml));base64,([A-Za-z0-9+/]+={0,2})$/i.exec(url);
+  const match = /^data:(image\/(?:jxl|png|jpeg|webp|gif|svg\+xml));base64,([A-Za-z0-9+/]+={0,2})$/i.exec(url);
   if (!match || match[2].length % 4) return null;
   const padding = match[2].endsWith('==') ? 2 : match[2].endsWith('=') ? 1 : 0;
   const byteLength = match[2].length / 4 * 3 - padding;
@@ -94,36 +216,33 @@ export function parseAssets(source, factory = configured || globalThis.markdowni
   if (prior) return prior.index;
   const definition = !bodyOffset && preparedDefinitions.find(row => row.source === source && row.factory === factory);
   if (definition) return definition.index;
-  const parser = parserFor(factory), env = {}, tokens = [];
-  const starts = [bodyOffset];
-  for (let at = bodyOffset; at < source.length; at++) {
-    if (source[at] === '\r') { if (source[at + 1] === '\n') at++; starts.push(at + 1); }
-    else if (source[at] === '\n') starts.push(at + 1);
-  }
-  parser.block.parse(source.slice(bodyOffset).replace(/\r\n?/g, '\n').replace(/\0/g, '\ufffd'), parser, env, tokens);
-  const references = env.references || Object.create(null), assets = new Map(), blocks = [], seen = new Set(), duplicateLabels = new Set();
-  for (const token of tokens) {
-    if (token.type !== 'reference_definition' || !token.map) continue;
-    const id = token.meta.label, definition = token.meta.mdImageDefinition, first = !seen.has(id);
-    if (!first) duplicateLabels.add(id);
-    seen.add(id);
-    const info = dataImage(definition?.href);
-    if (!info) continue;
-    const start = starts[token.map[0]], stop = starts[token.map[1]] ?? source.length;
-    let end = stop;
-    if (source[end - 1] === '\n') end--;
-    if (source[end - 1] === '\r') end--;
-    // Repeated definitions are source, not additional image owners.
-    const raw = source.slice(start, end), found = raw.indexOf(definition.href);
-    const repeated = found >= 0 ? raw.indexOf(definition.href, found + 1) : -1;
-    const labelContainsUrl = definition.href.length <= id.length && id.includes(parser.utils.normalizeReference(definition.href));
-    const urlStart = found >= 0 && repeated < 0 && !labelContainsUrl ? start + found : null;
-    const row = {id, label: id, source: raw, url: definition.href, title: definition.title || '', start, end,
-      ...info, urlStart, urlEnd: urlStart == null ? null : urlStart + definition.href.length,
-      payloadStart: urlStart == null ? null : urlStart + info.payloadStart, payloadEnd: urlStart == null ? null : urlStart + definition.href.length, status: 'unverified', active: first, topLevel: token.level === 0};
-    blocks.push(row);
-    if (first) assets.set(id, row);
-  }
+  const parser = parserFor(factory), env = {};
+  const assets = new Map(), blocks = [], seen = new Set(), duplicateLabels = new Set();
+  eachBlockWindow(source, bodyOffset, parser, env, ({tokens, lineStart}) => {
+    for (const token of tokens) {
+      if (token.type !== 'reference_definition' || !token.map) continue;
+      const id = token.meta.label, definition = token.meta.mdImageDefinition, first = !seen.has(id);
+      if (!first) duplicateLabels.add(id);
+      seen.add(id);
+      const info = dataImage(definition?.href);
+      if (!info) continue;
+      const start = lineStart(token.map[0]), stop = lineStart(token.map[1]) ?? source.length;
+      let end = stop;
+      if (source[end - 1] === '\n') end--;
+      if (source[end - 1] === '\r') end--;
+      // Repeated definitions are source, not additional image owners.
+      const raw = source.slice(start, end), found = raw.indexOf(definition.href);
+      const repeated = found >= 0 ? raw.indexOf(definition.href, found + 1) : -1;
+      const labelContainsUrl = definition.href.length <= id.length && id.includes(parser.utils.normalizeReference(definition.href));
+      const urlStart = found >= 0 && repeated < 0 && !labelContainsUrl ? start + found : null;
+      const row = {id, label: id, source: raw, url: definition.href, title: definition.title || '', start, end,
+        ...info, urlStart, urlEnd: urlStart == null ? null : urlStart + definition.href.length,
+        payloadStart: urlStart == null ? null : urlStart + info.payloadStart, payloadEnd: urlStart == null ? null : urlStart + definition.href.length, status: 'unverified', active: first, topLevel: token.level === 0};
+      blocks.push(row);
+      if (first) assets.set(id, row);
+    }
+  });
+  const references = env.references || Object.create(null);
   if (assets.size > IMAGE_LIMITS.assets) for (const asset of assets.values()) asset.status = 'asset_count_limit';
   let appendixStart = source.length;
   for (let index = blocks.length - 1; index >= 0; index--) {
@@ -332,7 +451,7 @@ function occurrenceChange(image, splices) {
 
 // A permissive gate keeps ordinary typing out of full-document image parsing.
 // Recognition and retirement proof still belong to Markdown-it below.
-export function mayRetireImageDefinitions(source, splices, factory) {
+export function mayRetireImageDefinitions(source, splices, factory, hint) {
   const store = typeof source === 'string' ? null : source;
   // A definition's closing bracket is immediately followed by its colon (parseAssets uses the same necessary condition).
   if (store ? !store.contains(']:') || !store.contains('data:image/', true)
@@ -349,13 +468,36 @@ export function mayRetireImageDefinitions(source, splices, factory) {
     if (!row.removed && !row.inserted) return false;
     const start = original(row.pos, false, index), end = original(row.pos + row.removed.length, true, index);
     if (store) {
+      // No image use exists without this marker. A definition appendix alone must
+      // not make a prose keystroke join the document to prove that.
+      if (!store.contains('![')) return false;
       const from = Math.max(0, start - 8192);
       const local = store.readSlice(from, Math.min(store.length, end + 4));
       const image = local.lastIndexOf('![', end - from);
       const separator = Math.max(local.lastIndexOf('\n\n', start - from),
         local.lastIndexOf('\r\n\r\n', start - from), local.lastIndexOf('\r\r', start - from));
       if (image >= 0) return image + from >= start || separator < image;
-      return from > 0 && separator < 0;
+      const exclude = left => {
+        if (hint && splices.length === 1) hint.excluded = {start: left, end};
+        return false;
+      };
+      if (separator >= 0 || from === 0) return exclude(separator >= 0 ? from + separator + 4 : 0);
+      // Still inside a longer paragraph. Walk back in slices to the blank line.
+      // Finding an image there is the same "possible" answer as the 8KiB window;
+      // finding the break, or none, does not read the joined document.
+      let cursor = from;
+      while (cursor > 0) {
+        const sliceFrom = Math.max(0, cursor - 8192);
+        const chunk = store.readSlice(sliceFrom, Math.min(store.length, cursor + 3));
+        const limit = cursor - sliceFrom;
+        const sep = Math.max(chunk.lastIndexOf('\n\n', limit), chunk.lastIndexOf('\r\n\r\n', limit),
+          chunk.lastIndexOf('\r\r', limit));
+        const imageAt = chunk.lastIndexOf('![', limit);
+        if (imageAt >= 0 && (sep < 0 || imageAt > sep)) return true;
+        if (sep >= 0 || sliceFrom === 0) return exclude(sep >= 0 ? sliceFrom + sep + 4 : 0);
+        cursor = sliceFrom;
+      }
+      return false;
     }
     const image = source.lastIndexOf('![', end);
     return image >= 0 && (image >= start || Math.max(source.lastIndexOf('\n\n', start),
@@ -443,10 +585,10 @@ export function serializeAsset(asset) {
 }
 // Pure: re-derived at commit against the moved document; appends only at the text's end.
 // A replay supplies the retained definition's line ending instead of choosing one from later prose.
-export function appendAssetText(source, asset, lineEnding) {
+export function appendAssetText(source, asset, lineEnding, {preserveLabel = false} = {}) {
   if (typeof source !== 'string' || !asset || normalizeLabel(asset.label) !== asset.id) return fail('image_source_invalid');
   const parsed = documentAssets(source), title = assetTitle(asset.title);
-  const existing = [...parsed.assets.values()].find(row => row.url === asset.url && row.title === title);
+  const existing = !preserveLabel && [...parsed.assets.values()].find(row => row.url === asset.url && row.title === title);
   if (existing) return {source, id: existing.id, reference: existing.label, added: false, suffix: ''};
   const previous = parsed.references[asset.id];
   const block = serializeAsset(asset);

package/dist/spec/md-layout.mjs

@@ -103,14 +103,16 @@ export const parseLayoutAttribute = value => parseLayout(decodeLayoutAttribute(v
 export function textStyle(value, {portable = false, pointSize, indentOffset = 0} = {}) {
   if (!validLayout(value)) return '';
   const property = {first: 'text-indent', indent: 'margin-inline-start'};
-  return (portable ? ['first', 'indent'] : ['first', 'indent', 'marker'])
+  const css = (portable ? ['first', 'indent'] : ['first', 'indent', 'marker'])
     .filter(key => has(value, key) || key === 'indent' && indentOffset).map(key => {
       const level = (value[key] || 0) + (key === 'indent' ? indentOffset : 0);
       const measure = decimal(Number((level * 2).toFixed(6)));
       return (portable ? property[key] : '--md-' + key) + ':' + (portable ?
         pointSize ? decimal(Math.round(level * pointSize * 40) / 20) + 'pt' : measure + 'em' :
         'calc(' + measure + ' * var(--md-text-body))');
-    }).join(';');
+    });
+  if (portable && value.hyphens === 'auto') css.push('hyphens:auto');
+  return css.join(';');
 }
 
 // Raw HTML tables carry ordinary paragraph CSS. Read the browser's parsed declarations on the same
@@ -127,6 +129,7 @@ export function textLayout(style, {listMarker = false, pointSize, offset = 0} =
     // rather than each intermediate declaration, is the measurement the writer must keep.
     if (Number.isFinite(level) && level) value[key] = level;
   }
+  if (!listMarker && style?.getPropertyValue('hyphens').trim() === 'auto') value.hyphens = 'auto';
   return value;
 }
 
@@ -149,6 +152,14 @@ export function imageStyle(value) {
 
 export const linesHeightCss = lines => lines === 1 ? '1cap' : 'calc(' + (lines - 1) + ' * var(--md-line, 1.6em) + 1cap)';
 
+// An HTML object has an outer clip box and an independent browser viewport.
+// SCALE keeps that authored viewport; REFLOW keeps measured content height.
+export function objectHeight(width, naturalHeight, attrs, line) {
+  if (attrs.height && attrs.height !== 'auto') return Math.min(4096, Number(attrs.height) * line);
+  const [w, h] = (attrs.viewport || '640x360').split('x').map(Number);
+  return attrs.resize === 'scale' ? Math.min(4096, width * h / w) : naturalHeight;
+}
+
 // Controls remain real DOM nodes while their surrounding text flows. A checkbox, link or
 // disclosure is not a reason to exclude its entire block from picture placement.
 export function wrapTextBlock(element) {