emf-converter 4.20.0 → 4.20.2

package/dist/index.mjs

@@ -21483,7 +21483,7 @@ function axisFilter(kernel, scale, copy) {
       return { radius: 0.5, weight: (i, c) => Math.floor(c + 0.5) === i ? 1 : 0 };
   }
 }
-function blendSeparable(rgba, width, box, iu0, wu, iv0, wv, verticalFirst, edge = { wrap: void 0, clamp: null }, integerBicubic = false, premult = false) {
+function blendSeparable(rgba, width, box, iu0, wu, iv0, wv, verticalFirst, edge = { wrap: void 0, clamp: null }, integerBicubic = false, premult = false, integerPremult = false) {
   const [outer0, outerW, inner0, innerW] = verticalFirst ? [iu0, wu, iv0, wv] : [iv0, wv, iu0, wu];
   const [oMin, oMax, iMin, iMax] = verticalFirst ? [box.x0, box.x1, box.y0, box.y1] : [box.y0, box.y1, box.x0, box.x1];
   let r = 0;
@@ -21524,9 +21524,9 @@ function blendSeparable(rgba, width, box, iu0, wu, iv0, wv, verticalFirst, edge
       }
       const alpha = px[s + 3];
       const wa = wi * alpha / 255;
-      lr += premult ? wi * px[s] : integerBicubic ? wi * Math.round(alpha * px[s] / 255) : wa * px[s];
-      lg += premult ? wi * px[s + 1] : integerBicubic ? wi * Math.round(alpha * px[s + 1] / 255) : wa * px[s + 1];
-      lb += premult ? wi * px[s + 2] : integerBicubic ? wi * Math.round(alpha * px[s + 2] / 255) : wa * px[s + 2];
+      lr += premult ? wi * px[s] : integerBicubic || integerPremult ? wi * Math.round(alpha * px[s] / 255) : wa * px[s];
+      lg += premult ? wi * px[s + 1] : integerBicubic || integerPremult ? wi * Math.round(alpha * px[s + 1] / 255) : wa * px[s + 1];
+      lb += premult ? wi * px[s + 2] : integerBicubic || integerPremult ? wi * Math.round(alpha * px[s + 2] / 255) : wa * px[s + 2];
       la += wi * alpha;
     }
     if (integerBicubic) {
@@ -21718,8 +21718,25 @@ function resampleImage(rgba, width, height, spec, surface, options2 = {}) {
         for (let t = iv0; t <= iv1; t++) {
           wv.push(integerBicubic ? Math.round(fv.weight(t, cv) * 65536) / 65536 : fv.weight(t, cv));
         }
-        return blendSeparable(rgba, width, box, iu0, wu, iv0, wv, kernel === "bicubic", edge, integerBicubic, premultSource);
+        return blendSeparable(
+          rgba,
+          width,
+          box,
+          iu0,
+          wu,
+          iv0,
+          wv,
+          kernel === "bicubic",
+          edge,
+          integerBicubic,
+          premultSource,
+          kernel === "bilinear"
+        );
       };
+      if (kernel === "bilinear") {
+        u = Math.floor(u) + Math.round((u - Math.floor(u)) * 2048) / 2048;
+        v = Math.floor(v) + Math.round((v - Math.floor(v)) * 2048) / 2048;
+      }
       let [r, g, b, a] = sampleAt(u, v);
       if (a <= 0) {
         continue;
@@ -21730,7 +21747,7 @@ function resampleImage(rgba, width, height, spec, surface, options2 = {}) {
         b = Math.trunc(b);
         a = Math.trunc(a);
         if (a <= 0) continue;
-      } else if (premultSource) {
+      } else if (premultSource || kernel === "bilinear") {
         r = Math.round(r);
         g = Math.round(g);
         b = Math.round(b);
@@ -22628,8 +22645,8 @@ function writeTextureColor(inv2, width, height, rgba, wrap, halfPixel2, dx, dy,
   const cv = inv2[1] * px + inv2[3] * py + inv2[5] - off;
   const iu = Math.floor(cu + 1e-9);
   const iv = Math.floor(cv + 1e-9);
-  const fu = Math.max(0, cu - iu);
-  const fv = Math.max(0, cv - iv);
+  const fu = Math.round(Math.max(0, cu - iu) * 2048) / 2048;
+  const fv = Math.round(Math.max(0, cv - iv) * 2048) / 2048;
   const clamp2 = wrap === "clamp";
   const mirrorX = wrap === "tile-flip-x" || wrap === "tile-flip-xy";
   const mirrorY = wrap === "tile-flip-y" || wrap === "tile-flip-xy";
@@ -22657,18 +22674,19 @@ function writeTextureColor(inv2, width, height, rgba, wrap, halfPixel2, dx, dy,
       y = wrapTexel(tv, height, mirrorY);
     }
     const s = (y * width + x) * 4;
-    const wa = w * rgba[s + 3];
-    r += wa * rgba[s];
-    g += wa * rgba[s + 1];
-    b += wa * rgba[s + 2];
-    a += wa;
+    const alpha = rgba[s + 3];
+    r += w * Math.round(rgba[s] * alpha / 255);
+    g += w * Math.round(rgba[s + 1] * alpha / 255);
+    b += w * Math.round(rgba[s + 2] * alpha / 255);
+    a += w * alpha;
   }
+  a = Math.round(a);
   if (a <= 0) {
     return;
   }
-  out[o] = r / a;
-  out[o + 1] = g / a;
-  out[o + 2] = b / a;
+  out[o] = Math.round(Math.round(r) * 255 / a);
+  out[o + 1] = Math.round(Math.round(g) * 255 / a);
+  out[o + 2] = Math.round(Math.round(b) * 255 / a);
   out[o + 3] = a;
 }
 var IDENTITY2 = [1, 0, 0, 1, 0, 0];
@@ -28996,6 +29014,46 @@ function mulDivRound(a, b, c) {
   const d = c > 0 ? Math.floor((a * b + Math.floor(c / 2)) / c) : 2147483647;
   return s < 0 ? -d : d;
 }
+var MonoStubContour = class {
+  constructor(o) {
+    this.points = Array.from(o.xs, (x, i) => [x / 64 - 0.5, o.ys[i] / 64 - 0.5]);
+  }
+  isStub(flipped, scan, crossing, lo, hi, precision) {
+    const points = this.points;
+    const n = points.length;
+    const point = (i) => flipped ? [points[i][1], points[i][0]] : points[i];
+    let edge = -1;
+    let distance = Infinity;
+    for (let i = 0; i < n; i++) {
+      const a2 = point(i), b2 = point((i + 1) % n);
+      if (a2[1] === b2[1] || scan < Math.min(a2[1], b2[1]) || scan > Math.max(a2[1], b2[1])) continue;
+      const x = a2[0] + (b2[0] - a2[0]) * (scan - a2[1]) / (b2[1] - a2[1]);
+      if (Math.abs(x - crossing) < distance) {
+        distance = Math.abs(x - crossing);
+        edge = i;
+      }
+    }
+    if (edge < 0 || distance > 2 / precision) return null;
+    const trace = (step) => {
+      let i = step === 1 ? (edge + 1) % n : edge;
+      let previous = [crossing, scan];
+      let side = 0;
+      for (let k = 0; k < n; k++, i = (i + step + n) % n) {
+        const p = point(i), dy = p[1] - scan;
+        if (!side && dy) side = Math.sign(dy);
+        if (side && dy * side < 0) {
+          const x = previous[0] + (p[0] - previous[0]) * (scan - previous[1]) / (p[1] - previous[1]);
+          return { side, continues: x <= lo || x >= hi };
+        }
+        if (p[0] <= lo || p[0] >= hi || dy * side >= 1) return { side, continues: true };
+        previous = p;
+      }
+      return { side, continues: false };
+    };
+    const a = trace(1), b = trace(-1);
+    return !(a.side * b.side < 0 && a.continues && b.continues);
+  }
+};
 function monoBox(o) {
   const n = o.xs.length;
   if (n === 0) {
@@ -29017,18 +29075,13 @@ function monoBox(o) {
   let xMax = Math.floor((cxMax + 32) / 64);
   let yMin = Math.floor((cyMin + 31) / 64);
   let yMax = Math.floor((cyMax + 32) / 64);
-  const rem = (v, add) => (v + add & 63) - add;
-  if (xMin === xMax) {
-    if (rem(cxMin, 31) + rem(cxMax, 32) < 0) xMin -= 1;
-    else xMax += 1;
-  }
-  if (yMin === yMax) {
-    if (rem(cyMin, 31) + rem(cyMax, 32) < 0) yMin -= 1;
-    else yMax += 1;
-  }
-  return { xMin, xMax, yMin, yMax };
+  const collapsedX = xMin === xMax;
+  const collapsedY = yMin === yMax;
+  if (collapsedX) xMax += 1;
+  if (collapsedY) yMax += 1;
+  return { xMin, xMax, yMin, yMax, collapsedX, collapsedY };
 }
-function rasterizeMono(o, dropout, fixedBox, stubOvershoot = true) {
+function rasterizeMono(o, dropout, fixedBox, stubOvershoot = true, smartCrossings26Dot6 = false) {
   const box = fixedBox ?? monoBox(o);
   if (!box) {
     return null;
@@ -29050,6 +29103,15 @@ function rasterizeMono(o, dropout, fixedBox, stubOvershoot = true) {
   const at = (col, row2) => (height - 1 - row2) * width + col;
   const r = new Raster(dropout);
   const P = r.precision;
+  const monoContour = stubOvershoot && (dropout === 1 || dropout === 4 || dropout === 5) && local.endPts.length === 1 && Array.from(local.onCurve).every(Boolean) ? new MonoStubContour(local) : null;
+  const smartPixel = (raster, x1, x2) => {
+    if (monoContour && smartCrossings26Dot6) {
+      const step = P / 64;
+      x1 = Math.round(x1 / step) * step;
+      x2 = Math.round(x2 / step) * step;
+    }
+    return raster.floorPub(Math.floor((x1 + x2 + Math.floor(P * 63 / 64)) / 2));
+  };
   if (r.convert(local, false, 0, (height - 1) * P)) {
     r.sweep(
       (y, x1, x2) => {
@@ -29080,17 +29142,19 @@ function rasterizeMono(o, dropout, fixedBox, stubOvershoot = true) {
               pxl = e2;
               break;
             case 4:
-              pxl = r.floorPub(Math.floor((x1 + x2 + Math.floor(P * 63 / 64)) / 2));
+              pxl = smartPixel(r, x1, x2);
               break;
             case 1:
             case 5:
-              if (left.next === right && left.height <= 0 && !(stubOvershoot && left.flags & OVERSHOOT_TOP && x2 - x1 >= r.half)) {
+              const stub = monoContour && box.collapsedX ? false : monoContour?.isStub(false, y, x1 / P, e2 / P, e1 / P, P);
+              if (stub === true) return;
+              if (stub == null && left.next === right && left.height <= 0 && !(stubOvershoot && left.flags & OVERSHOOT_TOP && x2 - x1 >= r.half)) {
                 return;
               }
-              if (right.next === left && left.start === y && !(stubOvershoot && left.flags & OVERSHOOT_BOTTOM && x2 - x1 >= r.half)) {
+              if (stub == null && right.next === left && left.start === y && !(stubOvershoot && left.flags & OVERSHOOT_BOTTOM && x2 - x1 >= r.half)) {
                 return;
               }
-              pxl = mode === 1 ? e2 : r.floorPub(Math.floor((x1 + x2 + Math.floor(P * 63 / 64)) / 2));
+              pxl = mode === 1 ? e2 : smartPixel(r, x1, x2);
               break;
             default:
               return;
@@ -29139,17 +29203,19 @@ function rasterizeMono(o, dropout, fixedBox, stubOvershoot = true) {
                 pxl = e2;
                 break;
               case 4:
-                pxl = h.floorPub(Math.floor((x1 + x2 + Math.floor(P * 63 / 64)) / 2));
+                pxl = smartPixel(h, x1, x2);
                 break;
               case 1:
               case 5:
-                if (left.next === right && left.height <= 0 && !(stubOvershoot && left.flags & OVERSHOOT_TOP && x2 - x1 >= h.half)) {
+                const stub = monoContour && box.collapsedY ? false : monoContour?.isStub(true, col, x1 / P, e2 / P, e1 / P, P);
+                if (stub === true) return;
+                if (stub == null && left.next === right && left.height <= 0 && !(stubOvershoot && left.flags & OVERSHOOT_TOP && x2 - x1 >= h.half)) {
                   return;
                 }
-                if (right.next === left && left.start === col && !(stubOvershoot && left.flags & OVERSHOOT_BOTTOM && x2 - x1 >= h.half)) {
+                if (stub == null && right.next === left && left.start === col && !(stubOvershoot && left.flags & OVERSHOOT_BOTTOM && x2 - x1 >= h.half)) {
                   return;
                 }
-                pxl = mode === 1 ? e2 : h.floorPub(Math.floor((x1 + x2 + Math.floor(P * 63 / 64)) / 2));
+                pxl = mode === 1 ? e2 : smartPixel(h, x1, x2);
                 break;
               default:
                 return;
@@ -29505,6 +29571,7 @@ var RasterRealizedFont = class {
       fsSelection: face.italic ? 1 : 0,
       macStyle: 0,
       winAscent: this.ascent,
+      winDescent: this.descent,
       unitsPerEm: this.ppem || 1
     };
   }
@@ -29692,6 +29759,11 @@ var RealizedFont = class {
     }
     return base + (this.syntheticBold ? 1 : 0);
   }
+  /** GDI+ rounds tracked hmtx advances to font units before device scaling. */
+  designAdvance(index, tracking) {
+    const { advance } = this.ttf.hMetrics(index < this.ttf.numGlyphs ? index : NOTDEF);
+    return Math.round(advance * tracking) * this.ppemX / this.ttf.unitsPerEm + (this.syntheticBold ? 1 : 0);
+  }
   /**
    * Advance of glyph `index` in a font realised with an escapement: GDI
    * does not use the hinted/hdmx widths there but the linearly scaled
@@ -29742,12 +29814,14 @@ var RealizedFont = class {
     }
     let bitmap;
     if (this.mode === "mono") {
-      bitmap = rasterizeMono(o, dropoutMode(src.scanSet ? src.scanControl : this.ppem <= DEFAULT_DROPOUT_PPEM, src.scanType));
+      const smartGrid = this.ppemX === this.ppem && !m && !this.syntheticItalic && !subX && !subY;
+      bitmap = rasterizeMono(o, dropoutMode(src.scanSet ? src.scanControl : this.ppem <= DEFAULT_DROPOUT_PPEM, src.scanType), void 0, true, smartGrid);
     } else if (this.mode === "cleartype") {
       const dropout = src.scanSet ? dropoutMode(src.scanControl, src.scanType) : 2;
       bitmap = rasterizeClearType(o, this.gdiPlus, this.gdiPlus ? clearTypeSpread(this.ttf) : void 0, dropout);
     } else {
-      bitmap = rasterizeGray(o, src.scanSet ? dropoutMode(src.scanControl, src.scanType) : 2);
+      const dropout = src.scanSet ? dropoutMode(src.scanControl, src.scanType) : 2;
+      bitmap = this.gdiPlus && !this.gridFit && !m && !this.syntheticBold && !this.syntheticItalic && this.ttf.weightClass < 600 && this.ttf.family.toLowerCase() === "courier new" ? rasterizeCourierGray(o, dropout) : rasterizeGray(o, dropout);
     }
     if (bitmap && this.syntheticBold) {
       bitmap = embolden(bitmap, this.mode === "mono" ? 1 : 16);
@@ -30059,6 +30133,23 @@ function resolvePpem(font, height) {
   return ppem;
 }
 var CLEARTYPE_OVERSAMPLE = 6;
+function rasterizeCourierGray(o, dropout) {
+  const samples = rasterizeSamples(o, 4, 4, 1, dropout, false);
+  if (!samples) return null;
+  const { box, hi } = samples;
+  const width = box.xMax - box.xMin;
+  const height = box.yMax - box.yMin;
+  const data = new Uint8Array(width * height);
+  for (let y = 0; y < hi.height; y++) {
+    const row2 = y * hi.width;
+    for (let x = 0; x < hi.width; x++) {
+      if (hi.data[row2 + x] || x > 0 && hi.data[row2 + x - 1]) {
+        data[Math.floor(y / 4) * width + Math.floor(x / 4)]++;
+      }
+    }
+  }
+  return { width, height, left: box.xMin, top: box.yMax, data };
+}
 function clearTypeSpread(ttf) {
   if (ttf.family.toLowerCase() !== "courier new") {
     return void 0;
@@ -37314,7 +37405,7 @@ function emitSvgRun(ctx, font, run, glyphs, origins, fontFamilyMap) {
   for (let i = 0; i < origins.length; i++) {
     const code = run.glyphIndices ? font.charForGlyph(glyphs[i]) : run.codes[i];
     if (!run.glyphIndices && !(run.options & ETO_IGNORELANGUAGE) && isC1Control(code)) continue;
-    text += String.fromCharCode(code);
+    text += String.fromCodePoint(code);
     visibleOrigins.push(origins[i]);
   }
   if (text.length === 0) return;
@@ -39330,7 +39421,11 @@ function setViewportExt(m, cx, cy) {
   fixIsotropic(m);
 }
 function scaled(v, num, den) {
-  return Math.trunc(v * num / den);
+  const product = Math.imul(v, num);
+  if (product === -2147483648 && den === -1) {
+    return 0;
+  }
+  return Math.trunc(product / den);
 }
 function scaleWindowExt(m, xNum, xDen, yNum, yDen) {
   if (!extentsSettable(m) || !xDen || !yDen) {
@@ -39483,10 +39578,16 @@ function setExtent(r, viewport, cx, cy) {
   activateGdiMappingMode(r);
 }
 function scaleExtent(r, viewport, xNum, xDenom, yNum, yDenom) {
-  const ext = viewport ? r.viewportExt : r.windowExt;
-  const cx = xDenom !== 0 ? Math.round(ext.cx * xNum / xDenom) : ext.cx;
-  const cy = yDenom !== 0 ? Math.round(ext.cy * yNum / yDenom) : ext.cy;
-  setExtent(r, viewport, cx, cy);
+  const m = emfMapping(r);
+  if (!extentsSettable(m) || !xDenom || !yDenom) {
+    return;
+  }
+  (viewport ? scaleViewportExt : scaleWindowExt)(m, xNum, xDenom, yNum, yDenom);
+  if (r.windowExt.cx === m.winExt.cx && r.windowExt.cy === m.winExt.cy && r.viewportExt.cx === m.vpExt.cx && r.viewportExt.cy === m.vpExt.cy) {
+    return;
+  }
+  storeMapping(r, m);
+  activateGdiMappingMode(r);
 }
 function handleCoordinateRecord(rCtx, recType, dataOff, recSize) {
   const { view } = rCtx;
@@ -40350,6 +40451,35 @@ function surfaceSize5(ctx) {
   return typeof w === "number" && typeof h === "number" && w > 0 && h > 0 ? { w, h } : null;
 }
 
+// src/emf-plus-text-alignment.ts
+var SIMPLE_SCRIPT = /^(?:\p{Script=Latin}|\p{Script=Common}|\p{Co})$/u;
+var SHAPING_CHARACTER = /[\p{M}\p{Cf}\p{Emoji_Presentation}]/u;
+function layoutPlusAlignedString(font, codes, format, x, y, width, height) {
+  const horizontal = format.alignment, vertical = format.lineAlignment;
+  if (!horizontal && !vertical || horizontal < 0 || horizontal > 2 || vertical < 0 || vertical > 2 || font.gridFit || font.mode !== "gray" || !font.designAdvance || font.ttf.winDescent === void 0 || font.syntheticBold || font.syntheticItalic || format.flags & 3 || ![x, y, width, height].every(Number.isFinite) || width <= 0 || height <= 0 || codes.some((c) => !Number.isInteger(c) || c < 32 || c > 1114111 || c >= 127 && c <= 159 || c === 8232 || c === 8233)) return null;
+  if (codes.some((c) => {
+    const character = String.fromCodePoint(c);
+    return !SIMPLE_SCRIPT.test(character) || SHAPING_CHARACTER.test(character) || font.glyphIndex(c) === 0;
+  })) return null;
+  const em = font.ppem;
+  const tracking = format.tracking ?? 1.03;
+  const leading = em * (format.leadingMargin ?? 1 / 6);
+  const trailing = em * (format.trailingMargin ?? 1 / 6);
+  if (![tracking, leading, trailing].every((v) => Number.isFinite(v) && v >= 0)) return null;
+  if (!(format.flags & 4) && (font.ttf.fsSelection & 1 || font.ttf.macStyle & 2)) return null;
+  const dx = codes.map((c) => font.designAdvance(font.glyphIndex(c), tracking));
+  let measuredCount = codes.length;
+  if (!(format.flags & 2048)) while (measuredCount > 0 && codes[measuredCount - 1] === 32) measuredCount--;
+  const measuredWidth = dx.slice(0, measuredCount).reduce((a, b) => a + b, 0) + leading + trailing;
+  const measuredHeight = em * (font.ttf.winAscent + font.ttf.winDescent) / font.ttf.unitsPerEm + (format.flags & 4 ? 0 : em / 8);
+  if (measuredWidth > width || measuredHeight > height) return null;
+  return {
+    x: Math.fround(x + horizontal / 2 * (width - measuredWidth) + leading),
+    y: Math.fround(y + vertical / 2 * (height - measuredHeight)) + Math.round(em * font.ttf.winAscent / font.ttf.unitsPerEm),
+    dx
+  };
+}
+
 // src/emf-plus-text-image-handlers.ts
 function imageAttributesWrap(rCtx, attributesId) {
   const obj = attributesId <= 255 ? rCtx.objectTable.get(attributesId) : void 0;
@@ -40618,25 +40748,32 @@ function paintPlusEngineRun(rCtx, ef, run) {
   );
   return true;
 }
-function drawPlusStringWithEngine(rCtx, font, text, layoutX, layoutY, paint, alignment, format, brushSampler2 = null) {
-  if (alignment !== 0) {
-    return false;
-  }
+function drawPlusStringWithEngine(rCtx, font, text, layoutX, layoutY, layoutW, layoutH, paint, alignment, format, brushSampler2 = null) {
   const ef = realizePlusEngineFont(rCtx, font, paint, brushSampler2);
   if (!ef) {
     return false;
   }
   const { realized, emPx, m, unhinted } = ef;
+  const codes = Array.from(text, (character) => character.codePointAt(0));
+  if (format && (alignment !== 0 || format.lineAlignment !== 0) && unhinted && m[0] === 1 && m[3] === 1 && emPx === realized.ppem) {
+    const aligned = layoutPlusAlignedString(
+      realized,
+      codes,
+      format,
+      layoutX + m[4],
+      layoutY + m[5],
+      layoutW,
+      layoutH
+    );
+    if (aligned) return paintPlusEngineRun(rCtx, ef, { codes, glyphIndices: false, ...aligned, dy: null });
+  }
+  if (alignment !== 0) return false;
   const ttf = realized.ttf;
   const exactAscent = emPx * ttf.winAscent / ttf.unitsPerEm;
   const ascent = unhinted ? Math.round(exactAscent) : Math.ceil(exactAscent);
   let x = m[0] * layoutX + m[4] + emPx * (format?.leadingMargin ?? PLUS_LEADING_EM);
   if (!unhinted) x = Math.round(x);
   const y = m[3] * layoutY + m[5] + ascent;
-  const codes = [];
-  for (let i = 0; i < text.length; i++) {
-    codes.push(text.charCodeAt(i));
-  }
   const tracking = format?.tracking ?? PLUS_DEFAULT_TRACKING;
   const dx = unhinted ? codes.map((c) => realized.advance(realized.glyphIndex(c)) * tracking) : null;
   return paintPlusEngineRun(rCtx, ef, { codes, glyphIndices: false, x, y, dx, dy: null });
@@ -40718,8 +40855,8 @@ function handleEmfPlusTextImageRecord(rCtx, recType, recFlags, dataOff, recDataS
         const strLen = view.getUint32(dataOff + 8, true);
         const layoutX = view.getFloat32(dataOff + 12, true);
         const layoutY = view.getFloat32(dataOff + 16, true);
-        view.getFloat32(dataOff + 20, true);
-        view.getFloat32(dataOff + 24, true);
+        const layoutW = view.getFloat32(dataOff + 20, true);
+        const layoutH = view.getFloat32(dataOff + 24, true);
         const fontId = recFlags & 255;
         const font = objectTable.get(fontId);
         if (strLen > 0 && dataOff + 28 + strLen * 2 <= dataOff + recDataSize) {
@@ -40735,6 +40872,8 @@ function handleEmfPlusTextImageRecord(rCtx, recType, recFlags, dataOff, recDataS
               text,
               layoutX,
               layoutY,
+              layoutW,
+              layoutH,
               paint,
               alignment,
               format,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "emf-converter",
-	"version": "4.20.0",
+	"version": "4.20.2",
 	"description": "Convert EMF/WMF metafile binaries to PNG or JPEG data URLs, or SVG (markup, data URL, React/JSX)",
 	"keywords": [
 		"canvas",