rapier-math 1.0.2 → 1.1.0

package/examples/markdown.mjs

@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: MIT
+import MarkdownIt from 'markdown-it';
+import rapierMath from 'rapier-math/markdown-it';
+
+export const md = new MarkdownIt({html: false}).use(rapierMath);
+const source = 'It costs $5 and $10. Code: `$$x$$`. Math: \\(x^2\\).\n\n$$\\frac{1}{2}$$\n';
+const env = {};
+console.log(md.render(source, env));
+console.error(env.rapierMathErrors || []);

package/examples/react.tsx

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: MIT
+import {useEffect, useMemo, useRef} from 'react';
+import {render, observe} from 'rapier-math';
+
+export function Equation({source, displayMode = false}: {source: string; displayMode?: boolean}) {
+  const ref = useRef<HTMLSpanElement>(null);
+  const result = useMemo(() => {
+    try { return render(source, {displayMode}); }
+    catch { return null; }
+  }, [source, displayMode]);
+  const svg = result && result.errors.length === 0 ? result.svg : null;
+  useEffect(() => {
+    if (ref.current && svg) return observe(ref.current);
+  }, [svg]); // Cleanup runs before replacement setup and on unmount.
+  if (!svg) return <code>{source}</code>;
+  // The server and initial client render use identical source/options. Fit only
+  // after hydration; never pass authored HTML to dangerouslySetInnerHTML.
+  return <span ref={ref} dangerouslySetInnerHTML={{__html: svg}} />;
+}

package/examples/stream.mjs

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: MIT
+import MarkdownIt from 'markdown-it';
+import rapierMath from 'rapier-math/markdown-it';
+import {createMarkdownStream} from 'rapier-math/stream';
+
+const md = new MarkdownIt({html: false}).use(rapierMath);
+const stream = createMarkdownStream(source => md.render(source, {}), {previewEvery: 16});
+for (const chunk of ['The answer is \\(', '\\frac{1}', '{2}', '\\)', '. Code: `$$x$$`.']) {
+  const preview = stream.write(chunk);
+  if (preview) console.log({phase: 'preview', ...preview});
+}
+const final = stream.finish();
+console.log({phase: 'complete', ...final});
+if (final.html !== md.render(final.source, {})) throw new Error('Batch mismatch');
+
+// One stream per message. On replacement: cancel its transport, reset, write.
+stream.reset();
+stream.write('Replacement \\(y\\).');
+console.log(stream.finish());

package/examples/unified.mjs

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: MIT
+import {unified} from 'unified';
+import remarkParse from 'remark-parse';
+import remarkMath from 'remark-math';
+import remarkRehype from 'remark-rehype';
+import rehypeSanitize, {defaultSchema} from 'rehype-sanitize';
+import rehypeRapierMath from 'rapier-math/rehype';
+import rehypeStringify from 'rehype-stringify';
+import {pathToFileURL} from 'node:url';
+
+export const processor = unified().use(remarkParse)
+  .use(remarkMath, {singleDollarTextMath: false}).use(remarkRehype)
+  .use(rehypeSanitize, {
+    ...defaultSchema,
+    attributes: {...defaultSchema.attributes, code: [
+      ...(defaultSchema.attributes.code || []).filter(rule => !(Array.isArray(rule) && rule[0] === 'className')),
+      ['className', 'language-math', 'math-inline', 'math-display'],
+    ]},
+  })
+  .use(rehypeRapierMath).use(rehypeStringify);
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  const file = await processor.process('Price $5. Code `$$x$$`. Math $$x^2$$.\n\n$$\n\\frac{1}{2}\n$$');
+  console.log(String(file));
+  console.error(file.messages);
+}

package/examples/worker.mjs

@@ -0,0 +1,7 @@
+// SPDX-License-Identifier: MIT
+import {render} from '../index.mjs';
+self.onmessage = ({data: {id, source}}) => {
+  try { self.postMessage({id, source, result: render(source)}); }
+  catch (error) { self.postMessage({id, source, error: {code: error.code, message: error.message}}); }
+};
+// Keep a request id per message; install a reply only if it is still current.

package/index.d.ts

