rapier-math 0.0.0-stage → 1.0.1

package/src/math/responsive.js

@@ -0,0 +1,251 @@
+// SPDX-License-Identifier: MIT
+// Break only between mathematical atoms; each line keeps its complete vector ink.
+const mathInkWidth = box => Math.max(box.w,box.right)-Math.min(0,box.left);
+
+function mathFittedInk(svg, ratio, c) {
+  let growth=0;
+  if(c.screen)svg=svg.replace(/<path\b[^>]*\bdata-math-ink="([^"]+)"[^>]*\/>/g,(tag,original)=>{
+    const scale=Number(original)*ratio,stroke=mathScreenStroke({...c,level:0,size:scale});
+    const previous=Number(tag.match(/\bstroke-width="([^"]+)"/)?.[1] || 0)*scale/MATH_FONT.units;
+    growth=Math.max(growth,(stroke-previous)/2);
+    tag=tag.replace(/data-math-ink="[^"]+"/,'data-math-ink="'+mathNumber(scale)+'"');
+    const weight='stroke-width="'+mathNumber(stroke*MATH_FONT.units/scale)+'"';
+    return tag.includes('stroke-width=')?tag.replace(/stroke-width="[^"]+"/,weight):
+      tag.replace('/>',' stroke="currentColor" '+weight+' stroke-linejoin="round" paint-order="stroke fill"/>');
+  });
+  return {svg,growth};
+}
+
+function mathFitBox(box,width,c) {
+  let extent=mathInkWidth(box);
+  if(extent<=width || !extent)return box;
+  if(c.screen && box.refit) {
+    let ratio=width/extent,next;
+    for(let pass=0;pass<2;pass++) {
+      next=box.refit(ratio);
+      ratio=Math.min(ratio,width/mathInkWidth(next));
+    }
+    box=next;extent=mathInkWidth(box);
+  }
+  let ratio=width/extent,ink;
+  // Fitting changes the final pixel size. Regrade the outlines and reserve their new ink.
+  for(let pass=0;pass<3;pass++) {
+    ink=mathFittedInk(box.svg,ratio,c);
+    if(extent*ratio+2*ink.growth<=width)break;
+    ratio=Math.max(Number.EPSILON,(width-2*ink.growth)/extent);
+  }
+  ink=mathFittedInk(box.svg,ratio,c);
+  const scaled={...box,svg:'<g transform="scale('+mathNumber(ratio)+')">'+ink.svg+'</g>',fitted:true};
+  for(const key of ['w','h','d','left','right','inkTop','inkBottom'])scaled[key]*=ratio;
+  scaled.left-=ink.growth;scaled.right+=ink.growth;scaled.inkTop-=ink.growth;scaled.inkBottom+=ink.growth;
+  scaled.h+=ink.growth;scaled.d+=ink.growth;
+  delete scaled.rowItems;
+  delete scaled.refit;
+  return scaled;
+}
+
+function mathLineStack(lines,c) {
+  const items=[],gap=Math.max(mathConstant('MathLeading',c,0.15),0.3*mathScale(c));
+  let y=0,width=0;
+  for(let i=0;i<lines.length;i++) {
+    const {box,indent=0,gapBefore=0}=lines[i];
+    if(i)y+=lines[i-1].box.d+gap+box.h+gapBefore;
+    const x=indent-Math.min(0,box.left);
+    items.push([box,x,y]);width=Math.max(width,x+Math.max(box.w,box.right));
+  }
+  return mathCompose(items,width,{lines:lines.reduce((sum,line)=>sum+(line.box.lines || 1),0),
+    lastBaseline:y+(lines.at(-1)?.box.lastBaseline || 0),fitted:lines.some(line=>line.box.fitted)});
+}
+
+function mathPositionStack(lines,c,n) {
+  const box=mathLineStack(lines,c),shift=n.position==='t'?0:n.position==='b'?-box.lastBaseline:
+    (box.h-box.d)/2-mathConstant('AxisHeight',c,.25);
+  return mathCompose([[box,0,shift]],box.w,{class:'inner',lines:box.lines,lastBaseline:box.lastBaseline+shift,fitted:box.fitted});
+}
+
+function mathFlowAtoms(n,box,x=0,y=0) {
+  if(n.type==='row' && n.children.length && box.rowItems?.length===n.children.length)
+    return n.children.flatMap((child,i)=>{const [b,dx,dy]=box.rowItems[i];return mathFlowAtoms(child,b,x+dx,y+dy);});
+  if(n.type==='style' && n.width===undefined && !n.border && !n.background && !n.class && !n.limits) {
+    const atoms=mathFlowAtoms(n.body,box,x,y);
+    if(n.color) {
+      const paint=b=>({...b,svg:'<g fill="'+mathEscape(n.color)+'" color="'+mathEscape(n.color)+'" fill-opacity="1" stroke-opacity="1">'+b.svg+'</g>',
+        ...(b.refit?{refit:ratio=>paint(b.refit(ratio))}:{}),...(b.flowWrap?{flowWrap:width=>paint(b.flowWrap(width))}:{})});
+      return atoms.map(([b,dx,dy])=>[paint(b),dx,dy]);
+    }
+    return atoms;
+  }
+  if(n.type==='frac' && n.bar!==false && n.barThickness!==0)box={...box,flowFactor:true};
+  if(n.type==='glyph' && n.value==='⋯')box={...box,flowDots:true};
+  if(n.type==='glyph' && '([{⌈⌊⟨⦅⟦⟪⦃)]}⌉⌋⟩⦆⟧⟫⦄'.includes(n.value))
+    box={...box,flowFence:')]}⌉⌋⟩⦆⟧⟫⦄'.includes(n.value)?'close':'open'};
+  return [[box,x,y]];
+}
+
+function mathRefitRow(items,advance,ratio) {
+  let delta=0;
+  const fresh=items.map(([b,x,y])=>{
+    const next=b.refit?b.refit(ratio):b,placed=[next,x+delta,y];
+    delta+=next.w-b.w;return placed;
+  });
+  return mathCompose(fresh,advance+delta,{fitted:fresh.some(([b])=>b.fitted)});
+}
+
+function mathWrapRow(box,c,width,{relationIndent,binaryIndent}={}) {
+  if(mathInkWidth(box)<=width || !box.rowItems?.length)return mathFitBox(box,width,c);
+  const atoms=box.rowItems.map(item=>[...item]),breaks=[0];let ink=false,depth=0,previous=null;
+  for(let i=0;i<atoms.length;i++) {
+    const b=atoms[i][0],next=atoms[i+1]?.[0],fence=b.flowFence || b.class;
+    if(fence==='close')depth=Math.max(0,depth-1);
+    if(ink && !depth && (b.class==='rel' || b.class==='bin' || b.flowDots && (previous?.flowFactor && next?.flowFactor || (previous?.flowFence || previous?.class)==='close' && (next?.flowFence || next?.class)==='open')))breaks.push(i);
+    if(fence==='open')depth++;
+    if(b.svg){ink=true;previous=b;}
+  }
+  breaks.push(atoms.length);
+  // Reuse structural wrapping before shrinking an oversized, otherwise indivisible atom.
+  const deltas=Array(atoms.length).fill(0);let changed=false;
+  for(let segment=0;segment<breaks.length-1;segment++) {
+    const start=breaks[segment],end=breaks[segment+1],origin=atoms[start]?.[1] || 0;
+    let right=0,left=0;
+    for(let i=start;i<end;i++){const [b,x]=atoms[i];left=Math.min(left,x-origin+b.left);right=Math.max(right,x-origin+b.right,x-origin+b.w);}
+    let extent=right-left;
+    if(extent<=width)continue;
+    for(let i=start;i<end;i++) {
+      const b=atoms[i][0];if(!b.flowWrap)continue;
+      const allowance=width-(extent-mathInkWidth(b));
+      if(allowance<=.2*mathScale(c))continue;
+      const next=b.flowWrap(allowance),delta=next.w-b.w;
+      if(Math.max(next.innerLines || 1,next.lines || 1)<2 || delta>=0)continue;
+      atoms[i][0]=next;deltas[i]=delta;extent+=delta;changed=true;
+    }
+  }
+  if(changed) {
+    let shift=0,advance=0;
+    for(let i=0;i<atoms.length;i++){atoms[i][1]+=shift;shift+=deltas[i];advance=Math.max(advance,atoms[i][1]+atoms[i][0].w);}
+    box=mathCompose(atoms,advance,{rowItems:atoms,fitted:atoms.some(([b])=>b.fitted)});
+    if(c.screen)box.refit=ratio=>mathRefitRow(atoms,advance,ratio);
+  }
+  if(breaks.length===2)return mathFitBox(box,width,c);
+  const firstRelation=atoms.findIndex(([b])=>b.class==='rel');
+  const anchor=relationIndent ?? (firstRelation>=0 && atoms[firstRelation][1]<width*0.35?atoms[firstRelation][1]:0);
+  const continuation=binaryIndent ?? Math.min(anchor+mathScale(c),width*0.3);
+  const minimum=breaks.slice(0,-1).map((start,i)=>{
+    const origin=atoms[start][1];let left=0,right=0;
+    for(let j=start;j<breaks[i+1];j++){const [b,x]=atoms[j];left=Math.min(left,x-origin+b.left);right=Math.max(right,x-origin+b.right,x-origin+b.w);}
+    return right-left;
+  });
+  const inset=i=>{
+    const wanted=i===0?0:atoms[breaks[i]][0].class==='rel'?anchor:continuation;
+    return relationIndent===undefined?Math.min(wanted,Math.max(0,width-minimum[i])):wanted;
+  };
+  const costs=Array(breaks.length).fill(Infinity),next=Array(breaks.length).fill(0);
+  costs[breaks.length-1]=0;
+  // A bounded lookahead makes even thousands of break opportunities linear in input size.
+  for(let start=breaks.length-2;start>=0;start--) {
+    const first=breaks[start],origin=atoms[first][1],available=Math.max(.05,width-inset(start));
+    let left=0,right=0,cursor=first;
+    for(let end=start+1;end<Math.min(breaks.length,start+65);end++) {
+      while(cursor<breaks[end]) {
+        const [b,x]=atoms[cursor++];
+        left=Math.min(left,x-origin+b.left);right=Math.max(right,x-origin+b.right,x-origin+b.w);
+      }
+      const extent=right-left,over=Math.max(0,extent-available)/available,slack=Math.max(0,available-extent)/available;
+      const last=end===breaks.length-1,penalty=last?0:atoms[breaks[end]][0].class==='rel'?0:18;
+      const cost=costs[end]+12+penalty+(last?8:60)*slack*slack+(over?100000*(1+over*over):0);
+      if(cost<costs[start]) {costs[start]=cost;next[start]=end;}
+      if(extent>available && end>start+1)break;
+    }
+  }
+  const lines=[];
+  for(let start=0;start<breaks.length-1;) {
+    const end=next[start] || start+1,from=breaks[start],to=breaks[end],origin=atoms[from][1],items=[];
+    let advance=0;
+    for(let i=from;i<to;i++) {
+      const [b,x,y]=atoms[i];items.push([b,x-origin,y]);advance=Math.max(advance,x-origin+b.w);
+    }
+    const indent=inset(start),line=mathCompose(items,advance,{fitted:items.some(([b])=>b.fitted)});
+    if(c.screen)line.refit=ratio=>mathRefitRow(items,advance,ratio);
+    lines.push({box:mathFitBox(line,Math.max(.05,width-indent),c),indent});start=end;
+  }
+  return mathLineStack(lines,c);
+}
+
+function mathWrapAligned(n,c,width,natural) {
+  if(!/^(align(?:ed)?(?:at)?|flalign|split|eqnarray|gather(?:ed)?|multline)$/.test(n.env) ||
+      n.columnRules?.length || n.rowRules?.length || n.columnInsertions?.length)return mathFitBox(natural,width,c);
+  if(n.env==='eqnarray')n={...n,env:'aligned',rows:n.rows.map(row=>[row[0],{type:'row',children:row.slice(1).flatMap(cell=>cell.type==='row'?cell.children:[cell])}])};
+  const paired=/^(align(?:ed)?(?:at)?|flalign|split)$/.test(n.env),cellStyle={...c,display:true};
+  if(!paired) {
+    const lines=[];
+    for(let r=0;r<n.rows.length;r++) {
+      const row=n.rows[r];
+      const body=row.length===1?row[0]:{type:'row',children:row};
+      lines.push({box:mathResponsiveLayout(body,cellStyle,width),gapBefore:(n.rowGaps?.[r-1] || 0)*mathScale(c)});
+    }
+    return mathPositionStack(lines,c,n);
+  }
+  const rows=n.rows.map(row=>row.map(cell=>mathLayout(cell,cellStyle)));
+  const leftWidth=Math.max(0,...rows.flatMap(row=>row.filter((_,i)=>i%2===0).map(mathInkWidth)));
+  const separate=leftWidth>width*0.4,anchor=separate?0:leftWidth;
+  const lines=[],s=mathScale(c);
+  for(let r=0;r<n.rows.length;r++) {
+    const row=n.rows[r],start=lines.length;
+    for(let pair=0;pair<row.length;pair+=2) {
+      const left=rows[r][pair],rightNode=row[pair+1] || {type:'row',children:[]};
+      const rightTree={type:'row',children:[{type:'row',children:[]},...(rightNode.type==='row'?rightNode.children:[rightNode])]},right=mathRow(rightTree.children,cellStyle);
+      if(c.screen)right.refit=ratio=>mathScreenRelayout(rightTree,cellStyle,ratio);
+      right.rowItems=mathFlowAtoms(rightTree,right);
+      const relationGap=mathSpace('ord','rel',cellStyle);
+      const wrapped=mathWrapRow(right,cellStyle,Math.max(.05,width-anchor),{relationIndent:relationGap,binaryIndent:Math.min(relationGap+s,width*0.2)});
+      if(separate && left.svg)lines.push({box:mathResponsiveLayout(row[pair],cellStyle,width)});
+      const parts=separate?[[wrapped,0,0]]:[[left,anchor-left.w,0],[wrapped,anchor,0]];
+      lines.push({box:mathCompose(parts,anchor+mathInkWidth(wrapped),{lines:wrapped.lines || 1,lastBaseline:wrapped.lastBaseline || 0,fitted:wrapped.fitted})});
+    }
+    if(lines[start])lines[start].gapBefore=(n.rowGaps?.[r-1] || 0)*s;
+  }
+  return mathPositionStack(lines,c,n);
+}
+
+function mathHasMiddle(n) {
+  if(!n || typeof n!=='object' || n.type==='fence')return false;
+  if(n.type==='glyph' && n.delimiter)return true;
+  return Object.values(n).some(value=>Array.isArray(value)?value.some(mathHasMiddle):mathHasMiddle(value));
+}
+
+function mathResponsiveLayout(n,c,width,natural=mathLayout(n,c)) {
+  if(!Number.isFinite(width) || width<=0 || mathInkWidth(natural)<=width)return natural;
+  if(c.screen && !natural.refit)natural={...natural,refit:ratio=>mathScreenRelayout(n,c,ratio)};
+  if(n.type==='row') {
+    if(n.children.length===1)return mathResponsiveLayout(n.children[0],c,width,natural.rowItems?.[0]?.[0]);
+    return mathWrapRow({...natural,rowItems:mathFlowAtoms(n,natural)},c,width);
+  }
+  if(n.type==='style' && n.width===undefined && !n.border && !n.background && !n.class && !n.limits) {
+    const style={...c};
+    if(n.variant)style.variant=n.variant;
+    if(n.absoluteSize!==undefined)style.size=n.absoluteSize;
+    if(n.size!==undefined)style.size*=n.size;
+    if(n.mathStyle) {style.level=({display:0,text:0,script:1,scriptscript:2})[n.mathStyle];style.display=n.mathStyle==='display';style.cramped=false;}
+    const box=mathResponsiveLayout(n.body,style,width);
+    if(n.color)box.svg='<g fill="'+mathEscape(n.color)+'" color="'+mathEscape(n.color)+'" fill-opacity="1" stroke-opacity="1">'+box.svg+'</g>';
+    return box;
+  }
+  if(n.type==='frac' && n.bar!==false && n.barThickness!==0 && !n.left && !n.right) {
+    const wrapped=mathFraction(n,c,width);if(wrapped.innerLines>1)return mathFitBox(wrapped,width,c);
+  }
+  if(n.type==='table')return mathWrapAligned(n,c,width,natural);
+  if(n.type==='fence' && !n.size) {
+    if(mathHasMiddle(n.body))return mathFitBox(natural,width,c);
+    const local={...c,delimiterTarget:undefined};
+    let available=width,box=natural;
+    for(let pass=0;pass<4;pass++) {
+      let body=mathResponsiveLayout(n.body,local,Math.max(.05,available));
+      if(body.lines>1)body=mathCompose([[body,0,(body.h-body.d)/2-mathConstant('AxisHeight',c,.25)]],body.w,{lines:body.lines,fitted:body.fitted});
+      box=mathFenceBoxes(n.left,n.right,body,local);
+      box.lines=body.lines;box.fitted=body.fitted;
+      if(mathInkWidth(box)<=width)return box;
+      available=width-(box.w-body.w)-.05;
+    }
+    return mathFitBox(box,width,c);
+  }
+  return mathFitBox(natural,width,c);
+}

