update: 2.6.18 fix: patch opentype.js cmap Format 4 table overflow bug

fix: resolve cmap Format 4 table overflow in large font generation

opentype.js exhibits a critical overflow bug when processing fonts with
8000+ drawing glyphs. The cmap Format 4 segment generator lacks consecutive
segment merging logic, creating isolated segments for each Unicode codepoint.

When character count exceeds approximately 8192, the cumulative table length
calculation produces values exceeding the uint16 maximum (65535 bytes). The
Format 4 length field, defined as uint16, silently truncates on overflow.
Windows font parsers detect the length mismatch between the declared header
value and actual physical data offset, treating the entire font as corrupted
and rejecting it during parsing.

The root cause lies in the cmap.make algorithm operating within a closure,
making direct external patching unfeasible. Segment sorting occurs prior to
binary serialization but provides no opportunity for deduplication.

Implement segment merging via Array.prototype.sort interception during the
Font.prototype.toTables lifecycle. This technique:
- Intercepts sort operations on the segment array post-sort, pre-serialization
- Merges consecutive segments where curr.start equals prev.end + 1 and deltas
  are equal, reducing overall segment count proportionally to run lengths
- Restores original Array.sort after completion, avoiding side effects
- Operates at the optimal closure boundary without library modification

Testing confirms fonts with 8000+ glyphs now load correctly on Windows
platforms while maintaining backward compatibility with smaller fonts.

Author: mtsubs

app/index.html

@@ -21,7 +21,7 @@
   <link rel="alternate" hreflang="ar" href="https://subs.js.org/ass-subset/?lang=ar">
   <link rel="alternate" hreflang="x-default" href="https://subs.js.org/ass-subset/">
   <link rel="icon" type="image/jpeg" href="icons/icon-256.png">
-  <meta name="version" content="2.6.17">
+  <meta name="version" content="2.6.18">
   <meta property="og:type" content="website">
   <meta property="og:title" content="ASS Subsetter · Font Embedding for Subtitles">
   <meta property="og:description" content="Font embedding tool for ASS/SSA subtitles. Subset fonts to compress file size, or embed them fully. Perfect for complex subtitle typesetting with multiple font files.">

app/worker.js

@@ -2208,6 +2208,38 @@ self.onmessage = async function (e) {
         try {
           const path = (typeof OPENTYPE_PATH !== 'undefined') ? OPENTYPE_PATH : e.data.opentypePath;
           importScripts(path);
+          const applyCmapPatch = () => {
+            if (!self.opentype?.Font || self.opentype.Font.prototype._isPatched) return;
+            const origToTables = self.opentype.Font.prototype.toTables;
+            self.opentype.Font.prototype.toTables = function() {
+              const origSort = Array.prototype.sort;
+              Array.prototype.sort = function(cmp) {
+                const res = origSort.call(this, cmp);
+                if (this.length > 0 && 'start' in this[0] && 'end' in this[0] && 'delta' in this[0] && 'glyphIndex' in this[0]) {
+                  const comp = [];
+                  for (let i = 0; i < this.length; i++) {
+                    const curr = this[i];
+                    const prev = comp[comp.length - 1];
+                    if (prev && prev.end + 1 === curr.start && prev.delta === curr.delta) {
+                      prev.end = curr.end;
+                    } else {
+                      comp.push(curr);
+                    }
+                  }
+                  this.length = 0;
+                  for (let i = 0; i < comp.length; i++) this.push(comp[i]);
+                }
+                return res;
+              };
+              try {
+                return origToTables.call(this);
+              } finally {
+                Array.prototype.sort = origSort;
+              }
+            };
+            self.opentype.Font.prototype._isPatched = true;
+          };
+          applyCmapPatch();
         } catch (err) {
           self.postMessage({ type: 'error', id, error: 'Failed to load opentype.js: ' + err.message });
           return;