pdfnative 1.3.0 → 1.4.0

package/dist/worker/index.cjs

@@ -3583,15 +3583,86 @@ function radialShadingDict(p, m) {
   const s = (sx + sy) / 2 || 1;
   return `<< /ShadingType 3 /ColorSpace /DeviceRGB /Coords [${n(x0)} ${n(y0)} ${n(p.r0 * s)} ${n(x1)} ${n(y1)} ${n(p.r1 * s)}] /Function ${buildGradientFunction(p.stops)} /Extend ${extendFlags(p.extend)} >>`;
 }
+function colorAtOffset(stops, t) {
+  if (stops.length === 0) return [0, 0, 0, 255];
+  const sorted = stops.slice().sort((a, b) => a.offset - b.offset);
+  if (t <= sorted[0].offset) return sorted[0].color;
+  const last = sorted[sorted.length - 1];
+  if (t >= last.offset) return last.color;
+  for (let i = 0; i < sorted.length - 1; i++) {
+    const a = sorted[i], b = sorted[i + 1];
+    if (t >= a.offset && t <= b.offset) {
+      const span = b.offset - a.offset || 1;
+      const f = (t - a.offset) / span;
+      return [
+        Math.round(a.color[0] + (b.color[0] - a.color[0]) * f),
+        Math.round(a.color[1] + (b.color[1] - a.color[1]) * f),
+        Math.round(a.color[2] + (b.color[2] - a.color[2]) * f),
+        Math.round(a.color[3] + (b.color[3] - a.color[3]) * f)
+      ];
+    }
+  }
+  return last.color;
+}
+function emitSweep(p, cx, cy, maxR, body, gsFor, blendMode) {
+  const start = p.startAngle;
+  const end = p.endAngle;
+  const span = end - start;
+  if (Math.abs(span) < 0.01) {
+    const c = colorAtOffset(p.stops, 0);
+    const gs = gsFor(c[3] / 255, blendMode);
+    if (gs) body.push(`/${gs} gs`);
+    body.push(`${ch(c[0])} ${ch(c[1])} ${ch(c[2])} rg`);
+    body.push(`${n(cx - maxR)} ${n(cy - maxR)} ${n(2 * maxR)} ${n(2 * maxR)} re`);
+    body.push("f");
+    return;
+  }
+  const steps = Math.max(12, Math.min(180, Math.ceil(Math.abs(span) / 3)));
+  const r = maxR * 1.5;
+  const rad = Math.PI / 180;
+  for (let i = 0; i < steps; i++) {
+    const a0 = start + span * i / steps;
+    const a1 = start + span * (i + 1) / steps;
+    const tMid = (i + 0.5) / steps;
+    const c = colorAtOffset(p.stops, tMid);
+    const gs = gsFor(c[3] / 255, blendMode);
+    body.push("q");
+    if (gs) body.push(`/${gs} gs`);
+    body.push(`${ch(c[0])} ${ch(c[1])} ${ch(c[2])} rg`);
+    const x0 = cx + r * Math.cos(a0 * rad), y0 = cy + r * Math.sin(a0 * rad);
+    const x1 = cx + r * Math.cos(a1 * rad), y1 = cy + r * Math.sin(a1 * rad);
+    body.push(`${n(cx)} ${n(cy)} m ${n(x0)} ${n(y0)} l ${n(x1)} ${n(y1)} l h`);
+    body.push("f");
+    body.push("Q");
+  }
+}
 function renderColorGlyph(glyph, outlines, unitsPerEm) {
   const body = [];
   const shadings = [];
   const extGStates = [];
-  const alphaMap = /* @__PURE__ */ new Map();
+  const gsMap = /* @__PURE__ */ new Map();
   let shadingIdx = 0;
+  const gsFor = (alpha, bm) => {
+    const a = Math.max(0, Math.min(1, alpha));
+    const needAlpha = a < 0.999;
+    const needBm = bm !== void 0 && bm !== "Normal";
+    if (!needAlpha && !needBm) return "";
+    const key = `${needAlpha ? a.toFixed(3) : "1"}|${needBm ? bm : ""}`;
+    let name = gsMap.get(key);
+    if (!name) {
+      name = `Gs${gsMap.size}`;
+      gsMap.set(key, name);
+      const parts = [];
+      if (needAlpha) parts.push(`/ca ${n(a)}`, `/CA ${n(a)}`);
+      if (needBm) parts.push(`/BM /${bm}`);
+      extGStates.push({ name, dict: `<< ${parts.join(" ")} >>` });
+    }
+    return name;
+  };
   let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
   for (const layer of glyph.layers) {
     const m = layer.transform ?? ID;
+    const bm = layer.blendMode;
     const contours = outlines(layer.glyphId);
     if (contours.length === 0) continue;
     const path = contoursToPath(contours, m);
@@ -3606,26 +3677,36 @@ function renderColorGlyph(glyph, outlines, unitsPerEm) {
     }
     if (layer.paint.kind === "solid") {
       const c = layer.paint.color;
-      const alpha = c[3] / 255;
       body.push("q");
-      if (alpha < 0.999) {
-        let gs = alphaMap.get(c[3]);
-        if (!gs) {
-          gs = `GsA${alphaMap.size}`;
-          alphaMap.set(c[3], gs);
-          extGStates.push({ name: gs, dict: `<< /ca ${n(alpha)} /CA ${n(alpha)} >>` });
-        }
-        body.push(`/${gs} gs`);
-      }
+      const gs = gsFor(c[3] / 255, bm);
+      if (gs) body.push(`/${gs} gs`);
       body.push(`${ch(c[0])} ${ch(c[1])} ${ch(c[2])} rg`);
       body.push(path);
       body.push("f");
       body.push("Q");
+    } else if (layer.paint.kind === "sweep") {
+      const [cx, cy] = tx(m, layer.paint.center[0], layer.paint.center[1]);
+      let r2 = 0;
+      for (const contour of contours) {
+        for (const pt of contour) {
+          const [px, py] = tx(m, pt.x, pt.y);
+          const d = (px - cx) * (px - cx) + (py - cy) * (py - cy);
+          if (d > r2) r2 = d;
+        }
+      }
+      const maxR = Math.sqrt(r2) || 1;
+      body.push("q");
+      body.push(path);
+      body.push("W n");
+      emitSweep(layer.paint, cx, cy, maxR, body, gsFor, bm);
+      body.push("Q");
     } else {
       const name = `Sh${shadingIdx++}`;
       const dict = layer.paint.kind === "linear" ? linearShadingDict(layer.paint, m) : radialShadingDict(layer.paint, m);
       shadings.push({ name, dict });
       body.push("q");
+      const gs = gsFor(1, bm);
+      if (gs) body.push(`/${gs} gs`);
       body.push(path);
       body.push("W n");
       body.push(`/${name} sh`);