package/src/math/symbols.js

@@ -0,0 +1,98 @@
+// SPDX-License-Identifier: MIT
+// Command spellings name Unicode characters; glyph outlines belong to the font.
+const MATH_SYMBOLS = Object.create(null);
+function mathSymbolGroup(kind, entries, extra) {
+  for (const entry of entries.trim().split(/\s+/)) {
+    const split = entry.indexOf('=');
+    const value = entry.slice(split + 1);
+    for (const name of entry.slice(0, split).split('/'))
+      MATH_SYMBOLS[name] = Object.freeze({type: 'glyph', value, class: kind, ...extra});
+  }
+}
+mathSymbolGroup('ord', `
+alpha=α beta=β gamma=γ delta=δ epsilon=ϵ varepsilon=ε zeta=ζ eta=η theta=θ vartheta=ϑ
+iota=ι kappa=κ varkappa=ϰ lambda=λ mu=μ nu=ν xi=ξ omicron=ο pi=π varpi=ϖ rho=ρ varrho=ϱ
+sigma=σ varsigma=ς tau=τ upsilon=υ phi=ϕ varphi=φ chi=χ psi=ψ omega=ω digamma=ϝ
+Gamma=Γ Delta=Δ Theta=Θ Lambda=Λ Xi=Ξ Pi=Π Sigma=Σ Upsilon=Υ Phi=Φ Psi=Ψ Omega=Ω
+varGamma=Γ varDelta=Δ varTheta=Θ varLambda=Λ varXi=Ξ varPi=Π varSigma=Σ varUpsilon=Υ varPhi=Φ varPsi=Ψ varOmega=Ω
+aleph=ℵ beth=ℶ gimel=ℷ daleth=ℸ ell=ℓ hbar=ℏ hslash=ℏ imath=𝚤 jmath=𝚥
+Re=ℜ Im=ℑ wp=℘ partial=∂ nabla=∇ infty=∞ emptyset=∅ varnothing=∅ complement=∁
+top=⊤ bot=⊥ forall=∀ exists=∃ nexists=∄ neg/lnot=¬ angle=∠ measuredangle=∡ sphericalangle=∢
+triangle=△ blacktriangle=▴ triangledown=▽ blacktriangledown=▾ square/Box=□ blacksquare=■ Diamond=◇ blacklozenge=◆ lozenge=◊
+clubsuit=♣ diamondsuit=♢ heartsuit=♡ spadesuit=♠ checkmark=✓ maltese=✠ yen=¥ pounds=£ euro=€
+S=§ P=¶ copyright=© circledR=® circledS=Ⓢ mho=℧ Finv=Ⅎ Game=⅁ eth=ð
+prime=′ backprime=‵ doubleprime=″ tripleprime=‴ degree=° flat=♭ natural=♮ sharp=♯
+surd=√ diagup=╱ diagdown=╲ Bbbk=𝕜
+`, {variant: 'roman'});
+// Lowercase Greek retains the ordinary mathematical italic convention.
+for (const name of 'alpha beta gamma delta epsilon varepsilon zeta eta theta vartheta iota kappa varkappa lambda mu nu xi omicron pi varpi rho varrho sigma varsigma tau upsilon phi varphi chi psi omega digamma'.split(' '))
+  MATH_SYMBOLS[name] = Object.freeze({...MATH_SYMBOLS[name], variant: 'normal'});
+for (const name of Object.keys(MATH_SYMBOLS).filter(name => /^var[A-Z]/.test(name)))
+  MATH_SYMBOLS[name] = Object.freeze({...MATH_SYMBOLS[name], variant: 'italic'});
+mathSymbolGroup('bin', `
+pm=± mp=∓ times=× div=÷ cdot=⋅ cdotp=⋅ ast=∗ star=⋆ circ=∘ bullet=∙ diamond=⋄
+cap=∩ cup=∪ uplus=⊎ sqcap=⊓ sqcup=⊔ vee/lor=∨ wedge/land=∧ setminus=∖ smallsetminus=∖
+oplus=⊕ ominus=⊖ otimes=⊗ oslash=⊘ odot=⊙ bigcirc=◯ dag/dagger=† ddag/ddagger=‡ amalg=⨿
+triangleleft=◁ triangleright=▷ lhd=⊲ rhd=⊳ unlhd=⊴ unrhd=⊵ wr=≀
+barwedge=⊼ veebar=⊻ doublebarwedge=⩞ curlywedge=⋏ curlyvee=⋎ boxplus=⊞ boxminus=⊟ boxtimes=⊠ boxdot=⊡
+ltimes=⋉ rtimes=⋊ leftthreetimes=⋋ rightthreetimes=⋌ dotplus=∔ divideontimes=⋇
+circledast=⊛ circledcirc=⊚ circleddash=⊝ intercal=⊺ centerdot=· land=∧ lor=∨ bigtriangleup=△ bigtriangledown=▽
+`, {variant: 'roman'});
+mathSymbolGroup('rel', `
+le/leq=≤ ge/geq=≥ neq/ne=≠ equiv=≡ sim=∼ simeq=≃ approx=≈ cong=≅ asymp=≍ propto=∝
+ll=≪ gg=≫ prec=≺ succ=≻ preceq=⪯ succeq=⪰ subset=⊂ supset=⊃ subseteq=⊆ supseteq=⊇
+sqsubset=⊏ sqsupset=⊐ sqsubseteq=⊑ sqsupseteq=⊒ in=∈ ni/owns=∋ notin=∉ notni=∌
+vdash=⊢ dashv=⊣ models=⊨ perp=⊥ mid=∣ parallel=∥ smile=⌣ frown=⌢ bowtie=⋈ Join=⋈
+doteq=≐ dotsim=≐ doteqdot/Doteq=≑ triangleq=≜ bumpeq=≏ Bumpeq=≎ eqcirc=≖ circeq=≗
+risingdotseq=≓ fallingdotseq=≒ eqsim=≂ backsim=∽ backsimeq=⋍ approxeq=≊
+lesssim=≲ gtrsim=≳ lessapprox=⪅ gtrapprox=⪆ lessdot=⋖ gtrdot=⋗ lesseqgtr=⋚ gtreqless=⋛
+lesseqqgtr=⪋ gtreqqless=⪌ lessgtr=≶ gtrless=≷ lll/llless=⋘ ggg/gggtr=⋙
+leqq=≦ geqq=≧ leqslant=⩽ geqslant=⩾ eqslantless=⪕ eqslantgtr=⪖
+precsim=≾ succsim=≿ precapprox=⪷ succapprox=⪸ preccurlyeq=≼ succcurlyeq=≽ curlyeqprec=⋞ curlyeqsucc=⋟
+Subset=⋐ Supset=⋑ subseteqq=⫅ supseteqq=⫆ pitchfork=⋔ between=≬ Vdash=⊩ Vvdash=⊪ vDash=⊨ VDash=⊫
+blacktriangleleft=◂ blacktriangleright=▸ vartriangleleft=⊲ vartriangleright=⊳ trianglelefteq=⊴ trianglerighteq=⊵
+varpropto=∝ shortmid=∣ shortparallel=∥ smallsmile=⌣ smallfrown=⌢ therefore=∴ because=∵
+nless=≮ ngtr=≯ nleq=≰ ngeq=≱ nleqq=≰ ngeqq=≱ nleqslant=≰ ngeqslant=≱ lneq=⪇ gneq=⪈ lneqq=≨ gneqq=≩
+lvertneqq=≨ gvertneqq=≩ nsim=≁ ncong=≇ napprox=≉ lnsim=⋦ gnsim=⋧ lnapprox=⪉ gnapprox=⪊
+nprec=⊀ nsucc=⊁ npreceq=⋠ nsucceq=⋡ precneqq=⪵ succneqq=⪶ precnsim=⋨ succnsim=⋩ precnapprox=⪹ succnapprox=⪺
+nsubset=⊄ nsupset=⊅ nsubseteq=⊈ nsupseteq=⊉ nsubseteqq=⊈ nsupseteqq=⊉ subsetneq=⊊ supsetneq=⊋
+varsubsetneq=⊊ varsupsetneq=⊋ subsetneqq=⫋ supsetneqq=⫌ varsubsetneqq=⫋ varsupsetneqq=⫌
+nmid=∤ nparallel=∦ nshortmid=∤ nshortparallel=∦ nvdash=⊬ nVdash=⊮ nvDash=⊭ nVDash=⊯
+ntriangleleft=⋪ ntriangleright=⋫ ntrianglelefteq=⋬ ntrianglerighteq=⋭ coloneqq/coloneq=≔ eqqcolon=≕
+`, {variant: 'roman'});
+mathSymbolGroup('rel', `
+leftarrow/gets=← rightarrow/to=→ leftrightarrow=↔ Leftarrow=⇐ Rightarrow=⇒ Leftrightarrow=⇔
+longleftarrow=⟵ longrightarrow=⟶ longleftrightarrow=⟷ Longleftarrow=⟸ Longrightarrow=⟹ Longleftrightarrow=⟺
+mapsto=↦ longmapsto=⟼ hookleftarrow=↩ hookrightarrow=↪ nearrow=↗ searrow=↘ nwarrow=↖ swarrow=↙
+uparrow=↑ downarrow=↓ updownarrow=↕ Uparrow=⇑ Downarrow=⇓ Updownarrow=⇕
+leftharpoonup=↼ leftharpoondown=↽ rightharpoonup=⇀ rightharpoondown=⇁ rightleftharpoons=⇌ leftrightharpoons=⇋
+upharpoonleft=↿ upharpoonright=↾ downharpoonleft=⇃ downharpoonright=⇂ restriction=↾
+leftrightarrows=⇆ rightleftarrows=⇄ leftleftarrows=⇇ rightrightarrows=⇉ upuparrows=⇈ downdownarrows=⇊
+Lleftarrow=⇚ Rrightarrow=⇛ twoheadleftarrow=↞ twoheadrightarrow=↠ leftarrowtail=↢ rightarrowtail=↣
+looparrowleft=↫ looparrowright=↬ leftrightsquigarrow=↭ rightsquigarrow/leadsto=⇝ curvearrowleft=↶ curvearrowright=↷
+circlearrowleft=↺ circlearrowright=↻ dashleftarrow=⇠ dashrightarrow=⇢ multimap=⊸
+nleftarrow=↚ nrightarrow=↛ nleftrightarrow=↮ nLeftarrow=⇍ nRightarrow=⇏ nLeftrightarrow=⇎
+`, {variant: 'roman'});
+mathSymbolGroup('op', `
+sum=∑ prod=∏ coprod=∐ bigcup=⋃ bigcap=⋂ bigvee=⋁ bigwedge=⋀ biguplus=⨄ bigsqcup=⨆
+bigotimes=⨂ bigoplus=⨁ bigodot=⨀ bigamalg=⨿ bigsqcap=⨅
+`, {large: true, limits: 'display', variant: 'roman'});
+mathSymbolGroup('op', `
+int=∫ iint=∬ iiint=∭ iiiint=⨌ oint=∮ oiint=∯ oiiint=∰ intop=∫ smallint=∫
+intclockwise=∱ varointclockwise=∲ ointctrclockwise=∳ sumint=⨋
+`, {large: true, limits: 'never', variant: 'roman'});
+MATH_SYMBOLS.intop = Object.freeze({...MATH_SYMBOLS.intop, limits: 'display'});
+MATH_SYMBOLS.smallint = Object.freeze({...MATH_SYMBOLS.smallint, large: false});
+mathSymbolGroup('open', 'langle=⟨ lbrace={ lgroup=⟮ lbrack=[ lfloor=⌊ lceil=⌈ lvert=| lVert=‖ lmoustache=⎰', {variant: 'roman'});
+mathSymbolGroup('close', 'rangle=⟩ rbrace=} rgroup=⟯ rbrack=] rfloor=⌋ rceil=⌉ rvert=| rVert=‖ rmoustache=⎱', {variant: 'roman'});
+mathSymbolGroup('ord', 'vert=| Vert=‖ backslash=∖ slash=/', {variant: 'roman'});
+mathSymbolGroup('inner', 'dotsc=… cdots=⋯ dotsb=⋯ dotsm=⋯ dotsi=⋯ dotso=… ddots=⋱ mathellipsis=…', {variant: 'roman'});
+mathSymbolGroup('ord', 'vdots=⋮', {variant: 'roman'});
+mathSymbolGroup('punct', 'colon=: cdotp=⋅', {variant: 'roman'});
+MATH_SYMBOLS.ldots = MATH_SYMBOLS.dots = Object.freeze({type: 'glyph', value: '…', class: 'inner', variant: 'roman'});
+for (const [name, symbol] of Object.entries(MATH_SYMBOLS)) {
+  const {variant, ...fields} = symbol;
+  MATH_SYMBOLS[name] = Object.freeze({...fields, defaultVariant: variant});
+}
+const MATH_NAMED_OPERATORS = new Set(('arccos arcsin arctan arccot arcsec arccsc cos cosh cot coth csc csch sec sech sin sinh tan tanh exp log ln lg lb det dim gcd hom ker arg deg Pr erf erfc mod').split(' '));
+const MATH_LIMIT_OPERATORS = new Set(('lim limsup liminf sup inf max min injlim projlim varlimsup varliminf varinjlim varprojlim').split(' '));

