rapier-markdown-kit 1.2.45 → 1.2.46

package/dist/kit/render.mjs

@@ -49,8 +49,7 @@ async function _rapierBuildArtifact(options, providedContext) {
 	const opts = options || {};
 	const context = providedContext || _rapierBuildInterchangeContext(opts);
 	const preference = _rapierArtifactPreference('theme', ['system', 'light', 'dark']);
-	const theme = opts.print ? 'light' : preference === 'system'
-		? (globalThis.matchMedia?.('(prefers-color-scheme: dark)').matches ? 'dark' : 'light') : preference;
+	const theme = opts.print ? 'light' : preference;
 	const metadata = context.metadata;
 	const base = context.baseName;
 	const work = context.work || opts.work;
@@ -113,8 +112,8 @@ async function _rapierBuildArtifact(options, providedContext) {
 	const styledRoot = work ? await _rapierProjectStyledRootAsync(context.semanticRoot, styledOptions)
 		: _rapierProjectStyledRoot(context.semanticRoot, styledOptions);
 	styledRoot.setAttribute('lang', language);
-	const darkPaper = theme === 'dark' && _rapierArtifactPreference('invertImageAlpha', ['true', 'false']) !== 'false';
-	const templatePage = _rapierTemplatePage(context.canonical, settings, styledRoot, darkPaper);
+	const paperTheme = _rapierArtifactPreference('invertImageAlpha', ['true', 'false']) !== 'false' ? theme : 'light';
+	const templatePage = _rapierTemplatePage(context.canonical, settings, styledRoot, paperTheme);
 	if (completePage && typeof _rapierFinalizeExportCode === 'function') await _rapierFinalizeExportCode(styledRoot);
 	if (!opts.print) _rapierAnnotateExportBoxPolygons(styledRoot);
 	if (completePage || opts.print) {
@@ -204,7 +203,7 @@ async function _rapierBuildArtifact(options, providedContext) {
 	};
 }
 
-function _rapierTemplatePage(canonical, settings, root, darkPaper = false) {
+function _rapierTemplatePage(canonical, settings, root, paperTheme = 'light') {
 	if (!isTemplatePage(canonical)) return null;
 	const paper = pageSizeOf(settings);
 	let url = '';
@@ -219,9 +218,11 @@ function _rapierTemplatePage(canonical, settings, root, darkPaper = false) {
 	const margins = ['top', 'right', 'bottom', 'left'].map(side => (settings?.geometry?.[side] ?? 1440) / 15);
 	const padding = margins.map(value => value + 'px').join(' ');
 	const ground = 'background:var(--rapier-template-border) 0 0/100% 100% no-repeat';
-	const shown = darkPaper && globalThis.RapierImageAssets.dataImage(url)?.codec === 'image/svg+xml' ? _rapierDarkPaperSvgUrl(url, '#fafafa') : url;
+	const shown = paperTheme !== 'light' && globalThis.RapierImageAssets.dataImage(url)?.codec === 'image/svg+xml' ? _rapierDarkPaperSvgUrl(url, '#fafafa') : url;
+	const screenInk = shown !== url ? '@media screen' + (paperTheme === 'system' ? ' and (prefers-color-scheme:dark)' : '')
+		+ '{:root{--rapier-template-border:url("' + shown + '")}}\n' : '';
 	const css = ':root{--rapier-template-border:url("' + url + '")}\n'
-		+ '@media screen{' + (shown !== url ? ':root{--rapier-template-border:url("' + shown + '")}' : '') + '.rapier-template-border{display:none}body{background:var(--md-color-inset)}.rapier-page{box-sizing:border-box;width:min(100%,' + width + 'px);min-height:' + height + 'px;margin:0 auto;padding:' + padding
+		+ screenInk + '@media screen{.rapier-template-border{display:none}body{background:var(--md-color-inset)}.rapier-page{box-sizing:border-box;width:min(100%,' + width + 'px);min-height:' + height + 'px;margin:0 auto;padding:' + padding
 		+ ';background:var(--rapier-template-border) 0 0/100% ' + height + 'px repeat-y,var(--md-color-bg);color:var(--md-color-text)}}\n'
 		+ '@media screen and (max-width:' + width + 'px){.rapier-page{min-height:auto;aspect-ratio:' + width + '/' + height + ';padding:'
 		+ margins.map(value => 'min(' + value + 'px,' + Number((value / width * 100).toFixed(4)) + '%)').join(' ') + ';background-size:100% auto,auto}}\n'

package/dist/kit/typography.d.mts

@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: MIT
+import type {RichTextItem, PreparationOptions, Rect, SlotsForBand, SlotSequence, FlowPlan,
+  FlowFragment, FlowSlot} from './model.mjs';
+
+export interface TypographyApplyResult {
+  changed: number;
+  released: number;
+  pending: boolean;
+  prepared: number;
+}
+export interface InitialRange {start: number; end: number; text: string}
+export interface TypographySlotInput {
+  width: number;
+  top: number;
+  obstacles: readonly Rect[];
+  lineHeight: number;
+  minWidth: number;
+  slotsForBand: SlotsForBand;
+  slotSequence: SlotSequence;
+  columnsFilled(slots: readonly FlowSlot[], placed: readonly FlowSlot[]): boolean;
+  justify: boolean;
+  hyphenate: boolean;
+}
+export interface DerivedFlowFragment extends FlowFragment {
+  derive: true;
+  glyph?: string;
+}
+export interface TypographyController {
+  /** Pending work requires a subsequent call after the host yields. */
+  apply(root: Element | Document | DocumentFragment, options?: {all?: boolean; editing?: boolean}): TypographyApplyResult;
+  clear(root: Element | Document | DocumentFragment, options?: {forget?: boolean; keepSelection?: boolean}): void;
+  clearSelection(root: Element | Document | DocumentFragment): number;
+  firstLineEnd(paragraph: Element | null | undefined): number | null;
+  initialRange(input: string | Pick<Node, 'textContent'> | null | undefined): InitialRange | null;
+  protectInitial(root: Element | Document | DocumentFragment): void;
+  invalidateFonts(document?: Document | null): number;
+  retire(root: Element | Document | DocumentFragment, options?: {documentChanged?: boolean}): void;
+  slotPlan(paragraph: Element, items: readonly RichTextItem[],
+    options: Pick<PreparationOptions, 'language' | 'wordBreak'>, input: TypographySlotInput): FlowPlan<DerivedFlowFragment> | null;
+}
+/** Creates an independent disposable DOM projection owner; it never changes Markdown source. */
+export function createTypography(): TypographyController;

package/dist/kit/will.d.mts

@@ -2,7 +2,7 @@
 // Will/1: permissions a Markdown document gives agents, as HTML comments on their own lines.
 //   <!-- will/1 keep -->  ...  <!-- /will -->     keep: no change; append: add after the region's text only; edit: any change
 export type WillLaw = 'keep' | 'append' | 'edit';
-export type WillFault = 'malformed_marker' | 'unpaired_marker';
+export type WillFault = 'malformed_marker' | 'unpaired_marker' | 'unknown_version' | 'unknown_law' | 'intent_over_bound';
 /** A paired region; `start` to `end` is its text between the marker lines (UTF-16 offsets). */
 export interface WillRegion {
   index: number; law: WillLaw; intent: string | null;
@@ -40,6 +40,29 @@ export function willMarkerOf(line: string): WillMarker | null;
 export function terminatorWidth(last: number, prior: number): number;
 /** The text without one trailing line terminator. */
 export function stripOneTerminator(text: string): string;
+/** A sequential source edit in UTF-16 coordinates; removed must match the current source. */
+export interface WillSplice {pos: number; removed: string; inserted: string;}
+export interface WillRestoreOptions {
+  /** Exact splice objects the host has proved undo its own earlier act; text equality is not authority. */
+  restores?: readonly WillSplice[] | null;
+}
+export interface WillTransitionOptions extends WillRestoreOptions {
+  /** Optional output map populated with admitted contiguous append-tail inverse rows. */
+  restored?: Map<number, WillSplice[]> | null;
+}
+export type WillTransitionRefusal =
+  | {law: 'keep'; rule: 'before_faulted' | 'result_faulted'; faults: {mode: WillFault; line: number}[]; start: number; end: number}
+  | {law: WillLaw; rule: 'marker_span_touched'; editIndex: number; region: number; start: number; end: number}
+  | {law: 'keep'; rule: 'marker_sequence_mismatch'; start: number; end: number}
+  | {law: 'keep' | 'append'; rule: 'law_violated'; region: number; start: number; end: number};
+/** Maps a resulting UTF-16 offset back through sequential rows; -1 means it lies in inserted text. */
+export function willOffsetBefore(rows: readonly WillSplice[], offset: number): number;
+/** Checks marker identity and body laws after the host has proved the sequential splices. Null admits the transition. */
+export function willTransition(beforeText: string, afterText: string, splices: readonly WillSplice[],
+  markerSplices?: readonly WillSplice[], options?: WillTransitionOptions): WillTransitionRefusal | null;
+export type WillEvaluation =
+  | {outcome: 'applied'}
+  | {outcome: 'invalid'; reason: 'precondition'; rule: 'invalid_unicode' | 'malformed_splice' | 'out_of_range_splice' | 'source_mismatch'}
+  | ({outcome: 'refused'; reason: 'document_law'} & WillTransitionRefusal);
 /** Judges sequential UTF-16 source splices, including the resulting marker identities and protected text. */
-export function evaluateWill(beforeText: string, splices: {pos: number; removed: string; inserted: string}[]):
-  {outcome: 'applied'} | {outcome: 'invalid' | 'refused'; reason: string; rule: string; law?: WillLaw; region?: number};
+export function evaluateWill(beforeText: string, splices: readonly WillSplice[], options?: WillRestoreOptions): WillEvaluation;

package/dist/math/delimiters.mjs

@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: MIT
+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 === '$') {
+      let end = at + 1;
+      while (source[end] === '$') end++;
+      const count = end - at;
+      if (!(slashes & 1) && (count === 2 || count === 1 && singleDollar))
+        markers.set(at, {at, marker: count === 2 ? '$$' : '$', line});
+      at = end;
+    } else {
+      if (brackets && slashes & 1 && '()[]'.includes(char))
+        markers.set(at - 1, {at: at - 1, marker: '\\' + char, line});
+      at++;
+    }
+    slashes = 0;
+  }
+  for (const entry of [...markers.values()].reverse()) {
+    const closing = entry.marker === '\\(' ? '\\)' : entry.marker === '\\[' ? '\\]' : entry.marker;
+    entry.close = next[closing];
+    next[entry.marker] = entry;
+  }
+  return function match(start, limit = source.length) {
+    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;
+    if (open.marker === '$' && (open.line !== close.line || bodyStart === bodyEnd ||
+        /\s/.test(source[bodyStart]) || /\s/.test(source[bodyEnd - 1]) || /[0-9]/.test(source[bodyEnd + 1] || ''))) return null;
+    return {start, end: bodyEnd + close.marker.length, bodyStart, bodyEnd,
+      open: open.marker, close: close.marker, displayMode: open.marker === '$$' || open.marker === '\\['};
+  };
+}

package/dist/math/markdown-rules.mjs

@@ -0,0 +1,103 @@
+// SPDX-License-Identifier: MIT
+import {createMathMatcher} from './delimiters.mjs';
+
+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 => {
+    authored.set(state.tokens, {source: state.src});
+  });
+  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;
+    try { return tokenize.call(this, state, startLine, endLine); }
+    finally {
+      for (let index = first; index < state.tokens.length; 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;
+        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);
+        else {
+          if (!state.rapierSourceSlice) {
+            const starts = text => [0, ...Array.from(text.matchAll(/\r\n?|\n/g), match => match.index + match[0].length)];
+            held.rawLines ||= starts(source);
+            held.lines ||= starts(state.src);
+          }
+          const view = Object.create(state), parts = [];
+          view.bMarks = []; view.eMarks = [];
+          for (let line = token.map[0]; line < token.map[1]; line++) {
+            const shift = state.rapierSourceSlice ? 0 : held.rawLines[line] - held.lines[line];
+            view.src = state.rapierSourceSlice
+              ? state.rapierSourceSlice(state.bMarks[line], state.eMarks[line])
+              : source.slice(state.bMarks[line] + shift, state.eMarks[line] + shift);
+            view.bMarks[line] = 0; view.eMarks[line] = view.src.length;
+            parts.push(view.getLines(line, line + 1, state.blkIndent, false));
+            if (line + 1 < token.map[1]) parts.push(state.rapierSourceSlice
+              ? state.rapierSourceSlice(state.eMarks[line], state.eMarks[line] + 1)
+              : source.slice(state.eMarks[line] + shift, held.rawLines[line + 1]));
+          }
+          value = parts.join('');
+        }
+        token.meta = {...token.meta, mathSource: value};
+      }
+    }
+  };
+  const renderText = md.renderer.renderInlineAsText;
+  md.renderer.renderInlineAsText = function(tokens, options, env) {
+    return renderText.call(this, tokens.map(token =>
+      token.type === 'math_inline' || token.type === 'math_block'
+        ? {...token, type: 'text', content: token.meta?.mathSource ?? token.content}
+        : token), options, env);
+  };
+  const matchers = new WeakMap();
+  function match(state, at, limit) {
+    let entry = matchers.get(state);
+    if (!entry || entry.source !== state.src) {
+      entry = {source: state.src, match: createMathMatcher(state.src, {singleDollar, brackets})};
+      matchers.set(state, entry);
+    }
+    return entry.match(at, limit);
+  }
+  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 span = match(state, state.pos, state.posMax);
+    if (!span) return false;
+    if (!silent) {
+      const token = state.push(span.displayMode ? 'math_block' : 'math_inline', '', 0);
+      token.markup = span.open;
+      token.content = state.src.slice(span.bodyStart, span.bodyEnd);
+      token.meta = {mathSource: state.src.slice(span.start, span.end)};
+    }
+    state.pos = span.end;
+    return true;
+  });
+  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 span = match(state, start, state.eMarks[endLine - 1]);
+    if (!span?.displayMode) return false;
+    let last = startLine;
+    while (last < endLine && state.eMarks[last] < span.end) last++;
+    if (last >= endLine || span.bodyEnd < state.bMarks[last] + state.tShift[last] ||
+        state.src.slice(span.end, state.eMarks[last]).trim()) return false;
+    if (silent) return true;
+    const parts = [];
+    for (let line = startLine; line <= last; line++) {
+      const from = line === startLine ? span.bodyStart : state.bMarks[line] + state.tShift[line];
+      const to = line === last ? span.bodyEnd : state.eMarks[line];
+      parts.push(state.src.slice(from, to));
+    }
+    const token = state.push('math_block', 'math', 0);
+    token.block = true;
+    token.markup = span.open;
+    token.content = parts.join('\n');
+    token.meta = {mathSource: span.open + token.content + span.close};
+    token.map = [startLine, last + 1];
+    state.line = last + 1;
+    return true;
+  }, {alt: ['paragraph', 'reference', 'blockquote', 'list']});
+}