@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: MIT
+export interface MathError {
+  code: string;
+  message: string;
+  /** Zero-based UTF-16 offset in the formula. */
+  offset: number;
+  command?: string;
+  messageTruncated?: boolean;
+  commandTruncated?: boolean;
+  /** True only when refused oversized source is not embedded in diagnostic SVG. */
+  sourceOmitted?: boolean;
+}
+export interface RenderOptions {
+  displayMode?: boolean;
+  maxWidth?: number;
+  screen?: {fontSize: number; pixelRatio: number; dark: boolean};
+}
+export interface RenderResult {
+  svg: string;
+  width: number;
+  height: number;
+  depth: number;
+  lines: number;
+  fitted: boolean;
+  errors: MathError[];
+}
+/** Parser nodes are inspectable; the internal node vocabulary can grow. */
+export interface MathNode {type: string; [field: string]: unknown}
+/** Browser nodes (including Element, Document and DocumentFragment) satisfy this
+ * structural type without requiring the DOM type library in server projects. */
+export interface MathContainer {readonly nodeType: number}
+export const version: string;
+/** Oversized source returns a bounded resource-limit diagnostic with sourceOmitted. */
+export function render(source: unknown, options?: RenderOptions): RenderResult;
+export function renderToString(source: unknown, options?: RenderOptions): string;
+export function parse(source: string): MathNode;
+export function fit(container: MathContainer): number;
+export function observe(container: MathContainer): () => void;
+declare const RapierMath: Readonly<{
+  version: typeof version; render: typeof render; renderToString: typeof renderToString;
+  parse: typeof parse; fit: typeof fit; observe: typeof observe;
+}>;
+export default RapierMath;

package/index.mjs

@@ -2309,7 +2309,7 @@ function mathLayout(n,c) {
     case 'smash': {const b=mathLayout(n.body,c);return {...b,h:n.mode==='b'?b.h:0,d:n.mode==='t'?b.d:0};}
     case 'raise': {const b=mathLayout(n.body,c),s=mathScale(c);return mathCompose([[b,0,-n.amount*s]],b.w,{class:b.class,...(n.height===undefined?{}:{h:n.height*s}),...(n.depth===undefined?{}:{d:n.depth*s})});}
     case 'rule': {const s=mathScale(c);return mathRule(n.width*s,(n.height+n.depth)*s,-n.height*s);}
-    case 'link': {const b=mathLayout(n.body,c);const url=new URL(n.href);if(!['http:','https:'].includes(url.protocol))throw Object.assign(new Error('Unsupported equation link'),{code:'unsafe-url'});b.svg='<a href="'+mathEscape(n.href)+'" target="_blank" rel="noopener noreferrer">'+b.svg+'</a>';return b;}
+    case 'link': {const b=mathLayout(n.body,c);const url=new URL(n.href);if(!['http:','https:'].includes(url.protocol))throw Object.assign(new Error('Unsupported equation link'),{code:'unsafe-url'});b.svg='<a href="'+mathEscape(n.href)+'" aria-label="'+mathEscape(n.href)+'" tabindex="0" target="_blank" rel="noopener noreferrer">'+b.svg+'</a>';return b;}
     default: throw Object.assign(new Error('Unsupported maths construct: '+n.type),{code:'unsupported-construct'});
   }
 }
