rapier-math 1.0.1 → 1.1.0

package/src/math/browser.js

@@ -88,12 +88,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');
@@ -116,35 +122,66 @@ function mathFit(root) {
   return nodes.length;
 }
 
+function mathObserveDocument(doc) {
+  const view=doc.defaultView,nodes=new Map(),columns=new Set();
+  let frame=null,active=true,printing=view.matchMedia('print').matches;
+  const refresh=()=> {
+    if(!active)return;
+    if(frame!==null)view.cancelAnimationFrame(frame);
+    frame=null;
+    const wanted=new Set();
+    for(const svg of nodes.keys()) {
+      if(!svg.isConnected || svg.ownerDocument!==doc || !svg.matches(mathSvgSelector))continue;
+      const column=mathFitElement(svg,printing);if(column)wanted.add(column);
+    }
+    for(const column of columns)if(!wanted.has(column)) {resize.unobserve(column);columns.delete(column);}
+    for(const column of wanted)if(!columns.has(column)) {resize.observe(column);columns.add(column);}
+  };
+  const schedule=()=>{if(active && frame===null)frame=view.requestAnimationFrame(refresh);};
+  const resize=new view.ResizeObserver(schedule),theme=new view.MutationObserver(records=>{
+    for(const {target} of records)for(const svg of nodes.keys())
+      if(target!==svg && target.contains(svg)) {schedule();return;}
+  });
+  const beforePrint=()=>{printing=true;refresh();},afterPrint=()=>{printing=false;schedule();};
+  const media=['(forced-colors: active)','(prefers-contrast: more)','(prefers-color-scheme: dark)'].map(query=>view.matchMedia(query));
+  const fonts=doc.fonts;
+  theme.observe(doc.documentElement,{subtree:true,attributes:true,attributeFilter:['class','style','data-rapier-theme','data-md-theme']});
+  view.addEventListener('resize',schedule,{passive:true});
+  view.addEventListener('beforeprint',beforePrint);view.addEventListener('afterprint',afterPrint);
+  for(const query of media)query.addEventListener('change',schedule);
+  fonts?.addEventListener('loadingdone',schedule);
+  const state={nodes,schedule,dispose:()=>{
+    active=false;
+    if(frame!==null)view.cancelAnimationFrame(frame);
+    frame=null;
+    resize.disconnect();theme.disconnect();columns.clear();nodes.clear();
+    view.removeEventListener('resize',schedule);
+    view.removeEventListener('beforeprint',beforePrint);view.removeEventListener('afterprint',afterPrint);
+    for(const query of media)query.removeEventListener('change',schedule);
+    fonts?.removeEventListener('loadingdone',schedule);
+    mathBrowserDocuments.delete(doc);
+  }};
+  mathBrowserDocuments.set(doc,state);
+  return state;
+}
+
 function mathObserve(root) {
-  const doc=root?.ownerDocument || root,view=doc?.defaultView;
-  if(!view)return ()=>{};
-  let state=mathBrowserDocuments.get(doc);
-  if(!state) {
-    const nodes=new Map(),columns=new Set();let frame=0,printing=false;
-    const refresh=()=> {
-      frame=0;
-      for(const [svg,column] of nodes) {
-        if(!svg.isConnected) {nodes.delete(svg);continue;}
-        const next=mathFitElement(svg,printing);if(next)nodes.set(svg,next);
-      }
-      const wanted=new Set(nodes.values());
-      for(const column of columns)if(!wanted.has(column)) {resize.unobserve(column);columns.delete(column);}
-      for(const column of wanted)if(!columns.has(column)) {resize.observe(column);columns.add(column);}
-    };
-    const schedule=()=>{if(!frame)frame=view.requestAnimationFrame(refresh);};
-    const resize=new view.ResizeObserver(schedule),theme=new view.MutationObserver(records=>{
-      if(records.some(({target})=>[...nodes.keys()].some(svg=>target!==svg && target.contains(svg))))schedule();
-    });
-    theme.observe(doc.documentElement,{subtree:true,attributes:true,attributeFilter:['class','style','data-rapier-theme','data-md-theme']});
-    view.addEventListener('resize',schedule,{passive:true});
-    view.addEventListener('beforeprint',()=>{printing=true;refresh();});view.addEventListener('afterprint',()=>{printing=false;schedule();});
-    for(const query of ['(forced-colors: active)','(prefers-contrast: more)','(prefers-color-scheme: dark)'])view.matchMedia(query).addEventListener('change',schedule);
-    doc.fonts?.addEventListener('loadingdone',schedule);
-    state={nodes,schedule};mathBrowserDocuments.set(doc,state);
-  }
-  const nodes=mathElements(root);
-  for(const svg of nodes)state.nodes.set(svg,mathColumn(svg));
+  const doc=root?.ownerDocument || root;
+  if(!doc?.defaultView)return ()=>{};
+  let owned=mathElements(root);
+  if(!owned.length)return ()=>{};
+  let state=mathBrowserDocuments.get(doc) || mathObserveDocument(doc);
+  // Each returned cleanup owns its subscription, including overlap and detached nodes.
+  for(const svg of owned)state.nodes.set(svg,(state.nodes.get(svg) || 0)+1);
   state.schedule();
-  return ()=>{for(const svg of nodes)state.nodes.delete(svg);state.schedule();};
+  return ()=>{
+    if(!owned)return;
+    const current=state;state=null;
+    for(const svg of owned) {
+      const remaining=current.nodes.get(svg)-1;
+      if(remaining)current.nodes.set(svg,remaining);else current.nodes.delete(svg);
+    }
+    owned=null;
+    if(current.nodes.size)current.schedule();else current.dispose();
+  };
 }