package/dist/spec/document-fonts.mjs

@@ -2,20 +2,12 @@
 import {markdownParser, installMarkdownImages, normalizeLabel} from './md-assets.mjs';
 import {splitOpeningFrontmatter} from './frontmatter.mjs';
 import {readDocumentSettings, documentFont} from './document-settings.mjs';
-import {normalizeFontFamily, fontFamilyCss, FONT_STACKS, typography} from './md-marks.mjs';
+import {normalizeFontFamily, fontFamilyCss, FONT_STACKS, typography, fontDataUrl} from './md-marks.mjs';
+export {fontDataUrl};
 
 export const CSS_GENERIC_FONT_FAMILIES = Object.freeze(['serif', 'sans-serif', 'monospace', 'cursive', 'fantasy', 'system-ui',
   'ui-serif', 'ui-sans-serif', 'ui-monospace', 'ui-rounded', 'emoji', 'math', 'fangsong', 'initial', 'revert', 'revert-layer']);
 
-export function fontDataUrl(url) {
-	if (typeof url !== 'string') return null;
-	const match = /^data:font\/(woff2|woff|ttf|otf);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;
-	return byteLength >= 12 ? {format: match[1].toLowerCase(), byteLength, data: match[2]} : null;
-}
-
 function parserFor(parser) {
 	const md = installMarkdownImages(markdownParser(parser));
 	if (!md.__rapierFontsInstalled) {

package/dist/spec/md-assets.mjs

@@ -9,6 +9,7 @@ const cached = [];
 let preparedDefinitions = [];
 let configured = null, splitSource = null;
 export function configureParser(parser, split) { configured = parser; splitSource = split; cached.length = 0; preparedDefinitions = []; }
+export const configuredMarkdownParser = () => configured;
 function fail(reason) { throw new Error(reason); }
 export const normalizeLabel = label => String(label).trim().replace(/\s+/g, ' ').toLowerCase().toUpperCase();
 export const assetTitle = value => String(value || '').replace(/[\r\n]/g, ' ').replace(/\0/g, '\ufffd');