package/src/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "rapier-math-source",
+  "private": true,
+  "version": "1.0.1",
+  "type": "module",
+  "scripts": {
+    "build": "node tools/build-math.mjs"
+  }
+}

package/src/shell/math-resources.json

@@ -0,0 +1,105 @@
+{
+  "bundle": "rapier-math-1.0.1.js",
+  "version": "1.0.1",
+  "license": "MIT AND LicenseRef-GUST-Font-License",
+  "bytes": 803451,
+  "gzipBytes": 496298,
+  "sha256": "77640802b52935b60a66e2fd04c19d4702cee4b1a8b64aece5ca332236c09283",
+  "sha384": "1kdn6mohx3a5MAiwqRWY+6oviUHUheHfY1VMsxjDsUrn7woTaa7FSKo4juYtuNaF",
+  "sources": [
+    {
+      "file": "math/font.js",
+      "bytes": 651457,
+      "sha256": "b697b5ba770e35904fe56a0aa6c2f748253b3d3c5b9ab39c68f4a25afae02a0d"
+    },
+    {
+      "file": "math/symbols.js",
+      "bytes": 8415,
+      "sha256": "80f485e8023afe3783d30c4616709e0a3b0ed0ba8a238bd818085cdd107f03ad"
+    },
+    {
+      "file": "math/parser.js",
+      "bytes": 69355,
+      "sha256": "067594e1b1391a7c29b71ff51e0e812f16785e14a863dbc04069627760435633"
+    },
+    {
+      "file": "math/layout.js",
+      "bytes": 37394,
+      "sha256": "37cd00667aa1c7ef8b375c5e62171b1a7ceef53490cd13c8a77201e7ea6b13e8"
+    },
+    {
+      "file": "math/fallbacks.js",
+      "bytes": 7958,
+      "sha256": "a59c9a32f4a1ea49ad7454ea48aa25489e8e786459055d91fef045b8cc2b5f4b"
+    },
+    {
+      "file": "math/responsive.js",
+      "bytes": 13566,
+      "sha256": "387e2952317ba8124bd7f56a71feb9555f3cb6081de687d79eb4c9e6cab4b6ed"
+    },
+    {
+      "file": "math/browser.js",
+      "bytes": 8363,
+      "sha256": "0bf9fc6c5f02c2b0c5012118b80a8fad337fe25c3a4557e2747d4d4caa5c2e1b"
+    },
+    {
+      "file": "math/api.js",
+      "bytes": 5825,
+      "sha256": "f05bc69c0e13230079526a98072a2ae8ffd58bfb2df2aecb0e2f26fdb43dbeb6"
+    }
+  ],
+  "recipe": [
+    {
+      "file": "math/build-font.py",
+      "bytes": 24804,
+      "sha256": "83f27e773d451a7275f6b7d521a257f79c27b3c61452a869703fe44c4ca8b878"
+    },
+    {
+      "file": "math/FONT-SOURCE.md",
+      "bytes": 8095,
+      "sha256": "05e0bba9e9bf340029c8bcc97492c17958949533717a62644505846905e65499"
+    },
+    {
+      "file": "math/FONT-LICENSE.txt",
+      "bytes": 21246,
+      "sha256": "91ded9a2a371cbeff028bfaf3bd3e97fddfb68af6f186aa261bfaff35baf800c"
+    },
+    {
+      "file": "math/package-verify.mjs",
+      "bytes": 2691,
+      "sha256": "6a53081729c020b7840363812138264195cb851a297c5542ef7aca007fdfc61f"
+    },
+    {
+      "file": "tools/build-math.mjs",
+      "bytes": 5795,
+      "sha256": "7f8582f07832c2c2a50b0b6b552df3819e8e246f8aa7857e409d443b79d463f4"
+    },
+    {
+      "file": "math/LICENSE-MIT",
+      "bytes": 1071,
+      "sha256": "a3bc5d619ab9159f4eef2924e48dfb935556f4bc163f5ea61610b66a5915de70"
+    }
+  ],
+  "components": [
+    {
+      "name": "Latin Modern Math",
+      "version": "1.959",
+      "license": "LicenseRef-GUST-Font-License",
+      "source": "https://mirror.apps.cam.ac.uk/pub/tex-archive/fonts/lm-math/opentype/latinmodern-math.otf",
+      "sha256": "6075562b771f8b82f0c179e363389684f2dd09de30038269e2628e504bd7be0f"
+    }
+  ],
+  "font": {
+    "name": "Latin Modern Math",
+    "version": "1.959",
+    "license": "LicenseRef-GUST-Font-License",
+    "licenseName": "GUST Font License",
+    "source": "https://mirror.apps.cam.ac.uk/pub/tex-archive/fonts/lm-math/opentype/latinmodern-math.otf",
+    "sourceSha256": "6075562b771f8b82f0c179e363389684f2dd09de30038269e2628e504bd7be0f",
+    "copyright": "Copyright 2012--2014 for Latin Modern Math OTF by B. Jackowski, P. Strzelczyk and P. Pianowski (on behalf of TeX users groups). This work is released under the GUST Font License -- see http://tug.org/fonts/licenses/GUST-FONT-LICENSE.txt for details.",
+    "licenseSource": "https://mirror.apps.cam.ac.uk/pub/tex-archive/fonts/lm-math/doc/GUST-FONT-LICENSE.txt",
+    "licenseFile": "math/FONT-LICENSE.txt",
+    "licenseSha256": "91ded9a2a371cbeff028bfaf3bd3e97fddfb68af6f186aa261bfaff35baf800c",
+    "licenseBytes": 21246
+  }
+}

