@poe-platform/safe-bash 0.1.780 → 0.1.781

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

@@ -26760,7 +26760,7 @@ function cosString(value, span) {
   if (typeof value === "string") {
     let needsUtf16 = false;
     for (let i = 0; i < value.length; i++) {
-      if (value.charCodeAt(i) > 255) {
+      if (!PDF_DOC_ENCODING_REVERSE.has(value.charCodeAt(i))) {
         needsUtf16 = true;
         break;
       }
@@ -26778,7 +26778,7 @@ function cosString(value, span) {
     }
     const bytes = new Uint8Array(value.length);
     for (let i = 0; i < value.length; i++) {
-      bytes[i] = value.charCodeAt(i) & 255;
+      bytes[i] = PDF_DOC_ENCODING_REVERSE.get(value.charCodeAt(i));
     }
     return { kind: "string", format: "literal", bytes, span };
   }
@@ -26925,6 +26925,9 @@ var PDF_DOC_ENCODING_MAP = {
   160: 8364,
   173: 65533
 };
+var PDF_DOC_ENCODING_REVERSE = new Map(
+  Array.from({ length: 256 }, (_, byte) => [PDF_DOC_ENCODING_MAP[byte] ?? byte, byte])
+);
 function decodeUtf16UnitsWithSurrogateCheck(units) {
   let out = "";
   for (let i = 0; i < units.length; i++) {
@@ -27216,6 +27219,7 @@ var CosByteLexer = class {
     const start = this.pos;
     this.pos++;
     let depth = 1;
+    let recovery;
     const out = [];
     while (this.pos < this.end && depth > 0) {
       const b = this.bytes[this.pos++];
@@ -27250,7 +27254,15 @@ var CosByteLexer = class {
         out.push(b);
       } else if (b === 41) {
         depth--;
-        if (depth > 0) out.push(b);
+        if (depth > 0) {
+          const next = this.bytes[this.pos];
+          const afterLine = next === 13 && this.bytes[this.pos + 1] === 10 ? this.pos + 2 : this.pos + 1;
+          const delimiter = this.bytes[afterLine];
+          if (!recovery && this.pos + 2 < this.end && (next === 10 || next === 13) && (delimiter === 47 || delimiter === 62)) {
+            recovery = { offset: this.pos, length: out.length };
+          }
+          out.push(b);
+        }
       } else if (b === 13) {
         if (this.pos < this.end && this.bytes[this.pos] === 10) this.pos++;
         out.push(10);
@@ -27261,6 +27273,10 @@ var CosByteLexer = class {
         throw new PdfError("E_LIMIT", "PDF literal string exceeds maximum byte length");
       }
     }
+    if (depth > 0 && recovery) {
+      this.pos = recovery.offset;
+      out.length = recovery.length;
+    }
     return {
       kind: "string",
       bytes: Uint8Array.from(out),
@@ -38976,6 +38992,7 @@ function evaluateContentStreamToDisplayList(params) {
   };
   const initialState = {
     ctm: [1, 0, 0, 1, 0, 0],
+    initialCtm: [1, 0, 0, 1, 0, 0],
     strokeColor: { r: 0, g: 0, b: 0 },
     fillColor: { r: 0, g: 0, b: 0 },
     strokeAlpha: 1,
@@ -39273,6 +39290,116 @@ function evaluateContentStreamToDisplayList(params) {
     ] }], void 0, void 0, resources, activeFonts, depth);
     stateStack.pop();
   };
+  const paintPattern = (segments, fillRule, resources, activeFonts, depth, mcid, actualText) => {
+    const st = curState(), doc = params.cosDoc;
+    if (!st.fillPatternName || !doc || !resources) return false;
+    if (depth >= 8) throw new PdfError("E_LIMIT", "Pattern nesting exceeds the form depth limit");
+    const patterns = doc.resolveDict(dictGet(resources, "Pattern"));
+    const pattern = patterns && doc.resolve(dictGet(patterns, st.fillPatternName));
+    const dict = pattern?.kind === "stream" ? pattern.dict : pattern?.kind === "dict" ? pattern : void 0;
+    if (!dict) return false;
+    const nums = (key, fallback) => {
+      const array = doc.resolveArray(dictGet(dict, key));
+      return array ? array.items.map((item, i) => {
+        const value = doc.resolve(item);
+        return value?.kind === "number" ? value.value : fallback[i] ?? 0;
+      }) : fallback;
+    };
+    let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
+    const include = (x, y) => {
+      x0 = Math.min(x0, x);
+      y0 = Math.min(y0, y);
+      x1 = Math.max(x1, x);
+      y1 = Math.max(y1, y);
+    };
+    for (const segment of segments) {
+      if (segment.kind === "close") continue;
+      include(segment.x, segment.y);
+      if (segment.kind === "cubic") {
+        include(segment.x1, segment.y1);
+        include(segment.x2, segment.y2);
+      }
+      if (segment.kind === "rect") include(segment.x + segment.width, segment.y + segment.height);
+    }
+    const [originX, originY] = params.origin ?? [0, 0];
+    const clip = st.clipRect ?? [originX, originY, originX + params.width, originY + params.height];
+    const bounds = [Math.max(x0, clip[0]), Math.max(y0, clip[1]), Math.min(x1, clip[2]), Math.min(y1, clip[3])];
+    if (!(bounds[2] > bounds[0] && bounds[3] > bounds[1])) return true;
+    const matrix = multiplyMatrices(nums("Matrix", [1, 0, 0, 1, 0, 0]), st.initialCtm);
+    const type = doc.resolve(dictGet(dict, "PatternType"));
+    stateStack.push({ ...st, clipRect: bounds, clipPaths: [...st.clipPaths ?? [], { segments, fillRule }] });
+    try {
+      if (type?.kind === "number" && type.value === 2) {
+        const shading = doc.resolve(dictGet(dict, "Shading"));
+        const shadingDict = shading?.kind === "stream" ? shading.dict : shading?.kind === "dict" ? shading : void 0;
+        if (!shadingDict) return false;
+        const image = renderShadingDictToImage(
+          doc,
+          shadingDict,
+          matrix,
+          bounds,
+          st.fillAlpha,
+          "PatternShading_" + st.fillPatternName,
+          bounds,
+          shading?.kind === "stream" ? shading : void 0,
+          st.blendMode
+        );
+        if (image) emit({ kind: "image", value: image });
+        return !!image;
+      }
+      if (pattern?.kind !== "stream") return false;
+      const xStepNode = doc.resolve(dictGet(dict, "XStep"));
+      const yStepNode = doc.resolve(dictGet(dict, "YStep"));
+      const xStep = xStepNode?.kind === "number" ? Math.abs(xStepNode.value) : 0;
+      const yStep = yStepNode?.kind === "number" ? Math.abs(yStepNode.value) : 0;
+      const determinant = matrix[0] * matrix[3] - matrix[1] * matrix[2];
+      if (!xStep || !yStep || !determinant) return true;
+      const inverse = [
+        matrix[3] / determinant,
+        -matrix[1] / determinant,
+        -matrix[2] / determinant,
+        matrix[0] / determinant,
+        (matrix[2] * matrix[5] - matrix[3] * matrix[4]) / determinant,
+        (matrix[1] * matrix[4] - matrix[0] * matrix[5]) / determinant
+      ];
+      const corners = [[bounds[0], bounds[1]], [bounds[2], bounds[1]], [bounds[2], bounds[3]], [bounds[0], bounds[3]]].map(([x, y]) => transformPoint(inverse, x, y));
+      const box = nums("BBox", [0, 0, xStep, yStep]);
+      const ix0 = Math.floor((Math.min(...corners.map((p) => p[0])) - box[2]) / xStep) + 1;
+      const ix1 = Math.ceil((Math.max(...corners.map((p) => p[0])) - box[0]) / xStep) - 1;
+      const iy0 = Math.floor((Math.min(...corners.map((p) => p[1])) - box[3]) / yStep) + 1;
+      const iy1 = Math.ceil((Math.max(...corners.map((p) => p[1])) - box[1]) / yStep) - 1;
+      if ((ix1 - ix0 + 1) * (iy1 - iy0 + 1) > 2e4) throw new PdfError("E_LIMIT", "Pattern tile count exceeds 20000");
+      const nodes = parseContentStream(doc.decodeStream(pattern));
+      const patternResources = doc.resolveDict(dictGet(dict, "Resources")) ?? resources;
+      const patternFonts = new Map(activeFonts);
+      for (const [key, font] of resolvePageFonts(doc, patternResources)) patternFonts.set(key, font);
+      for (let iy = iy0; iy <= iy1; iy++) {
+        for (let ix = ix0; ix <= ix1; ix++) {
+          const tileCtm = multiplyMatrices([1, 0, 0, 1, ix * xStep, iy * yStep], matrix);
+          const points = [[box[0], box[1]], [box[2], box[1]], [box[2], box[3]], [box[0], box[3]]].map(([x, y]) => transformPoint(tileCtm, x, y));
+          const tileClip = [
+            ...points.map(([x, y], i) => ({ kind: i === 0 ? "move" : "line", x, y })),
+            { kind: "close" }
+          ];
+          stateStack.push({
+            ...curState(),
+            fillPatternName: void 0,
+            ctm: tileCtm,
+            initialCtm: tileCtm,
+            clipPaths: [...curState().clipPaths ?? [], tileClip]
+          });
+          try {
+            walkNodes(nodes, mcid, actualText, patternResources, patternFonts, depth + 1);
+          } finally {
+            stateStack.pop();
+          }
+        }
+      }
+      return true;
+    } finally {
+      stateStack.pop();
+    }
+  };
   const paintForm = (form, activeResources, activeFonts, depth, mcid, actualText, maskGroup = false) => {
     const st = curState();
     const group = params.cosDoc.resolveDict(dictGet(form.dict, "Group"));
@@ -39331,7 +39458,7 @@ function evaluateContentStreamToDisplayList(params) {
     }
     const parentOperations = capturedOperations;
     const children = [];
-    const nextState = { ...st, ctm: nextCtm };
+    const nextState = { ...st, ctm: nextCtm, initialCtm: nextCtm };
     if (compositeGroup) {
       capturedOperations = children;
       nextState.fillAlpha = nextState.strokeAlpha = 1;
@@ -39489,136 +39616,15 @@ function evaluateContentStreamToDisplayList(params) {
           }
           const isFill = ["f", "F", "f*", "B", "B*", "b", "b*"].includes(node.paint);
           const isStroke = ["S", "s", "B", "B*", "b", "b*"].includes(node.paint);
-          let evaluatedFillPattern = false;
-          if (isFill && st.fillPatternName && params.cosDoc && activeResources && depth < 6) {
-            const patMap = params.cosDoc.resolveDict(dictGet(activeResources, "Pattern"));
-            const patNode = patMap ? params.cosDoc.resolve(dictGet(patMap, st.fillPatternName)) : void 0;
-            const patDict = patNode?.kind === "stream" ? patNode.dict : patNode?.kind === "dict" ? patNode : void 0;
-            const patTypeNode = patDict && params.cosDoc ? params.cosDoc.resolve(dictGet(patDict, "PatternType")) : void 0;
-            const patType = patTypeNode?.kind === "number" ? patTypeNode.value : patNode?.kind === "stream" ? 1 : 0;
-            if (patDict && patType === 2 && params.cosDoc) {
-              let pMinX = Infinity, pMinY = Infinity, pMaxX = -Infinity, pMaxY = -Infinity;
-              for (const s of transformedSegments) {
-                if (s.kind === "move" || s.kind === "line") {
-                  pMinX = Math.min(pMinX, s.x);
-                  pMinY = Math.min(pMinY, s.y);
-                  pMaxX = Math.max(pMaxX, s.x);
-                  pMaxY = Math.max(pMaxY, s.y);
-                } else if (s.kind === "cubic") {
-                  pMinX = Math.min(pMinX, s.x1, s.x2, s.x);
-                  pMinY = Math.min(pMinY, s.y1, s.y2, s.y);
-                  pMaxX = Math.max(pMaxX, s.x1, s.x2, s.x);
-                  pMaxY = Math.max(pMaxY, s.y1, s.y2, s.y);
-                } else if (s.kind === "rect") {
-                  pMinX = Math.min(pMinX, s.x);
-                  pMinY = Math.min(pMinY, s.y);
-                  pMaxX = Math.max(pMaxX, s.x + s.width);
-                  pMaxY = Math.max(pMaxY, s.y + s.height);
-                }
-              }
-              if (Number.isFinite(pMinX) && Number.isFinite(pMinY) && pMaxX > pMinX && pMaxY > pMinY) {
-                const shading = params.cosDoc.resolve(dictGet(patDict, "Shading"));
-                const shDict = shading?.kind === "stream" ? shading.dict : shading?.kind === "dict" ? shading : void 0;
-                if (shDict) {
-                  let patMatrix = [1, 0, 0, 1, 0, 0];
-                  const pmArr = params.cosDoc.resolveArray(dictGet(patDict, "Matrix"));
-                  if (pmArr && pmArr.items.length >= 6) {
-                    const mn = (idx, fb = 0) => {
-                      const r = params.cosDoc.resolve(pmArr.items[idx]);
-                      return r?.kind === "number" ? r.value : fb;
-                    };
-                    patMatrix = [mn(0, 1), mn(1, 0), mn(2, 0), mn(3, 1), mn(4, 0), mn(5, 0)];
-                  }
-                  const patClip = st.clipRect ? [
-                    Math.max(st.clipRect[0], pMinX),
-                    Math.max(st.clipRect[1], pMinY),
-                    Math.min(st.clipRect[2], pMaxX),
-                    Math.min(st.clipRect[3], pMaxY)
-                  ] : [pMinX, pMinY, pMaxX, pMaxY];
-                  const shImg = renderShadingDictToImage(
-                    params.cosDoc,
-                    shDict,
-                    patMatrix,
-                    patClip,
-                    st.fillAlpha,
-                    "PatternShading_" + st.fillPatternName,
-                    patClip,
-                    shading?.kind === "stream" ? shading : void 0,
-                    st.blendMode
-                  );
-                  if (shImg) {
-                    emit({ kind: "image", value: shImg });
-                    evaluatedFillPattern = true;
-                  }
-                }
-              }
-            } else if (patNode?.kind === "stream") {
-              let pMinX = Infinity, pMinY = Infinity, pMaxX = -Infinity, pMaxY = -Infinity;
-              for (const s of transformedSegments) {
-                if (s.kind === "move" || s.kind === "line") {
-                  pMinX = Math.min(pMinX, s.x);
-                  pMinY = Math.min(pMinY, s.y);
-                  pMaxX = Math.max(pMaxX, s.x);
-                  pMaxY = Math.max(pMaxY, s.y);
-                } else if (s.kind === "cubic") {
-                  pMinX = Math.min(pMinX, s.x1, s.x2, s.x);
-                  pMinY = Math.min(pMinY, s.y1, s.y2, s.y);
-                  pMaxX = Math.max(pMaxX, s.x1, s.x2, s.x);
-                  pMaxY = Math.max(pMaxY, s.y1, s.y2, s.y);
-                } else if (s.kind === "rect") {
-                  pMinX = Math.min(pMinX, s.x);
-                  pMinY = Math.min(pMinY, s.y);
-                  pMaxX = Math.max(pMaxX, s.x + s.width);
-                  pMaxY = Math.max(pMaxY, s.y + s.height);
-                }
-              }
-              if (Number.isFinite(pMinX) && Number.isFinite(pMinY) && pMaxX > pMinX && pMaxY > pMinY) {
-                const xsNode = params.cosDoc.resolve(dictGet(patNode.dict, "XStep"));
-                const ysNode = params.cosDoc.resolve(dictGet(patNode.dict, "YStep"));
-                const xStep = xsNode?.kind === "number" && Math.abs(xsNode.value) > 1e-3 ? Math.abs(xsNode.value) : 40;
-                const yStep = ysNode?.kind === "number" && Math.abs(ysNode.value) > 1e-3 ? Math.abs(ysNode.value) : 40;
-                let patMatrix = [1, 0, 0, 1, 0, 0];
-                const pmArr = params.cosDoc.resolveArray(dictGet(patNode.dict, "Matrix"));
-                if (pmArr && pmArr.items.length >= 6) {
-                  const mn = (idx, fb = 0) => {
-                    const r = params.cosDoc.resolve(pmArr.items[idx]);
-                    return r?.kind === "number" ? r.value : fb;
-                  };
-                  patMatrix = [mn(0, 1), mn(1, 0), mn(2, 0), mn(3, 1), mn(4, 0), mn(5, 0)];
-                }
-                const tileClip = st.clipRect ? [
-                  Math.max(st.clipRect[0], pMinX),
-                  Math.max(st.clipRect[1], pMinY),
-                  Math.min(st.clipRect[2], pMaxX),
-                  Math.min(st.clipRect[3], pMaxY)
-                ] : [pMinX, pMinY, pMaxX, pMaxY];
-                const patNodes = parseContentStream(params.cosDoc.decodeStream(patNode));
-                const patResDict = params.cosDoc.resolveDict(dictGet(patNode.dict, "Resources")) ?? activeResources;
-                const patFonts = new Map(activeFonts);
-                for (const [fk, fv] of resolvePageFonts(params.cosDoc, patResDict).entries()) {
-                  patFonts.set(fk, fv);
-                }
-                const ixStart = Math.floor(pMinX / xStep);
-                const ixEnd = Math.min(ixStart + 8, Math.ceil(pMaxX / xStep) - 1);
-                const iyStart = Math.floor(pMinY / yStep);
-                const iyEnd = Math.min(iyStart + 8, Math.ceil(pMaxY / yStep) - 1);
-                for (let iy = iyStart; iy <= iyEnd; iy++) {
-                  for (let ix = ixStart; ix <= ixEnd; ix++) {
-                    const tileCtm = multiplyMatrices([1, 0, 0, 1, ix * xStep, iy * yStep], patMatrix);
-                    stateStack.push({
-                      ...st,
-                      fillPatternName: void 0,
-                      ctm: tileCtm,
-                      clipRect: tileClip
-                    });
-                    walkNodes(patNodes, mcid, actualText, patResDict, patFonts, depth + 1);
-                    if (stateStack.length > 1) stateStack.pop();
-                  }
-                }
-                evaluatedFillPattern = true;
-              }
-            }
-          }
+          const evaluatedFillPattern = isFill && paintPattern(
+            transformedSegments,
+            node.paint.includes("*") ? "evenodd" : "nonzero",
+            activeResources,
+            activeFonts,
+            depth,
+            mcid,
+            actualText
+          );
           if (evaluatedFillPattern && !isStroke) {
             applyClip();
             break;
@@ -39819,10 +39825,19 @@ function evaluateContentStreamToDisplayList(params) {
                   if (st.textRenderMode >= 4 && st.textRenderMode <= 7) pendingTextClip.push(...transformedGlyphSegs);
                   const isFillGlyph = st.textRenderMode === 0 || st.textRenderMode === 2 || st.textRenderMode === 4 || st.textRenderMode === 6;
                   const isStrokeGlyph = st.textRenderMode === 1 || st.textRenderMode === 2 || st.textRenderMode === 5 || st.textRenderMode === 6;
+                  const patterned = isFillGlyph && paintPattern(
+                    transformedGlyphSegs,
+                    "nonzero",
+                    activeResources,
+                    activeFonts,
+                    depth,
+                    mcid,
+                    actualText
+                  );
                   const paint = {
                     segments: transformedGlyphSegs,
-                    fillColor: isFillGlyph ? st.fillColor : void 0,
-                    fillAlpha: isFillGlyph ? st.fillAlpha : void 0,
+                    fillColor: isFillGlyph && !patterned ? st.fillColor : void 0,
+                    fillAlpha: isFillGlyph && !patterned ? st.fillAlpha : void 0,
                     strokeColor: isStrokeGlyph ? st.strokeColor : void 0,
                     strokeAlpha: isStrokeGlyph ? st.strokeAlpha : void 0,
                     strokeWidth: isStrokeGlyph ? st.strokeWidth : 0,
@@ -43462,10 +43477,14 @@ function computePdfBlendRgb(cbR, cbG, cbB, csR, csG, csB, mode) {
     blendChannelSeparable(cbB, csB, mode)
   ];
 }
-function blendPixel(rgba, width, height, px, py, color, alpha, blendMode, clipMask) {
+function blendPixel(rgba, width, height, px, py, color, alpha, blendMode, clipMask, groupAlpha) {
   if (px < 0 || py < 0 || px >= width || py >= height || alpha <= 0) return;
   const a = Math.min(1, Math.max(0, alpha)) * (clipMask ? clipMask[(py * width + px) * 4 + 3] / 255 : 1);
   const idx = (py * width + px) * 4;
+  if (groupAlpha) {
+    const pixel = py * width + px;
+    groupAlpha[pixel] = a + groupAlpha[pixel] * (1 - a);
+  }
   const csR = Math.min(1, Math.max(0, color.r));
   const csG = Math.min(1, Math.max(0, color.g));
   const csB = Math.min(1, Math.max(0, color.b));
@@ -43597,7 +43616,7 @@ function pathsToEdges(paths, closeSubpaths = false) {
   }
   return edges;
 }
-function fillEdgesScanline4x4(rgba, width, height, edges, color, alpha = 1, fillRule = "nonzero", clipScreen, antialias = true, blendMode, clipMask) {
+function fillEdgesScanline4x4(rgba, width, height, edges, color, alpha = 1, fillRule = "nonzero", clipScreen, antialias = true, blendMode, clipMask, groupAlpha) {
   if (edges.length === 0) return;
   let minY = Infinity;
   let maxY = -Infinity;
@@ -43663,7 +43682,7 @@ function fillEdgesScanline4x4(rgba, width, height, edges, color, alpha = 1, fill
       const count = rowCounts[px];
       if (count > 0) {
         const cov = antialias ? count / 16 : count >= 8 ? 1 : 0;
-        blendPixel(rgba, width, height, px, py, color, cov * alpha, blendMode, clipMask);
+        blendPixel(rgba, width, height, px, py, color, cov * alpha, blendMode, clipMask, groupAlpha);
       }
     }
   }
@@ -43742,22 +43761,19 @@ function hasCompositingEffects(operations, includeSoftMasks = false) {
   return operations.some((operation) => includeSoftMasks && !!operation.value.softMask || !!operation.value.blendMode && operation.value.blendMode !== "Normal" && operation.value.blendMode !== "Compatible" || operation.kind === "group" && hasCompositingEffects(operation.value.operations, includeSoftMasks));
 }
 function needsGroupBackdrop(group) {
-  return group.isolated === false && !!group.softMask && hasCompositingEffects(group.operations, true);
+  return group.isolated === false && hasCompositingEffects(group.operations, true);
 }
 function containsBackdropGroup(operations) {
   return operations.some((operation) => operation.kind === "group" && (needsGroupBackdrop(operation.value) || containsBackdropGroup(operation.value.operations)));
 }
-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;
-  const scaleY = options.dpiY !== void 0 ? options.dpiY / 72 : baseScale;
-  const scale = scaleX;
+function renderDisplayListLayer(displayList, options, scale, backdrop) {
   const [originX, originY] = displayList.origin ?? [0, 0];
   const pageTop = originY + displayList.height;
   const toScreen = (x, y) => [(x - originX) * scale, (pageTop - y) * scale];
   const width = Math.max(1, Math.round(displayList.width * scale));
   const height = Math.max(1, Math.round(displayList.height * scale));
-  const rgba = new Uint8Array(width * height * 4);
+  const rgba = backdrop ? backdrop.slice() : new Uint8Array(width * height * 4);
+  const groupAlpha = backdrop ? new Float32Array(width * height) : void 0;
   const deferBackground = !options.transparent && hasCompositingEffects(paintOperations(displayList));
   const transparent = options.transparent || deferBackground;
   const bg = options.background ?? { r: 1, g: 1, b: 1 };
@@ -43765,7 +43781,7 @@ function renderDisplayListToBitmap(displayList, options = {}) {
   const bgG = transparent ? 0 : Math.round(bg.g * 255);
   const bgB = transparent ? 0 : Math.round(bg.b * 255);
   const bgA = transparent ? 0 : 255;
-  for (let i = 0; i < width * height; i++) {
+  for (let i = 0; !backdrop && i < width * height; i++) {
     rgba[i * 4] = bgR;
     rgba[i * 4 + 1] = bgG;
     rgba[i * 4 + 2] = bgB;
@@ -43783,20 +43799,12 @@ function renderDisplayListToBitmap(displayList, options = {}) {
     let operation = original.kind === "glyph" ? { kind: "path", value: glyphPaint(original.value) } : original;
     if (operation.kind === "group") {
       const group = operation.value;
-      let operations = group.operations;
-      if (needsGroupBackdrop(group)) {
-        operations = [{ kind: "image", value: {
-          name: "GroupBackdrop",
-          width,
-          height,
-          decodedRgba: rgba.slice(),
-          matrix: [width / scale, 0, 0, height / scale, originX, pageTop - height / scale],
-          colorSpace: "DeviceRGB",
-          bitsPerComponent: 8,
-          ...group.bboxClip ? { clipPaths: [group.bboxClip] } : {}
-        } }, ...operations];
-      }
-      const bitmap = renderDisplayListToBitmap({ ...displayList, rotation: 0, operations }, { ...options, scale, dpiX: void 0, dpiY: void 0, cropRect: void 0, useCropBox: false, transparent: true });
+      const bitmap = renderDisplayListLayer(
+        { ...displayList, operations: group.operations },
+        { ...options, transparent: true },
+        scale,
+        needsGroupBackdrop(group) ? rgba : void 0
+      );
       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",
@@ -43866,7 +43874,7 @@ function renderDisplayListToBitmap(displayList, options = {}) {
       if (path.fillColor) {
         const edges = pathsToEdges(segmentsToScreenPaths(path.segments, displayList.height, scale, toScreen), true);
         const clipScreen = path.clipRect ? [(path.clipRect[0] - originX) * scale, (pageTop - path.clipRect[3]) * scale, (path.clipRect[2] - originX) * scale, (pageTop - path.clipRect[1]) * scale] : void 0;
-        fillEdgesScanline4x4(rgba, width, height, edges, path.fillColor, path.fillAlpha ?? 1, path.fillRule ?? "nonzero", clipScreen, original.kind === "glyph" ? aaTxt : aaVec, path.blendMode, clipMask);
+        fillEdgesScanline4x4(rgba, width, height, edges, path.fillColor, path.fillAlpha ?? 1, path.fillRule ?? "nonzero", clipScreen, original.kind === "glyph" ? aaTxt : aaVec, path.blendMode, clipMask, groupAlpha);
       }
       if (path.strokeColor) {
         const rawSw = path.strokeWidth * scale * (path.strokeMatrix ? Math.hypot(path.strokeMatrix[0], path.strokeMatrix[1]) : 1);
@@ -43884,7 +43892,8 @@ function renderDisplayListToBitmap(displayList, options = {}) {
           clipScreen,
           original.kind === "glyph" ? aaTxt : aaVec,
           path.blendMode,
-          clipMask
+          clipMask,
+          groupAlpha
         );
       }
     } else if (operation.kind === "image") {
@@ -43948,12 +43957,31 @@ function renderDisplayListToBitmap(displayList, options = {}) {
             },
             sample[3] / 255,
             img.blendMode,
-            clipMask
+            clipMask,
+            groupAlpha
           );
         }
       }
     }
   }
+  if (backdrop && groupAlpha) {
+    for (let i = 0; i < rgba.length; i += 4) {
+      const alpha = groupAlpha[i / 4];
+      if (alpha === 0) {
+        rgba.fill(0, i, i + 4);
+        continue;
+      }
+      const factor = backdrop[i + 3] / 255 * (1 / alpha - 1);
+      for (let channel = 0; channel < 3; channel++) {
+        const color = rgba[i + channel];
+        rgba[i + channel] = Math.max(0, Math.min(
+          255,
+          Math.round(color + (color - backdrop[i + channel]) * factor)
+        ));
+      }
+      rgba[i + 3] = Math.round(alpha * 255);
+    }
+  }
   if (deferBackground) {
     for (let i = 0; i < rgba.length; i += 4) {
       const alpha = rgba[i + 3] / 255;
@@ -43963,7 +43991,14 @@ function renderDisplayListToBitmap(displayList, options = {}) {
       rgba[i + 3] = 255;
     }
   }
-  let result = { width, height, data: rgba };
+  return { width, height, data: rgba };
+}
+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;
+  const scaleY = options.dpiY !== void 0 ? options.dpiY / 72 : baseScale;
+  let result = renderDisplayListLayer(displayList, options, scaleX);
+  const { width, height, data: rgba } = result;
   if (Math.abs(scaleX - scaleY) > 1e-6) {
     const targetW = Math.max(1, Math.round(displayList.width * scaleX));
     const targetH = Math.max(1, Math.round(displayList.height * scaleY));