fika-editor 3.1.2 → 3.2.1

package/dist/text/index.d.ts

@@ -0,0 +1,15 @@
+/** Transform only source spans classified as prose by the CommonMark/math parser.
+ * Code (including unmatched fences), formulas, link destinations and HTML remain
+ * byte-for-byte source. No Markdown serialization or delimiter guessing is used.
+ */
+export declare function mapMarkdownProse(source: string, transform: (text: string) => string): string;
+export declare function normalizeGeneratedMarkdown(source: string): string;
+export declare function normalizeGeneratedNewlines(source: string): string;
+export interface MarkdownMathSegment {
+    type: 'text' | 'math';
+    raw: string;
+    value: string;
+    display: boolean;
+}
+/** Source-preserving math segments derived from the same syntax tree. */
+export declare function markdownMathSegments(source: string): MarkdownMathSegment[];

package/dist/text/index.js

@@ -0,0 +1,206 @@
+import { fromMarkdown } from 'mdast-util-from-markdown';
+import { mathFromMarkdown } from 'mdast-util-math';
+import { math } from 'micromark-extension-llm-math';
+import { decodeHTML } from 'entities';
+import MarkdownIt from 'markdown-it';
+import texmath from 'markdown-it-texmath';
+const parseOptions = { extensions: [math()], mdastExtensions: [mathFromMarkdown()] };
+// Preserve the existing Fika support for bare TeX environments. This parser is
+// only used for that uncommon syntax; CommonMark code fences still take priority.
+const environmentParser = new MarkdownIt({ html: false }).use(texmath, {
+    delimiters: ['beg_end'], engine: { renderToString: (value) => value },
+});
+/** micromark math follows code-span dollar rules. TeX permits escaped dollars;
+ * mask only those lexical escapes in the parser input, keeping every offset.
+ * All returned content is sliced from the original source, never this mask.
+ */
+function parserInput(source) {
+    if (!source.includes('\\$'))
+        return source;
+    // Work in UTF-16 offsets, like micromark and source.position.offset.
+    const out = source.split('');
+    for (let i = 0; i < source.length; i++) {
+        if (source[i] !== '\\')
+            continue;
+        if (source[i + 1] === '$')
+            out[i + 1] = '\uE000';
+        i++;
+    }
+    return out.join('');
+}
+const parseGeneratedMarkdown = (source) => fromMarkdown(parserInput(source), parseOptions);
+function environmentSpans(source) {
+    if (!source.includes('\\begin{'))
+        return [];
+    const lines = [0];
+    for (let i = 0; i < source.length; i++)
+        if (source[i] === '\n')
+            lines.push(i + 1);
+    const spans = [];
+    for (const token of environmentParser.parse(source, {})) {
+        if (token.type !== 'math_block' || !token.map)
+            continue;
+        const start = source.indexOf(token.content, lines[token.map[0]]);
+        if (start >= 0)
+            spans.push({ start, end: start + token.content.length, value: token.content, display: true });
+    }
+    return spans;
+}
+function walk(node, visit) {
+    if (node.type !== 'root' && visit(node) === false)
+        return;
+    if ('children' in node)
+        for (const child of node.children)
+            walk(child, visit);
+}
+/** Real EOL conversion is independent of JSON-style escape recovery. */
+function normalizeEols(source) {
+    if (!source.includes('\r'))
+        return source;
+    const out = [];
+    for (let i = 0; i < source.length; i++) {
+        if (source[i] === '\r') {
+            out.push('\n');
+            if (source[i + 1] === '\n')
+                i++;
+        }
+        else
+            out.push(source[i]);
+    }
+    return out.join('');
+}
+/** A linear escape decoder. It never decides what is code or math. */
+function decodeProseNewlines(source) {
+    if (!source.includes('\\') && !source.includes('\r'))
+        return source;
+    const out = [];
+    for (let i = 0; i < source.length;) {
+        if (source[i] === '\r') {
+            out.push('\n');
+            i += source[i + 1] === '\n' ? 2 : 1;
+            continue;
+        }
+        if (source[i] !== '\\') {
+            out.push(source[i++]);
+            continue;
+        }
+        const start = i;
+        while (source[i] === '\\')
+            i++;
+        const escape = source[i];
+        if (escape !== 'n' && escape !== 'r') {
+            out.push(source.slice(start, i));
+            continue;
+        }
+        i++;
+        if (escape === 'r' && source[i] === '\\') {
+            let next = i;
+            while (source[next] === '\\')
+                next++;
+            if (source[next] === 'n')
+                i = next + 1;
+        }
+        out.push('\n');
+    }
+    return out.join('');
+}
+const opaqueNodes = new Set(['code', 'inlineCode', 'math', 'inlineMath', 'html']);
+/** Transform only source spans classified as prose by the CommonMark/math parser.
+ * Code (including unmatched fences), formulas, link destinations and HTML remain
+ * byte-for-byte source. No Markdown serialization or delimiter guessing is used.
+ */
+export function mapMarkdownProse(source, transform) {
+    if (!source)
+        return source;
+    const env = environmentSpans(source);
+    const spans = env.map(span => ({ ...span, prose: false }));
+    walk(parseGeneratedMarkdown(source), node => {
+        const start = node.position?.start.offset;
+        const end = node.position?.end.offset;
+        if (start === undefined || end === undefined)
+            return;
+        if (opaqueNodes.has(node.type)) {
+            spans.push({ start, end, prose: false });
+            return false;
+        }
+        if (node.type === 'text') {
+            // An environment may sit inside a CommonMark text node. Split at the
+            // library's source boundaries, preserving text around it as prose.
+            let cursor = start;
+            for (const block of env) {
+                if (block.end <= cursor || block.start >= end)
+                    continue;
+                if (cursor < block.start)
+                    spans.push({ start: cursor, end: block.start, prose: true });
+                cursor = Math.min(end, block.end);
+            }
+            if (cursor < end)
+                spans.push({ start: cursor, end, prose: true });
+        }
+    });
+    spans.sort((a, b) => a.start - b.start || b.end - a.end);
+    const out = [];
+    let cursor = 0;
+    for (const span of spans) {
+        if (span.start < cursor)
+            continue;
+        out.push(normalizeEols(source.slice(cursor, span.start)));
+        const raw = source.slice(span.start, span.end);
+        out.push(span.prose ? transform(raw) : raw);
+        cursor = span.end;
+    }
+    out.push(normalizeEols(source.slice(cursor)));
+    return out.join('');
+}
+export function normalizeGeneratedMarkdown(source) {
+    if (!source || (!source.includes('\\') && !source.includes('\r') && !source.includes('&')))
+        return source;
+    return mapMarkdownProse(source, text => decodeProseNewlines(decodeHTML(text)));
+}
+export function normalizeGeneratedNewlines(source) {
+    if (!source || (!source.includes('\\') && !source.includes('\r')))
+        return source;
+    return mapMarkdownProse(source, decodeProseNewlines);
+}
+/** Source-preserving math segments derived from the same syntax tree. */
+export function markdownMathSegments(source) {
+    const spans = environmentSpans(source);
+    walk(parseGeneratedMarkdown(source), node => {
+        if (node.type !== 'math' && node.type !== 'inlineMath')
+            return;
+        const start = node.position?.start.offset;
+        const end = node.position?.end.offset;
+        if (start !== undefined && end !== undefined) {
+            const raw = source.slice(start, end);
+            const display = node.type === 'math' || raw.startsWith('$$') || raw.startsWith('\\[');
+            if (!display && (raw.includes('\n') || raw.includes('\r')))
+                return false;
+            // Inline token values fold whitespace; TeX needs its original source.
+            let delimiter = raw.startsWith('\\') ? 2 : 0;
+            if (!delimiter)
+                while (raw[delimiter] === '$')
+                    delimiter++;
+            const value = raw.slice(delimiter, -delimiter);
+            spans.push({ start, end, value, display });
+        }
+        return false;
+    });
+    spans.sort((a, b) => a.start - b.start);
+    const out = [];
+    let cursor = 0;
+    for (const span of spans) {
+        if (span.start < cursor)
+            continue;
+        if (span.start > cursor) {
+            const raw = source.slice(cursor, span.start);
+            out.push({ type: 'text', raw, value: raw, display: false });
+        }
+        out.push({ type: 'math', raw: source.slice(span.start, span.end), value: span.value, display: span.display });
+        cursor = span.end;
+    }
+    if (cursor < source.length) {
+        const raw = source.slice(cursor);
+        out.push({ type: 'text', raw, value: raw, display: false });
+    }
+    return out;
+}