package/src/tools/build-math.mjs

@@ -0,0 +1,92 @@
+// SPDX-License-Identifier: MIT
+// Assemble the complete SVG math renderer from its own source and embedded font paths.
+import {readFile, writeFile, mkdir} from 'node:fs/promises';
+import {existsSync} from 'node:fs';
+import {dirname, resolve} from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {createHash} from 'node:crypto';
+import {gzipSync} from 'node:zlib';
+import {Script} from 'node:vm';
+
+const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+export const MATH_VERSION = '1.0.1';
+export const MATH_BUNDLE = 'rapier-math-' + MATH_VERSION + '.js';
+export const MATH_SOURCES = ['font.js', 'symbols.js', 'parser.js', 'layout.js', 'fallbacks.js', 'responsive.js', 'browser.js', 'api.js'].map(name => 'math/' + name);
+export const MATH_RECIPE = ['math/build-font.py', 'math/FONT-SOURCE.md', 'math/FONT-LICENSE.txt', 'math/package-verify.mjs', 'tools/build-math.mjs', 'math/LICENSE-MIT'];
+const FONT = {
+  name: 'Latin Modern Math', version: '1.959', license: 'LicenseRef-GUST-Font-License',
+  licenseName: 'GUST Font License',
+  source: 'https://mirror.apps.cam.ac.uk/pub/tex-archive/fonts/lm-math/opentype/latinmodern-math.otf',
+  sourceSha256: '6075562b771f8b82f0c179e363389684f2dd09de30038269e2628e504bd7be0f',
+  copyright: 'Copyright 2012--2014 for Latin Modern Math OTF by B. Jackowski, P. Strzelczyk and P. Pianowski (on behalf of TeX users groups). This work is released under the GUST Font License -- see http://tug.org/fonts/licenses/GUST-FONT-LICENSE.txt for details.',
+  licenseSource: 'https://mirror.apps.cam.ac.uk/pub/tex-archive/fonts/lm-math/doc/GUST-FONT-LICENSE.txt',
+  licenseFile: 'math/FONT-LICENSE.txt',
+  licenseSha256: '91ded9a2a371cbeff028bfaf3bd3e97fddfb68af6f186aa261bfaff35baf800c',
+};
+const digest = (bytes, algorithm = 'sha256', encoding = 'hex') => createHash(algorithm).update(bytes).digest(encoding);
+
+async function fontLicense(root) {
+  const bytes = await readFile(resolve(root, FONT.licenseFile));
+  if (digest(bytes) !== FONT.licenseSha256 || !bytes.includes(FONT.copyright))
+    throw new Error('The math font license differs from its source pin');
+  return bytes;
+}
+
+export async function fillMathLicense(markup, {root = ROOT} = {}) {
+  const marker = '<pre class="license-text" data-license="math-font"></pre>';
+  if (markup.split(marker).length !== 2) throw new Error('The math font license needs one sheet entry');
+  const escaped = (await fontLicense(root)).toString('utf8').replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;');
+  return markup.replace(marker, () => '<pre class="license-text">' + escaped + '</pre>');
+}
+
+export async function buildMath({root = ROOT, updatePins = true} = {}) {
+  const inputs = [];
+  for (const file of MATH_SOURCES) {
+    const bytes = await readFile(resolve(root, file));
+    inputs.push({file, bytes, text: bytes.toString('utf8')});
+  }
+  const license = await fontLicense(root);
+  if (!inputs[0].text.includes(license.toString('utf8').trim())) throw new Error('The embedded math font is missing its complete license');
+  const ownLicense = await readFile(resolve(root, 'math/LICENSE-MIT'), 'utf8');
+  const bytes = Buffer.from('/*!\n' + ownLicense.trim() + '\n*/\n(function(){\n\'use strict\';\n' + inputs.map(input => input.text.trimEnd()).join('\n\n') + '\n})();\n');
+  new Script(bytes.toString('utf8'), {filename: MATH_BUNDLE});
+  const gzipBytes = gzipSync(bytes, {level: 9}).length;
+  if (gzipBytes >= 500_000) throw new Error('The math plugin exceeds its 500 KB gzip budget: ' + gzipBytes);
+  const sha256 = digest(bytes), sha384 = digest(bytes, 'sha384', 'base64');
+  const recipe = [];
+  for (const file of MATH_RECIPE) {
+    const content = await readFile(resolve(root, file));
+    recipe.push({file, bytes: content.length, sha256: digest(content)});
+  }
+  const resources = {
+    bundle: MATH_BUNDLE, version: MATH_VERSION, license: 'MIT AND ' + FONT.license,
+    bytes: bytes.length, gzipBytes, sha256, sha384,
+    sources: inputs.map(input => ({file: input.file, bytes: input.bytes.length, sha256: digest(input.bytes)})),
+    recipe,
+    components: [{name: FONT.name, version: FONT.version, license: FONT.license, source: FONT.source, sha256: FONT.sourceSha256}],
+    font: {...FONT, licenseBytes: license.length},
+  };
+  const vendor = resolve(root, 'shell/vendor');
+  await mkdir(vendor, {recursive: true});
+  await writeFile(resolve(vendor, MATH_BUNDLE), bytes);
+  await writeFile(resolve(root, 'shell/math-resources.json'), JSON.stringify(resources, null, 2) + '\n');
+  const provenancePath = resolve(vendor, 'PROVENANCE.json');
+  const provenance = existsSync(provenancePath) ? JSON.parse(await readFile(provenancePath, 'utf8')) : {files: {}};
+  provenance.files[MATH_BUNDLE] = {
+    package: 'rapier-math', version: MATH_VERSION, path: 'tools/build-math.mjs; math/; shell/math-resources.json',
+    license: 'MIT AND ' + FONT.license + ' (math/LICENSE-MIT; math/FONT-LICENSE.txt)', bytes: bytes.length, sha256,
+  };
+  await writeFile(provenancePath, JSON.stringify(provenance, null, 2) + '\n');
+  const loaderPath = resolve(root, 'shell/plugin-loader.js');
+  if (updatePins && existsSync(loaderPath)) {
+    const loader = await readFile(loaderPath, 'utf8');
+    const block = /(key: 'math',[\s\S]*?bytes: )\d+(,[\s\S]*?sri: ')[^']+(')/;
+    if (!block.test(loader)) throw new Error('The math loader pin could not be located');
+    await writeFile(loaderPath, loader.replace(block, (_, before, middle, after) => before + bytes.length + middle + sha384 + after));
+  }
+  return {bundle: MATH_BUNDLE, bytes: bytes.length, gzipBytes, sha256, sha384};
+}
+
+if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  console.log(JSON.stringify(await buildMath({root: process.argv[2] ? resolve(process.argv[2]) : ROOT})));
+}

