Fix some NaN in svg paths

This is a quick commit to fix a few NaN issues in SVG paths. This commit is not suitable for a PR, as it was created for a temporary use case.

More context: opentypejs#797

Author: o1y

src/font.mjs

@@ -380,7 +380,7 @@ Font.prototype.forEachGlyph = function(text, x, y, fontSize, options, callback)
     y = y !== undefined ? y : 0;
     fontSize = fontSize !== undefined ? fontSize : 72;
     options = Object.assign({}, this.defaultRenderOptions, options);
-    const fontScale = 1 / this.unitsPerEm * fontSize;
+    const fontScale = 1 / (this.unitsPerEm || 1000) * fontSize;
     const glyphs = this.stringToGlyphs(text, options);
     let kerningLookups;
     if (options.kerning) {

src/glyph.mjs

@@ -399,7 +399,7 @@ Glyph.prototype.drawPoints = function(ctx, x, y, fontSize, options, font) {
     x = x !== undefined ? x : 0;
     y = y !== undefined ? y : 0;
     fontSize = fontSize !== undefined ? fontSize : 24;
-    const scale = 1 / this.path.unitsPerEm * fontSize;
+    const scale = 1 / (this.path.unitsPerEm || 1000) * fontSize;
 
     const blueCircles = [];
     const redCircles = [];
@@ -446,7 +446,7 @@ Glyph.prototype.drawMetrics = function(ctx, x, y, fontSize) {
     x = x !== undefined ? x : 0;
     y = y !== undefined ? y : 0;
     fontSize = fontSize !== undefined ? fontSize : 24;
-    scale = 1 / this.path.unitsPerEm * fontSize;
+    scale = 1 / (this.path.unitsPerEm || 1000) * fontSize;
     ctx.lineWidth = 1;
 
     // Draw the origin

src/hintingtt.mjs

@@ -224,7 +224,7 @@ const xUnitVector = {
         const rpdx = rpx + d * pv.x;
         const rpdy = rpy + d * pv.y;
 
-        p.x = rpdx + (p.y - rpdy) / pv.normalSlope;
+        p.x = (isFinite(pv.normalSlope) && pv.normalSlope !== 0) ? rpdx + (p.y - rpdy) / pv.normalSlope : rpdx;
     },
 
     // Slope of vector line.
@@ -366,8 +366,8 @@ function UnitVector(x, y) {
     this.x = x;
     this.y = y;
     this.axis = undefined;
-    this.slope = y / x;
-    this.normalSlope = -x / y;
+    this.slope = x === 0 ? (y === 0 ? 0 : Infinity) : y / x;
+    this.normalSlope = y === 0 ? (x === 0 ? 0 : Infinity) : -x / y;
     Object.freeze(this);
 }
 
@@ -440,7 +440,8 @@ UnitVector.prototype.setRelative = function(p, rp, d, pv, org) {
     const px = p.x;
     const py = p.y;
 
-    p.x = (fvs * px - pvns * rpdx + rpdy - py) / (fvs - pvns);
+    const denom = fvs - pvns;
+    p.x = denom === 0 ? px : (fvs * px - pvns * rpdx + rpdy - py) / denom;
     p.y = fvs * (p.x - px) + py;
 };
 
@@ -1109,8 +1110,14 @@ function ISECT(state)
     const f1 = x1 * y2 - y1 * x2;
     const f2 = x3 * y4 - y3 * x4;
 
-    p.x = (f1 * (x3 - x4) - f2 * (x1 - x2)) / div;
-    p.y = (f1 * (y3 - y4) - f2 * (y1 - y2)) / div;
+    if (div === 0) {
+        // Lines are parallel, use midpoint
+        p.x = (x1 + x2) / 2;
+        p.y = (y1 + y2) / 2;
+    } else {
+        p.x = (f1 * (x3 - x4) - f2 * (x1 - x2)) / div;
+        p.y = (f1 * (y3 - y4) - f2 * (y1 - y2)) / div;
+    }
 }
 
 // SRP0[] Set Reference Point 0
@@ -2116,7 +2123,7 @@ function DIV(state) {
 
     if (DEBUG) console.log(state.step, 'DIV[]', n2, n1);
 
-    stack.push(n1 * 64 / n2);
+    stack.push(n2 === 0 ? 0 : n1 * 64 / n2);
 }
 
 // MUL[] MUL
@@ -2195,7 +2202,8 @@ function WCVTF(state) {
 
     if (DEBUG) console.log(state.step, 'WCVTF[]', v, l);
 
-    state.cvt[l] = v * state.ppem / state.font.unitsPerEm;
+    const unitsPerEm = state.font.unitsPerEm || 1000;
+    state.cvt[l] = v * state.ppem / unitsPerEm;
 }
 
 // DELTAC1[] DELTA exception C1

src/path.mjs

@@ -32,8 +32,8 @@ function roundDecimal(float, places) {
         const roundedDecimalPart = decimalRoundingCache[places][decimalPart];
         return integerPart + roundedDecimalPart;
     }
-    
-    const roundedDecimalPart = +(Math.round(decimalPart + 'e+' + places) + 'e-' + places);
+
+    const roundedDecimalPart = Number((Math.round(decimalPart * Math.pow(10, places)) / Math.pow(10, places)).toFixed(places));
     decimalRoundingCache[places][decimalPart] = roundedDecimalPart;
 
     return integerPart + roundedDecimalPart;

src/tables/cpal.mjs

@@ -108,13 +108,18 @@ function rgbToHSL(bgra) {
         h = s = 0;
     } else {
         const d = max - min;
-        s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
-        switch (max) {
-            case r: h = (g - b) / d + (g < b ? 6 : 0); break;
-            case g: h = (b - r) / d + 2; break;
-            case b: h = (r - g) / d + 4; break;
+        if (d === 0) {
+            h = s = 0;
+        } else {
+            const denomS = l > 0.5 ? (2 - max - min) : (max + min);
+            s = denomS === 0 ? 0 : d / denomS;
+            switch (max) {
+                case r: h = (g - b) / d + (g < b ? 6 : 0); break;
+                case g: h = (b - r) / d + 2; break;
+                case b: h = (r - g) / d + 4; break;
+            }
+            h /= 6;
         }
-        h /= 6;
     }
 
     return {

src/variationprocessor.mjs

@@ -46,9 +46,11 @@ export class VariationProcessor {
                 tagValue = axis.defaultValue;
             }
             if (tagValue < axis.defaultValue) {
-                normalized.push((tagValue - axis.defaultValue + Number.EPSILON) / (axis.defaultValue - axis.minValue + Number.EPSILON));
+                const denom = axis.defaultValue - axis.minValue;
+                normalized.push(denom === 0 ? 0 : (tagValue - axis.defaultValue) / denom);
             } else {
-                normalized.push((tagValue - axis.defaultValue + Number.EPSILON) / (axis.maxValue - axis.defaultValue + Number.EPSILON));
+                const denom = axis.maxValue - axis.defaultValue;
+                normalized.push(denom === 0 ? 0 : (tagValue - axis.defaultValue) / denom);
             }
         }
 
@@ -61,10 +63,13 @@ export class VariationProcessor {
                     let pair = segment.axisValueMaps[j];
                     if (j >= 1 && normalized[i] < pair.fromCoordinate) {
                         let prev = segment.axisValueMaps[j - 1];
-                        normalized[i] = ((normalized[i] - prev.fromCoordinate) * (pair.toCoordinate - prev.toCoordinate) + Number.EPSILON) /
-                            (pair.fromCoordinate - prev.fromCoordinate + Number.EPSILON) +
-                            prev.toCoordinate;
-            
+                        const denom = pair.fromCoordinate - prev.fromCoordinate;
+                        if (denom === 0) {
+                            normalized[i] = prev.toCoordinate;
+                        } else {
+                            normalized[i] = ((normalized[i] - prev.fromCoordinate) * (pair.toCoordinate - prev.toCoordinate)) / denom + prev.toCoordinate;
+                        }
+
                         break;
                     }
                 }
@@ -284,15 +289,18 @@ export class VariationProcessor {
                         break;
                     }
 
-                    factor = (factor * normalizedCoords[a] + Number.EPSILON) / (tupleCoords[a] + Number.EPSILON);
+                    const denom = tupleCoords[a];
+                    factor = denom === 0 ? 0 : (factor * normalizedCoords[a]) / denom;
                 } else {
                     if ((normalizedCoords[a] < header.intermediateStartTuple[a]) || (normalizedCoords[a] > header.intermediateEndTuple[a])) {
                         factor = 0;
                         break;
                     } else if (normalizedCoords[a] < tupleCoords[a]) {
-                        factor = factor * (normalizedCoords[a] - header.intermediateStartTuple[a] + Number.EPSILON) / (tupleCoords[a] - header.intermediateStartTuple[a] + Number.EPSILON);
+                        const denom = tupleCoords[a] - header.intermediateStartTuple[a];
+                        factor = denom === 0 ? 0 : factor * (normalizedCoords[a] - header.intermediateStartTuple[a]) / denom;
                     } else {
-                        factor = factor * (header.intermediateEndTuple[a] - normalizedCoords[a] + Number.EPSILON) / (header.intermediateEndTuple[a] - tupleCoords[a] + Number.EPSILON);
+                        const denom = header.intermediateEndTuple[a] - tupleCoords[a];
+                        factor = denom === 0 ? 0 : factor * (header.intermediateEndTuple[a] - normalizedCoords[a]) / denom;
                     }
                 }
             }
@@ -526,11 +534,11 @@ export class VariationProcessor {
                     if (normalizedCoords[j] === axis.peakCoord) {
                         axisScalar = 1;
                     } else if (normalizedCoords[j] < axis.peakCoord) {
-                        axisScalar = (normalizedCoords[j] - axis.startCoord + Number.EPSILON) /
-                  (axis.peakCoord - axis.startCoord + Number.EPSILON);
+                        const denom = axis.peakCoord - axis.startCoord;
+                        axisScalar = denom === 0 ? 1 : (normalizedCoords[j] - axis.startCoord) / denom;
                     } else {
-                        axisScalar = (axis.endCoord - normalizedCoords[j] + Number.EPSILON) /
-                  (axis.endCoord - axis.peakCoord + Number.EPSILON);
+                        const denom = axis.endCoord - axis.peakCoord;
+                        axisScalar = denom === 0 ? 1 : (axis.endCoord - normalizedCoords[j]) / denom;
                     }
                 }