package/src/math/build-font.py

@@ -257,21 +257,39 @@ def edge_profile(glyph_set, name):
     return [first, *([math.floor(min(strip) - 1e-7), math.ceil(max(strip) + 1e-7)] if strip else None for strip in strips)]
 
 
-def pack_paths(glyphs, profiles):
-    """Store exact coordinate deltas, sharing matching outline structures."""
-    output = bytearray()
+PAGE_BYTES = 16384
+PAGE_STRIDE = 32768
+PARENT_DEPTH = 4
+SCALAR_MAPS = ("chars", "dotless", "flatAccents", "extendedShapes")
+
+
+def pack_font(data):
+    """Share translated contours and retain independently inflatable record pages."""
+    glyphs, profiles = data["glyphs"], data["edgeProfiles"]
+    commands = "MLHVCZ"
+    lengths = (2, 2, 1, 1, 6, 0)
 
     def unsigned(value, target):
+        if value < 0 or value > 2**53 - 1:
+            raise ValueError("Font integer exceeds exact JavaScript arithmetic")
         while value >= 128:
             target.append((value & 127) | 128)
             value >>= 7
         target.append(value)
 
     def signed(value, target):
-        unsigned(value * 2 if value >= 0 else -value * 2 - 1, target)
+        value = value * 2 if value >= 0 else -value * 2 - 1
+        if value > 2**53 - 1:
+            raise ValueError("Font integer exceeds exact JavaScript arithmetic")
+        if value < 240:
+            target.append(value)
+        elif value < 4080:
+            value -= 240
+            target.extend((240 + (value >> 8), value & 255))
+        else:
+            target.append(255)
+            unsigned(value - 4080, target)
 
-    commands = "MLHVCZ"
-    lengths = (2, 2, 1, 1, 6, 0)
     paths = [re.findall(r"[MLHVCZ]|-?\d+(?:\.\d+)?", glyph[7]) for glyph in glyphs]
     unit = 1
     for glyph, tokens in zip(glyphs, paths):
@@ -280,21 +298,27 @@ def pack_paths(glyphs, profiles):
         for token in tokens:
             if "." in token:
                 unit = math.lcm(unit, Fraction(token).denominator)