package/verify.mjs

@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: MIT
+// Verify a standalone package and rebuild its payload from the carried source.
+import assert from 'node:assert/strict';
+import {readFile} from 'node:fs/promises';
+import {createHash} from 'node:crypto';
+import {dirname, resolve} from 'node:path';
+import {fileURLToPath} from 'node:url';
+
+const root = dirname(fileURLToPath(import.meta.url));
+const source = resolve(root, 'src');
+const read = path => readFile(resolve(root, path));
+const hash = (bytes, algorithm = 'sha256', encoding = 'hex') => createHash(algorithm).update(bytes).digest(encoding);
+const resources = JSON.parse(await read('src/shell/math-resources.json'));
+const payload = await read(resources.bundle);
+assert.equal(payload.length, resources.bytes, 'payload length');
+assert.equal(hash(payload), resources.sha256, 'payload SHA-256');
+assert.equal(hash(payload, 'sha384', 'base64'), resources.sha384, 'payload SHA-384');
+for (const input of [...resources.sources, ...resources.recipe]) {
+  const bytes = await read('src/' + input.file);
+  assert.equal(bytes.length, input.bytes, input.file + ': length');
+  assert.equal(hash(bytes), input.sha256, input.file + ': SHA-256');
+}
+const rendererLicense = await read('src/math/LICENSE-MIT');
+for (const file of ['LICENSE-MIT', 'math-LICENSE.txt']) assert.deepEqual(await read(file), rendererLicense, file);
+const fontLicense = await read('src/' + resources.font.licenseFile);
+assert.equal(hash(fontLicense), resources.font.licenseSha256, 'font license SHA-256');
+assert.deepEqual(await read('math-font-LICENSE.txt'), fontLicense, 'font license bytes');
+assert(payload.includes(rendererLicense.toString('utf8').trim()), 'payload renderer license');
+assert(payload.includes(fontLicense.toString('utf8').trim()), 'payload font license');
+const sbom = JSON.parse(await read('math-components.json'));
+const font = sbom.packages.find(item => item.name === resources.font.name);
+assert.equal(font?.copyrightText, resources.font.copyright, 'font copyright');
+assert.equal(font.licenseDeclared, resources.font.license, 'font license identity');
+assert.equal(sbom.hasExtractedLicensingInfos.find(item => item.licenseId === resources.font.license)?.extractedText,
+  fontLicense.toString('utf8'), 'complete extracted font license');
+const {buildMath} = await import('./src/tools/build-math.mjs');
+await buildMath({root: source, updatePins: false});
+assert.deepEqual(await read('src/shell/vendor/' + resources.bundle), payload, 'rebuilt payload bytes');
+console.log(JSON.stringify({file: resources.bundle, bytes: payload.length, sha256: resources.sha256,
+  sources: resources.sources.length + resources.recipe.length, rebuild: 'exact', licenses: 'complete'}));