@@ -2768,12 +2768,18 @@ function mathFitElement(svg, printing = false) {
   if(screenKey!==state.screen || (target===null)!==(state.width===null) || target!==null && Math.abs(target-state.width)>.005) {
     const rendered=renderMath(source,{displayMode:display,maxWidth:(screenKey!==state.screen?width:target) || undefined,screen});
     if(!rendered.errors.length) {
+      const active=doc.activeElement,links=active && svg.contains(active)?[...svg.querySelectorAll('a')]:[];
+      const focusIndex=links.indexOf(active),focusHref=focusIndex<0?null:active.getAttribute('href');
       const replacement=new view.DOMParser().parseFromString(rendered.svg,'image/svg+xml').documentElement;
-      for(const name of ['width','height','viewBox','data-math-natural-width','data-math-max-width','data-math-lines','data-math-screen']) {
+      for(const name of ['role','width','height','viewBox','data-math-natural-width','data-math-max-width','data-math-lines','data-math-screen']) {
         if(replacement.hasAttribute(name))svg.setAttribute(name,replacement.getAttribute(name));else svg.removeAttribute(name);
       }
       svg.style.verticalAlign=replacement.style.verticalAlign;
       svg.replaceChildren(...Array.from(replacement.childNodes,node=>doc.importNode(node,true)));
+      if(focusIndex>=0 && (!doc.activeElement || doc.activeElement===doc.body)) {
+        const link=svg.querySelectorAll('a')[focusIndex];
+        if(link?.getAttribute('href')===focusHref)link.focus({preventScroll:true});
+      }
       state.natural=Number(svg.getAttribute('data-math-natural-width'));state.screen=screenKey;
       state.width=state.natural>width?width:null;
       if(state.width===null)svg.removeAttribute('data-math-max-width');
@@ -2869,23 +2875,27 @@ function mathSvg(box,source,error,utf16,options={}) {
   const opacity=options.screen?.dark ? .94 : 1;
   if (![width,height,depth,left,...viewBox].every(Number.isFinite)) throw new Error('Mathematical dimensions are not finite');
   const escapedSource=mathEscape(source);
-  const svg='<svg xmlns="http://www.w3.org/2000/svg" role="img" aria-label="'+escapedSource+'"'+
+  // A group exposes authored links to accessibility APIs; an image would hide them.
+  const svg='<svg xmlns="http://www.w3.org/2000/svg" role="'+(box.svg.includes('<a ')?'group':'img')+'" aria-label="'+escapedSource+'"'+
     ' data-rapier-math="'+(options.displayMode?'display':'inline')+'" data-math-lines="'+(box.lines || 1)+'"'+
     ' data-math-natural-width="'+mathNumber(options.naturalWidth ?? width)+'"'+
     (options.screen?' data-math-screen="'+mathNumber(options.screen.fontSize)+'|'+mathNumber(options.screen.pixelRatio)+'|'+options.screen.dark+'"':'')+
     (options.maxWidth?' data-math-max-width="'+mathNumber(options.maxWidth)+'"':'')+
     (utf16?' data-tex-utf16="'+utf16+'"':'')+
+    (error?.sourceOmitted?' data-math-source-omitted="true"':'')+
     (error?' data-math-error="'+mathEscape(error.code)+'"':'')+' width="'+mathNumber(width)+'em" height="'+mathNumber(height+depth)+'em"'+
     ' viewBox="'+viewBox.map(mathNumber).join(' ')+'"'+
     ' style="font-size:'+mathNumber(mathFontRatio)+'em;max-width:100%;height:auto;vertical-align:-'+mathNumber(depth)+'em;'+
     'fill-opacity:'+opacity+';stroke-opacity:'+opacity+'" fill="currentColor">'+
     '<title>'+escapedSource+'</title>'+(error?'<desc>'+mathEscape(error.message)+'</desc>':'')+
     '<g transform="scale(1000)">'+box.svg+'</g></svg>';
+  if(svg.length>24*1024*1024)throw Object.assign(new Error('The complete formula markup exceeds its output budget.'),{code:'resource-limit'});
   return {svg,width,height,depth,lines:box.lines || 1,fitted:!!box.fitted,errors:error?[error]:[]};
 }
 
 function mathSourceAlternative(source) {
-  let alternative='',first=-1,kept=0;
+  const alternatives=[],parts=[];
+  let first=-1,kept=0;
   for(let i=0;i<source.length;i++) {
     const code=source.charCodeAt(i);
     if(code>=0xd800 && code<=0xdbff && i+1<source.length) {
@@ -2894,19 +2904,32 @@ function mathSourceAlternative(source) {
     }
     if((code>=0x20 && code<=0xd7ff) || (code>=0xe000 && code<=0xfffd) || code===9 || code===10 || code===13)continue;
     if(first<0)first=i;
-    alternative+=source.slice(kept,i)+'\\u'+code.toString(16).toUpperCase().padStart(4,'0');kept=i+1;
+    if(i>kept)parts.push(source.slice(kept,i));
+    parts.push('\\u'+code.toString(16).toUpperCase().padStart(4,'0'));kept=i+1;
+    // Flatten small batches instead of retaining one rope node per bad code unit.
+    if(parts.length>=1024) {alternatives.push(parts.join(''));parts.length=0;}
   }
   if(first<0)return {alternative:source};
-  alternative+=source.slice(kept);
+  parts.push(source.slice(kept));alternatives.push(parts.join(''));
   // Only malformed XML text needs a separate carrier; each four hex digits keep one original code unit.
-  let utf16='';
-  for(let i=0;i<source.length;i++)utf16+=source.charCodeAt(i).toString(16).padStart(4,'0');
-  return {alternative,utf16,error:{code:'invalid-source-character',offset:first,
+  const encoded=[];parts.length=0;
+  for(let i=0;i<source.length;i++) {
+    parts.push(source.charCodeAt(i).toString(16).padStart(4,'0'));
+    if(parts.length===1024) {encoded.push(parts.join(''));parts.length=0;}
+  }
+  encoded.push(parts.join(''));
+  return {alternative:alternatives.join(''),utf16:encoded.join(''),error:{code:'invalid-source-character',offset:first,
     message:'A source character cannot be embedded in SVG. The text alternative shows Unicode escapes; data-tex-utf16 keeps the original source.'}};
 }
 
 function renderMath(source,options={}) {
-  const text=String(source ?? ''),safe=mathSourceAlternative(text),context={size:1,level:0,variant:'normal',cramped:false,display:!!options?.displayMode,cache:new WeakMap(),budget:{nodes:0,outlineBytes:0}};
+  const text=String(source ?? '');
+  // Reject before scanning, escaping or parsing. Keep the diagnostic-return
+  // contract, but explicitly omit refused source instead of expanding it.
+  const safe=text.length>1000000?{alternative:'Formula source omitted: source limit exceeded.',error:{
+    code:'resource-limit',offset:0,sourceOmitted:true,
+    message:'This formula is too long to render safely. Its source was not embedded; retain the original input.'
+  }}:mathSourceAlternative(text),context={size:1,level:0,variant:'normal',cramped:false,display:!!options?.displayMode,cache:new WeakMap(),budget:{nodes:0,outlineBytes:0}};
   try {
     if(safe.error)throw safe.error;
     if(options?.screen!==undefined) {
@@ -2923,11 +2946,16 @@ function renderMath(source,options={}) {
     return mathSvg(box,safe.alternative,undefined,undefined,{displayMode:context.display,maxWidth,naturalWidth:mathInkWidth(natural)+.05,screen:context.screen});
   }
   catch (cause) {
-    const error={code:cause.code || 'invalid-tex',message:String(cause.message || cause),offset:Number.isFinite(cause.offset)?cause.offset:0};
-    if(cause.command)error.command=cause.command;
+    const message=String(cause.message || cause);
+    const error={code:cause.code || 'invalid-tex',message:message.length>1024?message.slice(0,1024).replace(/[\ud800-\udbff]$/,'')+'…':message,offset:Number.isFinite(cause.offset)?cause.offset:0};
+    if(message.length>1024)error.messageTruncated=true;
+    if(cause.sourceOmitted)error.sourceOmitted=true;
+    if(cause.command) {
+      error.command=String(cause.command).slice(0,128);
+      if(cause.command.length>128)error.commandTruncated=true;
+    }
     // A diagnostic is visible, but remains distinct from a successfully typeset formula.
-    // A hostile command can have a very long name. Keep its full diagnostic in desc/errors,
-    // while the visible notice stays finite and can render after the formula exhausted its budget.
+    // Diagnostics have an explicit bound. Exact input stays in the source alternative.
     const label=error.message.length>240?'This formula could not be rendered. The complete diagnostic is in its text description.':error.message.replace(/[^\x20-\x7e]/g,'?');
     const diagnostic={...context,variant:'roman',size:0.8,budget:{nodes:0,outlineBytes:0}};
     try {
@@ -2940,7 +2968,7 @@ function renderMath(source,options={}) {
 }
 
 const RapierMath=Object.freeze({
-  version:'1.0.2',
+  version:'1.1.0',
   parse:parseMathTex,
   render:renderMath,
   fit:mathFit,

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.2",
-  "documentNamespace": "https://rapier.website/spdx/rapier-math-1.0.2-55c326429ed51564670c67fb4e35eddbe4115fb077440146e4fbb5f81a247f9a",
+  "name": "rapier-math-1.1.0",
+  "documentNamespace": "https://rapier.website/spdx/rapier-math-1.1.0-22e5e40abbd1087922335893ad546fb7ffaeaa710338c97e5686e7b7b0b62021",
   "creationInfo": {
-    "created": "2026-10-12T10:57:51.103Z",
+    "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.2",
-      "downloadLocation": "https://cdn.jsdelivr.net/gh/jackskip22/rapier-plugins@main/math/rapier-math-1.0.2.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": "55c326429ed51564670c67fb4e35eddbe4115fb077440146e4fbb5f81a247f9a"
+          "checksumValue": "22e5e40abbd1087922335893ad546fb7ffaeaa710338c97e5686e7b7b0b62021"
         }
       ]
     },

package/package.json

@@ -1,17 +1,67 @@
 {
   "name": "rapier-math",
-  "version": "1.0.2",
+  "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.2.js": "./rapier-math-1.0.2.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.2.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",