package/dist/types/configs/exportWatermark.d.ts

@@ -8,9 +8,19 @@
  * — the engine never silently drops a mark the host asked for.
  */
 export type FikaExportWatermarkPosition = 'bottom-right' | 'bottom-left' | 'top-right' | 'top-left';
+export type FikaWatermarkSurface = 'light' | 'dark';
 export interface FikaExportWatermark {
-    /** PNG or JPEG as a `data:` URL or a URL the browser can fetch. */
+    /**
+     * Mark for light slide fills (dark artwork). PNG or JPEG as a `data:` URL
+     * or a URL the browser can fetch.
+     */
     image: string;
+    /**
+     * Mark for dark / photo slides (light artwork). When omitted every slide
+     * uses `image`. Polarities come from the same `preferredInk` query as editor
+     * chrome and text contrast.
+     */
+    imageOnDark?: string;
     /** Corner of the slide. @default 'bottom-right' */
     position?: FikaExportWatermarkPosition;
     /** Mark width as a fraction of the slide width (0–1]. @default 0.12 */

package/dist/types/embed/index.d.ts

@@ -3,7 +3,7 @@ export type { FikaController, FikaDocument, FikaHeaderMenuItem, FikaMountOptions
 export type { FikaDeckAtlasOptions, FikaDeckAtlasSheet, FikaDeckAtlasTile, FikaRenderSlideOptions, } from './render';
 export type { ExportTabId, FikaExportTabsConfig } from '../configs/exportTabs';
 export type { FikaExportMediaResolver } from '../configs/exportMediaResolver';
-export type { FikaExportWatermark, FikaExportWatermarkPosition, FikaExportWatermarkResolver, } from '../configs/exportWatermark';
+export type { FikaExportWatermark, FikaExportWatermarkPosition, FikaExportWatermarkResolver, FikaWatermarkSurface, } from '../configs/exportWatermark';
 export { createFikaMediaUploader, } from '../configs/mediaUpload';
 export type { FikaMediaConfig, FikaMediaConstraints, FikaMediaKind, FikaMediaSizeLimit, FikaMediaUploadProgress, FikaMediaUploadRequest, FikaMediaUploadResult, FikaMediaUploader, FikaXhrMediaUploaderOptions, } from '../configs/mediaUpload';
 export type * from './agentic/types';

package/dist/types/embed/types.d.ts

@@ -1,13 +1,13 @@
 import type { FikaExportTabsConfig } from '../configs/exportTabs';
 import type { FikaExportMediaResolver } from '../configs/exportMediaResolver';
-import type { FikaExportWatermark, FikaExportWatermarkPosition, FikaExportWatermarkResolver } from '../configs/exportWatermark';
+import type { FikaExportWatermark, FikaExportWatermarkPosition, FikaExportWatermarkResolver, FikaWatermarkSurface } from '../configs/exportWatermark';
 import type { FikaMediaConfig } from '../configs/mediaUpload';
 import type { Locales } from '../i18n/locale';
 import type { Slide, SlideTheme, SlideTemplate } from '../types/slides';
 import type { FikaAgentApi, FikaDeckViewport, FikaSlideReference } from './agentic/types';
 import type { FikaRevealOptions } from './reveal';
 export type { FikaExportMediaResolver };
-export type { FikaExportWatermark, FikaExportWatermarkPosition, FikaExportWatermarkResolver };
+export type { FikaExportWatermark, FikaExportWatermarkPosition, FikaExportWatermarkResolver, FikaWatermarkSurface };
 export type { FikaRevealOptions };
 export type { FikaMediaConfig, FikaMediaConstraints, FikaMediaKind, FikaMediaSizeLimit, FikaMediaUploadProgress, FikaMediaUploadRequest, FikaMediaUploadResult, FikaMediaUploader, FikaXhrMediaUploaderOptions } from '../configs/mediaUpload';
 export interface FikaTemplatePayload {

package/dist/types/text/index.d.ts

@@ -0,0 +1,15 @@
+/** Transform only source spans classified as prose by the CommonMark/math parser.
+ * Code (including unmatched fences), formulas, link destinations and HTML remain
+ * byte-for-byte source. No Markdown serialization or delimiter guessing is used.
+ */
+export declare function mapMarkdownProse(source: string, transform: (text: string) => string): string;
+export declare function normalizeGeneratedMarkdown(source: string): string;
+export declare function normalizeGeneratedNewlines(source: string): string;
+export interface MarkdownMathSegment {
+    type: 'text' | 'math';
+    raw: string;
+    value: string;
+    display: boolean;
+}
+/** Source-preserving math segments derived from the same syntax tree. */
+export declare function markdownMathSegments(source: string): MarkdownMathSegment[];

package/dist/types/utils/agentText.d.ts

@@ -1,3 +1,4 @@
+import { normalizeGeneratedNewlines } from '../text/index';
 /**
  * Tiny helpers for agent-authored plain text before it becomes slide HTML.
  *
@@ -5,21 +6,13 @@
  *  - literal escape sequences (`\n`, `\r\n`, `\r`) instead of real newlines
  *  - HTML entities (`&`, ` `, `„`, …) instead of characters
  *
- * These helpers are intentionally dumb — no math parsing here. Callers that mix
- * TeX must run newline unescaping only on non-math text via `normalizeAgentText`
- * in `markdown.ts` (which uses the real `tokenizeMath` scanner).
- */
-/**
- * Decode HTML entities in a plain-text / markdown string.
- * Prefer a DOM textarea when available; fall back to a pure regex path for Node tests.
+ * Newline recovery uses the shared CommonMark/math parser to preserve literal
+ * code and TeX. Markdown rendering and editable run styling live in markdown.ts.
  */
+/** Decode complete HTML entities, including invalid numeric references safely. */
 export declare function decodeHtmlEntities(text: string): string;
-/**
- * Turn literal `\r\n` / `\n` / `\r` escape sequences into real newlines.
- * Inline code spans are left untouched so `` `$\\nu$` `` stays intact; this is
- * not a math parser — TeX protection belongs to {@link tokenizeMath}.
- */
-export declare function unescapeAgentNewlines(text: string): string;
+/** Shared parser-backed recovery; code and math source are never decoded. */
+export declare const unescapeAgentNewlines: typeof normalizeGeneratedNewlines;
 /**
  * Convert real newlines (`\r\n` / `\r` / `\n`) to `<br/>` for HTML `content` paths.
  * Literal escape sequences are unescaped first. Entity decoding runs only when the

package/dist/types/utils/markdown.d.ts

@@ -1,3 +1,4 @@
+import { markdownMathSegments, normalizeGeneratedMarkdown } from '../text/index';
 /** True when a string carries math delimiters the math parser should handle. */
 export declare function containsMath(source: string): boolean;
 /** Delimited math or any TeX control sequence in the source. */
@@ -16,17 +17,9 @@ export interface ContentSegment {
     /** Math only: display (block) vs inline. */
     display: boolean;
 }
-/**
- * Split `source` into ordered text and math segments. This is the robust core
- * behind both line-splitting and inline rendering: it scans once, picking the
- * earliest opener at each position (longest on ties, so `$$` beats `$`), honors
- * backslash escapes (`\$`, `\\`), skips inline code spans (so `` `$x` `` is not
- * read as math) and keeps unterminated openers as literal text (graceful for
- * partial/streamed content). Inline math may not span newlines; display math
- * (`$$`, `\[`, `\begin{}`) may.
- */
-export declare function tokenizeMath(source: string): ContentSegment[];
-export declare function normalizeAgentText(text: string): string;
+/** Parser-backed code/math boundaries shared with the server compiler. */
+export declare const tokenizeMath: typeof markdownMathSegments;
+export declare const normalizeAgentText: typeof normalizeGeneratedMarkdown;
 export declare function splitLinesPreservingMath(value: string): string[];
 export declare function markdownToHtml(markdown: string): Promise<string>;
 /**

package/dist/types/utils/pptxExportWatermark.d.ts

@@ -1,4 +1,4 @@
-import type { FikaExportWatermark } from '../configs/exportWatermark';
+import type { FikaExportWatermark, FikaWatermarkSurface } from '../configs/exportWatermark';
 export declare const EXPORT_WATERMARK_MARKER = "fika:export-watermark";
 export interface WatermarkImage {
     bytes: Uint8Array;
@@ -6,17 +6,32 @@ export interface WatermarkImage {
     width: number;
     height: number;
 }
+export interface ApplyPptxExportWatermarkImages {
+    onLight: WatermarkImage;
+    onDark?: WatermarkImage;
+    /** Per-slide polarity from `preferredInk`. Gaps are inferred from the slide XML. */
+    slideSurfaces?: Array<FikaWatermarkSurface | undefined>;
+    masterSurface?: FikaWatermarkSurface;
+}
 /** Reads dimensions from the PNG/JPEG header — no decoder or DOM needed. */
 export declare function readWatermarkImage(bytes: Uint8Array): WatermarkImage;
 /** Resolves `image` (data: URL or fetchable URL) to raw bytes plus dimensions. */
 export declare function loadWatermarkImage(image: string): Promise<WatermarkImage>;
+/**
+ * Same cliff as `perceivedDark` in textContrast: AERT brightness 140 or WCAG
+ * luminance 0.25. Dark surface → light mark.
+ */
+export declare function watermarkSurfaceFromRgb(r: number, g: number, b: number): FikaWatermarkSurface;
+export declare function watermarkSurfaceFromHex(hex: string): FikaWatermarkSurface;
+/** Photo fills use the invert mark; solids/gradients follow the sampled color. */
+export declare function inferWatermarkSurfaceFromSlideXml(xml: string): FikaWatermarkSurface;
 /** True when the package already carries the export watermark on any slide. */
 export declare function hasPptxExportWatermark(bytes: ArrayBuffer | Uint8Array): Promise<boolean>;
 /**
  * Returns a new package with the watermark on every slide and slide master.
  * Throws when the input is not a presentation package.
  */
-export declare function applyPptxExportWatermark(bytes: ArrayBuffer | Uint8Array, watermark: FikaExportWatermark, image: WatermarkImage): Promise<Uint8Array>;
+export declare function applyPptxExportWatermark(bytes: ArrayBuffer | Uint8Array, watermark: FikaExportWatermark, images: WatermarkImage | ApplyPptxExportWatermarkImages): Promise<Uint8Array>;
 /**
  * Browser download through a real `HTMLAnchorElement.click()` — the same seam
  * pptxgenjs uses, which embedding hosts rely on to capture export bytes.

package/dist/types/utils/prosemirror/schema/index.d.ts

@@ -2,6 +2,7 @@ export declare const schemaNodes: {
     doc: import("prosemirror-model").NodeSpec;
     paragraph: import("prosemirror-model").NodeSpec;
     blockquote: import("prosemirror-model").NodeSpec;
+    hard_break: import("prosemirror-model").NodeSpec;
     text: import("prosemirror-model").NodeSpec;
     math: import("prosemirror-model").NodeSpec;
     ordered_list: import("prosemirror-model").NodeSpec;

package/dist/types/utils/prosemirror/schema/nodes.d.ts

@@ -3,6 +3,7 @@ declare const _default: {
     doc: NodeSpec;
     paragraph: NodeSpec;
     blockquote: NodeSpec;
+    hard_break: NodeSpec;
     text: NodeSpec;
     math: NodeSpec;
     ordered_list: NodeSpec;

package/docs/EMBED.md

@@ -292,7 +292,8 @@ await mountFika(host, {
   exportWatermark: () =>
     isFreeTier()
       ? {
-          image: `${location.origin}/images/logo.png`, // PNG or JPEG; data: URLs work too
+          image: `${location.origin}/images/logo.png`,      // light slides (dark artwork)
+          imageOnDark: `${location.origin}/images/logo-on-dark.png`, // optional; dark / photo slides
           position: 'bottom-right',                    // default
           widthRatio: 0.12,                            // fraction of slide width, default
           marginRatio: 0.02,                           // fraction of slide width, default
@@ -304,7 +305,7 @@ await mountFika(host, {
 
 The mark is written into the OOXML after generation, so it is identical for regenerated decks and retained source packages:
 
-- one shared media part, referenced from **every slide and every slide master**;
+- one media part per polarity (`image` on light fills, `imageOnDark` on dark / photo fills). The engine picks the variant with the same `preferredInk` query as editor chrome; image backgrounds follow the invert mark;
 - the slide copy sits last in the shape tree (visible over full-bleed content) and is fully locked — `noSelect` keeps PowerPoint from selecting it by click, marquee, Ctrl+A or the selection pane, so there is no in-app way to delete it;
 - the master copy is `userDrawn` and locked too; it survives slide-level deletions in editors that ignore locks and only goes away through the slide master view (or by hiding background graphics on a slide);
 - parts already carrying the mark are skipped, so a re-imported export does not stack marks.
@@ -453,3 +454,28 @@ Persist `document.viewport` from `onChange` / `getDocument()` and pass it back o
 - `postMessage` optional bridge for cross-origin CDN hosting
 - Persist `FikaDocument` in `linked_materials` + `presentation` kind in workspace tabs
 - Split chunk / lazy `import('fika-editor/embed')` on first open of presentation tab
+
+### Generated Markdown outside the editor
+
+`fika-editor/text` is a small ESM entry without React or DOM dependencies. It
+uses CommonMark and math syntax trees with source positions, so servers and
+browsers can recover escaped line breaks without changing code, formulas,
+link destinations, or HTML source.
+
+```ts
+import { normalizeGeneratedMarkdown, normalizeGeneratedNewlines } from 'fika-editor/text'
+
+normalizeGeneratedMarkdown(String.raw`**Title**\r\nSecond line`)
+// "**Title**\nSecond line" (a real newline)
+
+// Preserve entities if only newline recovery is wanted:
+normalizeGeneratedNewlines(String.raw`# Heading\n- **Point**`)
+```
+
+`controller.markdownToHtml()` and Markdown layout slots use this normalization
+before rendering formatted runs. `getDocument()` returns the complete target
+slide during `revealSlide()`, so a host can safely snapshot it during animation.
+The ProseMirror schema preserves hard line breaks and Markdown strikethrough
+through storage, static rendering, and editing.
+Pass `assetBaseUrl` to `mountFika()` to resolve lazy editor CSS under the same
+asset directory as the embed stylesheet.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fika-editor",
-  "version": "3.1.2",
+  "version": "3.2.1",
   "description": "Fika presentation editor embed bundle with a typed agentic bridge.",
   "type": "module",
   "main": "dist/embed/fika-embed.js",
@@ -11,7 +11,8 @@
     "dist/types",
     "docs/EMBED.md",
     "docs/AGENTIC_BRIDGE.md",
-    "docs/RELEASE.md"
+    "docs/RELEASE.md",
+    "dist/text"
   ],
   "exports": {
     ".": {
@@ -29,7 +30,12 @@
       "default": "./dist/embed/fika-embed.css"
     },
     "./agentic-manifest.json": "./dist/embed/agentic-manifest.json",
-    "./package.json": "./package.json"
+    "./package.json": "./package.json",
+    "./text": {
+      "types": "./dist/text/index.d.ts",
+      "import": "./dist/text/index.js",
+      "default": "./dist/text/index.js"
+    }
   },
   "engines": {
     "node": ">=24 <25"
@@ -49,7 +55,7 @@
     "dx:start": "1dxway start",
     "doctor": "react-doctor --no-telemetry",
     "build": "run-p type-check \"build-only {@}\" --",
-    "build:embed": "node scripts/run-i18n.mjs --no-watch && npm run build:types && rsbuild build --config rsbuild.config.embed.ts && node scripts/rewrite-embed-base-uri.mjs && node scripts/merge-embed-css.mjs && node scripts/scope-embed-css.mjs && node scripts/extract-embed-fonts.mjs && node scripts/copy-embed-public.mjs && node scripts/generate-agentic-manifest.mjs",
+    "build:embed": "node scripts/run-i18n.mjs --no-watch && npm run build:text && npm run build:types && rsbuild build --config rsbuild.config.embed.ts && node scripts/rewrite-embed-base-uri.mjs && node scripts/merge-embed-css.mjs && node scripts/scope-embed-css.mjs && node scripts/extract-embed-fonts.mjs && node scripts/copy-embed-public.mjs && node scripts/generate-agentic-manifest.mjs",
     "agentic:manifest": "node scripts/generate-agentic-manifest.mjs",
     "build:types": "node -e \"require('node:fs').rmSync('dist/types',{recursive:true,force:true})\" && tsc -p tsconfig.types.json && node scripts/rewrite-embed-types.mjs",
     "prepack": "node scripts/verify-embed-pack.mjs",
@@ -62,7 +68,8 @@
     "lint:fix": "oxlint --fix",
     "test": "node scripts/test.mjs",
     "i18n": "node scripts/run-i18n.mjs",
-    "i18n:build": "node scripts/run-i18n.mjs --no-watch"
+    "i18n:build": "node scripts/run-i18n.mjs --no-watch",
+    "build:text": "tsc -p tsconfig.text.json"
   },
   "author": "Matěj \"lofcz\" Štágl",
   "license": "MIT",
@@ -111,7 +118,10 @@
     "markdown-it-texmath": "^1.0.0",
     "mathlive": "npm:@lofcz/mathlive@^0.110.10",
     "mathml2omml-plus": "^0.6.4",
+    "mdast-util-from-markdown": "^2.0.3",
+    "mdast-util-math": "^3.0.0",
     "mermaid": "^11.17.0",
+    "micromark-extension-llm-math": "^3.1.1-20250610",
     "mitt": "^3.0.1",
     "nanoid": "^6.0.1",
     "number-precision": "^1.6.0",

package/dist/embed/chunks/5992.js

@@ -1 +0,0 @@
-export const __rspack_esm_id=5992;export const __rspack_esm_ids=[5992];export const __webpack_modules__={88651(e,n,t){function a(e){return e.replace(/&/g,"&amp;").replace(/</g,"&lt;").replace(/>/g,"&gt;").replace(/"/g,"&quot;").replace(/'/g,"&#039;")}function r(e,n){let o=r.mergeDelimiters(n&&n.delimiters),l=n&&n.outerSpace||!1,s=n&&n.katexOptions||{};for(let a of(s.throwOnError=s.throwOnError||!1,s.macros=s.macros||n&&n.macros,r.katex||(n&&"object"==typeof n.engine?r.katex=n.engine:r.katex=t(37826)),o.inline))l&&"outerSpace"in a&&(a.outerSpace=!0),e.inline.ruler.before("escape",a.name,r.inline(a)),e.renderer.rules[a.name]=(e,n)=>a.tmpl.replace(/\$1/,r.render(e[n].content,!!a.displayMode,s));for(let n of o.block)e.block.ruler.before("fence",n.name,r.block(n)),e.renderer.rules[n.name]=(e,t)=>n.tmpl.replace(/\$2/,a(e[t].info)).replace(/\$1/,r.render(e[t].content,!0,s))}r.mergeDelimiters=function(e){let n=Array.isArray(e)?e:"string"==typeof e?[e]:["dollars"],t={inline:[],block:[]};for(let e of n)e in r.rules&&(t.inline.push(...r.rules[e].inline),t.block.push(...r.rules[e].block));return t},r.inline=e=>function(n,t){let a=n.pos,r=n.src,o=r.startsWith(e.tag,e.rex.lastIndex=a)&&(!e.pre||e.pre(r,e.outerSpace,a))&&e.rex.exec(r),l=!!o&&a<e.rex.lastIndex&&(!e.post||e.post(r,e.outerSpace,e.rex.lastIndex-1));if(l){if(!t){let t=n.push(e.name,"math",0);t.content=o[1],t.markup=e.tag}n.pos=e.rex.lastIndex}return l},r.block=e=>function(n,t,a,r){let o=n.bMarks[t]+n.tShift[t],l=n.src,s=l.startsWith(e.tag,e.rex.lastIndex=o)&&(!e.pre||e.pre(l,!1,o))&&e.rex.exec(l),i=!!s&&o<e.rex.lastIndex&&(!e.post||e.post(l,!1,e.rex.lastIndex-1));if(i&&!r){let r,o=e.rex.lastIndex-1;for(r=t;r<a&&(!(o>=n.bMarks[r]+n.tShift[r])||!(o<=n.eMarks[r]));r++);let l=n.lineMax,i=n.parentType;n.lineMax=r,n.parentType="math","blockquote"===i&&(s[1]=s[1].replace(/(\n*?^(?:\s*>)+)/gm,""));let m=n.push(e.name,"math",0);m.block=!0,m.tag=e.tag,m.markup="",m.content=s[1],m.info=s[s.length-1],m.map=[t,r+1],n.parentType=i,n.lineMax=l,n.line=r+1}return i},r.render=function(e,n,t){let o;t.displayMode=n;try{o=r.katex.renderToString(e,t)}catch(n){o=a(`${e}:${n.message}`)}return o},r.use=function(e){return r.katex=e,r},r.inlineRuleNames=["math_inline","math_inline_double"],r.blockRuleNames=["math_block","math_block_eqno"],r.$_pre=(e,n,t)=>{let a=t>0&&e[t-1].charCodeAt(0);return n?!a||32===a:!a||92!==a&&(a<48||a>57)},r.$_post=(e,n,t)=>{let a=e[t+1]&&e[t+1].charCodeAt(0);return n?!a||32===a||46===a||44===a||59===a:!a||a<48||a>57},r.rules={brackets:{inline:[{name:"math_inline",rex:/\\\((.+?)\\\)/gy,tmpl:"<eq>$1</eq>",tag:"\\("}],block:[{name:"math_block_eqno",rex:/\\\[(((?!\\\]|\\\[)[\s\S])+?)\\\]\s*?\(([^)$\r\n]+?)\)/gmy,tmpl:'<section class="eqno"><eqn>$1</eqn><span>($2)</span></section>',tag:"\\["},{name:"math_block",rex:/\\\[([\s\S]+?)\\\]/gmy,tmpl:"<section><eqn>$1</eqn></section>",tag:"\\["}]},doxygen:{inline:[{name:"math_inline",rex:/\\f\$(.+?)\\f\$/gy,tmpl:"<eq>$1</eq>",tag:"\\f$"}],block:[{name:"math_block_eqno",rex:/\\f\[([^]+?)\\f\]\s*?\(([^)\s]+?)\)/gmy,tmpl:'<section class="eqno"><eqn>$1</eqn><span>($2)</span></section>',tag:"\\f["},{name:"math_block",rex:/\\f\[([^]+?)\\f\]/gmy,tmpl:"<section><eqn>$1</eqn></section>",tag:"\\f["}]},gitlab:{inline:[{name:"math_inline",rex:/\$`(.+?)`\$/gy,tmpl:"<eq>$1</eq>",tag:"$`"}],block:[{name:"math_block_eqno",rex:/`{3}math\s*([^`]+?)\s*?`{3}\s*\(([^)\r\n]+?)\)/gm,tmpl:'<section class="eqno"><eqn>$1</eqn><span>($2)</span></section>',tag:"```math"},{name:"math_block",rex:/`{3}math\s*([^`]*?)\s*`{3}/gm,tmpl:"<section><eqn>$1</eqn></section>",tag:"```math"}]},julia:{inline:[{name:"math_inline",rex:/`{2}([^`]+?)`{2}/gy,tmpl:"<eq>$1</eq>",tag:"``"},{name:"math_inline",rex:/\$((?:\S?)|(?:\S.*?\S))\$/gy,tmpl:"<eq>$1</eq>",tag:"$",spaceEnclosed:!1,pre:r.$_pre,post:r.$_post}],block:[{name:"math_block_eqno",rex:/`{3}math\s+?([^`]+?)\s+?`{3}\s*?\(([^)$\r\n]+?)\)/gmy,tmpl:'<section class="eqno"><eqn>$1</eqn><span>($2)</span></section>',tag:"```math"},{name:"math_block",rex:/`{3}math\s+?([^`]+?)\s+?`{3}/gmy,tmpl:"<section><eqn>$1</eqn></section>",tag:"```math"}]},kramdown:{inline:[{name:"math_inline",rex:/\${2}(.+?)\${2}/gy,tmpl:"<eq>$1</eq>",tag:"$$"}],block:[{name:"math_block_eqno",rex:/\${2}([^$]+?)\${2}\s*?\(([^)\s]+?)\)/gmy,tmpl:'<section class="eqno"><eqn>$1</eqn><span>($2)</span></section>',tag:"$$"},{name:"math_block",rex:/\${2}([^$]+?)\${2}/gmy,tmpl:"<section><eqn>$1</eqn></section>",tag:"$$"}]},beg_end:{inline:[],block:[{name:"math_block",rex:/(\\(?:begin)\{([a-z]+)\}[\s\S]+?\\(?:end)\{\2\})/gmy,tmpl:"<section><eqn>$1</eqn></section>",tag:"\\"}]},dollars:{inline:[{name:"math_inline_double",rex:/\${2}([^$]*?[^\\])\${2}/gy,tmpl:"<section><eqn>$1</eqn></section>",tag:"$$",displayMode:!0,pre:r.$_pre,post:r.$_post},{name:"math_inline",rex:/\$((?:[^\s\\])|(?:\S.*?[^\s\\]))\$/gy,tmpl:"<eq>$1</eq>",tag:"$",outerSpace:!1,pre:r.$_pre,post:r.$_post}],block:[{name:"math_block_eqno",rex:/\${2}([^$]*?[^\\])\${2}\s*?\(([^)\s]+?)\)/gmy,tmpl:'<section class="eqno"><eqn>$1</eqn><span>($2)</span></section>',tag:"$$"},{name:"math_block",rex:/\${2}([^$]*?[^\\])\${2}/gmy,tmpl:"<section><eqn>$1</eqn></section>",tag:"$$"}]}},e.exports&&(e.exports=r)},37826(e,n,t){function a(){return""}t.r(n),n.default={renderToString:a},t.d(n,{renderToString:()=>a})}};

package/dist/embed/chunks/8735.js

@@ -1 +0,0 @@
-export const __rspack_esm_id=8735;export const __rspack_esm_ids=[8735];export const __webpack_modules__={37826(_,e,r){function t(){return""}r.r(e),e.default={renderToString:t},r.d(e,{renderToString:()=>t})}};