@poe-platform/safe-bash 0.1.762 → 0.1.764

package/dist/safe-bash-command-ssconvert/index.js

@@ -209075,14 +209075,18 @@ function evaluateContentStreamToDisplayList(params) {
   const paths = [];
   const images = [];
   const operations = [];
+  let capturedOperations;
+  let insideSoftMask = false;
   const emit = (operation) => {
-    const { clipPaths, clipImages } = curState();
-    if (clipPaths || clipImages) operation = { ...operation, value: {
+    const { clipPaths, clipImages, softMask } = curState();
+    if (clipPaths || clipImages || softMask) operation = { ...operation, value: {
       ...operation.value,
       ...clipPaths ? { clipPaths } : {},
-      ...clipImages ? { clipImages } : {}
+      ...clipImages ? { clipImages } : {},
+      ...softMask ? { softMask } : {}
     } };
-    operations.push(operation);
+    (capturedOperations ?? operations).push(operation);
+    if (insideSoftMask) return;
     switch (operation.kind) {
       case "path":
         paths.push(operation.value);
@@ -209188,7 +209192,7 @@ function evaluateContentStreamToDisplayList(params) {
     );
     return { r: kClamp(r), g: kClamp(g), b: kClamp(b3) };
   };
-  const applyStateOperator = (st, operator, ops, activeResources) => {
+  const applyStateOperator = (st, operator, ops, activeResources, activeFonts, depth) => {
     const num = (i, fb = 0) => ops[i]?.kind === "number" ? ops[i].value : fb;
     if (operator === "cm") {
       const m = [num(0, 1), num(1, 0), num(2, 0), num(3, 1), num(4, 0), num(5, 0)];
@@ -209271,6 +209275,46 @@ function evaluateContentStreamToDisplayList(params) {
       const extDict = params.cosDoc.resolveDict(dictGet(activeResources, "ExtGState"));
       const gsDict = extDict ? params.cosDoc.resolveDict(dictGet(extDict, ops[0].decoded)) : void 0;
       if (gsDict) {
+        const mask = params.cosDoc.resolve(dictGet(gsDict, "SMask"));
+        if (mask?.kind === "name" && mask.decoded === "None") {
+          st.softMask = void 0;
+        } else if (mask?.kind === "dict") {
+          const subtype = params.cosDoc.resolve(dictGet(mask, "S"));
+          const form = params.cosDoc.resolve(dictGet(mask, "G"));
+          if (form?.kind === "stream" && subtype?.kind === "name" && (subtype.decoded === "Alpha" || subtype.decoded === "Luminosity")) {
+            if (depth >= 8) throw new PdfError2("E_LIMIT", "Soft-mask nesting exceeds the form depth limit");
+            const parentOperations = capturedOperations;
+            const parentInsideSoftMask = insideSoftMask;
+            const savedTextState = { pendingTextClip, hasTextClip, activeTm, activeTlm };
+            const captured = [];
+            capturedOperations = captured;
+            insideSoftMask = true;
+            const maskState = { ...st, softMask: void 0, fillAlpha: 1, strokeAlpha: 1, blendMode: "Normal" };
+            delete maskState.clipPaths;
+            delete maskState.clipImages;
+            delete maskState.clipRect;
+            stateStack.push(maskState);
+            try {
+              paintForm(form, activeResources, activeFonts, depth, void 0, void 0, true);
+            } finally {
+              stateStack.pop();
+              capturedOperations = parentOperations;
+              insideSoftMask = parentInsideSoftMask;
+              ({ pendingTextClip, hasTextClip, activeTm, activeTlm } = savedTextState);
+            }
+            const group = params.cosDoc.resolveDict(dictGet(form.dict, "Group"));
+            const colorSpace = group ? dictGet(group, "CS") : void 0;
+            const bc = params.cosDoc.resolveArray(dictGet(mask, "BC"));
+            const components22 = bc?.items.map((item) => {
+              const value3 = params.cosDoc.resolve(item);
+              return value3?.kind === "number" ? value3.value : 0;
+            });
+            const [r, g, b3] = components22 ? convertColorSpaceComponentsToRgb(params.cosDoc, colorSpace, "DeviceRGB", components22, activeResources) : [0, 0, 0];
+            const transfer = params.cosDoc.resolve(dictGet(mask, "TR"));
+            const transferMap = transfer?.kind === "dict" || transfer?.kind === "stream" ? Uint8Array.from({ length: 256 }, (_, i) => Math.floor(kClamp(Math.fround(evalShadingFunctionToComponents(params.cosDoc, transfer, Math.fround(i / 255))[0] ?? 0)) * 255)) : void 0;
+            st.softMask = { subtype: subtype.decoded, operations: captured, backdrop: { r, g, b: b3 }, transferMap };
+          }
+        }
         const bmNode = params.cosDoc.resolve(dictGet(gsDict, "BM"));
         if (bmNode?.kind === "name") {
           st.blendMode = bmNode.decoded === "Compatible" ? "Normal" : bmNode.decoded;
@@ -209357,6 +209401,84 @@ function evaluateContentStreamToDisplayList(params) {
     ] }], void 0, void 0, resources, activeFonts, depth);
     stateStack.pop();
   };
+  const paintForm = (form, activeResources, activeFonts, depth, mcid, actualText, maskGroup = false) => {
+    const st = curState();
+    const group = params.cosDoc.resolveDict(dictGet(form.dict, "Group"));
+    const groupType = group ? params.cosDoc.resolve(dictGet(group, "S")) : void 0;
+    const isolated = group ? params.cosDoc.resolve(dictGet(group, "I")) : void 0;
+    const isolate = !maskGroup && groupType?.kind === "name" && groupType.decoded === "Transparency" && isolated?.kind === "boolean" && isolated.value;
+    const formStreamBytes = params.cosDoc.decodeStream(form);
+    const formNodes = parseContentStream(formStreamBytes);
+    const formResDict = params.cosDoc.resolveDict(dictGet(form.dict, "Resources")) ?? activeResources;
+    const formFonts = new Map(activeFonts);
+    for (const [k, v] of resolvePageFonts(params.cosDoc, formResDict).entries()) {
+      formFonts.set(k, v);
+    }
+    let nextCtm = [...st.ctm];
+    const matArr = params.cosDoc.resolveArray(dictGet(form.dict, "Matrix"));
+    if (matArr && matArr.items.length >= 6) {
+      const mn = (idx, fb = 0) => {
+        const resolved = params.cosDoc.resolve(matArr.items[idx]);
+        return resolved?.kind === "number" ? resolved.value : fb;
+      };
+      const formMat = [mn(0, 1), mn(1, 0), mn(2, 0), mn(3, 1), mn(4, 0), mn(5, 0)];
+      nextCtm = multiplyMatrices(formMat, nextCtm);
+    }
+    let nextClip = !isolate && st.clipRect ? [...st.clipRect] : void 0;
+    let nextClipPaths = isolate ? void 0 : st.clipPaths;
+    const bboxArr = params.cosDoc.resolveArray(dictGet(form.dict, "BBox"));
+    if (bboxArr && bboxArr.items.length >= 4) {
+      const bn = (idx, fb = 0) => {
+        const resolved = params.cosDoc.resolve(bboxArr.items[idx]);
+        return resolved?.kind === "number" ? resolved.value : fb;
+      };
+      const bx0 = bn(0, 0), by0 = bn(1, 0), bx1 = bn(2, 0), by1 = bn(3, 0);
+      const pts = [
+        transformPoint(nextCtm, bx0, by0),
+        transformPoint(nextCtm, bx1, by0),
+        transformPoint(nextCtm, bx1, by1),
+        transformPoint(nextCtm, bx0, by1)
+      ];
+      nextClipPaths = [...nextClipPaths ?? [], [
+        ...pts.map(([x, y], index2) => ({ kind: index2 === 0 ? "move" : "line", x, y })),
+        { kind: "close" }
+      ]];
+      const fMinX = Math.min(...pts.map((p2) => p2[0]));
+      const fMinY = Math.min(...pts.map((p2) => p2[1]));
+      const fMaxX = Math.max(...pts.map((p2) => p2[0]));
+      const fMaxY = Math.max(...pts.map((p2) => p2[1]));
+      if (fMaxX > fMinX && fMaxY > fMinY) {
+        nextClip = nextClip ? [
+          Math.max(nextClip[0], fMinX),
+          Math.max(nextClip[1], fMinY),
+          Math.min(nextClip[2], fMaxX),
+          Math.min(nextClip[3], fMaxY)
+        ] : [fMinX, fMinY, fMaxX, fMaxY];
+      }
+    }
+    const parentOperations = capturedOperations;
+    const children8 = [];
+    const nextState = { ...st, ctm: nextCtm };
+    if (isolate) {
+      capturedOperations = children8;
+      nextState.fillAlpha = nextState.strokeAlpha = 1;
+      nextState.blendMode = "Normal";
+      nextState.softMask = void 0;
+      delete nextState.clipImages;
+      delete nextState.clipPaths;
+      delete nextState.clipRect;
+    }
+    if (nextClip) nextState.clipRect = nextClip;
+    if (nextClipPaths) nextState.clipPaths = nextClipPaths;
+    stateStack.push(nextState);
+    try {
+      walkNodes(formNodes, mcid, actualText, formResDict, formFonts, depth + 1);
+    } finally {
+      stateStack.pop();
+      capturedOperations = parentOperations;
+    }
+    if (isolate) emit({ kind: "group", value: { operations: children8, alpha: st.fillAlpha, blendMode: st.blendMode, clipRect: st.clipRect } });
+  };
   const walkNodes = (nodes, mcid, actualText, activeResources = params.resourcesDict, activeFonts = fonts, depth = 0) => {
     for (const node3 of nodes) {
       switch (node3.kind) {
@@ -209401,7 +209523,7 @@ function evaluateContentStreamToDisplayList(params) {
           break;
         }
         case "state-op": {
-          applyStateOperator(curState(), node3.operator, node3.operands, activeResources);
+          applyStateOperator(curState(), node3.operator, node3.operands, activeResources, activeFonts, depth);
           break;
         }
         case "path-op": {
@@ -209687,53 +209809,7 @@ function evaluateContentStreamToDisplayList(params) {
                   ...st.clipRect ? { clipRect: [...st.clipRect] } : {}
                 }, patternMask, activeResources, activeFonts, depth);
               } else if (sub === "Form" && depth < 8) {
-                const formStreamBytes = params.cosDoc.decodeStream(xobjNode);
-                const formNodes = parseContentStream(formStreamBytes);
-                const formResDict = params.cosDoc.resolveDict(dictGet(xobjNode.dict, "Resources")) ?? activeResources;
-                const formFonts = new Map(activeFonts);
-                for (const [k, v] of resolvePageFonts(params.cosDoc, formResDict).entries()) {
-                  formFonts.set(k, v);
-                }
-                let nextCtm = [...st.ctm];
-                const matArr = params.cosDoc.resolveArray(dictGet(xobjNode.dict, "Matrix"));
-                if (matArr && matArr.items.length >= 6) {
-                  const mn = (idx, fb = 0) => {
-                    const resolved = params.cosDoc.resolve(matArr.items[idx]);
-                    return resolved?.kind === "number" ? resolved.value : fb;
-                  };
-                  const formMat = [mn(0, 1), mn(1, 0), mn(2, 0), mn(3, 1), mn(4, 0), mn(5, 0)];
-                  nextCtm = multiplyMatrices(formMat, nextCtm);
-                }
-                let nextClip = st.clipRect ? [...st.clipRect] : void 0;
-                const bboxArr = params.cosDoc.resolveArray(dictGet(xobjNode.dict, "BBox"));
-                if (bboxArr && bboxArr.items.length >= 4) {
-                  const bn = (idx, fb = 0) => {
-                    const resolved = params.cosDoc.resolve(bboxArr.items[idx]);
-                    return resolved?.kind === "number" ? resolved.value : fb;
-                  };
-                  const bx0 = bn(0, 0), by0 = bn(1, 0), bx1 = bn(2, 0), by1 = bn(3, 0);
-                  const pts = [
-                    transformPoint(nextCtm, bx0, by0),
-                    transformPoint(nextCtm, bx1, by0),
-                    transformPoint(nextCtm, bx0, by1),
-                    transformPoint(nextCtm, bx1, by1)
-                  ];
-                  const fMinX = Math.min(...pts.map((p2) => p2[0]));
-                  const fMinY = Math.min(...pts.map((p2) => p2[1]));
-                  const fMaxX = Math.max(...pts.map((p2) => p2[0]));
-                  const fMaxY = Math.max(...pts.map((p2) => p2[1]));
-                  if (fMaxX > fMinX && fMaxY > fMinY) {
-                    nextClip = nextClip ? [
-                      Math.max(nextClip[0], fMinX),
-                      Math.max(nextClip[1], fMinY),
-                      Math.min(nextClip[2], fMaxX),
-                      Math.min(nextClip[3], fMaxY)
-                    ] : [fMinX, fMinY, fMaxX, fMaxY];
-                  }
-                }
-                stateStack.push({ ...st, ctm: nextCtm, ...nextClip ? { clipRect: nextClip } : {} });
-                walkNodes(formNodes, mcid, actualText, formResDict, formFonts, depth + 1);
-                if (stateStack.length > 1) stateStack.pop();
+                paintForm(xobjNode, activeResources, activeFonts, depth, mcid, actualText);
               }
             }
           }
@@ -209952,7 +210028,7 @@ function evaluateContentStreamToDisplayList(params) {
                 st.textRenderMode = cmd.mode;
                 break;
               case "state-op":
-                applyStateOperator(st, cmd.operator, cmd.operands, activeResources);
+                applyStateOperator(st, cmd.operator, cmd.operands, activeResources, activeFonts, depth);
                 break;
               case "show-text":
                 emitTokenBytes(cmd.token.bytes);
@@ -212256,6 +212332,184 @@ function downscaleImage(image, widthScale, heightScale) {
   }
   return image;
 }
+var MAX_STROKE_VERTICES = 1e6;
+function dashSubpath(path2, pattern, phase) {
+  const cycle = pattern.reduce((sum2, value3) => sum2 + value3, 0);
+  if (!(cycle > 0)) return [path2];
+  let offset = (phase % cycle + cycle) % cycle, index2 = 0;
+  while (offset > 0) {
+    if (offset < pattern[index2]) break;
+    offset -= pattern[index2];
+    index2 = (index2 + 1) % pattern.length;
+  }
+  let remaining = pattern[index2] - offset;
+  const points = path2.closed ? [...path2.points, path2.points[0]] : path2.points;
+  const result2 = [];
+  let current = [];
+  let steps = 0;
+  const flush = () => {
+    if (current.length) result2.push({ points: current, closed: false });
+    current = [];
+  };
+  const advance2 = (point) => {
+    while (remaining <= 0) {
+      if (++steps > MAX_STROKE_VERTICES) throw new PdfError2("E_LIMIT", "Stroke dash expansion exceeds the vertex limit");
+      if (index2 % 2 === 0) {
+        if (pattern[index2] === 0) result2.push({ points: [point, point], closed: false });
+        flush();
+      }
+      index2 = (index2 + 1) % pattern.length;
+      remaining = pattern[index2];
+    }
+  };
+  for (let i = 1; i < points.length; i++) {
+    const start = points[i - 1], end2 = points[i];
+    const dx = end2[0] - start[0], dy = end2[1] - start[1];
+    const length = Math.hypot(dx, dy);
+    if (!Number.isFinite(length) || length / cycle * pattern.length > MAX_STROKE_VERTICES) {
+      throw new PdfError2("E_LIMIT", "Stroke dash expansion exceeds the vertex limit");
+    }
+    let distance2 = 0;
+    while (distance2 < length) {
+      const point = [start[0] + dx * distance2 / length, start[1] + dy * distance2 / length];
+      advance2(point);
+      const step = Math.min(remaining, length - distance2);
+      if (distance2 + step === distance2 || ++steps > MAX_STROKE_VERTICES) throw new PdfError2("E_LIMIT", "Stroke dash expansion exceeds the vertex limit");
+      distance2 += step;
+      remaining -= step;
+      if (index2 % 2 === 0) {
+        if (!current.length) current.push(point);
+        current.push([start[0] + dx * distance2 / length, start[1] + dy * distance2 / length]);
+      }
+    }
+  }
+  flush();
+  if (path2.closed && result2.length) {
+    const first = result2[0], last = result2[result2.length - 1];
+    const start = path2.points[0];
+    const firstPoint = first.points[0], lastPoint = last.points[last.points.length - 1];
+    if (firstPoint[0] === start[0] && firstPoint[1] === start[1] && lastPoint[0] === start[0] && lastPoint[1] === start[1]) {
+      if (first === last) result2[0] = { points: first.points, closed: true };
+      else {
+        result2[0] = { points: [...last.points, ...first.points.slice(1)], closed: false };
+        result2.pop();
+      }
+    }
+  }
+  return result2;
+}
+function strokeOutlines(paths, width2, cap, join3, miterLimit, dashArray = [], dashPhase = 0) {
+  const half = width2 / 2;
+  const contours = [];
+  const pattern = dashArray.length % 2 ? [...dashArray, ...dashArray] : dashArray;
+  let count = 0;
+  let contour = [];
+  const add5 = (x, y) => {
+    if (++count > MAX_STROKE_VERTICES) throw new PdfError2("E_LIMIT", "Stroke outline exceeds the vertex limit");
+    contour.push([x, y]);
+  };
+  const arc = (point, dx1, dy1, dx2, dy2) => {
+    let a1 = Math.atan2(dy1, dx1), a22 = Math.atan2(dy2, dx2);
+    const ccw = a1 - a22 > 0 && a1 - a22 < Math.PI;
+    const step = Math.acos(half / (half + 0.125)) * 2;
+    add5(point[0] + dx1, point[1] + dy1);
+    if (step > 0) {
+      if (!ccw) {
+        if (a1 > a22) a22 += 2 * Math.PI;
+        a22 -= step / 4;
+        if ((a22 - a1) / step > MAX_STROKE_VERTICES - count) throw new PdfError2("E_LIMIT", "Stroke arc exceeds the vertex limit");
+        for (a1 += step; a1 < a22; a1 += step) add5(point[0] + half * Math.cos(a1), point[1] + half * Math.sin(a1));
+      } else {
+        if (a1 < a22) a22 -= 2 * Math.PI;
+        a22 += step / 4;
+        if ((a1 - a22) / step > MAX_STROKE_VERTICES - count) throw new PdfError2("E_LIMIT", "Stroke arc exceeds the vertex limit");
+        for (a1 -= step; a1 > a22; a1 -= step) add5(point[0] + half * Math.cos(a1), point[1] + half * Math.sin(a1));
+      }
+    }
+    add5(point[0] + dx2, point[1] + dy2);
+  };
+  const addCap = (point, next) => {
+    const length = Math.hypot(next[0] - point[0], next[1] - point[1]);
+    const dx = half * (next[1] - point[1]) / length;
+    const dy = half * (next[0] - point[0]) / length;
+    if (cap !== 1) {
+      const sx = cap === 2 ? dy : 0, sy = cap === 2 ? dx : 0;
+      add5(point[0] - dx - sx, point[1] + dy - sy);
+      add5(point[0] + dx - sx, point[1] - dy - sy);
+    } else {
+      const angle = Math.atan2(dy, -dx);
+      const step = Math.max(1e-3, Math.acos(half / (half + 0.125)) * 2);
+      add5(point[0] - dx, point[1] + dy);
+      for (let a3 = angle + step; a3 < angle + Math.PI - step / 4; a3 += step) add5(point[0] + half * Math.cos(a3), point[1] + half * Math.sin(a3));
+      add5(point[0] + dx, point[1] - dy);
+    }
+  };
+  const addJoin = (prev, point, next) => {
+    const len1 = Math.hypot(point[0] - prev[0], point[1] - prev[1]);
+    const len2 = Math.hypot(next[0] - point[0], next[1] - point[1]);
+    const dx1 = half * (point[1] - prev[1]) / len1, dy1 = half * (point[0] - prev[0]) / len1;
+    const dx2 = half * (next[1] - point[1]) / len2, dy2 = half * (next[0] - point[0]) / len2;
+    const inner = (next[0] - point[0]) * (point[1] - prev[1]) - (next[1] - point[1]) * (point[0] - prev[0]) > 0;
+    if (!inner && join3 === 1) {
+      arc(point, dx1, -dy1, dx2, -dy2);
+      return;
+    }
+    if (inner || join3 === 0) {
+      const ax = prev[0] + dx1, ay = prev[1] - dy1;
+      const bx = point[0] + dx1, by = point[1] - dy1;
+      const cx = point[0] + dx2, cy = point[1] - dy2;
+      const dx = next[0] + dx2, dy = next[1] - dy2;
+      const den = (bx - ax) * (dy - cy) - (by - ay) * (dx - cx);
+      if (Math.abs(den) >= 1e-30) {
+        const t = ((ay - cy) * (dx - cx) - (ax - cx) * (dy - cy)) / den;
+        const x = ax + (bx - ax) * t, y = ay + (by - ay) * t;
+        if (Math.hypot(x - point[0], y - point[1]) <= half * (inner ? 1.01 : miterLimit)) {
+          add5(x, y);
+          return;
+        }
+      } else if ((bx - prev[0]) * dy1 - (prev[1] - by) * dx1 < 0 !== (bx - next[0]) * dy1 - (next[1] - by) * dx1 < 0) {
+        add5(bx, by);
+        return;
+      }
+    }
+    add5(point[0] + dx1, point[1] - dy1);
+    add5(point[0] + dx2, point[1] - dy2);
+  };
+  for (const path2 of paths) {
+    for (const subpath of pattern.length ? dashSubpath(path2, pattern, dashPhase) : [path2]) {
+      const points = [];
+      for (const point of subpath.points) {
+        const prev = points[points.length - 1];
+        if (!prev || Math.hypot(prev[0] - point[0], prev[1] - point[1]) > 1e-14) points.push(point);
+      }
+      let closed = subpath.closed;
+      if (closed && points.length > 1 && Math.hypot(points[0][0] - points[points.length - 1][0], points[0][1] - points[points.length - 1][1]) <= 1e-14) points.pop();
+      if (points.length < 3) closed = false;
+      if (points.length === 1 && subpath.points.length > 1 && cap === 1) {
+        contour = [];
+        const [x, y] = points[0];
+        addCap([x, y], [x + 1, y]);
+        addCap([x, y], [x - 1, y]);
+        contours.push(contour);
+      } else if (points.length >= 2) {
+        contour = [];
+        if (!closed) addCap(points[0], points[1]);
+        for (let i = closed ? 0 : 1; i < points.length - (closed ? 0 : 1); i++) {
+          addJoin(points[(i + points.length - 1) % points.length], points[i], points[(i + 1) % points.length]);
+        }
+        if (closed) {
+          contours.push(contour);
+          contour = [];
+        } else addCap(points[points.length - 1], points[points.length - 2]);
+        for (let i = points.length - (closed ? 1 : 2); i >= (closed ? 0 : 1); i--) {
+          addJoin(points[(i + 1) % points.length], points[i], points[(i + points.length - 1) % points.length]);
+        }
+        contours.push(contour);
+      }
+    }
+  }
+  return contours;
+}
 function decodePng2(pngBytes) {
   if (pngBytes.length < 24 || pngBytes[0] !== 137 || pngBytes[1] !== 80 || pngBytes[2] !== 78 || pngBytes[3] !== 71) {
     throw new Error("Invalid PNG signature");
@@ -212950,111 +213204,60 @@ function blendPixel(rgba, width2, height, px, py, color5, alpha, blendMode, clip
   rgba[idx + 2] = Math.round((effB * a3 + cbB * dstA * (1 - a3)) / outA * 255);
   rgba[idx + 3] = Math.round(outA * 255);
 }
-function drawAntiAliasedSegment(rgba, width2, height, x0, y0, x1, y1, strokeWidth, color5, alpha = 1, lineCap = 0, antialias = true, blendMode, clipMask) {
-  const halfW = Math.max(0.6, strokeWidth * 0.5);
-  const dx = x1 - x0;
-  const dy = y1 - y0;
-  const lenSq = dx * dx + dy * dy;
-  const segLen = Math.sqrt(lenSq);
-  const pad = lineCap === 2 ? halfW + 2 : halfW + 1;
-  const minX = Math.max(0, Math.floor(Math.min(x0, x1) - pad));
-  const maxX = Math.min(width2 - 1, Math.ceil(Math.max(x0, x1) + pad));
-  const minY = Math.max(0, Math.floor(Math.min(y0, y1) - pad));
-  const maxY = Math.min(height - 1, Math.ceil(Math.max(y0, y1) + pad));
-  for (let py = minY; py <= maxY; py++) {
-    for (let px = minX; px <= maxX; px++) {
-      const cx = px + 0.5;
-      const cy = py + 0.5;
-      if (segLen > 1e-6 && (lineCap === 0 || lineCap === 2)) {
-        const ux = dx / segLen;
-        const uy = dy / segLen;
-        const along = (cx - x0) * ux + (cy - y0) * uy;
-        const perp = Math.abs(-(cx - x0) * uy + (cy - y0) * ux);
-        const minAlong = lineCap === 2 ? -halfW : 0;
-        const maxAlong = lineCap === 2 ? segLen + halfW : segLen;
-        const overAlong = along < minAlong ? minAlong - along : along > maxAlong ? along - maxAlong : 0;
-        const dist2 = overAlong > 0 ? Math.max(perp, halfW + overAlong) : perp;
-        if (dist2 <= halfW + 0.75) {
-          const cov = antialias ? Math.max(0, Math.min(1, halfW + 0.5 - dist2)) : dist2 <= halfW + 0.25 ? 1 : 0;
-          blendPixel(rgba, width2, height, px, py, color5, cov * alpha, blendMode, clipMask);
-        }
-        continue;
-      }
-      let t = lenSq > 1e-6 ? ((cx - x0) * dx + (cy - y0) * dy) / lenSq : 0;
-      t = Math.max(0, Math.min(1, t));
-      const projX = x0 + t * dx;
-      const projY = y0 + t * dy;
-      const dist = Math.hypot(cx - projX, cy - projY);
-      if (dist <= halfW + 0.75) {
-        const cov = antialias ? Math.max(0, Math.min(1, halfW + 0.5 - dist)) : dist <= halfW + 0.25 ? 1 : 0;
-        blendPixel(rgba, width2, height, px, py, color5, cov * alpha, blendMode, clipMask);
-      }
+function segmentsToScreenPaths(segments, pageHeight, scale2) {
+  const paths = [];
+  let points = [];
+  let current = [0, 0];
+  const toScreen = (x, y) => [x * scale2, (pageHeight - y) * scale2];
+  for (const segment of segments) {
+    if (segment.kind === "move") {
+      if (points.length) paths.push({ points, closed: false });
+      current = toScreen(segment.x, segment.y);
+      points = [current];
+    } else if (segment.kind === "line") {
+      if (!points.length) points = [current];
+      current = toScreen(segment.x, segment.y);
+      points.push(current);
+    } else if (segment.kind === "cubic") {
+      if (!points.length) points = [current];
+      const a3 = toScreen(segment.x1, segment.y1), b3 = toScreen(segment.x2, segment.y2);
+      const end2 = toScreen(segment.x, segment.y);
+      const curve = flattenCubic(current[0], current[1], a3[0], a3[1], b3[0], b3[1], end2[0], end2[1]);
+      for (let i = 1; i < curve.length; i++) points.push(curve[i]);
+      current = end2;
+    } else if (segment.kind === "close") {
+      if (points.length) {
+        paths.push({ points, closed: true });
+        current = points[0];
+        points = [];
+      }
+    } else if (segment.kind === "rect") {
+      if (points.length) paths.push({ points, closed: false });
+      const first = toScreen(segment.x, segment.y);
+      paths.push({ points: [
+        first,
+        toScreen(segment.x + segment.width, segment.y),
+        toScreen(segment.x + segment.width, segment.y + segment.height),
+        toScreen(segment.x, segment.y + segment.height)
+      ], closed: true });
+      current = first;
+      points = [];
     }
   }
+  if (points.length) paths.push({ points, closed: false });
+  return paths;
 }
-function segmentsToScreenEdges(segments, pageHeight, scale2, closeSubpaths = false) {
+function pathsToEdges(paths, closeSubpaths = false) {
   const edges2 = [];
-  let curX = 0;
-  let curY = 0;
-  let startX = 0;
-  let startY = 0;
-  let hasOpenSubpath = false;
-  const toScreen = (x, y) => [x * scale2, (pageHeight - y) * scale2];
-  for (const seg of segments) {
-    if (seg.kind === "move") {
-      if (closeSubpaths && hasOpenSubpath && (curX !== startX || curY !== startY)) {
-        edges2.push({ x0: curX, y0: curY, x1: startX, y1: startY });
-      }
-      [curX, curY] = toScreen(seg.x, seg.y);
-      startX = curX;
-      startY = curY;
-      hasOpenSubpath = false;
-    } else if (seg.kind === "line") {
-      const [nx, ny] = toScreen(seg.x, seg.y);
-      edges2.push({ x0: curX, y0: curY, x1: nx, y1: ny });
-      curX = nx;
-      curY = ny;
-      hasOpenSubpath = true;
-    } else if (seg.kind === "cubic") {
-      const [p1x, p1y] = toScreen(seg.x1, seg.y1);
-      const [p2x, p2y] = toScreen(seg.x2, seg.y2);
-      const [p3x, p3y] = toScreen(seg.x, seg.y);
-      const points = flattenCubic(curX, curY, p1x, p1y, p2x, p2y, p3x, p3y);
-      let px = curX;
-      let py = curY;
-      for (let i = 1; i < points.length; i++) {
-        const [qx, qy] = points[i];
-        edges2.push({ x0: px, y0: py, x1: qx, y1: qy });
-        px = qx;
-        py = qy;
-      }
-      curX = p3x;
-      curY = p3y;
-      hasOpenSubpath = true;
-    } else if (seg.kind === "close") {
-      if (curX !== startX || curY !== startY) {
-        edges2.push({ x0: curX, y0: curY, x1: startX, y1: startY });
-        curX = startX;
-        curY = startY;
-      }
-      hasOpenSubpath = false;
-    } else if (seg.kind === "rect") {
-      if (closeSubpaths && hasOpenSubpath && (curX !== startX || curY !== startY)) {
-        edges2.push({ x0: curX, y0: curY, x1: startX, y1: startY });
-      }
-      const [rx0, ry0] = toScreen(seg.x, seg.y);
-      const [rx1, ry1] = toScreen(seg.x + seg.width, seg.y + seg.height);
-      edges2.push(
-        { x0: rx0, y0: ry0, x1: rx1, y1: ry0 },
-        { x0: rx1, y0: ry0, x1: rx1, y1: ry1 },
-        { x0: rx1, y0: ry1, x1: rx0, y1: ry1 },
-        { x0: rx0, y0: ry1, x1: rx0, y1: ry0 }
-      );
-      hasOpenSubpath = false;
+  for (const { points, closed } of paths) {
+    for (let i = 1; i < points.length; i++) {
+      const a3 = points[i - 1], b3 = points[i];
+      edges2.push({ x0: a3[0], y0: a3[1], x1: b3[0], y1: b3[1] });
+    }
+    if ((closed || closeSubpaths) && points.length > 1) {
+      const a3 = points[points.length - 1], b3 = points[0];
+      edges2.push({ x0: a3[0], y0: a3[1], x1: b3[0], y1: b3[1] });
     }
-  }
-  if (closeSubpaths && hasOpenSubpath && (curX !== startX || curY !== startY)) {
-    edges2.push({ x0: curX, y0: curY, x1: startX, y1: startY });
   }
   return edges2;
 }
@@ -213165,6 +213368,30 @@ function paintOperations(displayList) {
     ...displayList.glyphs.map((value3) => ({ kind: "glyph", value: value3 }))
   ];
 }
+function renderSoftMask(mask, displayList, scale2) {
+  const bitmap = renderDisplayListToBitmap({
+    ...displayList,
+    rotation: 0,
+    glyphs: [],
+    paths: [],
+    images: [],
+    operations: mask.operations
+  }, { scale: scale2, transparent: true });
+  const { data: data3 } = bitmap;
+  for (let i = 0; i < data3.length; i += 4) {
+    let value3 = data3[i + 3];
+    if (mask.subtype === "Luminosity") {
+      const alpha = value3 / 255;
+      const r = Math.round(data3[i] * alpha + mask.backdrop.r * 255 * (1 - alpha));
+      const g = Math.round(data3[i + 1] * alpha + mask.backdrop.g * 255 * (1 - alpha));
+      const b3 = Math.round(data3[i + 2] * alpha + mask.backdrop.b * 255 * (1 - alpha));
+      value3 = Math.round(pdfLum(r, g, b3));
+    }
+    data3[i] = data3[i + 1] = data3[i + 2] = 0;
+    data3[i + 3] = mask.transferMap?.[value3] ?? value3;
+  }
+  return bitmap;
+}
 function renderDisplayListToBitmap(displayList, options = {}) {
   const baseScale = options.scale ?? (options.dpi ? options.dpi / 72 : 1.5);
   const scaleX = options.dpiX !== void 0 ? options.dpiX / 72 : baseScale;
@@ -213188,10 +213415,28 @@ function renderDisplayListToBitmap(displayList, options = {}) {
   const aaTxt = options.antialiasText !== false;
   let cachedClips;
   let cachedClipMask;
+  let cachedSoftMask;
+  let cachedSoftMaskPixels;
   const imageClipMasks = /* @__PURE__ */ new Map();
   for (const original of paintOperations(displayList)) {
     if (original.kind === "glyph" && (original.value.renderMode === 3 || !original.value.outline && !original.value.unicode.trim())) continue;
-    const operation = original.kind === "glyph" ? { kind: "path", value: glyphPaint(original.value) } : original;
+    let operation = original.kind === "glyph" ? { kind: "path", value: glyphPaint(original.value) } : original;
+    if (operation.kind === "group") {
+      const group = operation.value;
+      const bitmap = renderDisplayListToBitmap({ ...displayList, rotation: 0, operations: group.operations }, { ...options, scale: scale2, dpiX: void 0, dpiY: void 0, cropRect: void 0, transparent: true });
+      for (let i = 3; i < bitmap.data.length; i += 4) bitmap.data[i] = Math.round(bitmap.data[i] * group.alpha);
+      operation = { kind: "image", value: {
+        name: "TransparencyGroup",
+        width: bitmap.width,
+        height: bitmap.height,
+        decodedRgba: bitmap.data,
+        matrix: [bitmap.width / scale2, 0, 0, bitmap.height / scale2, 0, displayList.height - bitmap.height / scale2],
+        colorSpace: "DeviceRGB",
+        bitsPerComponent: 8,
+        blendMode: group.blendMode,
+        clipRect: group.clipRect
+      } };
+    }
     const clips = original.value.clipPaths;
     let clipMask = clips && clips === cachedClips ? cachedClipMask : void 0;
     if (clips && !clipMask) {
@@ -213199,12 +213444,25 @@ function renderDisplayListToBitmap(displayList, options = {}) {
       for (const clip2 of clips) {
         const { segments, fillRule } = "segments" in clip2 ? clip2 : { segments: clip2, fillRule: "nonzero" };
         const layer = new Uint8Array(width2 * height * 4);
-        fillEdgesScanline4x4(layer, width2, height, segmentsToScreenEdges(segments, displayList.height, scale2, true), { r: 1, g: 1, b: 1 }, 1, fillRule);
+        fillEdgesScanline4x4(layer, width2, height, pathsToEdges(segmentsToScreenPaths(segments, displayList.height, scale2), true), { r: 1, g: 1, b: 1 }, 1, fillRule);
         for (let i = 3; i < layer.length; i += 4) clipMask[i] = Math.round(clipMask[i] * layer[i] / 255);
       }
       cachedClips = clips;
       cachedClipMask = clipMask;
     }
+    const softMask = original.value.softMask;
+    if (softMask) {
+      if (softMask !== cachedSoftMask) {
+        cachedSoftMaskPixels = renderSoftMask(softMask, displayList, scale2).data;
+        cachedSoftMask = softMask;
+      }
+      if (clipMask) {
+        clipMask = clipMask.slice();
+        for (let i = 3; i < clipMask.length; i += 4) clipMask[i] = Math.round(clipMask[i] * cachedSoftMaskPixels[i] / 255);
+      } else {
+        clipMask = cachedSoftMaskPixels;
+      }
+    }
     const imageClips = original.value.clipImages;
     if (imageClips) {
       let imageMask = imageClipMasks.get(imageClips);
@@ -213233,62 +213491,38 @@ function renderDisplayListToBitmap(displayList, options = {}) {
     if (operation.kind === "path") {
       const path2 = operation.value;
       if (path2.fillColor) {
-        const edges2 = segmentsToScreenEdges(path2.segments, displayList.height, scale2, true);
+        const edges2 = pathsToEdges(segmentsToScreenPaths(path2.segments, displayList.height, scale2), true);
         const clipScreen = path2.clipRect ? [path2.clipRect[0] * scale2, (displayList.height - path2.clipRect[3]) * scale2, path2.clipRect[2] * scale2, (displayList.height - path2.clipRect[1]) * scale2] : void 0;
         fillEdgesScanline4x4(rgba, width2, height, edges2, path2.fillColor, path2.fillAlpha ?? 1, path2.fillRule ?? "nonzero", clipScreen, original.kind === "glyph" ? aaTxt : aaVec, path2.blendMode, clipMask);
       }
       if (path2.strokeColor) {
-        const edges2 = segmentsToScreenEdges(path2.segments, displayList.height, scale2, false);
         const rawSw = path2.strokeWidth * scale2;
         const sw = Math.max(1, rawSw);
         const strokeAlpha = options.thinLineMode === "shape" && rawSw < 1 ? (path2.strokeAlpha ?? 1) * Math.max(0.25, rawSw) : path2.strokeAlpha ?? 1;
-        const dashArr = path2.dashArray && path2.dashArray.length > 0 ? path2.dashArray.map((d2) => Math.max(0, d2 * scale2)) : void 0;
-        const dashCycle = dashArr ? dashArr.reduce((a3, b3) => a3 + b3, 0) : 0;
-        let dashDist = (path2.dashPhase ?? 0) * scale2 % (dashCycle || 1);
-        if (dashDist < 0) dashDist += dashCycle;
-        for (const e of edges2) {
-          if (!dashArr || dashCycle <= 1e-4) {
-            drawAntiAliasedSegment(rgba, width2, height, e.x0, e.y0, e.x1, e.y1, sw, path2.strokeColor, strokeAlpha, path2.lineCap ?? 0, original.kind === "glyph" ? aaTxt : aaVec, path2.blendMode, clipMask);
-          } else {
-            const dx = e.x1 - e.x0;
-            const dy = e.y1 - e.y0;
-            const edgeLen = Math.hypot(dx, dy);
-            if (edgeLen <= 1e-4) continue;
-            let pos = 0;
-            while (pos < edgeLen) {
-              let cycleRem = dashDist % dashCycle;
-              let dIdx = 0;
-              while (dIdx < dashArr.length - 1 && cycleRem >= dashArr[dIdx]) {
-                cycleRem -= dashArr[dIdx];
-                dIdx++;
-              }
-              const segRemainInDash = Math.max(1e-4, dashArr[dIdx] - cycleRem);
-              const step = Math.min(edgeLen - pos, segRemainInDash);
-              if (dIdx % 2 === 0) {
-                const t0 = pos / edgeLen;
-                const t1 = (pos + step) / edgeLen;
-                drawAntiAliasedSegment(
-                  rgba,
-                  width2,
-                  height,
-                  e.x0 + dx * t0,
-                  e.y0 + dy * t0,
-                  e.x0 + dx * t1,
-                  e.y0 + dy * t1,
-                  sw,
-                  path2.strokeColor,
-                  strokeAlpha,
-                  path2.lineCap ?? 0,
-                  original.kind === "glyph" ? aaTxt : aaVec,
-                  path2.blendMode,
-                  clipMask
-                );
-              }
-              pos += step;
-              dashDist = (dashDist + step) % dashCycle;
-            }
-          }
-        }
+        const contours = strokeOutlines(
+          segmentsToScreenPaths(path2.segments, displayList.height, scale2),
+          sw,
+          path2.lineCap ?? 0,
+          path2.lineJoin ?? 0,
+          path2.miterLimit ?? 10,
+          path2.dashArray?.map((value3) => Math.max(0, value3 * scale2)),
+          (path2.dashPhase ?? 0) * scale2
+        );
+        const edges2 = pathsToEdges(contours.map((points) => ({ points, closed: true })));
+        const clipScreen = path2.clipRect ? [path2.clipRect[0] * scale2, (displayList.height - path2.clipRect[3]) * scale2, path2.clipRect[2] * scale2, (displayList.height - path2.clipRect[1]) * scale2] : void 0;
+        fillEdgesScanline4x4(
+          rgba,
+          width2,
+          height,
+          edges2,
+          path2.strokeColor,
+          strokeAlpha,
+          "nonzero",
+          clipScreen,
+          original.kind === "glyph" ? aaTxt : aaVec,
+          path2.blendMode,
+          clipMask
+        );
       }
     } else if (operation.kind === "image") {
       const img = operation.value;
@@ -231934,6 +232168,7 @@ function compile(pattern, host) {
     let assertion;
     let behind = false;
     let atomic = false;
+    let resetCaptures = false;
     let capture = pattern[at] === "?" ? void 0 : ++captures;
     if (pattern[at] === "?") {
       at++;
@@ -231942,6 +232177,37 @@ function compile(pattern, host) {
       else if (pattern[at] === ">") {
         at++;
         atomic = true;
+      } else if (pattern[at] === "|") {
+        at++;
+        resetCaptures = true;
+      } else if (pattern[at] === "(") {
+        at++;
+        let condition;
+        if (pattern[at] === "?" && (pattern[at + 1] === "=" || pattern[at + 1] === "!" || pattern[at + 1] === "<" && (pattern[at + 2] === "=" || pattern[at + 2] === "!"))) {
+          condition = { kind: "assertion", node: group({ ...mode }) };
+        } else {
+          const indices = [];
+          if (pattern[at] === "<" || pattern[at] === "'") {
+            const closing = pattern[at++] === "<" ? ">" : "'";
+            namedReferences.push({ name: identifier(closing), indices });
+          } else {
+            if (!(pattern[at] >= "1" && pattern[at] <= "9"))
+              return unsupported8();
+            const index2 = integer7();
+            if (index2 > 2147483647)
+              return unsupported8();
+            indices.push(index2);
+          }
+          if (pattern[at++] !== ")")
+            return unsupported8();
+          condition = { kind: "participation", indices };
+        }
+        const yes = sequence(mode);
+        const no = pattern[at] === "|" ? (at++, sequence(mode)) : node3({ kind: "sequence", nodes: [] });
+        if (pattern[at++] !== ")")
+          return unsupported8();
+        depth--;
+        return node3({ kind: "conditional", condition, yes, no });
       } else if (pattern[at] === "=" || pattern[at] === "!")
         assertion = pattern[at++] === "!";
       else if (pattern[at] === "<" && (pattern[at + 1] === "=" || pattern[at + 1] === "!")) {
@@ -232009,7 +232275,7 @@ function compile(pattern, host) {
           return unsupported8("embedded modifier grammar");
       }
     }
-    const inner = alternative(mode);
+    const inner = alternative(mode, resetCaptures);
     if (pattern[at++] !== ")")
       return unsupported8();
     depth--;
@@ -232044,7 +232310,7 @@ function compile(pattern, host) {
     } else {
       min = Infinity;
       max = 0;
-      for (const child7 of value3.nodes) {
+      for (const child7 of value3.kind === "conditional" ? [value3.yes, value3.no] : value3.nodes) {
         const width2 = widthRange(child7);
         min = Math.min(min, width2.min);
         max = Math.max(max, width2.max);
@@ -232144,12 +232410,18 @@ function compile(pattern, host) {
     }
     return node3({ kind: "sequence", nodes: result3 });
   }
-  function alternative(mode) {
+  function alternative(mode, resetCaptures = false) {
+    const firstCapture = captures;
     const result3 = [sequence(mode)];
+    let lastCapture = captures;
     while (pattern[at] === "|") {
       at++;
+      if (resetCaptures)
+        captures = firstCapture;
       result3.push(sequence(mode));
+      lastCapture = Math.max(lastCapture, captures);
     }
+    captures = lastCapture;
     return result3.length === 1 ? result3[0] : node3({ kind: "alternative", nodes: result3 });
   }
   const result2 = alternative(flags);
@@ -232201,6 +232473,23 @@ function* match2(node3, source, state, host) {
         return;
     }
     yield { ...state, position: position + length };
+  } else if (node3.kind === "conditional") {
+    let branch;
+    if (node3.condition.kind === "participation") {
+      for (const index2 of node3.condition.indices) {
+        host.tick();
+        if (state.captures[index2] !== void 0) {
+          branch = state;
+          break;
+        }
+      }
+    } else {
+      const inner = match2(node3.condition.node, source, state, host), result2 = inner.next();
+      inner.return(void 0);
+      if (!result2.done)
+        branch = result2.value;
+    }
+    yield* match2(branch === void 0 ? node3.no : node3.yes, source, branch ?? state, host);
   } else if (node3.kind === "capture") {
     for (const result2 of match2(node3.node, source, state, host)) {
       const captures = [];
@@ -232276,6 +232565,11 @@ function* match2(node3, source, state, host) {
             host.tick();
             nested.push(descendant);
           }
+        else if (child7.kind === "conditional") {
+          nested.push(child7.yes, child7.no);
+          if (child7.condition.kind === "assertion")
+            nested.push(child7.condition.node);
+        }
       }
       if (cleared.size) {
         const captures = [];
@@ -234080,6 +234374,18 @@ export {
  * Copyright 2012 Mozilla Foundation. Licensed under Apache-2.0.
  * See THIRD_PARTY_NOTICES.md for the source revision and adaptations.
  */
+/*!
+ * Anti-Grain Geometry - Version 2.3
+ * Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+ *
+ * Permission to copy, use, modify, sell and distribute this software
+ * is granted provided this copyright notice appears in all copies.
+ * This software is provided "as is" without express or implied
+ * warranty, and with no claim as to its suitability for any purpose.
+ *
+ * Adapted from PDFium agg_math_stroke.h and agg_vcgen_stroke.cpp.
+ * See THIRD_PARTY_NOTICES.md for the source revision and adaptations.
+ */
 /*! Bundled license information:
 
 tslib/tslib.js: