emf-converter 4.21.0 → 4.22.0

package/dist/browser.mjs

@@ -19839,11 +19839,16 @@ function recordDeviceFigures(buildPath, device) {
     const f = fig;
     f.curved = true;
     const n = f.pts.length;
+    const near = (qx, qy) => Math.abs(qx - f.pts[n - 2]) < 1e-3 && Math.abs(qy - f.pts[n - 1]) < 1e-3;
+    const degenerate = near(dx(c1x, c1y), dy(c1x, c1y)) && near(dx(c2x, c2y), dy(c2x, c2y)) && near(dx(x, y), dy(x, y));
     const fix2 = (v) => toPlusFix(v);
     const p0x = fix2(f.pts[n - 2]);
     const p0y = fix2(f.pts[n - 1]);
     f.pts[n - 2] = p0x / 16;
     f.pts[n - 1] = p0y / 16;
+    if (degenerate) {
+      (f.splits ?? (f.splits = [])).push({ x: p0x / 16, y: p0y / 16 });
+    }
     const out = [];
     const ctrl = [p0x, p0y, fix2(dx(c1x, c1y)), fix2(dy(c1x, c1y)), fix2(dx(c2x, c2y)), fix2(dy(c2x, c2y)), fix2(dx(x, y)), fix2(dy(x, y))];
     flattenBezierGdiplus(ctrl, out);
@@ -20217,7 +20222,7 @@ function sidePoints(pts, closed, o, pen) {
   }
   return out;
 }
-function dashFigure(pts, closed, pen) {
+function dashFigure(pts, closed, pen, splits) {
   const shorten = pen.dashCap !== 0 ? 2 * pen.half : 0;
   const dash = pen.dash.map((v, i) => {
     if (i % 2 === 0) {
@@ -20271,6 +20276,11 @@ function dashFigure(pts, closed, pen) {
     remaining -= segLen - t0;
     if (on && cur) {
       cur.push(b);
+      if (splits && i + 2 < path.length && splits.some((k) => Math.abs(k.x - b.x) < 1e-6 && Math.abs(k.y - b.y) < 1e-6)) {
+        out.push({ pts: cur, first: curFirst, last: false });
+        cur = [b];
+        curFirst = false;
+      }
     }
     segLen = 0;
   }
@@ -20400,7 +20410,7 @@ function widenFigures(figures, pen) {
       bands.push([lo, hi]);
     }
     const dashPen = pen.inset && closed ? { ...pen, dashOffset: pen.dashOffset * 2 } : pen;
-    const pieces = pen.dash ? dashFigure(pts, closed, dashPen) : [{ pts, first: true, last: true }];
+    const pieces = pen.dash ? dashFigure(pts, closed, dashPen, fig.splits) : [{ pts, first: true, last: true }];
     const pieceClosed = !pen.dash && closed;
     for (const piece of pieces) {
       const pp = cleanPoints(
@@ -20445,6 +20455,17 @@ function widenFigures(figures, pen) {
         const startCap = startCapOverride ?? (piece.first && !(pen.dash && closed) ? pen.startCap : pen.dashCap);
         const capEnd = capPoints(pp[pp.length - 1], fEnd, o1, o2, endCap, h);
         const capStart = capPoints(pp[0], f0, -o2, -o1, startCap, h);
+        if (endCap === 0 && capEnd.length === 2 && left.length > 2 && right.length > 2) {
+          const behind = (c2, q) => (c2.x - q.x) * fEnd.ux + (c2.y - q.y) * fEnd.uy < -1e-9;
+          const lq = left[left.length - 2];
+          const rq = right[1];
+          if (behind(capEnd[0], lq)) {
+            capEnd[0] = { x: lq.x, y: lq.y };
+          }
+          if (behind(capEnd[1], rq)) {
+            capEnd[1] = { x: rq.x, y: rq.y };
+          }
+        }
         const poly = [...left.slice(startCap === 1 ? 1 : 0, -1), ...capEnd, ...right.slice(1, -1), ...capStart];
         polys.push(poly);
         const sign = Math.sign(signedArea(poly));
@@ -22014,6 +22035,10 @@ var HQ_REDUCTION_STEP_NUDGE = 0.027;
 function hqReductionStep(reciprocal) {
   return Math.floor(reciprocal + 0.5 + HQ_REDUCTION_STEP_NUDGE);
 }
+function hqStartShift(edge) {
+  return edge > 512 ? 0 : edge > 256 ? 2 : edge > 64 ? 1 : 0;
+}
+var HQ_START_SHIFT_FRACTION_LIMIT = 0.9375 - 1e-9;
 function hqTentCdf(j) {
   if (j <= -128) {
     return -32768;
@@ -22113,9 +22138,12 @@ function resampleHqAxisAligned(rgba, width, height, spec, surface, m, premultOut
   const fraction2 = rawLeftEdge - Math.floor(rawLeftEdge);
   const offsetU = mirrorU ? 0 : snapsDown ? Math.round((1 + fraction2) * stepU) : snapsUp ? Math.round((fraction2 - 1) * stepU) : dx > 1e-9 ? Math.round((1 - dx) * stepU) : 0;
   const offsetV = dy > 1e-9 ? Math.round(dy * stepV) : 0;
+  const fractionU = rawLeftEdge - Math.floor(rawLeftEdge);
+  const startShiftU = mirrorU || fractionU >= HQ_START_SHIFT_FRACTION_LIMIT ? 0 : -hqStartShift(rawLeftEdge);
+  const startShiftV = hqStartShift(rawTop);
   const filterU = axisFilter(kernel, scaleU, false);
   const filterV = axisFilter(kernel, scaleV, false);
-  const tapsFor = (filter, step, offset, origin, from, to, scale, mirror2 = false) => {
+  const tapsFor = (filter, step, offset, origin, from, to, scale, startShift, mirror2 = false) => {
     const taps = [];
     const farBias = ((step & step - 1) === 0 ? 0 : Math.round(spec.srcW / 170)) + (mirror2 ? mirroredBias(spec, scale, dx > 1e-9) : 0);
     const position = (k) => mirror2 ? Math.round((mirroredPixels - k) * step) + farBias : k * step + offset;
@@ -22128,7 +22156,7 @@ function resampleHqAxisAligned(rgba, width, height, spec, surface, m, premultOut
     const originBins = origin * HQ_PHASES;
     const wholeBins = Math.abs(originBins - Math.round(originBins)) < 1e-6;
     if (scale < 1 && wholeBins) {
-      return hqReductionTaps(cubic, scale, step, position, origin, from, to);
+      return hqReductionTaps(cubic, scale, step, (k) => position(k) + startShift, origin, from, to);
     }
     const tabulated = cubic && wholeBins;
     for (let k = from; k <= to; k++) {
@@ -22153,8 +22181,8 @@ function resampleHqAxisAligned(rgba, width, height, spec, surface, m, premultOut
     }
     return taps;
   };
-  const colTaps = tapsFor(filterU, stepU, offsetU, spec.srcX, cx0 - xFirst, cx1 - xFirst, scaleU, mirrorU);
-  const rowTaps = tapsFor(filterV, stepV, offsetV, spec.srcY, cy0 - yFirst, cy1 - yFirst, scaleV);
+  const colTaps = tapsFor(filterU, stepU, offsetU, spec.srcX, cx0 - xFirst, cx1 - xFirst, scaleU, startShiftU, mirrorU);
+  const rowTaps = tapsFor(filterV, stepV, offsetV, spec.srcY, cy0 - yFirst, cy1 - yFirst, scaleV, startShiftV);
   let rowMin = Infinity;
   let rowMax = -Infinity;
   for (const t of rowTaps) {
@@ -22174,11 +22202,19 @@ function resampleHqAxisAligned(rgba, width, height, spec, surface, m, premultOut
     rowMax = Math.min(height - 1, rowMax);
   }
   const rows = Math.max(0, rowMax - rowMin + 1);
-  const rowMargin = edge || Math.abs(scaleV - 1) < 1e-9 ? Infinity : Math.ceil((cubic ? 2 : 1) / Math.min(1, scaleV));
+  const rowMargin = Math.abs(scaleV - 1) < 1e-9 ? Infinity : Math.ceil((cubic ? 2 : 1) / Math.min(1, scaleV));
   const inter = new Uint8Array(rows * w * 4);
   for (let r = 0; r < rows; r++) {
-    const rowTexel = edge ? wrapTap(rowMin + r, 0, height, edge.mirrorY, edge) : rowMin + r;
-    if (rowTexel === OUTSIDE_TRANSPARENT || rowTexel < spec.srcY - rowMargin || rowTexel > spec.srcY + spec.srcH + rowMargin - 1) {
+    let rowTexel = rowMin + r;
+    if (edge) {
+      if (Number.isFinite(rowMargin)) {
+        rowTexel = wrapTap(rowTexel, Math.max(0, spec.srcY - rowMargin), Math.min(height, spec.srcY + spec.srcH + rowMargin), edge.mirrorY, edge);
+      }
+      if (rowTexel !== OUTSIDE_TRANSPARENT && rowTexel !== OUTSIDE_CLAMP) {
+        rowTexel = wrapTap(rowTexel, 0, height, edge.mirrorY, edge);
+      }
+    }
+    if (rowTexel === OUTSIDE_TRANSPARENT || rowTexel !== OUTSIDE_CLAMP && (rowTexel < spec.srcY - rowMargin || rowTexel > spec.srcY + spec.srcH + rowMargin - 1)) {
       continue;
     }
     const srcRow = rowTexel * width;
@@ -26641,6 +26677,7 @@ var ceil64 = (x) => floor64(x + 63);
 var ON_CURVE = 1;
 var TOUCH_X = 8;
 var STEM_MIN_WIDTH = 16;
+var STEM_SMALL_SHIFT = 4;
 var TOUCH_Y = 16;
 var Zone = class _Zone {
   constructor(n, endPts = []) {
@@ -26729,6 +26766,8 @@ var HintedSize = class _HintedSize {
     this.iupy = false;
     /** IUP[x] has run in the current glyph program. */
     this.iupx = false;
+    /** Points that belong to a stem pair shifted so far in the glyph program (compatible-width ClearType). */
+    this.stemPoints = /* @__PURE__ */ new Set();
     this.count = 0;
     this.hintingGlyph = 0;
     this.font = font;
@@ -26809,8 +26848,10 @@ var HintedSize = class _HintedSize {
     const { advance } = this.font.hMetrics(g);
     const res2 = this.loadRecursive(g, 0);
     const n = res2.zone.n - 4;
-    const pp1x = res2.zone.curX[n];
     const pp2x = res2.zone.curX[n + 1];
+    const pp1x = res2.zone.curX[n];
+    const init = res2.zone.pp1Init ?? pp1x;
+    const rasterShift = pp1x - (init + round64(pp1x - init));
     const xs = new Float64Array(n);
     const ys = new Float64Array(n);
     const onCurve = new Uint8Array(n);
@@ -26825,6 +26866,7 @@ var HintedSize = class _HintedSize {
       onCurve,
       endPts: res2.zone.endPts,
       advance: pp2x - pp1x,
+      rasterShift,
       linearAdvance: mulFix(advance, this.xScale),
       scanControl: res2.scanControl,
       scanSet: res2.scanSet,
@@ -27003,15 +27045,30 @@ var HintedSize = class _HintedSize {
       return hinted;
     }
     if (this.hinting && !metricsFrom) {
-      zone.curX[total] = round64(zone.curX[total]);
-      zone.curX[total + 1] = round64(zone.curX[total + 1]);
       this.hintingGlyph = g;
+      this.roundHorizontalPhantoms(zone, total, round64);
       this.compatAdvance(zone, total + 1);
       zone.curY[total + 2] = round64(zone.curY[total + 2]);
       zone.curY[total + 3] = round64(zone.curY[total + 3]);
     }
+    zone.pp1Init = zone.curX[total];
     return { zone, ...lastScan };
   }
+  /**
+   * Places the horizontal phantom points `zone.curX[a]` (left) and `zone.curX[a + 1]` (advance) before the program runs.
+   * GDI's own interpreter leaves the left point where scaling put it and rounds the advance, so `pp2 = pp1 + round(width)`:
+   * Times New Roman Italic < and > (lsb 150 against xMin 39 and 37 units) start 39/64 pixel off the grid and native
+   * GGO_NATIVE shows it from the first instruction on (`prefix-timesi`, 58 prefixes at 11 and 17 px). Every other
+   * interpreter rounds both points.
+   */
+  roundHorizontalPhantoms(zone, a, round) {
+    if (this.gdiMath && !this.env.clearType) {
+      zone.curX[a + 1] = zone.curX[a] + round64(zone.curX[a + 1] - zone.curX[a]);
+      return;
+    }
+    zone.curX[a] = round(zone.curX[a]);
+    zone.curX[a + 1] = round(zone.curX[a + 1]);
+  }
   /** Under compatible-width ClearType the advance phantom point is held at the black-and-white advance. */
   compatAdvance(zone, k) {
     const bw = this.env.clearType && this.env.compatibleWidths !== false ? this.env.bwAdvance?.(this.hintingGlyph) : void 0;
@@ -27024,12 +27081,12 @@ var HintedSize = class _HintedSize {
     const n = zone.n;
     if (this.hinting && roundPhantoms) {
       const rx = this.env.clearType ? (v) => Math.floor((v + 2) / 4) * 4 : round64;
-      zone.curX[n - 4] = rx(zone.curX[n - 4]);
-      zone.curX[n - 3] = rx(zone.curX[n - 3]);
+      this.roundHorizontalPhantoms(zone, n - 4, rx);
       this.compatAdvance(zone, n - 3);
       zone.curY[n - 2] = round64(zone.curY[n - 2]);
       zone.curY[n - 1] = round64(zone.curY[n - 1]);
     }
+    zone.pp1Init = zone.curX[n - 4];
     if (!this.glyphHinting || instructions.length === 0) {
       return { zone, ...this.defaultScan };
     }
@@ -27042,6 +27099,7 @@ var HintedSize = class _HintedSize {
     this.stack = [];
     this.iupy = false;
     this.iupx = false;
+    this.stemPoints.clear();
     this.computeFuncs();
     try {
       this.execute(instructions);
@@ -27374,6 +27432,22 @@ var HintedSize = class _HintedSize {
     }
     return def.sizeTweak;
   }
+  /**
+   * GDI+ grayscale text (`shpixX`): which SHPIX shifts along x native honours. Measured with prefix copies of Arial Bold
+   * `y` (40 ppem), Arial `W` (12), Times New Roman Italic `T` (22) and Courier New `R` (22) and the 31,584 real glyphs
+   * (see docs/outstanding-work.md): a shift made by a function call (not a generic per-size helper, `inSizeTweak`)
+   * applies; one made inline in the glyph program applies to a point touched in exactly one direction, or in both once
+   * both IUPs have run, or in neither once both have run when it moves at least 32/64 px (Arial Bold `2`); smaller
+   * shifts of untouched points (Courier New `R` 22) and points touched in both before the IUPs (Times New Roman Italic
+   * `T` 22) are not applied: either costs pixels in the pinned controls.
+   */
+  plusShpixX(p, amt) {
+    if (!this.env.shpixX) return false;
+    if (this.callFrames.length > 0) return true;
+    const t = this.zp2.tags[p];
+    const tx = (t & TOUCH_X) !== 0, ty = (t & TOUCH_Y) !== 0;
+    return tx !== ty || this.iupx && this.iupy && (tx || Math.abs(amt) >= 32);
+  }
   /**
    * Whether backward-compatible ClearType (and the GDI+ grayscale text that runs the same interpreter) shifts a point by
    * a SHPIX along y: it must be touched in y, and a generic per-size helper function (`isSizeTweak`) stops shifting once
@@ -27874,7 +27948,7 @@ var HintedSize = class _HintedSize {
         while (gs.loop > 0) {
           const p = this.pop();
           if (p >= 0 && p < this.zp2.n) {
-            const keep = !this.ctCompat() || this.inComposite || gs.fvx === 0 && this.shpixAlongY(p) || gs.fvx !== 0 && !this.env.grayscale && !this.inSizeTweak();
+            const keep = !this.ctCompat() || this.inComposite || gs.fvx === 0 && this.shpixAlongY(p) || gs.fvx !== 0 && !this.inSizeTweak() && (!this.env.grayscale || this.plusShpixX(p, amt));
             if (keep) {
               this.moveZp2(p, dx, dy, true);
             }
@@ -27917,7 +27991,7 @@ var HintedSize = class _HintedSize {
         }
         this.move(this.zp1, p, target - dist);
         this.carryFrom(p);
-        this.pairShift(gs.rp0, p);
+        this.pairShift(gs.rp0, p, true);
         gs.rp1 = gs.rp0;
         gs.rp2 = p;
         if (op & 1) {
@@ -28483,7 +28557,7 @@ var HintedSize = class _HintedSize {
     }
   }
   /** A MIRP or MSIRP just placed `p` relative to rp0: if the two are the sides of a stem, shift the stem. */
-  pairShift(rp0, p) {
+  pairShift(rp0, p, black) {
     if (!this.widthShiftOn() || this.iupx) {
       return;
     }
@@ -28506,6 +28580,18 @@ var HintedSize = class _HintedSize {
     z.shifted ?? (z.shifted = new Uint8Array(z.n));
     const centre = (z.orgX[rp0] + z.orgX[p]) / 2;
     const shift = Math.round(centre * (bw / org2 - 1));
+    if (!black && Math.abs(shift) >= STEM_SMALL_SHIFT) {
+      return;
+    }
+    if (this.stemPoints.has(rp0) && Math.abs(shift) >= STEM_SMALL_SHIFT) {
+      z.applied ?? (z.applied = new Float64Array(z.n));
+      const own = Math.round(z.orgX[p] * (bw / org2 - 1)) - (z.carry ? z.carry[p] * (bw - org2) : 0);
+      z.curX[p] += own - z.applied[p];
+      z.applied[p] = own;
+      return;
+    }
+    this.stemPoints.add(rp0);
+    this.stemPoints.add(p);
     const offset = bw - org2;
     const lo = Math.min(z.curX[rp0], z.curX[p]);
     const hi = Math.max(z.curX[rp0], z.curX[p]);
@@ -28638,7 +28724,7 @@ var HintedSize = class _HintedSize {
     }
     this.move(this.zp1, p, distance - curDist);
     this.carryFrom(p);
-    this.pairShift(gs.rp0, p);
+    this.pairShift(gs.rp0, p, (op & 3) === 1);
     gs.rp1 = gs.rp0;
     if (op & 16) gs.rp0 = p;
     gs.rp2 = p;
@@ -30418,7 +30504,7 @@ var RasterRealizedFont = class {
   }
 };
 var RealizedFont = class {
-  constructor(ttf, ppem, ppemX, mode, syntheticBold, syntheticItalic, cellHeight = 0, stretchWidth = 0, gridFit = true, gdiPlus = false, playbackStretched = false) {
+  constructor(ttf, ppem, ppemX, mode, syntheticBold, syntheticItalic, cellHeight = 0, stretchWidth = 0, gridFit = true, gdiPlus = false, playbackStretched = false, plusUnscaled = false) {
     this.gdiPlus = gdiPlus;
     this.playbackStretched = playbackStretched;
     this.rotatedSizes = /* @__PURE__ */ new Map();
@@ -30474,7 +30560,7 @@ var RealizedFont = class {
       ttf,
       ppemX,
       ppem,
-      gdiPlus && mode === "gray" ? { version: 40, grayscale: true, clearType: true, compatibleWidths: false, grayClearType: true } : { version: 35, grayscale: mode !== "mono", gdiArithmetic: !gdiPlus, reportStretched: playbackStretched },
+      gdiPlus && mode === "gray" ? { version: 40, grayscale: true, clearType: true, compatibleWidths: false, grayClearType: true, shpixX: plusUnscaled } : { version: 35, grayscale: mode !== "mono", gdiArithmetic: !gdiPlus, reportStretched: playbackStretched },
       gridFit || gdiPlus && mode === "gray"
     );
     this.hdmx = ppemX === ppem ? ttf.hdmx.get(ppem) : void 0;
@@ -30557,7 +30643,7 @@ var RealizedFont = class {
       gdiArithmetic: !this.gdiPlus,
       smoothingBit18: !this.gdiPlus && gridFit && clearTypeSmoothsVertically(this.ttf, this.ppem),
       reportStretched: this.playbackStretched,
-      bwAdvance: !this.gdiPlus && !this.naturalWidths && gridFit ? (g) => this.advance(g) : void 0
+      bwAdvance: !this.gdiPlus && !this.naturalWidths && gridFit ? (g) => this.advance(g, true) : void 0
     }, gridFit));
     const u = this.ctSize.hintGlyph(gi);
     o = { xs: u.xs, ys: u.ys, onCurve: u.onCurve, endPts: u.endPts };
@@ -30587,8 +30673,22 @@ var RealizedFont = class {
     }
     return g;
   }
+  /** The scaled advance of glyph `index`, rounded once. */
+  linearAdvance(index) {
+    const { advance } = this.ttf.hMetrics(index < this.ttf.numGlyphs ? index : NOTDEF);
+    return Math.floor(advance * this.ppemX / this.ttf.unitsPerEm + 0.5);
+  }
+  /** Whether glyph `index` advances linearly at this size: `head.flags` bit 4 clear, or `LTSH` (an `hdmx` record for the size comes first). */
+  ltshLinear(index) {
+    if (this.gdiPlus || this.ppemX !== this.ppem) return false;
+    const hd = this.hdmx;
+    if (hd && index < hd.length) return false;
+    if ((this.ttf.headFlags & 16) === 0) return true;
+    const lt = this.ttf.ltsh;
+    return !!lt && index < lt.length && lt[index] > 0 && this.ppem >= lt[index];
+  }
   /** Integer advance width of glyph `index`, as GetCharWidth32 reports it (GDI+ ClearType: its hinted phantom advance rounded). */
-  advance(index) {
+  advance(index, hintedOnly = false) {
     const hd = this.hdmx;
     let base;
     if (this.stretchWidth > 0) {
@@ -30596,6 +30696,8 @@ var RealizedFont = class {
       base = Math.round(advance * this.stretchWidth / this.ttf.xAvgCharWidth);
     } else if (!this.gridFit) {
       base = this.outline(index).linearAdvance / 64;
+    } else if (!hintedOnly && this.ltshLinear(index)) {
+      base = this.linearAdvance(index);
     } else if (this.advanceSize) {
       let g = this.advanceOutlines.get(index);
       if (!g) {
@@ -30658,6 +30760,12 @@ var RealizedFont = class {
       m = roundedRotationMatrix(m, this.ppem);
     }
     let o = this.mode === "cleartype" && !m && !this.syntheticItalic ? this.ctOutline(index) : src;
+    const shift = this.gdiPlus || m || this.mode === "cleartype" ? 0 : src.rasterShift ?? 0;
+    if (shift !== 0) {
+      const xs = new Float64Array(o.xs.length);
+      for (let i = 0; i < xs.length; i++) xs[i] = o.xs[i] + shift;
+      o = { ...o, xs };
+    }
     if (this.syntheticItalic || m || subX || subY) {
       const base = o;
       const n = base.xs.length;
@@ -30923,7 +31031,8 @@ var GdiFontCollection = class _GdiFontCollection {
           spec.width,
           !spec.unhinted,
           spec.gdiPlus,
-          !!spec.playbackStretch && playbackStretchReacts(best, spec.height, spec.playbackStretch)
+          !!spec.playbackStretch && playbackStretchReacts(best, spec.height, spec.playbackStretch),
+          !!spec.unscaledText
         );
         tt2.naturalWidths = spec.quality === CLEARTYPE_NATURAL_QUALITY;
         return tt2;
@@ -33805,7 +33914,6 @@ function withoutOutline(spans, path) {
 var fix = (v) => Math.floor(v * 16 + 0.5) / 16;
 var TIE = 1e-6;
 var STRIP_TIE = 5e-3;
-var CONTAINMENT_TIE = 5e-4;
 var SLANTED_NEAR = 5e-6;
 var CEIL_EPSILON = 1e-9;
 function prepareCopies(shape, full, steps) {
@@ -34015,7 +34123,6 @@ function anisotropicTieStep(g, q, tie, dx, dy, px, py) {
   const hit = edgeAt(g, scaleX, scaleY, px, py);
   const half = g.steps - tie - 0.5;
   if (hit?.kind === "slanted") return half;
-  if (hit === null && Math.abs(q - tie) >= CONTAINMENT_TIE) return half;
   if (hit === null) return g.steps - tie - (insideCopy(g, scaleX, px, py, scaleY) ? 0 : 1);
   let odd = g.steps;
   while (odd % 2 === 0) odd /= 2;
@@ -42514,7 +42621,8 @@ function realizePlusEngineFont(rCtx, font, paint, brushSampler2) {
     // AntiAlias ignores the font's gasp table (measured: Arial 16 px is
     // grayscale there, but single-bit under AntiAliasGridFit, as in GDI).
     ignoreGasp: hint === 4,
-    gdiPlus: true
+    gdiPlus: true,
+    unscaledText: m[0] === 1 && m[3] === 1
   };
   const realized = fonts.realize(spec, rCtx.fontFamilyMap);
   if (!realized) {