rapier-math 1.0.1 → 1.0.2

package/src/math/FONT-SOURCE.md

@@ -82,7 +82,7 @@ vertical axis. Measurements are in design units unless specified otherwise.
 | `units`, `xHeight` | Math units per em and nominal x-height. |
 | `textUnits`, `textXHeight` | Geist units per em and nominal x-height. |
 | `chars` | Decimal Unicode code point to glyph index. |
-| `glyphs` | `[advance, xMin, yMin, xMax, yMax, italicCorrection, topAccent, path]`. |
+| `glyph(id)` | Demand-decoded `[advance, xMin, yMin, xMax, yMax, italicCorrection, topAccent, path]`. Missing IDs return `undefined`. |
 | `constants` | All 56 original OpenType `MathConstants`; percentage constants remain percentages. |
 | `vertical`, `horizontal` | Glyph index to `{variants, assembly?}`. |
 | `variants` | `[glyphIndex, advanceMeasurement]` pairs in font order. |
@@ -94,7 +94,7 @@ vertical axis. Measurements are in design units unless specified otherwise.
 | `flatAccents`, `dotless` | Alternate glyph indices for `flac` and `dtls`. |
 | `extendedShapes` | Glyphs marked by `MathGlyphInfo.ExtendedShapeCoverage`. |
 | `edgeStep` | Height of each contour strip: 32 design units. |
-| `edgeProfiles` | Glyph index to `[y0, [xMin, xMax], null, ...]`; each following entry describes one strip. |
+| `profile(id)` | Demand-decoded `[y0, [xMin, xMax], null, ...]` for a glyph, or `undefined` when absent; each following entry describes one strip. |
 
 Outline bounds round outward to whole units. The outlines themselves are unchanged, including exact fractional
 coordinates if present. Missing italic corrections are zero; missing accent attachments use half the advance.
@@ -107,10 +107,36 @@ dotless forms. Entry `i + 1` bounds the original contour within `[y0 + i * edgeS
 with a small numerical guard. Profiles are derived spacing data; they do not replace outlines or pretend to be
 an original MATH kern table. Layout compares intersecting strips from both glyphs when placing scripts.
 
-Glyph metrics use signed coordinate deltas. Outlines share command structures and exact coordinate differences.
-Profiles share matching strip structures and encode edge differences. A final raw DEFLATE stream stores these
-bytes. The small synchronous decoder reconstructs the original arrays and SVG paths once, checking input and
-output bounds. It requires no network, font installation, font parser or platform font shaping at runtime.
+Character mappings, optical substitutions and record offsets occupy a compact index decoded at module load.
+Glyph metrics, outlines and contour profiles stay in independent raw DEFLATE pages until requested. Every page
+ends at a record boundary and contains at most 16,384 decoded bytes. The complete set of pages travels in the
+same asset; rare characters, stretch parts and optical forms require no additional download.
+
+Outlines share exactly matching contours after translation. The 8,115 ordered contour references use 4,970
+unique contour records. A record either stores its original command structure and relative coordinates, or
+exact differences from an earlier contour with the same structure. Parent chains have at most four links.
+The generator prefers small coordinate differences as well as short records, because the smallest initial
+record does not necessarily produce the smallest compressed page. Glyph assembly restores the original
+absolute `M/L/H/V/C/Z` paths, including contour order; existing outline-part consumers use those commands.
+
+Glyph metrics use reversible bearing and half-advance predictors with a median origin per metric field.
+They retain the complete original bounds, advance, italic and accent measurements. Signed record integers
+use zigzag values: values below 240 take one byte, the next 3,840 values take two bytes, and larger values use
+an escape followed by unsigned LEB128. The coordinate unit is exact; this encoding performs no quantization.
+
+Profiles retain the original left/right strip coordinates and exact differences from matching strip structures.
+Identical arrays share storage: all 1,187 glyph-to-profile mappings are represented by 1,080 unique records.
+The renderer only asks for profiles when side-script placement can use them.
+
+The font owns three bounded least-recently-used caches: eight inflated pages, 256 completed glyph records and
+128 contour profiles. Temporary parent coordinates and page views are discarded after a glyph is assembled;
+cached glyphs contain the completed path and metrics. Reusing an evicted record reconstructs the same data.
+These caches contain font data only. They retain no formula source, parse tree, layout result, SVG element or
+document. Returned internal records are read-only to consumers.
+
+The synchronous decoder checks compressed input, output size, record boundaries and parent depth. It requires
+no network, font installation, font parser or platform font shaping at runtime. `glyph` and `profile` are
+internal font accessors; the public parser and rendering API remain independent of this storage format.
 
 The format follows the [OpenType MATH specification](https://learn.microsoft.com/en-us/typography/opentype/spec/math)
 and [RFC 1951](https://www.rfc-editor.org/rfc/rfc1951). Three retained constants have no active consumer:

package/src/math/api.js

@@ -6,7 +6,8 @@ function mathSvg(box,source,error,utf16,options={}) {
   const viewBox=[left*1000,-height*1000,width*1000,(height+depth)*1000];
   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 svg='<svg xmlns="http://www.w3.org/2000/svg" role="img" aria-label="'+mathEscape(source)+'"'+
+  const escapedSource=mathEscape(source);
+  const svg='<svg xmlns="http://www.w3.org/2000/svg" role="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+'"':'')+
@@ -16,7 +17,7 @@ function mathSvg(box,source,error,utf16,options={}) {
     ' 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>'+mathEscape(source)+'</title>'+(error?'<desc>'+mathEscape(error.message)+'</desc>':'')+
+    '<title>'+escapedSource+'</title>'+(error?'<desc>'+mathEscape(error.message)+'</desc>':'')+
     '<g transform="scale(1000)">'+box.svg+'</g></svg>';
   return {svg,width,height,depth,lines:box.lines || 1,fitted:!!box.fitted,errors:error?[error]:[]};
 }
@@ -77,7 +78,7 @@ function renderMath(source,options={}) {
 }
 
 globalThis.RapierMath=Object.freeze({
-  version:'1.0.1',
+  version:'1.0.2',
   parse:parseMathTex,
   render:renderMath,
   fit:mathFit,

package/src/math/browser.js

@@ -116,35 +116,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__":