-    unsigned(unit, output)
-    unsigned(len(glyphs), output)
-    metric_unit = math.lcm(*(Fraction(value).denominator for glyph in glyphs for value in glyph[:7]))
-    unsigned(metric_unit, output)
-    previous_metrics = [0] * 7
-    for glyph in glyphs:
-        for index, value in enumerate(glyph[:7]):
-            value = int(value * metric_unit)
-            signed(value - previous_metrics[index], output)
-            previous_metrics[index] = value
-    structures = {}
-    for glyph_index, (glyph, tokens) in enumerate(zip(glyphs, paths)):
-        cursor = 0
-        segments = []
-        previous = None
+    metric_unit = math.lcm(2, *(Fraction(value).denominator for glyph in glyphs for value in glyph[:7]))
+    metrics = [[int(value * metric_unit) for value in glyph[:7]] for glyph in glyphs]
+    for values in metrics:
+        values[3] -= values[0] - values[1]
+        values[6] -= values[0] // 2
+    metric_bases = [sorted(values[column] for values in metrics)[len(metrics) // 2] for column in range(7)]
+    contours, contour_ids, references = [], {}, []
+    for tokens in paths:
+        cursor, previous = 0, None
+        structure, coordinates, refs = [], [], []
+        first_x = first_y = x = y = 0
+
+        def keep_contour():
+            if not structure:
+                return
+            key = bytes(structure), tuple(coordinates)
+            if key not in contour_ids:
+                contour_ids[key] = len(contours)
+                contours.append(key)
+            refs.append((contour_ids[key], first_x, first_y))
+
         while cursor < len(tokens):
             if tokens[cursor] in commands:
                 command = commands.index(tokens[cursor])
@@ -303,52 +327,70 @@ def pack_paths(glyphs, profiles):
                 command = 1 if previous == 0 else previous
             else:
                 raise ValueError("Font path has an invalid repeated command")
-            length = lengths[command]
-            values = [int(Fraction(value) * unit) if "." in value else int(value) * unit for value in tokens[cursor:cursor + length]]
-            if len(values) != length:
+            count = lengths[command]
+            values = [int(Fraction(value) * unit) for value in tokens[cursor:cursor + count]]
+            if len(values) != count:
                 raise ValueError("Font path has an incomplete command")
             if any(abs(value) * 4 > 2**53 - 1 for value in values):
-                raise ValueError("Font coordinates exceed exact JavaScript integer arithmetic")
-            cursor += length
-            segments.append((command, values))
+                raise ValueError("Font coordinates exceed exact JavaScript arithmetic")
+            cursor += count
+            if command == 0:
+                keep_contour()
+                structure, coordinates = [], []
+                first_x, first_y = x, y = values
+            else:
+                if previous is None:
+                    raise ValueError("Font contour does not begin with a move")
+                structure.append(command)
+                for index, value in enumerate(values):
+                    if command == 3 or (command not in (2, 3) and index % 2):
+                        coordinates.append(value - y)
+                        y = value
+                    else:
+                        coordinates.append(value - x)
+                        x = value
+                if command == 5:
+                    x, y = first_x, first_y
             previous = command
+        keep_contour()
+        references.append(refs)
+
+    contour_records, shapes, depths = [], {}, []
+    for contour_id, (structure, coordinates) in enumerate(contours):
         record = bytearray()
-        unsigned(len(segments) * 2, record)
-        x = y = first_x = first_y = 0
-        for command, values in segments:
-            record.append(command)
-            for index, value in enumerate(values):
-                if command == 3 or (command not in (2, 3) and index % 2):
-                    signed(value - y, record)
-                    y = value
-                else:
-                    signed(value - x, record)
-                    x = value
-            if command == 0:
-                first_x, first_y = x, y
-            elif command == 5:
-                x, y = first_x, first_y
-        structure = bytes(command for command, _ in segments)
-        coordinates = tuple(value for _, values in segments for value in values)
-        candidates = structures.setdefault(structure, [])
-        for parent, previous_coordinates in candidates:
+        unsigned(len(structure) * 2, record)
+        record.extend(structure)
+        for value in coordinates:
+            signed(value, record)
+        # Small residuals compress better even when their first encoding costs another byte.
+        best = (len(record) + sum(abs(value).bit_length() for value in coordinates), len(record))
+        parent_depth = -1
+        for parent, previous_coordinates in shapes.setdefault(structure, []):
+            if depths[parent] >= PARENT_DEPTH:
+                continue
             shared = bytearray()
             unsigned(parent * 2 + 1, shared)
-            for value, previous in zip(coordinates, previous_coordinates):
-                signed(value - previous, shared)
-                if len(shared) >= len(record):
-                    break
-            if len(shared) < len(record):
-                record = shared
-        candidates.append((glyph_index, coordinates))
-        output.extend(record)
-        glyph[7] = ""
-    unsigned(len(profiles), output)
-    previous_id = -1
-    profile_shapes = {}
+            residuals = [value - previous_value for value, previous_value in zip(coordinates, previous_coordinates)]
+            for value in residuals:
+                signed(value, shared)
+            score = (len(shared) + sum(abs(value).bit_length() for value in residuals), len(shared))
+            if score < best:
+                best = score
+                record, parent_depth = shared, depths[parent]
+        depths.append(parent_depth + 1)
+        shapes[structure].append((contour_id, coordinates))
+        contour_records.append(record)
+
+    profile_records, profile_ids, profile_shapes, profile_depths = [], {}, {}, []
+    profile_values = {}
     for glyph_id, profile in sorted(profiles.items()):
-        unsigned(glyph_id - previous_id - 1, output)
-        previous_id = glyph_id
+        key = profile[0], tuple(None if strip is None else tuple(strip) for strip in profile[1:])
+        if key in profile_values:
+            profile_ids[glyph_id] = profile_values[key]
+            continue
+        profile_id = len(profile_records)
+        profile_ids[glyph_id] = profile_id
+        profile_values[key] = profile_id
         record = bytearray()
         unsigned((len(profile) - 1) * 2, record)
         signed(profile[0], record)
@@ -362,7 +404,10 @@ def pack_paths(glyphs, profiles):
             signed(strip[1] - right, record)
             left, right = strip
         shape = profile[0], tuple(strip is not None for strip in profile[1:])
+        parent_depth = -1
         for parent_id, parent in profile_shapes.setdefault(shape, []):
+            if profile_depths[parent_id] >= PARENT_DEPTH:
+                continue
             shared = bytearray()
             unsigned(parent_id * 2 + 1, shared)
             left = right = 0
@@ -376,18 +421,80 @@ def pack_paths(glyphs, profiles):
                 if len(shared) >= len(record):
                     break
             if len(shared) < len(record):
-                record = shared
-        profile_shapes[shape].append((glyph_id, profile))
-        output.extend(record)
-    packed = zlib.compress(output, level=9, wbits=-15)
-    return base64.b64encode(packed).decode("ascii"), len(output)
+                record, parent_depth = shared, profile_depths[parent_id]
+        profile_depths.append(parent_depth + 1)
+        profile_shapes[shape].append((profile_id, profile))
+        profile_records.append(record)
+
+    glyph_records = []
+    for glyph_id, (values, refs) in enumerate(zip(metrics, references)):
+        record = bytearray()
+        for value, base in zip(values, metric_bases):
+            signed(value - base, record)
+        unsigned(profile_ids.get(glyph_id, -1) + 1, record)
+        unsigned(len(refs), record)
+        for contour_id, x, y in refs:
+            unsigned(contour_id, record)
+            signed(x, record)
+            signed(y, record)
+        glyph_records.append(record)
+
+    pages, indices = [], bytearray()
+    unsigned(unit, indices)
+    unsigned(metric_unit, indices)
+    for value in metric_bases:
+        signed(value, indices)
+    for name in SCALAR_MAPS:
+        unsigned(len(data[name]), indices)
+        previous_key = previous_value = 0
+        for key, value in sorted(data[name].items()):
+            unsigned(key - previous_key, indices)
+            signed(value - previous_value, indices)
+            previous_key, previous_value = key, value
+    unsigned(len(data["scriptAlternates"]), indices)
+    previous_key, previous_values = 0, [0, 0]
+    for key, values in sorted(data["scriptAlternates"].items()):
+        unsigned(key - previous_key, indices)
+        previous_key = key
+        unsigned(len(values), indices)
+        for index, value in enumerate(values):
+            signed(value - previous_values[index], indices)
+            previous_values[index] = value
+    for records in (glyph_records, contour_records, profile_records):
+        page, offsets = bytearray(), []
+        for record in records:
+            if len(record) > PAGE_BYTES:
+                raise ValueError("Font record exceeds its independent page bound")
+            if len(page) + len(record) > PAGE_BYTES:
+                pages.append(bytes(page))
+                page = bytearray()
+            offsets.append(len(pages) * PAGE_STRIDE + len(page))
+            page.extend(record)
+        offsets.append(len(pages) * PAGE_STRIDE + len(page))
+        pages.append(bytes(page))
+        unsigned(len(offsets), indices)
+        previous = 0
+        for offset in offsets:
+            unsigned(offset - previous, indices)
+            previous = offset
+
+    def compressed(data):
+        return base64.b64encode(zlib.compress(data, level=9, wbits=-15)).decode("ascii")
+
+    packed = [(len(page), compressed(page)) for page in pages]
+    return packed, compressed(indices), len(indices), {
+        "contours": len(contours), "contourReferences": sum(map(len, references)), "profileRecords": len(profile_records),
+        "pages": len(pages), "pageBytes": PAGE_BYTES, "indexBytes": len(indices),
+        "recordBytes": sum(map(len, pages)), "maxParentDepth": PARENT_DEPTH,
+    }
 
 
 PATH_DECODER = """{
-const source=Uint8Array.from(atob(__PATHS__),value=>value.charCodeAt(0)),bytes=new Uint8Array(__SIZE__);
-let position=0,held=0,available=0,written=0,cursor=0;
-const invalid=()=>{throw new Error('Invalid math font data');};
-const fill=count=>{while(available<count&&position<source.length){held|=source[position++]<<available;available+=8;}};
+// The font owns immutable pages and bounded hot records. No document data enters these caches.
+const pages=__PAGES__,invalid=()=>{throw new Error('Invalid math font data');};
+const inflate=(encoded,size)=>{
+const source=atob(encoded),bytes=new Uint8Array(size);let position=0,held=0,available=0,written=0;
+const fill=count=>{while(available<count&&position<source.length){held|=source.charCodeAt(position++)<<available;available+=8;}};
 const bits=count=>{fill(count);if(available<count)invalid();const value=held&((1<<count)-1);held>>>=count;available-=count;return value;};
 const tree=lengths=>{const width=Math.max(...lengths),counts=new Uint16Array(width+1),next=new Uint16Array(width+1),table=new Uint16Array(1<<width);
 for(const length of lengths)if(length)counts[length]++;let code=0;
@@ -414,31 +521,64 @@ const code=value-257,extra=code<8?0:(code>>>2)-1,length=code===28?258:code<8?cod
 const offset=symbol(distance);if(offset>29)invalid();const shift=offset<4?0:(offset>>>1)-1,back=offset<4?offset+1:((offset&1)+2)*2**shift+1+bits(shift);
 if(back>written||written+length>bytes.length)invalid();for(let i=0;i<length;i++){bytes[written]=bytes[written-back];written++;}}
 }
-if(written!==bytes.length)invalid();
-const unsigned=()=>{let value=0,shift=0,byte;do{if(cursor>=bytes.length||shift>49)invalid();byte=bytes[cursor++];value+=(byte&127)*2**shift;shift+=7;}while(byte&128);return value;};
-const unit=unsigned();if(!unit)invalid();
-const signed=()=>{const value=unsigned();return value&1?-(value+1)/2:value/2;};
-const glyphCount=unsigned(),metricUnit=unsigned(),metrics=Array(7).fill(0);if(!metricUnit)invalid();
-for(let i=0;i<glyphCount;i++){const glyph=[];for(let j=0;j<7;j++){metrics[j]+=signed();glyph.push(metrics[j]/metricUnit);}glyph.push('');MATH_FONT.glyphs.push(glyph);}
-const commands='MLHVCZ',lengths=[2,2,1,1,6,0];
-for(const glyph of MATH_FONT.glyphs){const header=unsigned();
-if(header&1){glyph[7]=MATH_FONT.glyphs[header>>>1][7].replace(/-?\\d+(?:\\.\\d+)?/g,value=>(Math.round(Number(value)*unit)+signed())/unit);continue;}
-let x=0,y=0,firstX=0,firstY=0,path='';const count=header>>>1;
-for(let segment=0;segment<count;segment++){const command=bytes[cursor++];if(command>5)invalid();path+=commands[command];
-for(let index=0;index<lengths[command];index++){if(index)path+=' ';if(command===3||(command!==2&&command!==3&&index%2)){y+=signed();path+=y/unit;}else{x+=signed();path+=x/unit;}}
-if(command===0){firstX=x;firstY=y;}else if(command===5){x=firstX;y=firstY;}}
-glyph[7]=path;}
-const profileCount=unsigned();let id=-1;
-for(let i=0;i<profileCount;i++){id+=unsigned()+1;const header=unsigned();let profile,left=0,right=0;
-if(header&1){const parent=MATH_FONT.edgeProfiles[header>>>1];if(!parent)invalid();profile=[parent[0]];
-for(const strip of parent.slice(1)){if(!strip){profile.push(null);continue;}left+=signed();right+=signed();profile.push([strip[0]+left,strip[1]+right]);}}
-else{profile=[signed()];for(let j=0;j<header>>>1;j++){const token=unsigned();if(!token){profile.push(null);continue;}const value=token-1;left+=value&1?-(value+1)/2:value/2;right+=signed();profile.push([left,right]);}}
-MATH_FONT.edgeProfiles[id]=profile;}
-if(cursor!==bytes.length)invalid();
+if(written!==bytes.length||position-Math.floor(available/8)!==source.length)invalid();return bytes;
+};
+const unsigned=r=>{let value=0,shift=0,byte;do{if(r[1]>=r[2]||shift>49)invalid();byte=r[0][r[1]++];value+=(byte&127)*2**shift;shift+=7;}while(byte&128);if(!Number.isSafeInteger(value))invalid();return value;};
+const signed=r=>{if(r[1]>=r[2])invalid();let value=r[0][r[1]++];if(value>=240){if(value===255){value=4080+unsigned(r);if(!Number.isSafeInteger(value))invalid();}else{if(r[1]>=r[2])invalid();value=240+(value-240)*256+r[0][r[1]++];}}return value%2?-(value+1)/2:value/2;};
+const complete=r=>{if(r[1]!==r[2])invalid();};
+const [unit,metricUnit,metricBases,glyphs,contours,profiles]=(()=>{
+const bytes=inflate(__INDEX__,__SIZE__),r=[bytes,0,bytes.length],unit=unsigned(r),metricUnit=unsigned(r);if(!unit||!metricUnit)invalid();const metricBases=Array.from({length:7},()=>signed(r));
+for(const name of __MAP_FIELDS__){const count=unsigned(r),map=MATH_FONT[name]={};if(count>bytes.length)invalid();let key=0,value=0;
+for(let i=0;i<count;i++){key+=unsigned(r);value+=signed(r);map[key]=value;}}
+const scripts=MATH_FONT.scriptAlternates={},scriptCount=unsigned(r),previous=[0,0];let key=0;if(scriptCount>bytes.length)invalid();
+for(let i=0;i<scriptCount;i++){key+=unsigned(r);const count=unsigned(r);if(count<1||count>2)invalid();const values=[];for(let j=0;j<count;j++){previous[j]+=signed(r);values.push(previous[j]);}scripts[key]=values;}
+const tables=Array.from({length:3},()=>{const count=unsigned(r);if(count<1||count>bytes.length)invalid();const offsets=new Uint32Array(count);let previous=0;
+for(let i=0;i<count;i++){previous+=unsigned(r);if(previous>=pages.length*32768)invalid();offsets[i]=previous;}return offsets;});complete(r);return [unit,metricUnit,metricBases,...tables];
+})();
+const pageCache=new Map(),glyphCache=new Map(),profileCache=new Map();
+const remember=(cache,id,value,limit)=>{if(cache.size>=limit)cache.delete(cache.keys().next().value);cache.set(id,value);return value;};
+const touch=(cache,id)=>{const value=cache.get(id);if(value!==undefined){cache.delete(id);cache.set(id,value);}return value;};
+const record=(offsets,id)=>{
+if(!Number.isInteger(id)||id<0||id+1>=offsets.length)return;
+const offset=offsets[id],page=offset>>>15,next=offsets[id+1];let bytes=touch(pageCache,page);
+if(!bytes){const source=pages[page];if(!source||source[0]>16384)invalid();bytes=remember(pageCache,page,inflate(source[1],source[0]),8);}
+const begin=offset&32767,end=next>>>15===page?next&32767:bytes.length;if(begin>=end||end>bytes.length)invalid();return [bytes,begin,end];
+};
+const commandLengths=[2,2,1,1,6,0],commandNames='MLHVCZ';
+const contour=(id,local,depth=0)=>{
+if(local.has(id))return local.get(id);if(depth>4)invalid();const r=record(contours,id);if(!r)invalid();const header=unsigned(r);let commands,coordinates;
+if(header%2){const parentId=Math.floor(header/2);if(parentId>=id)invalid();const parent=contour(parentId,local,depth+1);commands=parent[0];coordinates=new Float64Array(parent[1].length);
+for(let i=0;i<coordinates.length;i++)coordinates[i]=parent[1][i]+signed(r);}
+else{const count=header/2;if(r[1]+count>r[2])invalid();commands=r[0].subarray(r[1],r[1]+count);r[1]+=count;let values=0;
+for(const command of commands){if(command<1||command>5)invalid();values+=commandLengths[command];}if(values>r[2]-r[1])invalid();coordinates=new Float64Array(values);
+for(let i=0;i<values;i++)coordinates[i]=signed(r);}
+complete(r);const value=[commands,coordinates];local.set(id,value);return value;
+};
+const glyphRecord=id=>{
+let cached=touch(glyphCache,id);if(cached)return cached;const r=record(glyphs,id);if(!r)return;
+const glyph=[];for(let i=0;i<7;i++)glyph.push(signed(r)+metricBases[i]);glyph[3]+=glyph[0]-glyph[1];glyph[6]+=glyph[0]/2;for(let i=0;i<7;i++)glyph[i]/=metricUnit;const profile=unsigned(r)-1,count=unsigned(r),local=new Map();let path='';
+if(profile>=profiles.length-1||count>r[2]-r[1])invalid();
+for(let part=0;part<count;part++){const id=unsigned(r),firstX=signed(r),firstY=signed(r),[commands,coordinates]=contour(id,local);let x=firstX,y=firstY,cursor=0;
+path+='M'+x/unit+' '+y/unit;
+for(const command of commands){path+=commandNames[command];for(let index=0;index<commandLengths[command];index++){if(index)path+=' ';
+if(command===3||(command!==2&&command!==3&&index%2)){y+=coordinates[cursor++];path+=y/unit;}else{x+=coordinates[cursor++];path+=x/unit;}}
+if(command===5){x=firstX;y=firstY;}}
+}complete(r);glyph.push(path);cached={glyph,profile};return remember(glyphCache,id,cached,256);
+};
+const profileRecord=(id,depth=0)=>{
+const cached=touch(profileCache,id);if(cached)return cached;if(depth>4)invalid();const r=record(profiles,id);if(!r)invalid();const header=unsigned(r);let profile,left=0,right=0;
+if(header%2){const parentId=Math.floor(header/2);if(parentId>=id)invalid();const parent=profileRecord(parentId,depth+1);profile=[parent[0]];
+for(let i=1;i<parent.length;i++){const strip=parent[i];if(!strip){profile.push(null);continue;}left+=signed(r);right+=signed(r);profile.push([strip[0]+left,strip[1]+right]);}}
+else{profile=[signed(r)];const count=header/2;if(count>r[2]-r[1])invalid();for(let i=0;i<count;i++){const token=unsigned(r);if(!token){profile.push(null);continue;}const value=token-1;left+=value%2?-(value+1)/2:value/2;right+=signed(r);profile.push([left,right]);}}
+complete(r);return remember(profileCache,id,profile,128);
+};
+MATH_FONT.glyph=id=>glyphRecord(id)?.glyph;
+MATH_FONT.profile=id=>{const glyph=glyphRecord(id);return glyph&&glyph.profile>=0?profileRecord(glyph.profile):undefined;};
 }
 """
 
 
+
 def main():
     parser = argparse.ArgumentParser(description=__doc__)
     parser.add_argument("--font", type=Path, help="Optional pinned source font; otherwise fetch it")
@@ -464,16 +604,18 @@ def main():
               "The font authors do not maintain this conversion.\n"
               "Complete original work: https://mirrors.ctan.org/fonts/lm-math.zip\n"
               "Conversion details: FONT-SOURCE.md.\n\n").encode("utf-8") + gust + b"\n" + lppl
-    paths, size = pack_paths(data["glyphs"], data["edgeProfiles"])
+    pages, index, size, packing = pack_font(data)
     glyph_count = len(data["glyphs"])
     profile_count = len(data["edgeProfiles"])
-    data["glyphs"] = []
-    data["edgeProfiles"] = {}
-    output = (b"/*!\n" + notice + b"\n*/\nconst MATH_FONT=" + json.dumps(data, ensure_ascii=True, separators=(",", ":")).encode("utf-8") + b";\n" + PATH_DECODER.replace("__PATHS__", json.dumps(paths)).replace("__SIZE__", str(size)).encode("utf-8"))
+    character_count = len(data["chars"])
+    del data["glyphs"], data["edgeProfiles"]
+    for name in (*SCALAR_MAPS, "scriptAlternates"):
+        del data[name]
+    output = (b"/*!\n" + notice + b"\n*/\nconst MATH_FONT=" + json.dumps(data, ensure_ascii=True, separators=(",", ":")).encode("utf-8") + b";\n" + PATH_DECODER.replace("__PAGES__", json.dumps(pages, separators=(",", ":"))).replace("__INDEX__", json.dumps(index)).replace("__SIZE__", str(size)).replace("__MAP_FIELDS__", json.dumps(SCALAR_MAPS, separators=(",", ":"))).encode("utf-8"))
     args.out.parent.mkdir(parents=True, exist_ok=True)
     args.out.write_bytes(output)
     args.out.with_name("FONT-LICENSE.txt").write_bytes(notice)
-    print(json.dumps({"sourceSha256": hashlib.sha256(font_bytes).hexdigest(), "licenseSha256": hashlib.sha256(notice).hexdigest(), "glyphs": glyph_count, "characters": len(data["chars"]), "edgeProfiles": profile_count, "bytes": len(output), "gzipBytes": len(gzip.compress(output, compresslevel=9, mtime=0))}, indent=2))
+    print(json.dumps({"sourceSha256": hashlib.sha256(font_bytes).hexdigest(), "licenseSha256": hashlib.sha256(notice).hexdigest(), "glyphs": glyph_count, "characters": character_count, "edgeProfiles": profile_count, "packing": packing, "bytes": len(output), "gzipBytes": len(gzip.compress(output, compresslevel=9, mtime=0))}, indent=2))
 
 
 if __name__ == "__main__":

package/src/math/classic.d.ts

@@ -0,0 +1,4 @@
+// SPDX-License-Identifier: MIT
+import type API from './index.js';
+declare global {var RapierMath: typeof API;}
+export {};

package/src/math/delimiters.d.ts

@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: MIT
+export interface DelimiterOptions {singleDollar?: boolean; brackets?: boolean}
+export interface MathSpan {
+  start: number; end: number; bodyStart: number; bodyEnd: number;
+  open: string; close: string; displayMode: boolean;
+}
+/** Index a raw, host-owned text region. Does not parse Markdown or unescape source. */
+export function createMathMatcher(source: string, options?: DelimiterOptions): (start: number, limit?: number) => MathSpan | null;

package/src/math/delimiters.mjs

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: MIT
+// A boundary index for a host-owned text region, not a Markdown parser.
+export function createMathMatcher(source, {singleDollar = false, brackets = true} = {}) {
+  if (typeof source !== 'string') throw new TypeError('Math boundaries require source text.');
+  const markers = new Map(), next = Object.create(null);
+  let slashes = 0, line = 0;
+  for (let at = 0; at < source.length;) {
+    const char = source[at];
+    if (char === '\\') { slashes++; at++; continue; }
+    if (char === '\n' || char === '\r') line++;
+    if (char === '$') {
+      let end = at + 1;
+      while (source[end] === '$') end++;
+      const count = end - at;
+      if (!(slashes & 1) && (count === 2 || count === 1 && singleDollar))
+        markers.set(at, {at, marker: count === 2 ? '$$' : '$', line});
+      at = end;
+    } else {
+      if (brackets && slashes & 1 && '()[]'.includes(char))
+        markers.set(at - 1, {at: at - 1, marker: '\\' + char, line});
+      at++;
+    }
+    slashes = 0;
+  }
+  for (const entry of [...markers.values()].reverse()) {
+    const closing = entry.marker === '\\(' ? '\\)' : entry.marker === '\\[' ? '\\]' : entry.marker;
+    entry.close = next[closing];
+    next[entry.marker] = entry;
+  }
+  return function match(start, limit = source.length) {
+    const open = markers.get(start), close = open?.close;
+    if (!close || open.marker === '\\)' || open.marker === '\\]' || close.at + close.marker.length > limit) return null;
+    const bodyStart = start + open.marker.length, bodyEnd = close.at;
+    if (open.marker === '$' && (open.line !== close.line || bodyStart === bodyEnd ||
+        /\s/.test(source[bodyStart]) || /\s/.test(source[bodyEnd - 1]) || /[0-9]/.test(source[bodyEnd + 1] || ''))) return null;
+    return {start, end: bodyEnd + close.marker.length, bodyStart, bodyEnd,
+      open: open.marker, close: close.marker, displayMode: open.marker === '$$' || open.marker === '\\['};
+  };
+}

package/src/math/examples/README.md

@@ -0,0 +1,25 @@
+# Run the installed examples
+
+From a consumer directory, install `rapier-math`, then run
+`node node_modules/rapier-math/examples/formula.mjs`.
+
+For Markdown and streaming, also install `markdown-it` and run `markdown.mjs` or `stream.mjs`.
+For unified, install `unified remark-parse remark-math remark-rehype rehype-sanitize rehype-stringify hast-util-from-html`
+and run `unified.mjs`. The remark example uses remark's syntax; it does not recognize backslash delimiters.
+
+Serve the package directory over HTTP and open `examples/browser.html`. Its external module imports the
+installed ESM renderer, fits the output and releases observation before replacement and on page exit.
+Start `new Worker('./worker.mjs', {type: 'module'})` from this directory and post `{id, source}`.
+Use an id owned by the current message and ignore stale replies. Workers render SVG; they do not call `observe`.
+
+`react.tsx` is a small React 19/SSR component to copy into an existing TypeScript application. Install
+`react react-dom` and the development types `@types/react @types/react-dom`. No framework is required by the core.
+
+For streamed UTF-8, use `TextDecoderStream` or `decoder.decode(bytes, {stream: true})` and flush the decoder
+at EOF. Feed decoded strings into one stream per message. Append incoming chunks to a text node for immediate
+literal progress, and replace the whole preview when `write` returns a snapshot. Replace it with `finish()` at EOF.
+Do not concatenate transport data into HTML. On cancellation call `abort`; on replacement cancel the old producer
+before `reset`. A producer that still runs needs its own generation check before calling `write`.
+
+The examples retain the original source as the editable/copyable authority. Markdown hosts can normalize
+newlines or escapes in their syntax nodes; an HTML serialization is not an exact source archive.

package/src/math/examples/browser.html

@@ -0,0 +1,10 @@
+<!doctype html>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width">
+<meta http-equiv="Content-Security-Policy" content="default-src 'none'; script-src 'self'; style-src-attr 'unsafe-inline'; style-src-elem 'none'; worker-src 'self'; connect-src 'none'; base-uri 'none'">
+<title>Rapier Math example</title>
+<label>TeX <textarea id="source">\frac{-b\pm\sqrt{b^2-4ac}}{2a}</textarea></label>
+<button id="render" type="button">Render</button>
+<main id="equation"></main>
+<pre id="errors"></pre>
+<script type="module" src="./browser.mjs"></script>