emf-converter 4.19.0 → 4.20.1

package/dist/browser.js

@@ -46,7 +46,7 @@ var require_encoder = __commonJS({
       var YAC_HT;
       var UVAC_HT;
       var bitcode = new Array(65535);
-      var category = new Array(65535);
+      var category2 = new Array(65535);
       var outputfDCTQuant = new Array(64);
       var DU = new Array(64);
       var byteout = [];
@@ -655,13 +655,13 @@ var require_encoder = __commonJS({
         var nrupper = 2;
         for (var cat = 1; cat <= 15; cat++) {
           for (var nr = nrlower; nr < nrupper; nr++) {
-            category[32767 + nr] = cat;
+            category2[32767 + nr] = cat;
             bitcode[32767 + nr] = [];
             bitcode[32767 + nr][1] = cat;
             bitcode[32767 + nr][0] = nr;
           }
           for (var nrneg = -(nrupper - 1); nrneg <= -nrlower; nrneg++) {
-            category[32767 + nrneg] = cat;
+            category2[32767 + nrneg] = cat;
             bitcode[32767 + nrneg] = [];
             bitcode[32767 + nrneg][1] = cat;
             bitcode[32767 + nrneg][0] = nrupper - 1 + nrneg;
@@ -943,7 +943,7 @@ var require_encoder = __commonJS({
           writeBits(HTDC[0]);
         } else {
           pos = 32767 + Diff;
-          writeBits(HTDC[category[pos]]);
+          writeBits(HTDC[category2[pos]]);
           writeBits(bitcode[pos]);
         }
         var end0pos = 63;
@@ -967,7 +967,7 @@ var require_encoder = __commonJS({
             nrzeroes = nrzeroes & 15;
           }
           pos = 32767 + DU[i];
-          writeBits(HTAC[(nrzeroes << 4) + category[pos]]);
+          writeBits(HTAC[(nrzeroes << 4) + category2[pos]]);
           writeBits(bitcode[pos]);
           i++;
         }
@@ -21484,7 +21484,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;
@@ -21525,9 +21525,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) {
@@ -21719,8 +21719,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;
@@ -21731,7 +21748,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);
@@ -22629,8 +22646,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";
@@ -22658,18 +22675,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];
@@ -24936,6 +24954,752 @@ function drawEmfPlusImageNow(rCtx, img, draw, source, effect = null) {
   return bitmap ? paintBitmapRaster(rCtx.ctx, bitmap, draw) : false;
 }
 
+// src/jpeg-encoder.ts
+var DEFAULT_JPEG_QUALITY = 0.92;
+var ZIGZAG2 = [
+  0,
+  1,
+  8,
+  16,
+  9,
+  2,
+  3,
+  10,
+  17,
+  24,
+  32,
+  25,
+  18,
+  11,
+  4,
+  5,
+  12,
+  19,
+  26,
+  33,
+  40,
+  48,
+  41,
+  34,
+  27,
+  20,
+  13,
+  6,
+  7,
+  14,
+  21,
+  28,
+  35,
+  42,
+  49,
+  56,
+  57,
+  50,
+  43,
+  36,
+  29,
+  22,
+  15,
+  23,
+  30,
+  37,
+  44,
+  51,
+  58,
+  59,
+  52,
+  45,
+  38,
+  31,
+  39,
+  46,
+  53,
+  60,
+  61,
+  54,
+  47,
+  55,
+  62,
+  63
+];
+var LUMA_QUANT = [
+  16,
+  11,
+  10,
+  16,
+  24,
+  40,
+  51,
+  61,
+  12,
+  12,
+  14,
+  19,
+  26,
+  58,
+  60,
+  55,
+  14,
+  13,
+  16,
+  24,
+  40,
+  57,
+  69,
+  56,
+  14,
+  17,
+  22,
+  29,
+  51,
+  87,
+  80,
+  62,
+  18,
+  22,
+  37,
+  56,
+  68,
+  109,
+  103,
+  77,
+  24,
+  35,
+  55,
+  64,
+  81,
+  104,
+  113,
+  92,
+  49,
+  64,
+  78,
+  87,
+  103,
+  121,
+  120,
+  101,
+  72,
+  92,
+  95,
+  98,
+  112,
+  100,
+  103,
+  99
+];
+var CHROMA_QUANT = [
+  17,
+  18,
+  24,
+  47,
+  99,
+  99,
+  99,
+  99,
+  18,
+  21,
+  26,
+  66,
+  99,
+  99,
+  99,
+  99,
+  24,
+  26,
+  56,
+  99,
+  99,
+  99,
+  99,
+  99,
+  47,
+  66,
+  99,
+  99,
+  99,
+  99,
+  99,
+  99,
+  99,
+  99,
+  99,
+  99,
+  99,
+  99,
+  99,
+  99,
+  99,
+  99,
+  99,
+  99,
+  99,
+  99,
+  99,
+  99,
+  99,
+  99,
+  99,
+  99,
+  99,
+  99,
+  99,
+  99,
+  99,
+  99,
+  99,
+  99,
+  99,
+  99,
+  99,
+  99
+];
+var DC_LUMA = { bits: [0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0], values: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] };
+var DC_CHROMA = { bits: [0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0], values: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] };
+var AC_LUMA = {
+  bits: [0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 125],
+  values: [
+    1,
+    2,
+    3,
+    0,
+    4,
+    17,
+    5,
+    18,
+    33,
+    49,
+    65,
+    6,
+    19,
+    81,
+    97,
+    7,
+    34,
+    113,
+    20,
+    50,
+    129,
+    145,
+    161,
+    8,
+    35,
+    66,
+    177,
+    193,
+    21,
+    82,
+    209,
+    240,
+    36,
+    51,
+    98,
+    114,
+    130,
+    9,
+    10,
+    22,
+    23,
+    24,
+    25,
+    26,
+    37,
+    38,
+    39,
+    40,
+    41,
+    42,
+    52,
+    53,
+    54,
+    55,
+    56,
+    57,
+    58,
+    67,
+    68,
+    69,
+    70,
+    71,
+    72,
+    73,
+    74,
+    83,
+    84,
+    85,
+    86,
+    87,
+    88,
+    89,
+    90,
+    99,
+    100,
+    101,
+    102,
+    103,
+    104,
+    105,
+    106,
+    115,
+    116,
+    117,
+    118,
+    119,
+    120,
+    121,
+    122,
+    131,
+    132,
+    133,
+    134,
+    135,
+    136,
+    137,
+    138,
+    146,
+    147,
+    148,
+    149,
+    150,
+    151,
+    152,
+    153,
+    154,
+    162,
+    163,
+    164,
+    165,
+    166,
+    167,
+    168,
+    169,
+    170,
+    178,
+    179,
+    180,
+    181,
+    182,
+    183,
+    184,
+    185,
+    186,
+    194,
+    195,
+    196,
+    197,
+    198,
+    199,
+    200,
+    201,
+    202,
+    210,
+    211,
+    212,
+    213,
+    214,
+    215,
+    216,
+    217,
+    218,
+    225,
+    226,
+    227,
+    228,
+    229,
+    230,
+    231,
+    232,
+    233,
+    234,
+    241,
+    242,
+    243,
+    244,
+    245,
+    246,
+    247,
+    248,
+    249,
+    250
+  ]
+};
+var AC_CHROMA = {
+  bits: [0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 119],
+  values: [
+    0,
+    1,
+    2,
+    3,
+    17,
+    4,
+    5,
+    33,
+    49,
+    6,
+    18,
+    65,
+    81,
+    7,
+    97,
+    113,
+    19,
+    34,
+    50,
+    129,
+    8,
+    20,
+    66,
+    145,
+    161,
+    177,
+    193,
+    9,
+    35,
+    51,
+    82,
+    240,
+    21,
+    98,
+    114,
+    209,
+    10,
+    22,
+    36,
+    52,
+    225,
+    37,
+    241,
+    23,
+    24,
+    25,
+    26,
+    38,
+    39,
+    40,
+    41,
+    42,
+    53,
+    54,
+    55,
+    56,
+    57,
+    58,
+    67,
+    68,
+    69,
+    70,
+    71,
+    72,
+    73,
+    74,
+    83,
+    84,
+    85,
+    86,
+    87,
+    88,
+    89,
+    90,
+    99,
+    100,
+    101,
+    102,
+    103,
+    104,
+    105,
+    106,
+    115,
+    116,
+    117,
+    118,
+    119,
+    120,
+    121,
+    122,
+    130,
+    131,
+    132,
+    133,
+    134,
+    135,
+    136,
+    137,
+    138,
+    146,
+    147,
+    148,
+    149,
+    150,
+    151,
+    152,
+    153,
+    154,
+    162,
+    163,
+    164,
+    165,
+    166,
+    167,
+    168,
+    169,
+    170,
+    178,
+    179,
+    180,
+    181,
+    182,
+    183,
+    184,
+    185,
+    186,
+    194,
+    195,
+    196,
+    197,
+    198,
+    199,
+    200,
+    201,
+    202,
+    210,
+    211,
+    212,
+    213,
+    214,
+    215,
+    216,
+    217,
+    218,
+    226,
+    227,
+    228,
+    229,
+    230,
+    231,
+    232,
+    233,
+    234,
+    242,
+    243,
+    244,
+    245,
+    246,
+    247,
+    248,
+    249,
+    250
+  ]
+};
+function buildCodes(spec) {
+  const code = new Uint16Array(256);
+  const size = new Uint8Array(256);
+  let next = 0;
+  let k = 0;
+  for (let len = 1; len <= 16; len++) {
+    for (let i = 0; i < spec.bits[len - 1]; i++) {
+      const symbol = spec.values[k++];
+      code[symbol] = next++;
+      size[symbol] = len;
+    }
+    next <<= 1;
+  }
+  return { code, size };
+}
+function scaleQuant(base, quality) {
+  const q = Math.min(100, Math.max(1, Math.round(quality * 100)));
+  const scale = q < 50 ? Math.floor(5e3 / q) : 200 - q * 2;
+  return Uint8Array.from(base, (v) => Math.min(255, Math.max(1, Math.floor((v * scale + 50) / 100))));
+}
+var COS = (() => {
+  const t = new Float64Array(64);
+  for (let u = 0; u < 8; u++) {
+    const c = u === 0 ? Math.SQRT1_2 : 1;
+    for (let x = 0; x < 8; x++) {
+      t[u * 8 + x] = c / 2 * Math.cos((2 * x + 1) * u * Math.PI / 16);
+    }
+  }
+  return t;
+})();
+function fdctQuantize(block, quant, out, tmp) {
+  for (let y = 0; y < 8; y++) {
+    for (let u = 0; u < 8; u++) {
+      let s = 0;
+      for (let x = 0; x < 8; x++) s += COS[u * 8 + x] * block[y * 8 + x];
+      tmp[y * 8 + u] = s;
+    }
+  }
+  for (let k = 0; k < 64; k++) {
+    const n = ZIGZAG2[k];
+    const v = n >> 3;
+    const u = n & 7;
+    let s = 0;
+    for (let y = 0; y < 8; y++) s += COS[v * 8 + y] * tmp[y * 8 + u];
+    out[k] = Math.round(s / quant[n]);
+  }
+}
+var BitWriter = class {
+  constructor() {
+    this.buf = new Uint8Array(4096);
+    this.length = 0;
+    this.acc = 0;
+    this.count = 0;
+  }
+  byte(b) {
+    if (this.length === this.buf.length) {
+      const grown = new Uint8Array(this.buf.length * 2);
+      grown.set(this.buf);
+      this.buf = grown;
+    }
+    this.buf[this.length++] = b;
+  }
+  bits(value, size) {
+    for (let i = size - 1; i >= 0; i--) {
+      this.acc = this.acc << 1 | value >> i & 1;
+      if (++this.count === 8) {
+        this.byte(this.acc);
+        if (this.acc === 255) this.byte(0);
+        this.acc = 0;
+        this.count = 0;
+      }
+    }
+  }
+  /** Pads the last byte with 1 bits and returns the segment. */
+  finish() {
+    if (this.count > 0) this.bits((1 << 8 - this.count) - 1, 8 - this.count);
+    return this.buf.subarray(0, this.length);
+  }
+};
+function category(v) {
+  let a = v < 0 ? -v : v;
+  let n = 0;
+  while (a) {
+    n++;
+    a >>= 1;
+  }
+  return n;
+}
+function writeBlock(w, coef, prevDc, dc, ac) {
+  const diff = coef[0] - prevDc;
+  const dcSize = category(diff);
+  w.bits(dc.code[dcSize], dc.size[dcSize]);
+  if (dcSize) w.bits(diff < 0 ? diff - 1 : diff, dcSize);
+  let run = 0;
+  for (let k = 1; k < 64; k++) {
+    const v = coef[k];
+    if (v === 0) {
+      run++;
+      continue;
+    }
+    while (run > 15) {
+      w.bits(ac.code[240], ac.size[240]);
+      run -= 16;
+    }
+    const size = category(v);
+    const symbol = run << 4 | size;
+    w.bits(ac.code[symbol], ac.size[symbol]);
+    w.bits(v < 0 ? v - 1 : v, size);
+    run = 0;
+  }
+  if (run > 0) w.bits(ac.code[0], ac.size[0]);
+  return coef[0];
+}
+function segment(marker, payload) {
+  const len = payload.length + 2;
+  return [255, marker, len >> 8, len & 255, ...payload];
+}
+function dhtPayload(tableClass, id, spec) {
+  return [tableClass << 4 | id, ...spec.bits, ...spec.values];
+}
+function encodeJpeg(data, width, height, options2 = {}) {
+  if (!(width >= 1 && height >= 1 && width <= 65535 && height <= 65535)) {
+    throw new RangeError(`JPEG dimensions out of range: ${width}x${height}`);
+  }
+  const quality = Number.isFinite(options2.quality) ? Math.min(1, Math.max(0, options2.quality)) : DEFAULT_JPEG_QUALITY;
+  const [bgR, bgG, bgB] = options2.background ?? [255, 255, 255];
+  const sub = options2.chromaSubsampling ?? false;
+  const lumaQuant = scaleQuant(LUMA_QUANT, quality);
+  const chromaQuant = scaleQuant(CHROMA_QUANT, quality);
+  const n = width * height;
+  const Y = new Float64Array(n);
+  const Cb = new Float64Array(n);
+  const Cr = new Float64Array(n);
+  for (let i = 0; i < n; i++) {
+    const a = data[i * 4 + 3] / 255;
+    const r = data[i * 4] * a + bgR * (1 - a);
+    const g = data[i * 4 + 1] * a + bgG * (1 - a);
+    const b = data[i * 4 + 2] * a + bgB * (1 - a);
+    Y[i] = 0.299 * r + 0.587 * g + 0.114 * b;
+    Cb[i] = -0.168736 * r - 0.331264 * g + 0.5 * b + 128;
+    Cr[i] = 0.5 * r - 0.418688 * g - 0.081312 * b + 128;
+  }
+  const dcL = buildCodes(DC_LUMA);
+  const acL = buildCodes(AC_LUMA);
+  const dcC = buildCodes(DC_CHROMA);
+  const acC = buildCodes(AC_CHROMA);
+  const factor = sub ? 2 : 1;
+  const mcu = 8 * factor;
+  const block = new Float64Array(64);
+  const tmp = new Float64Array(64);
+  const coef = new Int32Array(64);
+  const w = new BitWriter();
+  let dcY = 0;
+  let dcCb = 0;
+  let dcCr = 0;
+  const lumaBlock = (x0, y0) => {
+    for (let y = 0; y < 8; y++) {
+      const row2 = Math.min(height - 1, y0 + y) * width;
+      for (let x = 0; x < 8; x++) block[y * 8 + x] = Y[row2 + Math.min(width - 1, x0 + x)] - 128;
+    }
+  };
+  const chromaBlock = (plane, x0, y0) => {
+    for (let y = 0; y < 8; y++) {
+      for (let x = 0; x < 8; x++) {
+        let s = 0;
+        for (let dy = 0; dy < factor; dy++) {
+          const row2 = Math.min(height - 1, y0 + y * factor + dy) * width;
+          for (let dx = 0; dx < factor; dx++) s += plane[row2 + Math.min(width - 1, x0 + x * factor + dx)];
+        }
+        block[y * 8 + x] = s / (factor * factor) - 128;
+      }
+    }
+  };
+  for (let my = 0; my < height; my += mcu) {
+    for (let mx = 0; mx < width; mx += mcu) {
+      for (let by = 0; by < factor; by++) {
+        for (let bx = 0; bx < factor; bx++) {
+          lumaBlock(mx + bx * 8, my + by * 8);
+          fdctQuantize(block, lumaQuant, coef, tmp);
+          dcY = writeBlock(w, coef, dcY, dcL, acL);
+        }
+      }
+      chromaBlock(Cb, mx, my);
+      fdctQuantize(block, chromaQuant, coef, tmp);
+      dcCb = writeBlock(w, coef, dcCb, dcC, acC);
+      chromaBlock(Cr, mx, my);
+      fdctQuantize(block, chromaQuant, coef, tmp);
+      dcCr = writeBlock(w, coef, dcCr, dcC, acC);
+    }
+  }
+  const scan = w.finish();
+  const sampling = factor << 4 | factor;
+  const header = [
+    255,
+    216,
+    // APP0 JFIF 1.01, no density (aspect ratio 1:1), no thumbnail.
+    ...segment(224, [74, 70, 73, 70, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0]),
+    ...segment(219, [0, ...ZIGZAG2.map((i) => lumaQuant[i]), 1, ...ZIGZAG2.map((i) => chromaQuant[i])]),
+    ...segment(192, [8, height >> 8, height & 255, width >> 8, width & 255, 3, 1, sampling, 0, 2, 17, 1, 3, 17, 1]),
+    ...segment(196, [...dhtPayload(0, 0, DC_LUMA), ...dhtPayload(1, 0, AC_LUMA), ...dhtPayload(0, 1, DC_CHROMA), ...dhtPayload(1, 1, AC_CHROMA)]),
+    ...segment(218, [3, 1, 0, 2, 17, 3, 17, 0, 63, 0])
+  ];
+  const out = new Uint8Array(header.length + scan.length + 2);
+  out.set(header, 0);
+  out.set(scan, header.length);
+  out[out.length - 2] = 255;
+  out[out.length - 1] = 217;
+  return out;
+}
+
 // src/fnt-font.ts
 function parseFnt(view, base, end) {
   if (base + 118 > end) {
@@ -28251,6 +29015,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) {
@@ -28283,7 +29087,7 @@ function monoBox(o) {
   }
   return { xMin, xMax, yMin, yMax };
 }
-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;
@@ -28305,6 +29109,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) => {
@@ -28335,17 +29148,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?.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;
@@ -28394,17 +29209,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?.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;
@@ -28997,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);
@@ -29314,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;
@@ -36569,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;
@@ -38585,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) {
@@ -38738,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;
@@ -39889,8 +40735,8 @@ function drawPlusStringWithEngine(rCtx, font, text, layoutX, layoutY, paint, ali
   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));
+  for (const character of text) {
+    codes.push(character.codePointAt(0));
   }
   const tracking = format?.tracking ?? PLUS_DEFAULT_TRACKING;
   const dx = unhinted ? codes.map((c) => realized.advance(realized.glyphIndex(c)) * tracking) : null;
@@ -43381,6 +44227,54 @@ async function processDeferredImages(ctx, deferredImages, recursionDepth) {
   return complete;
 }
 async function convertMetafileToDataUrl(buffer, options2, recursionDepth = 0) {
+  const raster = await renderRaster(buffer, options2, recursionDepth, "convertMetafileToDataUrl");
+  if (!raster) {
+    return null;
+  }
+  try {
+    const url = await exportCanvasToPngDataUrl(raster.canvas);
+    if (!url) {
+      emfWarn("convertMetafileToDataUrl: exportCanvasToPngDataUrl returned null");
+    }
+    return url;
+  } catch (err) {
+    emfWarn("convertMetafileToDataUrl: EXCEPTION:", err instanceof Error ? err.message : err);
+    console.warn("[emf-converter] Conversion failed:", err instanceof Error ? err.message : err);
+    return null;
+  }
+}
+async function convertMetafileToJpegDataUrl(buffer, options2) {
+  const raster = await renderRaster(buffer, options2, 0, "convertMetafileToJpegDataUrl");
+  if (!raster) {
+    return null;
+  }
+  try {
+    const { canvas, ctx } = raster;
+    const pixels = canvas instanceof SoftwareRasterCanvas ? canvas.pixels : canvasGetImageData(ctx, 0, 0, canvas.width, canvas.height).data;
+    const jpeg = encodeJpeg(pixels, canvas.width, canvas.height, {
+      quality: options2?.quality,
+      background: parseBackground(options2?.background),
+      chromaSubsampling: options2?.chromaSubsampling
+    });
+    return `data:image/jpeg;base64,${bytesToBase64(jpeg)}`;
+  } catch (err) {
+    emfWarn("convertMetafileToJpegDataUrl: EXCEPTION:", err instanceof Error ? err.message : err);
+    console.warn("[emf-converter] Conversion failed:", err instanceof Error ? err.message : err);
+    return null;
+  }
+}
+function parseBackground(color) {
+  if (color === void 0) {
+    return [255, 255, 255];
+  }
+  const hex5 = /^#([0-9a-f]{3}|[0-9a-f]{6})$/i.exec(color.trim())?.[1];
+  if (!hex5) {
+    return [255, 255, 255];
+  }
+  const full = hex5.length === 3 ? [...hex5].map((c) => c + c).join("") : hex5;
+  return [0, 2, 4].map((i) => parseInt(full.slice(i, i + 2), 16));
+}
+async function renderRaster(buffer, options2, recursionDepth, caller) {
   await ensureNodeCanvasModule();
   if (recursionDepth > MAX_METAFILE_RECURSION) {
     return null;
@@ -43410,17 +44304,13 @@ async function convertMetafileToDataUrl(buffer, options2, recursionDepth = 0) {
     const soft = canvas instanceof SoftwareRasterCanvas ? canvas : null;
     if (soft && (soft.textDraws > 0 || !complete)) {
       emfWarn(
-        `convertMetafileToDataUrl: no canvas backend and the drawing ${soft.textDraws > 0 ? `contains text (${soft.textDraws} runs)` : "contains an image only a canvas can decode"}; install @napi-rs/canvas for PNG output, or use SVG output`
+        `${caller}: no canvas backend and the drawing ${soft.textDraws > 0 ? `contains text (${soft.textDraws} runs)` : "contains an image only a canvas can decode"}; install @napi-rs/canvas for raster output, or use SVG output`
       );
       return null;
     }
-    const url = await exportCanvasToPngDataUrl(canvas);
-    if (!url) {
-      emfWarn("convertMetafileToDataUrl: exportCanvasToPngDataUrl returned null");
-    }
-    return url;
+    return { canvas, ctx: result.surface.ctx };
   } catch (err) {
-    emfWarn("convertMetafileToDataUrl: EXCEPTION:", err instanceof Error ? err.message : err);
+    emfWarn(`${caller}: EXCEPTION:`, err instanceof Error ? err.message : err);
     console.warn("[emf-converter] Conversion failed:", err instanceof Error ? err.message : err);
     return null;
   }
@@ -43571,6 +44461,7 @@ async function convertMetafileToSvgDataUrl(buffer, options2) {
 
 exports.DEFAULT_DPI_SCALE = DEFAULT_DPI_SCALE;
 exports.convertMetafileToDataUrl = convertMetafileToDataUrl;
+exports.convertMetafileToJpegDataUrl = convertMetafileToJpegDataUrl;
 exports.convertMetafileToSvg = convertMetafileToSvg;
 exports.convertMetafileToSvgDataUrl = convertMetafileToSvgDataUrl;
 exports.convertMetafileToSvgTree = convertMetafileToSvgTree;