@poe-platform/safe-bash 0.1.780 → 0.1.782

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

@@ -3456,7 +3456,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;
       }
@@ -3474,7 +3474,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 };
   }
@@ -11454,6 +11454,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,
@@ -11751,6 +11752,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"));
@@ -11809,7 +11920,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;
@@ -11967,136 +12078,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;
@@ -12297,10 +12287,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,
@@ -14443,10 +14442,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));
@@ -14578,7 +14581,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;
@@ -14644,7 +14647,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);
       }
     }
   }
@@ -14723,19 +14726,16 @@ 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 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 };
@@ -14743,7 +14743,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;
@@ -14761,20 +14761,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",
@@ -14844,7 +14836,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);
@@ -14862,7 +14854,8 @@ function renderDisplayListToBitmap(displayList, options = {}) {
           clipScreen,
           original.kind === "glyph" ? aaTxt : aaVec,
           path.blendMode,
-          clipMask
+          clipMask,
+          groupAlpha
         );
       }
     } else if (operation.kind === "image") {
@@ -14926,12 +14919,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;
@@ -14941,7 +14953,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));
@@ -15472,6 +15491,7 @@ var CCITT_WHITE_CODES;
 var CCITT_BLACK_CODES;
 var textEncoder;
 var PDF_DOC_ENCODING_MAP;
+var PDF_DOC_ENCODING_REVERSE;
 var CosByteLexer;
 var MD5_S;
 var MD5_K;
