emf-converter 4.8.2 → 4.8.3

package/dist/index.js

@@ -17040,13 +17040,17 @@ function expandedBlur(rgba, width, height, radius, x0, y0, x1, y1, cropped) {
   const blurred = blurReduction(radius) > 1 ? effectBlur(buf, bw, bh, radius, cropped ? { x: r, y: r, w: x1 - x0, h: y1 - y0 } : void 0, true) : gdipBlur(buf, bw, bh, radius, cropped ? r : 0, cropped, Math.ceil((y1 - y0) / (x1 - x0)));
   const w = x1 - x0;
   const out = new Uint8ClampedArray(w * (y1 - y0) * 4);
+  const halo = new Uint8ClampedArray((y1 - y0) * 4);
   for (let y = 0; y < y1 - y0; y++) {
     const from = ((y + r) * bw + r) * 4;
     for (let i = 0; i < w * 4; i++) {
       out[y * w * 4 + i] = Math.round(blurred[from + i]);
     }
+    for (let i = 0; i < 4; i++) {
+      halo[y * 4 + i] = Math.round(blurred[from + w * 4 + i]);
+    }
   }
-  return out;
+  return { out, halo };
 }
 function applyImageEffectToRect(rgba, width, height, effect, src) {
   if (width <= 0 || height <= 0 || rgba.length !== width * height * 4) {
@@ -17079,7 +17083,12 @@ function applyImageEffectToRect(rgba, width, height, effect, src) {
   };
   if (src && effect.kind === "blur" && effect.expandEdge) {
     const cropped = Math.ceil(src.x + src.w) < width && Math.ceil(src.y + src.h) < height;
-    return result(expandedBlur(rgba, width, height, effect.radius, x0, y0, x1, y1, cropped));
+    const { out: out2, halo } = expandedBlur(rgba, width, height, effect.radius, x0, y0, x1, y1, cropped);
+    const region2 = result(out2);
+    if (shownWidth === w && shownHeight === h) {
+      region2.haloRight = halo;
+    }
+    return region2;
   }
   let region = rgba;
   if (w !== width || h !== height) {
@@ -20451,6 +20460,22 @@ function cubicIntegral(t, a) {
   }
   return Math.sign(t) * v;
 }
+var FAR_FADE = [1, 1, 0.985, 0.95, 0.91, 0.85, 0.8, 0.745, 0.69, 0.63, 0.56, 0.5, 0.43, 0.35, 0.28, 0.22, 0.16, 0.11, 0.065, 0.03, 0];
+function fadeAt(d, bilinear) {
+  if (d >= 1) {
+    return 0;
+  }
+  if (bilinear) {
+    return 1 - Math.max(0, d);
+  }
+  const x = Math.max(0, d) * 20;
+  const i = Math.floor(x);
+  return FAR_FADE[i] + (FAR_FADE[i + 1] - FAR_FADE[i]) * (x - i);
+}
+function nearSourceExtent(deviceLen, srcLen) {
+  const d = Math.ceil(deviceLen - 1e-6) - srcLen;
+  return d >= -1 && d <= 1;
+}
 var BICUBIC_A = -0.5;
 var HQ_BICUBIC_A = -1;
 function axisFilter(kernel, scale, copy) {
@@ -20555,13 +20580,39 @@ function mirroredOrigin(o) {
   return f === 0 ? o : Math.floor(o) + 1 - f;
 }
 function resampleImage(rgba, width, height, spec, surface) {
+  if (spec.rightHalo && spec.rightHalo.length === height * 4) {
+    const grown = new Uint8ClampedArray((width + 1) * height * 4);
+    for (let y = 0; y < height; y++) {
+      grown.set(rgba.subarray(y * width * 4, (y + 1) * width * 4), y * (width + 1) * 4);
+      grown.set(spec.rightHalo.subarray(y * 4, y * 4 + 4), (y * (width + 1) + width) * 4);
+    }
+    return resampleImage(grown, width + 1, height, { ...spec, rightHalo: void 0 }, surface);
+  }
   if (spec.kernel === "nearest" && !spec.wrap) {
     return resampleNearest(rgba, width, height, spec, surface);
   }
   let m = snapToDeviceGrid(spec);
-  const kernel = spec.kernel;
+  let kernel = spec.kernel;
   const hq = kernel === "hq-bilinear" || kernel === "hq-bicubic";
   const axisAligned = m[1] === 0 && m[2] === 0;
+  let farFade = false;
+  let shiftX = 0;
+  let shiftY = 0;
+  if (hq && !axisAligned) {
+    const extentU = Math.hypot(m[0], m[1]) * spec.srcW;
+    const extentV = Math.hypot(m[2], m[3]) * spec.srcH;
+    if (nearSourceExtent(extentU, spec.srcW) || nearSourceExtent(extentV, spec.srcH)) {
+      kernel = kernel === "hq-bicubic" ? "bicubic" : "bilinear";
+    } else {
+      farFade = true;
+      if (spec.halfPixelOffset) {
+        const lu = Math.hypot(m[0], m[1]);
+        const lv = Math.hypot(m[2], m[3]);
+        shiftX = 0.5 * m[0] / lu + 0.5 * m[2] / lv;
+        shiftY = 0.5 * m[1] / lu + 0.5 * m[3] / lv;
+      }
+    }
+  }
   if (hq && axisAligned) {
     const ox = m[0] * spec.srcX + m[4];
     m = [m[0], 0, 0, m[3], m[4] + mirroredOrigin(ox) - ox, m[5]];
@@ -20616,6 +20667,8 @@ function resampleImage(rgba, width, height, spec, surface) {
   const vMax = spec.srcY + spec.srcH;
   const wu = [];
   const wv = [];
+  const gradU = Math.hypot(inv2[0], inv2[2]);
+  const gradV = Math.hypot(inv2[1], inv2[3]);
   const c = spec.clampArgb ?? 0;
   const edge = {
     wrap: spec.wrap,
@@ -20627,8 +20680,8 @@ function resampleImage(rgba, width, height, spec, surface) {
     const py = by0 + j + o;
     for (let i = 0; i < w; i++) {
       const px = bx0 + i + o;
-      const u = inv2[0] * px + inv2[2] * py + inv2[4];
-      const v = inv2[1] * px + inv2[3] * py + inv2[5];
+      const u = inv2[0] * (px - shiftX) + inv2[2] * (py - shiftY) + inv2[4];
+      const v = inv2[1] * (px - shiftX) + inv2[3] * (py - shiftY) + inv2[5];
       const cx = px + COVERAGE_NUDGE_X;
       const cy = py + COVERAGE_NUDGE_Y;
       const eu = inv2[0] * cx + inv2[2] * cy + inv2[4];
@@ -20636,31 +20689,35 @@ function resampleImage(rgba, width, height, spec, surface) {
       if (eu < spec.srcX || ev < spec.srcY || eu >= uMax || ev >= vMax) {
         continue;
       }
-      const cu = u;
-      const cv = v;
-      const iu0 = Math.ceil(cu - fu.radius);
-      const iu1 = Math.floor(cu + fu.radius);
-      const iv0 = Math.ceil(cv - fv.radius);
-      const iv1 = Math.floor(cv + fv.radius);
-      wu.length = 0;
-      wv.length = 0;
-      for (let t = iu0; t <= iu1; t++) {
-        wu.push(fu.weight(t, cu));
-      }
-      for (let t = iv0; t <= iv1; t++) {
-        wv.push(fv.weight(t, cv));
-      }
-      const [r, g, b, a] = blendSeparable(
-        rgba,
-        width,
-        spec.wrap ? { x0: 0, y0: 0, x1: width, y1: height } : { x0: sx0, y0: sy0, x1: sx1, y1: sy1 },
-        iu0,
-        wu,
-        iv0,
-        wv,
-        kernel === "bicubic",
-        edge
-      );
+      const box = { x0: 0, y0: 0, x1: width, y1: height };
+      const sampleAt = (cu, cv) => {
+        const iu0 = Math.ceil(cu - fu.radius);
+        const iu1 = Math.floor(cu + fu.radius);
+        const iv0 = Math.ceil(cv - fv.radius);
+        const iv1 = Math.floor(cv + fv.radius);
+        wu.length = 0;
+        wv.length = 0;
+        for (let t = iu0; t <= iu1; t++) {
+          wu.push(fu.weight(t, cu));
+        }
+        for (let t = iv0; t <= iv1; t++) {
+          wv.push(fv.weight(t, cv));
+        }
+        return blendSeparable(rgba, width, box, iu0, wu, iv0, wv, kernel === "bicubic", edge);
+      };
+      let [r, g, b, a] = sampleAt(u, v);
+      if (farFade && !spec.wrap && a > 0) {
+        const du = (uMax - u) / gradU;
+        const dv = (vMax - v) / gradV;
+        const k = 1 - (du < 1 ? fadeAt(du, kernel === "hq-bilinear") * (sampleAt(uMax, v)[3] / a) : 0) - (dv < 1 ? fadeAt(dv, kernel === "hq-bilinear") * (sampleAt(u, vMax)[3] / a) : 0);
+        if (k < 1) {
+          const f = Math.max(0, k);
+          r *= f;
+          g *= f;
+          b *= f;
+          a *= f;
+        }
+      }
       if (a <= 0) {
         continue;
       }
@@ -23487,7 +23544,8 @@ function effectedDraw(img, bitmap, effect, draw, source) {
         srcY,
         srcW,
         srcH,
-        toDevice: mulMatrix(draw.resample.toDevice, shift)
+        toDevice: mulMatrix(draw.resample.toDevice, shift),
+        rightHalo: region.haloRight
       }
     }
   };
@@ -31426,6 +31484,15 @@ function illuminantCube(index) {
   }
   return cube;
 }
+var ILLUMINANT_MATRICES = {
+  1: [[1.64737, -0.59174, -0.05494], [0.02963, 0.96126, 881e-5], [0.2911, 0.40189, 0.30769]],
+  2: [[1.22319, -0.17765, -0.04515], [275e-5, 0.99054, 645e-5], [0.05514, 0.12795, 0.81816]],
+  3: [[1.02833, -0.01775, -0.01086], [861e-5, 0.98431, 728e-5], [-0.01616, -0.0448, 1.05995]],
+  4: [[1.17271, -0.14059, -0.03174], [-474e-5, 1.00266, 183e-5], [0.05783, 0.14663, 0.79683]],
+  5: [[1.10431, -0.08327, -0.02067], [-336e-5, 1.0025, 67e-5], [0.03344, 0.09072, 0.87702]],
+  7: [[0.92515, 0.05628, 0.01822], [318e-5, 0.9967, 34e-5], [-0.02086, -0.06817, 1.08783]],
+  8: [[1.31275, -0.26259, -0.04977], [-244e-5, 0.99695, 524e-5], [0.10854, 0.23443, 0.65827]]
+};
 function hasIlluminant(ca) {
   return illuminantCube(ca.illuminant) !== null;
 }
@@ -31496,9 +31563,9 @@ var BRIGHTNESS_STEP = 0.95625;
 var COLORFULNESS_SCALE = 1 / 100;
 var TINT_RADIANS = -Math.PI / 3;
 var RGB_TO_XYZ = [
-  [0.4124, 0.3576, 0.1805],
-  [0.2126, 0.7152, 0.0722],
-  [0.0193, 0.1192, 0.9505]
+  [0.4123908, 0.3575843, 0.1804808],
+  [0.212639, 0.7151687, 0.0721923],
+  [0.0193308, 0.1191948, 0.9505322]
 ];
 var XYZ_TO_RGB = invert3(RGB_TO_XYZ);
 var WHITE = RGB_TO_XYZ.map((row2) => row2[0] + row2[1] + row2[2]);
@@ -31526,13 +31593,13 @@ function adjustChroma(r, g, b, scale, angle) {
   const z = RGB_TO_XYZ[2][0] * r + RGB_TO_XYZ[2][1] * g + RGB_TO_XYZ[2][2] * b;
   const d = x + 15 * y + 3 * z;
   if (d <= 1e-9 || y <= 1e-9) {
-    return [r, g, b];
+    return [clamp255(r), clamp255(g), clamp255(b)];
   }
   const du = 4 * x / d - WHITE_U;
   const dv = 9 * y / d - WHITE_V;
   const cos = Math.cos(angle) * scale;
   const sin = Math.sin(angle) * scale;
-  const u = WHITE_U + du * cos - dv * sin;
+  const u = Math.max(0, WHITE_U + du * cos - dv * sin);
   const v = Math.max(1e-6, WHITE_V + du * sin + dv * cos);
   const x2 = y * 9 * u / (4 * v);
   const z2 = y * (12 - 3 * u - 20 * v) / (4 * v);
@@ -31551,6 +31618,7 @@ function adjustChroma(r, g, b, scale, angle) {
 }
 function colorAdjustmentMapper(ca) {
   const illuminant = illuminantCube(ca.illuminant);
+  const matrix = ILLUMINANT_MATRICES[ca.illuminant];
   const gammas = [ca.redGamma / 1e4, ca.greenGamma / 1e4, ca.blueGamma / 1e4];
   const black = ca.referenceBlack / 1e4 * 255;
   const span = Math.max(1e-6, ca.referenceWhite / 1e4 * 255 - black);
@@ -31579,16 +31647,17 @@ function colorAdjustmentMapper(ca) {
   }
   return (rgb2) => {
     let c = [rgb2 >> 16 & 255, rgb2 >> 8 & 255, rgb2 & 255];
-    if (illuminant) {
-      const mapped = lookupIlluminant(illuminant, c[0] / 255, c[1] / 255, c[2] / 255);
-      c = [mapped[0] * 255, mapped[1] * 255, mapped[2] * 255];
-    }
     if (chroma) {
-      if (!illuminant) {
-        c = c.map(exactPaletteLevel);
+      c = c.map(exactPaletteLevel);
+      if (matrix) {
+        const [r, g, b] = c;
+        c = matrix.map((row2) => row2[0] * r + row2[1] * g + row2[2] * b);
       }
-      c = adjustChroma(clamp255(c[0]), clamp255(c[1]), clamp255(c[2]), scale, angle);
+      c = adjustChroma(c[0], c[1], c[2], scale, angle);
       c = c.map(roundHalfUp);
+    } else if (illuminant) {
+      const mapped = lookupIlluminant(illuminant, c[0] / 255, c[1] / 255, c[2] / 255);
+      c = [mapped[0] * 255, mapped[1] * 255, mapped[2] * 255];
     }
     return curve(c[0], 0) << 16 | curve(c[1], 1) << 8 | curve(c[2], 2);
   };
@@ -31942,20 +32011,6 @@ function halftoneDespeckle(px, w, h) {
     }
   }
 }
-function halftoneSharpen(px, w, h) {
-  const src = px.slice();
-  const at = (x, y, c) => src[(Math.max(0, Math.min(h - 1, y)) * w + Math.max(0, Math.min(w - 1, x))) * 3 + c];
-  for (let y = 0; y < h; y++) {
-    for (let x = 0; x < w; x++) {
-      for (let c = 0; c < 3; c++) {
-        const v = at(x, y, c);
-        const sum = at(x - 1, y, c) + at(x + 1, y, c) + at(x, y - 1, c) + at(x, y + 1, c);
-        const out = v + Math.floor((4 * v - sum) / 8);
-        px[(y * w + x) * 3 + c] = out < 0 ? 0 : out > 255 ? 255 : out;
-      }
-    }
-  }
-}
 function halftonePairDespeckle(px, w, h, rows) {
   const n = rows ? w : h;
   const at = (k, side) => (rows ? side * w + k : k * w + side) * 3;
@@ -31978,6 +32033,46 @@ function halftoneKeepLast(px, w, h, rows) {
   }
   return out;
 }
+function halftoneReduceBoth(rect, sw, sh, dw, dh, flipX, flipY) {
+  const cols = halftoneReduceTaps(sw, dw, flipX);
+  const rows = halftoneReduceTaps(sh, dh, flipY);
+  const wide = new Int32Array(dw * sh * 3);
+  for (let y = 0; y < sh; y++) {
+    for (let x = 0; x < dw; x++) {
+      let total = 0;
+      for (const [, w] of cols[x]) total += w;
+      for (let c = 0; c < 3; c++) {
+        let sum = 0;
+        for (const [xx, w] of cols[x]) sum += rect[(y * sw + xx) * 3 + c] * w;
+        wide[(y * dw + x) * 3 + c] = Math.floor((2 * sum + total) / (2 * total));
+      }
+    }
+  }
+  const avg = new Float64Array(dw * dh * 3);
+  for (let y = 0; y < dh; y++) {
+    let total = 0;
+    for (const [, w] of rows[y]) total += w;
+    for (let x = 0; x < dw; x++) {
+      for (let c = 0; c < 3; c++) {
+        let sum = 0;
+        for (const [yy, w] of rows[y]) sum += wide[(yy * dw + x) * 3 + c] * w;
+        avg[(y * dw + x) * 3 + c] = sum / total;
+      }
+    }
+  }
+  const at = (x, y, c) => avg[(Math.max(0, Math.min(dh - 1, y)) * dw + Math.max(0, Math.min(dw - 1, x))) * 3 + c];
+  const out = new Int32Array(dw * dh * 3);
+  for (let y = 0; y < dh; y++) {
+    for (let x = 0; x < dw; x++) {
+      for (let c = 0; c < 3; c++) {
+        const v = at(x, y, c);
+        const sum = at(x - 1, y, c) + at(x + 1, y, c) + at(x, y - 1, c) + at(x, y + 1, c);
+        out[(y * dw + x) * 3 + c] = Math.max(0, Math.min(255, Math.floor(v + (4 * v - sum) / 8)));
+      }
+    }
+  }
+  return out;
+}
 function stretchHalftone(src, sx, sy, sw, sh, dw, dh, adjust, adjustAfterSampling = false, directDib = false, dither, curves) {
   const W = Math.max(0, Math.round(Math.abs(dw)));
   const H = Math.max(0, Math.round(Math.abs(dh)));
@@ -32029,11 +32124,18 @@ function stretchHalftone(src, sx, sy, sw, sh, dw, dh, adjust, adjustAfterSamplin
   }
   const reducedEven = W < SW ? SW % 2 === 0 && H % SH === 0 : SH % 2 === 0 && W % SW === 0;
   const ditherAtSource = dithered && (W >= SW && H >= SH || nativeMixed && reducedEven);
+  const extendRow = ditherAtSource && nativeMixed && W < SW && H > SH && !flipY;
+  if (extendRow) {
+    const bigger = new Int32Array((SH + 1) * SW * 3);
+    bigger.set(rect);
+    bigger.copyWithin(SH * SW * 3, (SH - 1) * SW * 3, SH * SW * 3);
+    rect = bigger;
+  }
   if (ditherAtSource) {
     ditherPixels(
       rect,
       SW,
-      SH,
+      extendRow ? SH + 1 : SH,
       dither,
       false,
       false,
@@ -32073,7 +32175,10 @@ function stretchHalftone(src, sx, sy, sw, sh, dw, dh, adjust, adjustAfterSamplin
     linear(rows, SH, H, flipY);
   }
   let out = nativeMixed ? new Float64Array(sampleW * sampleH * 3) : new Int32Array(W * H * 3);
-  for (let y = 0; y < sampleH; y++) {
+  if (reducing) {
+    out = halftoneReduceBoth(rect, SW, SH, W, H, flipX, flipY);
+  }
+  for (let y = 0; !reducing && y < sampleH; y++) {
     const ys = rows[y];
     for (let x = 0; x < sampleW; x++) {
       const xs = cols[x];
@@ -32098,15 +32203,38 @@ function stretchHalftone(src, sx, sy, sw, sh, dw, dh, adjust, adjustAfterSamplin
       out[o + 2] = round(b);
     }
   }
-  if (reducing) {
-    halftoneSharpen(out, W, H);
-  }
   if (nativeMixed) {
     const reduceHorizontal = W < SW;
+    let extension;
+    if (extendRow) {
+      const reduced = new Float64Array(sampleW * 3);
+      for (let x = 0; x < sampleW; x++) {
+        let total = 0;
+        const sums = [0, 0, 0];
+        for (const [xx, wx] of cols[x]) {
+          total += wx;
+          for (let c = 0; c < 3; c++) sums[c] += rect[(SH * SW + xx) * 3 + c] * wx;
+        }
+        for (let c = 0; c < 3; c++) reduced[x * 3 + c] = sums[c] / total;
+      }
+      extension = reduced;
+    }
     for (const horizontal of [reduceHorizontal, !reduceHorizontal]) {
       const source2 = out;
       out = new Int32Array(source2.length);
-      const at = (x, y, c) => source2[(Math.max(0, Math.min(sampleH - 1, y)) * sampleW + Math.max(0, Math.min(sampleW - 1, x))) * 3 + c];
+      const ext = extension;
+      const at = (x, y, c) => y >= sampleH && ext ? ext[Math.max(0, Math.min(sampleW - 1, x)) * 3 + c] : source2[(Math.max(0, Math.min(sampleH - 1, y)) * sampleW + Math.max(0, Math.min(sampleW - 1, x))) * 3 + c];
+      if (horizontal && ext) {
+        const next = new Int32Array(sampleW * 3);
+        for (let x = 0; x < sampleW; x++) {
+          for (let c = 0; c < 3; c++) {
+            const v = ext[x * 3 + c];
+            const sum = at(x - 1, sampleH, c) + at(x + 1, sampleH, c);
+            next[x * 3 + c] = Math.max(0, Math.min(255, Math.floor(v + (2 * v - sum) / 4)));
+          }
+        }
+        extension = next;
+      }
       for (let y = 0; y < sampleH; y++) {
         for (let x = 0; x < sampleW; x++) {
           for (let c = 0; c < 3; c++) {