fix: upstream pull-requests

- foliojs/fontkit#311
- foliojs/fontkit#310
- foliojs/fontkit#305
- foliojs/fontkit#306
- foliojs/fontkit#307
- foliojs/fontkit#323
- foliojs/fontkit#341
- foliojs/fontkit#349
- foliojs/fontkit#352
- foliojs/fontkit#338

Author: chr33s

packages/fontkit/README.md

@@ -102,6 +102,7 @@ The following properties describe the general metrics of the font. See [here](ht
 * `underlinePosition` - the offset from the normal underline position that should be used
 * `underlineThickness` - the weight of the underline that should be used
 * `italicAngle` - if this is an italic font, the angle the cursor should be drawn at to match the font design
+* `lineHeight` - is the vertical space between adjacent lines (their baselines) of text, also known as leading. See [here](https://en.wikipedia.org/wiki/Leading) for more details.
 * `capHeight` - the height of capital letters above the baseline. See [here](http://en.wikipedia.org/wiki/Cap_height) for more details.
 * `xHeight`- the height of lower case letters. See [here](http://en.wikipedia.org/wiki/X-height) for more details.
 * `bbox` - the font’s bounding box, i.e. the box that encloses all glyphs in the font
@@ -205,7 +206,14 @@ You do not create glyph objects directly. They are created by various methods on
 * `path` - a vector Path object representing the glyph
 * `bbox` - the glyph’s bounding box, i.e. the rectangle that encloses the glyph outline as tightly as possible.
 * `cbox` - the glyph’s control box. This is often the same as the bounding box, but is faster to compute. Because of the way bezier curves are defined, some of the control points can be outside of the bounding box. Where `bbox` takes this into account, `cbox` does not. Thus, `cbox` is less accurate, but faster to compute. See [here](http://www.freetype.org/freetype2/docs/glyphs/glyphs-6.html#section-2) for a more detailed description.
+* `width` - the glyph’s width.
+* `height` - the glyph’s height.
 * `advanceWidth` - the glyph’s advance width.
+* `advanceHeight` - the glyph’s advance height.
+* `leftBearing` - the glyph’s left side bearing.
+* `topBearing` - the glyph’s top side bearing.
+* `rightBearing` - the glyph’s right side bearing.
+* `bottomBearing` - the glyph’s bottom side bearing.
 
 ### `glyph.render(ctx, size)`
 

packages/fontkit/src/base.ts

@@ -46,7 +46,7 @@ interface FontInstance {
   variationAxes: Record<string, unknown>;
   namedVariations: Record<string, VariationSettings>;
   cff: unknown;
-  "OS/2": { sFamilyClass: number };
+  "OS/2"?: { sFamilyClass: number };
   head: { macStyle: { italic: boolean } };
   post: { isFixedPitch: boolean };
   hasGlyphForCodePoint(codePoint: number): boolean;

packages/fontkit/src/cmap-processor.ts

@@ -299,6 +299,7 @@ export default class CmapProcessor {
 
   getVariationSelector(codepoint: number, variationSelector: number): number {
     if (!this.#uvs) {
+      // This font file does not contain information about variation forms.
       return 0;
     }
 
@@ -307,8 +308,8 @@ export default class CmapProcessor {
       selectors,
       (record: VariationSelectorRecord) => variationSelector - record.varSelector,
     );
-
     if (selectorIndex === -1) {
+      // There is no information about the specified variation form.
       return 0;
     }
 
@@ -324,16 +325,21 @@ export default class CmapProcessor {
             ? +1
             : 0,
       );
+      if (matchIndex !== -1) {
+        // Since this variation is the default form of this character,
+        // the base character’s glyph should be searched for as usual.
+        return 0;
+      }
     }
 
-    if (matchIndex !== -1 && sel.nonDefaultUVS) {
+    if (sel.nonDefaultUVS) {
       const nonDefaultRecords = materialize(sel.nonDefaultUVS);
       const nonDefaultIndex = binarySearch(
         nonDefaultRecords,
         (record: UVSMapping) => codepoint - record.unicodeValue,
       );
-
       if (nonDefaultIndex !== -1) {
+        // The glyph for this variation form has been identified.
         return nonDefaultRecords[nonDefaultIndex].glyphID;
       }
     }
@@ -419,7 +425,7 @@ export default class CmapProcessor {
               }
             }
 
-            if (g === gid) {
+            if ((g & 0xffff) === gid) {
               res.push(c);
             }
           }

packages/fontkit/src/glyph/cff-glyph.ts

@@ -1,3 +1,5 @@
+import { StandardEncoding } from "../cff/cff-encodings.js";
+import CFFStandardStrings from "../cff/cff-standard-strings.js";
 import Glyph from "./glyph.js";
 import Path from "./path.js";
 
@@ -88,12 +90,23 @@ export default class CFFGlyph extends Glyph {
     let vsindex = privateDict.vsindex;
     const variationProcessor = this._font._variationProcessor;
 
+    let encodingVector;
+    const font = this._font;
+
     const checkWidth = (): void => {
       if (width == null) {
         width = stack.shift() + privateDict.nominalWidthX;
       }
     };
 
+    function glyphForName(name) {
+      if (!encodingVector) {
+        encodingVector = cff.topDict.charset.glyphs.map((g) => CFFStandardStrings[g]);
+      }
+      const glyphId = Math.max(0, encodingVector.indexOf(name) + 1); // .notdef is not included, hence + 1
+      return font.getGlyph(glyphId);
+    }
+
     const parseStems = (): void => {
       if (stack.length % 2 !== 0) {
         checkWidth();
@@ -218,7 +231,23 @@ export default class CFFGlyph extends Glyph {
                 break;
               }
 
-              if (stack.length > 0) {
+              if (stack.length >= 4) {
+                // Type 2 Charstring Format Appendix C
+                // treat like Type 1 seac command (standard encoding accented character)
+                const acharName = StandardEncoding?.[stack.pop()];
+                const bcharName = StandardEncoding?.[stack.pop()];
+                const ady = stack.pop();
+                const adx = stack.pop();
+                // const asb = stack.pop(); // ignored for Type 2
+
+                const achar = glyphForName(acharName);
+                const bchar = glyphForName(bcharName);
+
+                const aPathShifted = achar.path.translate(adx, ady);
+                path.commands = [...bchar.path.commands, ...aPathShifted.commands];
+
+                open = false;
+              } else if (stack.length > 0) {
                 checkWidth();
               }
 

packages/fontkit/src/glyph/glyph.ts

@@ -72,6 +72,10 @@ type GlyphMetrics = {
   advanceHeight: number;
   leftBearing: number;
   topBearing: number;
+  width: number;
+  height: number;
+  rightBearing: number;
+  bottomBearing: number;
 };
 
 export type CanvasContextLike = {
@@ -152,44 +156,49 @@ export default class Glyph {
     return res;
   }
 
-  _getMetrics(cbox?: { maxY: number } | null): GlyphMetrics {
+  _getMetrics(cbox?: { maxY: number; width: number; height: number } | null): GlyphMetrics {
     if (this._metrics) {
       return this._metrics;
     }
+    if (typeof cbox === "undefined" || cbox === null) {
+      ({ cbox } = this);
+    }
 
     const { advance: advanceWidthRaw, bearing: leftBearing } = this._getTableMetrics(
       this._font.hmtx,
     );
     let advanceWidth = advanceWidthRaw;
 
-    // For vertical metrics, use vmtx if available, or fall back to global data from OS/2 or hhea
+    // For vertical metrics, use vmtx if available, or fall back to global data
     if (this._font.vmtx) {
       var { advance: advanceHeight, bearing: topBearing } = this._getTableMetrics(this._font.vmtx);
     } else {
-      let os2;
       if (typeof cbox === "undefined" || cbox === null) {
         ({ cbox } = this);
       }
 
-      if ((os2 = this._font["OS/2"]) && os2.version > 0) {
-        var advanceHeight = Math.abs(os2.typoAscender - os2.typoDescender);
-        var topBearing = os2.typoAscender - cbox.maxY;
-      } else {
-        let { hhea } = this._font;
-        var advanceHeight = Math.abs(hhea.ascent - hhea.descent);
-        var topBearing = hhea.ascent - cbox.maxY;
-      }
+      var advanceHeight = Math.abs(this._font.ascent - this._font.descent);
+      var topBearing = this._font.ascent - cbox.maxY;
     }
 
     if (this._font._variationProcessor && this._font.HVAR) {
       advanceWidth += this._font._variationProcessor.getAdvanceAdjustment(this.id, this._font.HVAR);
     }
 
+    let width = cbox.width;
+    let height = cbox.height;
+    let rightBearing = advanceWidth - leftBearing - width;
+    let bottomBearing = advanceHeight - topBearing - height;
+
     return (this._metrics = {
+      width,
+      height,
       advanceWidth,
       advanceHeight,
       leftBearing,
       topBearing,
+      rightBearing,
+      bottomBearing,
     });
   }
 
@@ -249,6 +258,24 @@ export default class Glyph {
     return this._getMetrics().advanceWidth;
   }
 
+  /**
+   * The glyph's width.
+   * @type {number}
+   */
+  @cache
+  get width() {
+    return this._getMetrics().width;
+  }
+
+  /**
+   * The glyph's height.
+   * @type {number}
+   */
+  @cache
+  get height() {
+    return this._getMetrics().height;
+  }
+
   /**
    * The glyph's advance height.
    * @type {number}
@@ -258,6 +285,42 @@ export default class Glyph {
     return this._getMetrics().advanceHeight;
   }
 
+  /**
+   * The glyph's left side bearing.
+   * @type {number}
+   */
+  @cache
+  get leftBearing() {
+    return this._getMetrics().leftBearing;
+  }
+
+  /**
+   * The glyph's top side bearing.
+   * @type {number}
+   */
+  @cache
+  get topBearing() {
+    return this._getMetrics().topBearing;
+  }
+
+  /**
+   * The glyph's right side bearing.
+   * @type {number}
+   */
+  @cache
+  get rightBearing() {
+    return this._getMetrics().rightBearing;
+  }
+
+  /**
+   * The glyph's bottom side bearing.
+   * @type {number}
+   */
+  @cache
+  get bottomBearing() {
+    return this._getMetrics().bottomBearing;
+  }
+
   get ligatureCaretPositions(): number[] | null {
     return null;
   }

packages/fontkit/src/glyph/path.ts

@@ -83,6 +83,14 @@ export default class Path {
         }
       }
 
+      if (this.commands.length === 0) {
+        // No content, put 0 instead of Infinity
+        cbox.minX = 0;
+        cbox.minY = 0;
+        cbox.maxX = 0;
+        cbox.maxY = 0;
+      }
+
       this.#cbox = Object.freeze(cbox);
     }
 
@@ -198,6 +206,14 @@ export default class Path {
       }
     }
 
+    if (this.commands.length === 0) {
+      // No content, put 0 instead of Infinity
+      bbox.minX = 0;
+      bbox.minY = 0;
+      bbox.maxX = 0;
+      bbox.maxY = 0;
+    }
+
     this.#bbox = Object.freeze(bbox);
     return this.#bbox;
   }

packages/fontkit/src/glyph/ttf-glyph.ts

@@ -87,8 +87,17 @@ export default class TTFGlyph extends Glyph {
       return this.path.cbox;
     }
 
+    let glyfPos = this._font.loca.offsets[this.id];
+    let nextPos = this._font.loca.offsets[this.id + 1];
+
+    // No data for this glyph (space?)
+    if (glyfPos === nextPos) {
+      return super._getCBox();
+    }
+
     let stream = this._font._getTableStream("glyf");
-    stream.pos += this._font.loca.offsets[this.id];
+    stream.pos += glyfPos;
+
     let glyph = GlyfHeader.decode(stream);
 
     let cbox = new BBox(glyph.xMin, glyph.yMin, glyph.xMax, glyph.yMax);

packages/fontkit/src/opentype/gpos-processor.ts

@@ -391,6 +391,9 @@ export default class GPOSProcessor extends OTProcessor {
   }
 
   getAnchor(anchor: any): { x: number; y: number } {
+    if (anchor == null) {
+      return { x: 0, y: 0 };
+    }
     // TODO: contour point, device tables
     let x = anchor.xCoordinate;
     let y = anchor.yCoordinate;

packages/fontkit/src/subset/subset.ts

@@ -8,11 +8,13 @@ export default abstract class Subset<TFont extends FontLike = FontLike> {
   protected font: TFont;
   protected glyphs: number[];
   protected mapping: Record<number, number>;
+  protected tables: string[];
 
   constructor(font: TFont) {
     this.font = font;
     this.glyphs = [];
     this.mapping = {};
+    this.tables = [];
 
     // always include the missing glyph
     this.includeGlyph(0);
@@ -29,6 +31,12 @@ export default abstract class Subset<TFont extends FontLike = FontLike> {
     return this.mapping[glyphId];
   }
 
+  includeTable(table: unknown) {
+    if (typeof table === "string" && table.length === 4) {
+      this.tables.push(table);
+    }
+  }
+
   /**
    * Encode the subset to a Uint8Array buffer.
    */