@@ -39928,6 +39948,9 @@ var init_dist = __esm({
       160: 8364,
       173: 65533
     };
+    PDF_DOC_ENCODING_REVERSE = new Map(
+      Array.from({ length: 256 }, (_, byte) => [PDF_DOC_ENCODING_MAP[byte] ?? byte, byte])
+    );
     CosByteLexer = class {
       constructor(bytes, start = 0, end = bytes.length, maxTokenBytes = Infinity, knownCommands) {
         this.knownCommands = knownCommands;
@@ -40160,6 +40183,7 @@ var init_dist = __esm({
         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++];
@@ -40194,7 +40218,15 @@ var init_dist = __esm({
             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);
@@ -40205,6 +40237,10 @@ var init_dist = __esm({
             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),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poe-platform/safe-bash",
-  "version": "0.1.780",
+  "version": "0.1.782",
   "description": "Extensible virtual shell with pluggable filesystems and streaming commands",
   "type": "module",
   "license": "MIT",
@@ -841,7 +841,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@poe-platform/safe-fs": "0.1.780",
+    "@poe-platform/safe-fs": "0.1.782",
     "pdf-lib": "1.17.1",
     "@noble/hashes": "2.4.0",
     "pako": "3.0.1",

package/third-party/pdf-ast/THIRD_PARTY_NOTICES.md

@@ -404,15 +404,16 @@ and intermediate-surface state reset. Bitmap and SVG exports follow
 `beginDrawing` in keeping the viewer background outside page blend calculations.
 `src/render/transparency-group.test.ts` adds local opacity/blend/mask cases and
 ports the unchanged `transparency_group.pdf` and `bug1873345.pdf` equality
-fixtures, with independently obtained reference pixels. Full non-isolated
-backdrop compositing for groups with outer effects retains PDF.js's documented
-limitation.
+fixtures, with independently obtained reference pixels. Non-isolated backdrop
+compositing now uses PDFBox's group-alpha and backdrop-removal algorithm,
+described below.
 
 Masked non-isolated Forms with inner blending or soft-mask effects follow
 PDF.js `beginGroup`'s `needsBackdropCopy && inSMaskMode` path. The raster adapter
 copies the existing page within the transformed Form BBox before painting the
-group; ordinary outer-opacity groups keep their transparent intermediate.
-`src/render/masked-group-backdrop.test.ts` covers this distinction and the
+group. The PDFBox adaptation below extends this to ordinary outer-opacity
+groups and removes the copied backdrop before final compositing.
+`src/render/masked-group-backdrop.test.ts` covers these cases and the
 unchanged `issue13520.pdf` fixture. SVG uses a raster fallback for pages requiring
 this backdrop copy; other Form groups retain their vector output.
 
@@ -504,3 +505,70 @@ or zero when absent. Standard-font widths apply only without an explicit
 Widths table. `src/fonts/explicit-widths.test.ts` covers Type1, TrueType and
 Type3 widths with and without ToUnicode, plus the unchanged upstream
 `Type3WordSpacing.pdf` fixture.
+
+# Apache PDFBox rendering regressions
+
+`src/render/pdfbox-patterns.test.ts` adapts `TestQuality.java` at revision
+`c4d556abc9d5f0cbc486d459c84682321dd38ff4`, retaining its original page,
+100 dpi resolution, pixel coordinates, and assertions. Test fixture provenance
+and checksums are recorded in `src/fixtures/SOURCES.md`. Licensed under
+Apache-2.0; see `licenses/PDFJS-APACHE-2.0.txt`.
+
+Source: https://github.com/apache/pdfbox
+
+The pattern transform handling in `src/content/evaluator.ts` follows PDFBox
+`TilingPaint` and `PageDrawer`: concatenate the containing stream initial
+matrix with the pattern matrix, then clip the paint to the glyph or path.
+
+Relevant upstream NOTICE:
+
+Apache PDFBox
+Copyright 2014 The Apache Software Foundation
+
+This product includes software developed at
+The Apache Software Foundation (http://www.apache.org/).
+
+Based on source code originally developed in the PDFBox and
+FontBox projects.
+
+Copyright (c) 2002-2007, www.pdfbox.org
+
+Based on source code originally developed in the PaDaF project.
+Copyright (c) 2010 Atos Worldline SAS
+
+`src/pdfbox-strings.test.ts` adapts `TestCOSString` and
+`PDFDocEncodingTest` at the same PDFBox revision, retaining the Unicode inputs
+and expected round trips, including all 256 PDFBOX-3864 characters. Local COS
+nodes preserve byte representation, so decoded strings replace Java COSString
+value equality. `src/ast.ts` follows `COSString` in using PDFDocEncoding only
+for representable characters and UTF-16BE otherwise. The reverse encoding map
+is derived from the existing decoder table. Apache-2.0, ASF notice above.
+
+`src/cos/pdfbox-lexer.test.ts` adapts `TestCOSParser` and `TestCOSNumber`,
+keeping the upstream literal, name, and numeric expectations through the local
+token API. Java-specific number range and object identity checks are omitted.
+Literal recovery in `src/cos/lexer.ts` follows `BaseParser.checkForEndOfString`;
+the adapter defers the recovery until EOF to preserve balanced multiline
+strings. Additional local cases check following fields and token budgets.
+
+`src/edit/pdfbox-forms.test.ts` adapts `TestRadioButtons.testRadioButtonPDModel`
+and the PDFBOX-4366/PDFBOX-6207 checkbox regressions. In-memory COS dictionaries
+replace PDFBox model builders; field values and widget appearance states retain
+the original expectations. Empty dictionaries stand in for unused appearances.
+`src/render/pdfbox-blend-mode.test.ts` ports all four
+`TestPDFRendererBlendMode` cases, preserving page dimensions, sample coordinates,
+and expected blue/white pixels. Vitest replaces JUnit; bitmap RGBA values replace
+Java packed ARGB integers. Both use the same PDFBox revision and ASF license.
+
+Non-isolated group compositing in `src/render/raster.ts` adapts PDFBox
+`PageDrawer.TransparencyGroup` and `GroupGraphics.removeBackdrop` at the same
+revision. Each paint accumulates group-only alpha separately from its color
+surface, which starts with the parent backdrop. Backdrop removal retains inner
+blend effects and restores group alpha before applying outer opacity and masks.
+The local implementation uses a Float32 alpha plane and straight RGBA bytes,
+with a raster SVG fallback for affected pages. `transparency-group.test.ts`
+checks opaque and partial backdrops, nested opacity, masks, overlapping paints,
+strokes, images, untouched pixels, and normal/incremental/copied-page saves.
+Opaque RGB expectations were independently checked using Poppler 26.08.0's
+Splash renderer; transparent expectations also check the PDF compositing
+formula. ASF, Apache-2.0, notices and license above.