rapier-html 1.2.30 → 1.2.32

package/dist/ledger/md-source.mjs

@@ -0,0 +1,153 @@
+// SPDX-License-Identifier: MIT
+import {splitOpeningFrontmatter} from './frontmatter.mjs';
+
+export function markdownSourcePositions(source, parser) {
+  if (typeof source !== 'string' || !parser) throw new TypeError('Source positions require text and its Markdown parser');
+  const {body, bodyOffset} = splitOpeningFrontmatter(source), lines = [bodyOffset];
+  for (const row of body.matchAll(/\r\n?|\n/g)) lines.push(bodyOffset + row.index + row[0].length);
+  const lineAt = line => lines[line] ?? source.length;
+  const literal = [], comments = new Map(), observed = new WeakMap(), typography = [], openedStyles = new Map();
+  const add = (start, end) => { if (end > start) literal.push({start, end}); };
+  if (bodyOffset) add(0, bodyOffset);
+  const owner = Object.create(parser), inline = Object.create(parser.inline), ruler = Object.create(parser.inline.ruler);
+  owner.inline = inline; inline.ruler = ruler;
+  ruler.getRules = chain => parser.inline.ruler.getRules(chain).map(rule => (state, silent) => {
+    const start = state.pos, first = state.tokens.length;
+    const matched = rule(state, silent), token = state.tokens.at(-1);
+    if (matched && !silent && state.tokens.length > first && !observed.has(token) &&
+        ['code_inline', 'html_inline', 'image', 'footnote_ref'].includes(token?.type)) {
+      observed.set(token, {start, end: state.pos, source: state.src,
+        comment: token.type === 'html_inline' && token.content.startsWith('<!--'),
+        footnote: token.type === 'footnote_ref' && state.src.startsWith('^[', start)
+          ? state.env.footnotes?.list?.[token.meta.id] : null});
+    }
+    return matched;
+  });
+  const read = new WeakMap();
+  inline.parse = function (text, md, env, children) { read.set(children, text); return parser.inline.parse.call(this, text, md, env, children); };
+  const {tokens, cells} = markdownTableSources(body, owner, {}, lines);
+  const readInline = (children, content, rawOffset) => {
+    for (const child of children || []) {
+      const span = observed.get(child);
+      if (!span || span.source !== content) continue;
+      if (span.footnote?.tokens) {
+        readInline(span.footnote.tokens, span.footnote.content, pos => rawOffset(span.start + 2 + pos));
+      } else if (child.type !== 'footnote_ref') {
+        const start = rawOffset(span.start), end = rawOffset(span.end);
+        const style = child.meta?.typography;
+        if (style && child.nesting === 1) openedStyles.set(style, {start, innerStart: end, style: style.style});
+        else if (style && child.nesting === -1 && openedStyles.has(style)) {
+          typography.push({...openedStyles.get(style), innerEnd: start, end});
+          openedStyles.delete(style);
+        }
+        if (span.comment) comments.set(start, end);
+        else add(start, end);
+      }
+    }
+  };
+  for (const token of tokens) {
+    if (token.map && ['fence', 'code_block', 'html_block', 'reference_definition'].includes(token.type)) {
+      const start = lineAt(token.map[0]), end = lineAt(token.map[1]);
+      add(start, end);
+      if (token.type === 'html_block' && /^\s*<!--/.test(token.content)) {
+        let at = source.indexOf('<!--', start);
+        while (at >= start && at < end) {
+          const close = source.indexOf('-->', at + 4);
+          const stop = close >= 0 && close + 3 <= end ? close + 3 : end;
+          comments.set(at, stop);
+          at = source.indexOf('<!--', stop);
+        }
+      }
+      continue;
+    }
+    const content = read.get(token.children) ?? token.content;
+    if (token.type !== 'inline' || !content) continue;
+    let rawOffset;
+    if (token.map) {
+      const offsets = [], starts = [], spaces = [], rows = content.split('\n');
+      let local = 0;
+      for (let i = 0; i < rows.length; i++) {
+        const start = lineAt(token.map[0] + i), end = lineAt(token.map[0] + i + 1), line = source.slice(start, end).replace(/\0/g, '\ufffd');
+        let at = line.indexOf(rows[i]), lead = 0;
+        if (at < 0) { const rest = rows[i].replace(/^ +/, ''); lead = rows[i].length - rest.length; at = line.indexOf(rest); if (!lead || line[at - 1] !== '\t') at = -1; }
+        if (at < 0) throw new Error('Markdown inline source mapping failed');
+        starts.push(local); spaces.push(lead); offsets.push(start + at - lead); local += rows[i].length + 1;
+      }
+      rawOffset = pos => {
+        let row = starts.length - 1;
+        while (row > 0 && starts[row] > pos) row--;
+        return offsets[row] + Math.max(pos - starts[row], spaces[row] - 1);
+      };
+    } else if (cells.has(token)) {
+      rawOffset = cells.get(token);
+    } else continue;
+    readInline(token.children, content, rawOffset);
+  }
+  literal.sort((a, b) => a.start - b.start || b.end - a.end);
+  const merged = [];
+  for (const range of literal) {
+    const last = merged.at(-1);
+    if (last && range.start <= last.end) last.end = Math.max(last.end, range.end);
+    else merged.push({...range});
+  }
+  const isText = position => {
+    if (comments.has(position)) return false;
+    let low = 0, high = merged.length;
+    while (low < high) { const mid = (low + high) >> 1; if (merged[mid].end <= position) low = mid + 1; else high = mid; }
+    return low < merged.length && merged[low].start <= position;
+  };
+  return {isText, isComment: (start, end) => comments.get(start) === end, typography: typography.sort((a, b) => a.start - b.start)};
+}
+
+export function markdownTableSources(source, parser, environment, lineStarts = null, parse = null) {
+  const cells = new WeakMap();
+  const read = owner => {
+    if (parse) return parse(owner, source, environment).then(tokens => ({tokens, cells}));
+    return {tokens: owner.parse(source, environment), cells};
+  };
+  if (!source.includes('|')) return read(parser);
+  const lines = lineStarts || [0];
+  if (!lineStarts) for (const row of source.matchAll(/\r\n?|\n/g)) lines.push(row.index + row[0].length);
+  const owner = Object.create(parser), block = Object.create(parser.block), ruler = Object.create(parser.block.ruler);
+  owner.block = block; block.ruler = ruler;
+  ruler.getRules = chain => parser.block.ruler.getRules(chain).map(rule => (state, start, end, silent) => {
+    const first = state.tokens.length, matched = rule(state, start, end, silent);
+    if (matched && !silent && state.tokens[first]?.type === 'table_open') {
+      let cell;
+      for (let at = first; at < state.tokens.length; at++) {
+        const token = state.tokens[at];
+        if (token.type === 'tr_open') {
+          const row = token.map[0], from = state.bMarks[row] + state.tShift[row];
+          const line = state.src.lastIndexOf('\n', from - 1) + 1;
+          cell = tableSource(state.src.slice(from, state.eMarks[row]), lines[row + (state.rapierFirstLine || 0)] + from - line);
+        } else if (token.type === 'inline' && cell) cells.set(token, cell(token.content));
+        else if (token.type === 'tr_close') cell = null;
+      }
+    }
+    return matched;
+  });
+  return read(owner);
+}
+
+function tableSource(row, base) {
+  const trim = row.trimStart();
+  base += row.length - trim.length; row = trim.trimEnd();
+  const offsets = [], stops = [];
+  let text = '', cursor = 0;
+  for (let at = 0; at < row.length; at++) {
+    if (row[at] === '\\' && row[at + 1] === '|') at++;
+    else if (row[at] === '|') stops.push(text.length);
+    offsets.push(base + at); text += row[at];
+  }
+  offsets.push(base + row.length);
+  let next = stops[0] === 0 ? 1 : 0;
+  if (next) cursor = 1;
+  if (stops.at(-1) !== text.length - 1) stops.push(text.length);
+  return content => {
+    const stop = stops[next++] ?? text.length, raw = text.slice(cursor, stop);
+    const start = Math.min(text.length, cursor + raw.length - raw.trimStart().length);
+    if (raw.trim() !== content) throw new Error('Markdown table source mapping failed');
+    cursor = stop + 1;
+    return pos => offsets[start + pos];
+  };
+}

package/dist/ledger/template-page.mjs

@@ -1,6 +1,4 @@
 // SPDX-License-Identifier: MIT
-export function isTemplatePage(source) {
-  const match = /^(?:)?---[ \t]*\r?\n([\s\S]*?)\r?\n---[ \t]*(?:\r?\n|$)/.exec(String(source).slice(0, 65536));
-  return !!match && /^template:[ \t]*page[ \t]*(?:#.*)?$/m.test(match[1]);
-}
+import {readDocumentSettings} from './document-settings.mjs';
+export const isTemplatePage = source => readDocumentSettings(source).template === 'page';
 export const isPageBorderLayout = layout => layout?.wrap === 'behind' && layout.lock === 'on';