fika-editor 3.2.0 → 3.2.2

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/embed/index.d.ts

@@ -1,3 +1,4 @@
+export { renderSlideImage, renderDeckAtlas } from "./render";
 export { mountFika, unmountFika } from './mount';
 export type { FikaController, FikaDocument, FikaHeaderMenuItem, FikaMountOptions, FikaMountResult, FikaDocumentLoader, FikaStarterPresentationOptions, FikaTemplateLoader, FikaTemplatePayload, FikaImportPptxOptions, FikaImportApplyMode, FikaViewMode, } from './types';
 export type { FikaDeckAtlasOptions, FikaDeckAtlasSheet, FikaDeckAtlasTile, FikaRenderSlideOptions, } from './render';

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/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

@@ -454,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.2.0",
+  "version": "3.2.2",
   "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})}};