rapier-math 1.0.1 → 1.1.0

package/integration.d.ts

@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: MIT
+import type {RenderOptions} from './index.js';
+export interface IntegrationOptions {
+  renderOptions?: RenderOptions;
+  /** Per document. Default 1024. Exhaustion leaves subsequent math as source. */
+  maxFormulas?: number;
+  /** Combined successful SVG code units per document. Default 16 * 1024 * 1024. */
+  maxOutputLength?: number;
+}

package/integration.mjs

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: MIT
+import {render} from './index.mjs';
+
+export const escapeText = text => text.replace(/[&<>"'\r]/g, char =>
+  ({'&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;', '\r': '&#13;'}[char]));
+
+// One budget per document render. Rejection leaves the host's text node intact.
+export function createFormulaRenderer(options = {}) {
+  const maxFormulas = options.maxFormulas ?? 1024, maxOutputLength = options.maxOutputLength ?? 16 * 1024 * 1024;
+  for (const value of [maxFormulas, maxOutputLength])
+    if (!Number.isSafeInteger(value) || value < 0) throw new RangeError('Math integration budgets must be finite nonnegative integers.');
+  let count = 0, length = 0;
+  return (source, displayMode) => {
+    let result;
+    if (count >= maxFormulas || length >= maxOutputLength) return {errors: [{code: 'resource-limit', offset: 0,
+      message: 'The document math budget is exhausted.'}]};
+    count++;
+    try { result = render(source, {...options.renderOptions, displayMode}); }
+    catch (error) { return {errors: [{code: error.code || 'invalid-tex', message: String(error.message), offset: error.offset || 0}]}; }
+    if (result.errors.length) return {errors: result.errors};
+    if (result.svg.length > maxOutputLength - length) {
+      length = maxOutputLength;
+      return {errors: [{code: 'resource-limit', offset: 0, message: 'The document math output budget is exhausted.'}]};
+    }
+    length += result.svg.length;
+    return result;
+  };
+}

package/markdown-it.d.ts

@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: MIT
+import type MarkdownIt from 'markdown-it';
+import type {DelimiterOptions} from './delimiters.js';
+import type {IntegrationOptions} from './integration.js';
+export interface MarkdownMathOptions extends DelimiterOptions, IntegrationOptions {}
+export default function rapierMath(md: InstanceType<typeof MarkdownIt>, options?: MarkdownMathOptions): void;

package/markdown-it.mjs

@@ -0,0 +1,45 @@
+// SPDX-License-Identifier: MIT
+import {installMathRules} from './markdown-rules.mjs';
+import {createFormulaRenderer, escapeText} from './integration.mjs';
+
+export default function rapierMath(md, options = {}) {
+  installMathRules(md, options);
+  let session;
+  function withSession(renderer, render, tokens, opts, env) {
+    const previous = session, current = {render: createFormulaRenderer(options), children: new WeakSet()};
+    const visit = tokens => {
+      for (const token of tokens) {
+        if (token.children) { current.children.add(token.children); visit(token.children); }
+      }
+    };
+    visit(tokens);
+    session = current;
+    try { return render.call(renderer, tokens, opts, env); }
+    finally { session = previous; }
+  }
+  const render = md.renderer.render, renderInline = md.renderer.renderInline;
+  md.renderer.render = function(tokens, opts, env) {
+    return withSession(this, render, tokens, opts, env);
+  };
+  md.renderer.renderInline = function(tokens, opts, env) {
+    // The block renderer's inline children share its document budget. A separate
+    // inline tree, including a nested host renderInline call, owns a fresh one.
+    if (session?.children.has(tokens)) return renderInline.call(this, tokens, opts, env);
+    return withSession(this, renderInline, tokens, opts, env);
+  };
+  function formula(tokens, index, _options, env) {
+    const token = tokens[index], display = token.type === 'math_block';
+    const result = (session?.render || createFormulaRenderer(options))(token.content, display);
+    if (result.errors.length) {
+      (env.rapierMathErrors ||= []).push({source: token.content, errors: result.errors});
+      return '<code data-math-error="' + escapeText(result.errors[0].code) + '">' +
+        escapeText(token.meta?.mathSource ?? token.content) + '</code>';
+    }
+    return result.svg;
+  }
+  md.renderer.rules.math_inline = formula;
+  md.renderer.rules.math_block = (tokens, index, opts, env) => {
+    const result = formula(tokens, index, opts, env);
+    return tokens[index].block ? '<div class="math-display">' + result + '</div>\n' : result;
+  };
+}

package/markdown-rules.mjs

@@ -0,0 +1,65 @@
+// SPDX-License-Identifier: MIT
+// Original neutral adapter. The host owns Markdown structure and normalization.
+import {createMathMatcher} from './delimiters.mjs';
+
+export function installMathRules(md, {singleDollar = false, brackets = true, ruleName = 'rapier_math', inLink = false} = {}) {
+  // The host's image-alt renderer ignores unknown token types. Keep math as
+  // literal source in text-only output, while leaving escaping to that host.
+  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) => {
+    // An indented code block belongs to the host even when it begins with dollars.
+    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/math-components.json

@@ -2,10 +2,10 @@
   "spdxVersion": "SPDX-2.3",
   "dataLicense": "CC0-1.0",
   "SPDXID": "SPDXRef-DOCUMENT",
-  "name": "rapier-math-1.0.1",
-  "documentNamespace": "https://rapier.website/spdx/rapier-math-1.0.1-77640802b52935b60a66e2fd04c19d4702cee4b1a8b64aece5ca332236c09283",
+  "name": "rapier-math-1.1.0",
+  "documentNamespace": "https://rapier.website/spdx/rapier-math-1.1.0-22e5e40abbd1087922335893ad546fb7ffaeaa710338c97e5686e7b7b0b62021",
   "creationInfo": {
-    "created": "2026-10-12T08:38:30.378Z",
+    "created": "2026-10-12T15:47:04.000Z",
     "creators": [
       "Tool: rapier-math-components",
       "Organization: rapier.website"
@@ -15,8 +15,8 @@
     {
       "name": "rapier-math",
       "SPDXID": "SPDXRef-rapier-math",
-      "versionInfo": "1.0.1",
-      "downloadLocation": "https://cdn.jsdelivr.net/gh/jackskip22/rapier-plugins@main/math/rapier-math-1.0.1.js",
+      "versionInfo": "1.1.0",
+      "downloadLocation": "NOASSERTION",
       "filesAnalyzed": false,
       "licenseConcluded": "MIT AND LicenseRef-GUST-Font-License",
       "licenseDeclared": "MIT AND LicenseRef-GUST-Font-License",
@@ -24,7 +24,7 @@
       "checksums": [
         {
           "algorithm": "SHA256",
-          "checksumValue": "77640802b52935b60a66e2fd04c19d4702cee4b1a8b64aece5ca332236c09283"
+          "checksumValue": "22e5e40abbd1087922335893ad546fb7ffaeaa710338c97e5686e7b7b0b62021"
         }
       ]
     },

package/package.json

@@ -1,17 +1,67 @@
 {
   "name": "rapier-math",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "Self-contained TeX-to-SVG math renderer with Latin Modern outlines.",
   "type": "module",
   "main": "./index.mjs",
+  "types": "./index.d.ts",
+  "sideEffects": [
+    "./rapier-math-1.1.0.js"
+  ],
   "exports": {
-    ".": "./index.mjs",
-    "./rapier-math-1.0.1.js": "./rapier-math-1.0.1.js",
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./index.mjs"
+    },
+    "./delimiters": {
+      "types": "./delimiters.d.ts",
+      "default": "./delimiters.mjs"
+    },
+    "./markdown-it": {
+      "types": "./markdown-it.d.ts",
+      "default": "./markdown-it.mjs"
+    },
+    "./rehype": {
+      "types": "./rehype.d.ts",
+      "default": "./rehype.mjs"
+    },
+    "./stream": {
+      "types": "./stream.d.ts",
+      "default": "./stream.mjs"
+    },
+    "./rapier-math-1.1.0.js": {
+      "types": "./classic.d.ts",
+      "default": "./rapier-math-1.1.0.js"
+    },
     "./package.json": "./package.json"
   },
+  "peerDependencies": {
+    "markdown-it": "^14.1.0 || ^15.0.0",
+    "@types/markdown-it": "^14.1.0",
+    "hast-util-from-html": "^2.0.0",
+    "@types/hast": "^3.0.0",
+    "vfile": "^6.0.0"
+  },
+  "peerDependenciesMeta": {
+    "markdown-it": {
+      "optional": true
+    },
+    "@types/markdown-it": {
+      "optional": true
+    },
+    "hast-util-from-html": {
+      "optional": true
+    },
+    "@types/hast": {
+      "optional": true
+    },
+    "vfile": {
+      "optional": true
+    }
+  },
   "files": [
     "index.mjs",
-    "rapier-math-1.0.1.js",
+    "rapier-math-1.1.0.js",
     "LICENSE",
     "LICENSE-MIT",
     "math-LICENSE.txt",
@@ -20,10 +70,33 @@
     "README.md",
     "verify.mjs",
     "check.mjs",
+    "adoption-check.mjs",
     "src/math",
     "src/tools/build-math.mjs",
     "src/shell/math-resources.json",
-    "src/package.json"
+    "src/package.json",
+    "delimiters.mjs",
+    "markdown-rules.mjs",
+    "integration.mjs",
+    "markdown-it.mjs",
+    "rehype.mjs",
+    "stream.mjs",
+    "index.d.ts",
+    "classic.d.ts",
+    "delimiters.d.ts",
+    "integration.d.ts",
+    "markdown-it.d.ts",
+    "rehype.d.ts",
+    "stream.d.ts",
+    "examples/formula.mjs",
+    "examples/markdown.mjs",
+    "examples/stream.mjs",
+    "examples/unified.mjs",
+    "examples/browser.html",
+    "examples/browser.mjs",
+    "examples/react.tsx",
+    "examples/worker.mjs",
+    "examples/README.md"
   ],
   "license": "SEE LICENSE IN LICENSE",
   "author": "Jack Skipworth",