fix: Performance improvement (#707)

- Improve caching: generating images with the same font buffer will
re-use the parsed font file;
- Improve caching: avoid re-computing paths of the same glyph in one
pass (this is highly inspired by @NiteshSingh17's work in #679).

```
clk: ~4.15 GHz
cpu: Apple M4 Pro
runtime: node 22.13.1 (arm64-darwin)

benchmark                   avg (min … max) p75 / p99    (min … top 1%)
------------------------------------------- -------------------------------
satori                         3.88 ms/iter   4.07 ms  █                   
                        (3.40 ms … 7.24 ms)   6.00 ms  █▅ ▆ ▃              
                    (  3.63 mb …  11.83 mb)   6.76 mb ███████▄▄▂▂▂▂▁▁▂▁▂▁▁▂

satori + resvg                31.76 ms/iter  32.07 ms █  █               █ 
                      (31.31 ms … 32.50 ms)  32.21 ms █▅▅█▅ ▅ ▅▅   ▅▅  ▅▅█▅
                    (  6.78 mb …   6.82 mb)   6.79 mb █████▁█▁██▁▁▁██▁▁████

satori + sharp                14.30 ms/iter  14.36 ms     █ ▅█             
                      (13.95 ms … 15.21 ms)  15.11 ms   ███▆██             
                    (  6.80 mb …   6.92 mb)   6.83 mb █▁████████▄▁▁▄▁▁▄▁▁▁▄

summary
  satori
   3.69x faster than satori + sharp
   8.19x faster than satori + resvg
```

Before this change:

```
satori                         4.06 ms/iter   4.29 ms  █                   
                        (3.47 ms … 7.41 ms)   6.48 ms ▅█▅▆▆ ▃              
                    (  3.57 mb …  11.78 mb)   6.60 mb ███████▄▆▄▂▁▂▁▂▁▂▂▁▁▂
```

It's a ~7% change in P99.

Author: shuding

src/font.ts

@@ -87,6 +87,11 @@ function compareFont(
   return -1
 }
 
+const cachedParsedFont = new WeakMap<
+  Buffer | ArrayBuffer,
+  opentype.Font | null | undefined
+>()
+
 export default class FontLoader {
   defaultFont: opentype.Font
   fonts = new Map<string, [opentype.Font, Weight?, FontStyle?][]>()
@@ -143,30 +148,37 @@ export default class FontLoader {
         )
       }
       const _lang = lang ?? SUFFIX_WHEN_LANG_NOT_SET
-      const font = opentype.parse(
-        // Buffer to ArrayBuffer.
-        'buffer' in data
-          ? data.buffer.slice(
-              data.byteOffset,
-              data.byteOffset + data.byteLength
-            )
-          : data,
-        // @ts-ignore
-        { lowMemory: true }
-      )
+      let font
 
-      // Modify the `charToGlyphIndex` method, so we can know which char is
-      // being mapped to which glyph.
-      const originalCharToGlyphIndex = font.charToGlyphIndex
-      font.charToGlyphIndex = (char) => {
-        const index = originalCharToGlyphIndex.call(font, char)
-        if (index === 0) {
-          // The current requested char is missing a glyph.
-          if ((font as any)._trackBrokenChars) {
-            ;(font as any)._trackBrokenChars.push(char)
+      if (cachedParsedFont.has(data)) {
+        font = cachedParsedFont.get(data)
+      } else {
+        font = opentype.parse(
+          // Buffer to ArrayBuffer.
+          'buffer' in data
+            ? data.buffer.slice(
+                data.byteOffset,
+                data.byteOffset + data.byteLength
+              )
+            : data,
+          // @ts-ignore
+          { lowMemory: true }
+        )
+        // Modify the `charToGlyphIndex` method, so we can know which char is
+        // being mapped to which glyph.
+        const originalCharToGlyphIndex = font.charToGlyphIndex
+        font.charToGlyphIndex = (char) => {
+          const index = originalCharToGlyphIndex.call(font, char)
+          if (index === 0) {
+            // The current requested char is missing a glyph.
+            if ((font as any)._trackBrokenChars) {
+              ;(font as any)._trackBrokenChars.push(char)
+            }
           }
+          return index
         }
-        return index
+
+        cachedParsedFont.set(data, font)
       }
 
       // We use the first font as the default font fallback.
@@ -494,11 +506,53 @@ export default class FontLoader {
       if (fontSize === 0) {
         return ''
       }
-      return font
-        .getPath(content.replace(/\n/g, ''), left, top, fontSize, {
-          letterSpacing: letterSpacing / fontSize,
-        })
-        .toPathData(1)
+
+      const fullPath = new opentype.Path()
+
+      const options = {
+        letterSpacing: letterSpacing / fontSize,
+      }
+
+      const cachedPath = new WeakMap<
+        opentype.Glyph,
+        [number, number, opentype.Path]
+      >()
+
+      font.forEachGlyph(
+        content.replace(/\n/g, ''),
+        left,
+        top,
+        fontSize,
+        options,
+        function (glyph, gX, gY, gFontSize) {
+          let glyphPath: opentype.Path
+          if (!cachedPath.has(glyph)) {
+            glyphPath = glyph.getPath(gX, gY, gFontSize, options)
+            cachedPath.set(glyph, [gX, gY, glyphPath])
+          } else {
+            const [_x, _y, _glyphPath] = cachedPath.get(glyph)
+            glyphPath = new opentype.Path()
+            glyphPath.commands = _glyphPath.commands.map((command) => {
+              const movedCommand = { ...command }
+              for (let k in movedCommand) {
+                if (typeof movedCommand[k] === 'number') {
+                  if (k === 'x' || k === 'x1' || k === 'x2') {
+                    movedCommand[k] += gX - _x
+                  }
+                  if (k === 'y' || k === 'y1' || k === 'y2') {
+                    movedCommand[k] += gY - _y
+                  }
+                }
+              }
+              return movedCommand
+            })
+          }
+
+          fullPath.extend(glyphPath)
+        }
+      )
+
+      return fullPath.toPathData(1)
     } finally {
       unpatch()
     }