@poe-platform/safe-bash 0.1.772 → 0.1.774

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

@@ -2595,6 +2595,295 @@ function utf8PasswordToBytes(password) {
   }
   return stringToBytes(password);
 }
+function resizeRgbImage(src, dest, w1, h1, w2, h2, alpha01) {
+  const COMPONENTS = 3;
+  alpha01 = alpha01 !== 1 ? 0 : alpha01;
+  const xRatio = w1 / w2;
+  const yRatio = h1 / h2;
+  let newIndex = 0, oldIndex;
+  const xScaled = new Uint16Array(w2);
+  const w1Scanline = w1 * COMPONENTS;
+  for (let i = 0; i < w2; i++) {
+    xScaled[i] = Math.floor(i * xRatio) * COMPONENTS;
+  }
+  for (let i = 0; i < h2; i++) {
+    const py = Math.floor(i * yRatio) * w1Scanline;
+    for (let j = 0; j < w2; j++) {
+      oldIndex = py + xScaled[j];
+      dest[newIndex++] = src[oldIndex++];
+      dest[newIndex++] = src[oldIndex++];
+      dest[newIndex++] = src[oldIndex++];
+      newIndex += alpha01;
+    }
+  }
+}
+function isDefaultDecodeHelper(decode, expectedLen) {
+  if (!Array.isArray(decode)) {
+    return true;
+  }
+  const decodeLen = decode.length;
+  if (decodeLen < expectedLen) {
+    warn2("Decode map length is too short.");
+    return true;
+  }
+  if (decodeLen > expectedLen) {
+    info("Truncating too long decode map.");
+    decode.length = expectedLen;
+  }
+  return false;
+}
+function parsePostScriptFunction(source) {
+  return new Parser(new Lexer(source)).parse();
+}
+function _nodesEqual(a, b) {
+  if (a === b) {
+    return true;
+  }
+  if (a.type !== b.type) {
+    return false;
+  }
+  switch (a.type) {
+    case PS_NODE.arg:
+      return a.index === b.index;
+    case PS_NODE.const:
+      return a.value === b.value;
+    case PS_NODE.unary:
+      return a.op === b.op && _nodesEqual(a.operand, b.operand);
+    case PS_NODE.binary:
+      return a.op === b.op && _nodesEqual(a.first, b.first) && _nodesEqual(a.second, b.second);
+    case PS_NODE.ternary:
+      return _nodesEqual(a.cond, b.cond) && _nodesEqual(a.then, b.then) && _nodesEqual(a.otherwise, b.otherwise);
+    default:
+      return false;
+  }
+}
+function _evalBinaryConst(op, a, b) {
+  switch (op) {
+    case TOKEN.add:
+      return a + b;
+    case TOKEN.sub:
+      return a - b;
+    case TOKEN.mul:
+      return a * b;
+    case TOKEN.div:
+      return b !== 0 ? a / b : 0;
+    // div by zero → 0
+    case TOKEN.idiv:
+      return b !== 0 ? Math.trunc(a / b) : 0;
+    // div by zero → 0
+    case TOKEN.mod:
+      return b !== 0 ? a - Math.trunc(a / b) * b : 0;
+    // div by zero → 0
+    case TOKEN.exp: {
+      const r = a ** b;
+      return Number.isFinite(r) ? r : void 0;
+    }
+    case TOKEN.atan: {
+      let deg = Math.atan2(a, b) * (180 / Math.PI);
+      if (deg < 0) {
+        deg += 360;
+      }
+      return deg;
+    }
+    case TOKEN.eq:
+      return a === b;
+    case TOKEN.ne:
+      return a !== b;
+    case TOKEN.gt:
+      return a > b;
+    case TOKEN.ge:
+      return a >= b;
+    case TOKEN.lt:
+      return a < b;
+    case TOKEN.le:
+      return a <= b;
+    case TOKEN.and:
+      return typeof a === "boolean" ? a && b : a & b | 0;
+    case TOKEN.or:
+      return typeof a === "boolean" ? a || b : a | b | 0;
+    case TOKEN.xor:
+      return typeof a === "boolean" ? a !== b : a ^ b | 0;
+    case TOKEN.bitshift:
+      return b >= 0 ? a << b | 0 : a >> -b | 0;
+    case TOKEN.min:
+      return Math.min(a, b);
+    case TOKEN.max:
+      return Math.max(a, b);
+    default:
+      return void 0;
+  }
+}
+function _evalUnaryConst(op, v) {
+  switch (op) {
+    case TOKEN.abs:
+      return Math.abs(v);
+    case TOKEN.neg:
+      return -v;
+    case TOKEN.ceiling:
+      return Math.ceil(v);
+    case TOKEN.floor:
+      return Math.floor(v);
+    case TOKEN.round:
+      return Math.round(v);
+    case TOKEN.truncate:
+      return Math.trunc(v);
+    case TOKEN.sqrt: {
+      const r = Math.sqrt(v);
+      return Number.isFinite(r) ? r : void 0;
+    }
+    case TOKEN.sin:
+      return Math.sin(v % 360 * Math.PI / 180);
+    case TOKEN.cos:
+      return Math.cos(v % 360 * Math.PI / 180);
+    case TOKEN.ln: {
+      const r = Math.log(v);
+      return Number.isFinite(r) ? r : void 0;
+    }
+    case TOKEN.log: {
+      const r = Math.log10(v);
+      return Number.isFinite(r) ? r : void 0;
+    }
+    case TOKEN.cvi:
+      return Math.trunc(v);
+    case TOKEN.cvr:
+      return v;
+    case TOKEN.not:
+      return typeof v === "boolean" ? !v : ~v;
+    default:
+      return void 0;
+  }
+}
+function _unaryValueType(op, operandType) {
+  return op === TOKEN.not ? operandType : PS_VALUE_TYPE.numeric;
+}
+function _binaryValueType(op, firstType, secondType) {
+  switch (op) {
+    // Comparison operators always produce a boolean.
+    case TOKEN.eq:
+    case TOKEN.ne:
+    case TOKEN.gt:
+    case TOKEN.ge:
+    case TOKEN.lt:
+    case TOKEN.le:
+      return PS_VALUE_TYPE.boolean;
+    // and / or / xor preserve the type when both operands are the same known
+    // type (both boolean or both numeric); otherwise the type is unknown.
+    case TOKEN.and:
+    case TOKEN.or:
+    case TOKEN.xor:
+      return firstType === secondType && firstType !== PS_VALUE_TYPE.unknown ? firstType : PS_VALUE_TYPE.unknown;
+    // All arithmetic / bitshift operators produce a numeric result.
+    default:
+      return PS_VALUE_TYPE.numeric;
+  }
+}
+function buildPostScriptJsFunction(source, domain, range, forceInterpreter = false) {
+  const program = parsePostScriptFunction(source);
+  const ir = !forceInterpreter && new PsJsCompiler(domain, range).compile(program);
+  if (ir) {
+    return (src, srcOffset, dest, destOffset) => {
+      PsJsCompiler.execute(ir, src, srcOffset, dest, destOffset);
+    };
+  }
+  return PSStackBasedInterpreter.build(program, domain, range);
+}
+function meshUpdateBounds(self) {
+  let minX = self.coords[0][0], minY = self.coords[0][1], maxX = minX, maxY = minY;
+  for (let i = 1, ii = self.coords.length; i < ii; i++) {
+    const x = self.coords[i][0], y = self.coords[i][1];
+    minX = minX > x ? x : minX;
+    minY = minY > y ? y : minY;
+    maxX = maxX < x ? x : maxX;
+    maxY = maxY < y ? y : maxY;
+  }
+  self.bounds = [minX, minY, maxX, maxY];
+}
+function meshPackData(self) {
+  let i, j, ii;
+  const coords = self.coords;
+  const coordsPacked = new Float32Array(coords.length * 2);
+  for (i = 0, j = 0, ii = coords.length; i < ii; i++) {
+    const xy = coords[i];
+    coordsPacked[j++] = xy[0];
+    coordsPacked[j++] = xy[1];
+  }
+  self.coords = coordsPacked;
+  const colors = self.colors;
+  const colorsPacked = new Uint8Array(colors.length * 4);
+  for (i = 0, j = 0, ii = colors.length; i < ii; i++) {
+    const c = colors[i];
+    colorsPacked[j++] = c[0];
+    colorsPacked[j++] = c[1];
+    colorsPacked[j++] = c[2];
+    j++;
+  }
+  self.colors = colorsPacked;
+  for (const figure of self.figures) {
+    figure.coords = new Uint32Array(figure.coords);
+    figure.colors = new Uint32Array(figure.colors);
+  }
+}
+function buildMeshVertexData(coords, colors, figures) {
+  let vertexCount = 0;
+  for (const figure of figures) {
+    if (figure.type === MeshFigureType.TRIANGLES) {
+      vertexCount += figure.coords.length;
+    } else if (figure.type === MeshFigureType.LATTICE) {
+      const vpr = figure.verticesPerRow;
+      vertexCount += (Math.floor(figure.coords.length / vpr) - 1) * (vpr - 1) * 6;
+    }
+  }
+  const posData = new Float32Array(vertexCount * 2);
+  const colData = new Uint8Array(vertexCount * 4);
+  let pOff = 0, cOff = 0;
+  const addVertex = (pi, ci) => {
+    posData[pOff++] = coords[pi * 2];
+    posData[pOff++] = coords[pi * 2 + 1];
+    colData[cOff++] = colors[ci * 4];
+    colData[cOff++] = colors[ci * 4 + 1];
+    colData[cOff++] = colors[ci * 4 + 2];
+    cOff++;
+  };
+  for (const figure of figures) {
+    const ps = figure.coords;
+    const cs = figure.colors;
+    if (figure.type === MeshFigureType.TRIANGLES) {
+      for (let i = 0, ii = ps.length; i < ii; i++) {
+        addVertex(ps[i], cs[i]);
+      }
+    } else if (figure.type === MeshFigureType.LATTICE) {
+      const vpr = figure.verticesPerRow;
+      const rows = Math.floor(ps.length / vpr) - 1;
+      const cols = vpr - 1;
+      for (let i = 0; i < rows; i++) {
+        let q = i * vpr;
+        for (let j = 0; j < cols; j++, q++) {
+          addVertex(ps[q], cs[q]);
+          addVertex(ps[q + 1], cs[q + 1]);
+          addVertex(ps[q + vpr], cs[q + vpr]);
+          addVertex(ps[q + vpr + 1], cs[q + vpr + 1]);
+          addVertex(ps[q + 1], cs[q + 1]);
+          addVertex(ps[q + vpr], cs[q + vpr]);
+        }
+      }
+    }
+  }
+  return { posData, colData, vertexCount };
+}
+function getB(count) {
+  if (bCache?.has(count)) return bCache.get(count);
+  const values = Array.from({ length: count + 1 }, (_, i) => {
+    const t = i / count, t_ = 1 - t;
+    return new Float32Array([
+      t_ ** 3,
+      3 * t * t_ ** 2,
+      3 * t ** 2 * t_,
+      t ** 3
+    ]);
+  });
+  (bCache ??= /* @__PURE__ */ new Map()).set(count, values);
+  return values;
+}
 function encodeFlate(bytes) {
   return deflate(bytes);
 }
@@ -4682,11 +4971,16 @@ function parseDictionaryStream(dictNode, lexer, bytes) {
     let streamEnd = streamStart;
     if (resolvedLength !== void 0 && resolvedLength >= 0 && streamStart + resolvedLength <= bytes.length) {
       const candidateEnd = streamStart + resolvedLength;
-      const tailSlice = bytes.subarray(candidateEnd, Math.min(bytes.length, candidateEnd + 32));
-      const tailStr = new TextDecoder("latin1").decode(tailSlice);
-      if (tailStr.includes("endstream")) {
+      const tailLexer = new CosByteLexer(bytes, candidateEnd);
+      let endToken;
+      try {
+        endToken = tailLexer.nextToken();
+      } catch (error) {
+        if (!(error instanceof PdfError) || error.code !== "E_PARSE") throw error;
+      }
+      if (endToken?.kind === "keyword" && endToken.value === "endstream") {
         rawStreamBytes = bytes.subarray(streamStart, candidateEnd);
-        streamEnd = candidateEnd + tailStr.indexOf("endstream") + "endstream".length;
+        streamEnd = tailLexer.offset;
       }
     }
     if (!rawStreamBytes) {
@@ -9629,6 +9923,24 @@ function initializeTile(context, tileIndex) {
   }
   tile.codingStyleDefaultParameters = context.currentTile.COD;
 }
+function createCalibratedColorSpace(doc, family, parameters) {
+  const dict = doc.resolveDict(parameters);
+  const array = (key) => {
+    const value = dict ? doc.resolveArray(dictGet(dict, key)) : void 0;
+    return value?.items.map((item) => {
+      const number = doc.resolve(item);
+      return number?.kind === "number" ? number.value : 0;
+    });
+  };
+  const whitePoint = array("WhitePoint") ?? [0.95047, 1, 1.08883];
+  const blackPoint = array("BlackPoint");
+  if (family === "CalGray") {
+    const gamma = dict ? doc.resolve(dictGet(dict, "Gamma")) : void 0;
+    return new CalGrayCS(whitePoint, blackPoint, gamma?.kind === "number" ? gamma.value : void 0);
+  }
+  if (family === "CalRGB") return new CalRGBCS(whitePoint, blackPoint, array("Gamma"), array("Matrix"));
+  return new LabCS(whitePoint, blackPoint, array("Range"));
+}
 function resolveColorSpaceInfo(doc, csNode, resourcesDict) {
   if (!csNode) return { colorSpace: "rgb", colorSpaceLabel: "rgb", components: 3 };
   const resolved = doc.resolve(csNode);
@@ -9669,7 +9981,7 @@ function resolveColorSpaceInfo(doc, csNode, resourcesDict) {
         palette = lookupNode.bytes;
       }
       let resolvedBaseComp = baseInfo.components;
-      if (palette && (baseInfo.isLab || baseInfo.isSeparation || baseInfo.isDeviceN || baseInfo.calRgbGamma !== void 0 || baseInfo.calGrayGamma !== void 0)) {
+      if (palette && (baseInfo.isSeparation || baseInfo.isDeviceN || baseInfo.calibrated !== void 0)) {
         const numEntries = Math.max(1, Math.min(hival + 1, Math.floor(palette.length / Math.max(1, baseInfo.components))));
         const rgbaPal = decodeSamplesToRgba(palette, numEntries, 1, 8, baseInfo);
         const rgbPal = new Uint8Array(numEntries * 3);
@@ -9699,74 +10011,21 @@ function resolveColorSpaceInfo(doc, csNode, resourcesDict) {
       }
       return { colorSpace: "rgb", colorSpaceLabel: "icc", components: 3 };
     }
-    if (kindName === "CalGray") {
-      const calDict = doc.resolveDict(resolved.items[1]);
-      const gammaNode = calDict ? doc.resolve(dictGet(calDict, "Gamma")) : void 0;
-      const gamma = gammaNode?.kind === "number" && gammaNode.value > 0 ? gammaNode.value : 1;
-      return { colorSpace: "gray", colorSpaceLabel: "cal-gray", components: 1, calGrayGamma: gamma };
-    }
-    if (kindName === "CalRGB") {
-      const calDict = doc.resolveDict(resolved.items[1]);
-      const gammaArr = calDict ? doc.resolveArray(dictGet(calDict, "Gamma")) : void 0;
-      let calRgbGamma = [1, 1, 1];
-      if (gammaArr && gammaArr.items.length >= 3) {
-        const gNums = gammaArr.items.slice(0, 3).map((it) => {
-          const r = doc.resolve(it);
-          return r?.kind === "number" && r.value > 0 ? r.value : 1;
-        });
-        calRgbGamma = [gNums[0], gNums[1], gNums[2]];
-      }
-      const matArr = calDict ? doc.resolveArray(dictGet(calDict, "Matrix")) : void 0;
-      let calRgbMatrix;
-      if (matArr && matArr.items.length >= 9) {
-        calRgbMatrix = matArr.items.slice(0, 9).map((it) => {
-          const r = doc.resolve(it);
-          return r?.kind === "number" ? r.value : 0;
-        });
-      }
+    if (kindName === "CalGray" || kindName === "CalRGB" || kindName === "Lab") {
+      const calibrated = createCalibratedColorSpace(doc, kindName, resolved.items[1]);
       return {
-        colorSpace: "rgb",
-        colorSpaceLabel: "cal-rgb",
-        components: 3,
-        calRgbGamma,
-        calRgbMatrix
+        colorSpace: kindName === "CalGray" ? "gray" : "rgb",
+        colorSpaceLabel: kindName === "CalGray" ? "cal-gray" : kindName === "CalRGB" ? "cal-rgb" : "lab",
+        components: kindName === "CalGray" ? 1 : 3,
+        calibrated
       };
     }
-    if (kindName === "Lab") {
-      const labDict = doc.resolveDict(resolved.items[1]);
-      const rangeArr = labDict ? doc.resolveArray(dictGet(labDict, "Range")) : void 0;
-      let labRange = [-100, 100, -100, 100];
-      if (rangeArr && rangeArr.items.length >= 4) {
-        const nums = rangeArr.items.slice(0, 4).map((it) => {
-          const r = doc.resolve(it);
-          return r?.kind === "number" ? r.value : 0;
-        });
-        labRange = [nums[0], nums[1], nums[2], nums[3]];
-      }
-      return { colorSpace: "rgb", colorSpaceLabel: "lab", components: 3, isLab: true, labRange };
-    }
     if (kindName === "Separation" || kindName === "DeviceN") {
       const isDevN = kindName === "DeviceN";
       const namesArr = isDevN ? doc.resolveArray(resolved.items[1]) : void 0;
       const devNComponents = isDevN && namesArr ? Math.max(1, namesArr.items.length) : 1;
       const altInfo = resolveColorSpaceInfo(doc, resolved.items[2], resourcesDict);
       const altSpace = altInfo.colorSpace === "cmyk" ? "cmyk" : altInfo.colorSpace === "gray" ? "gray" : "rgb";
-      const fnResolved = doc.resolve(resolved.items[3]);
-      const fnDict = fnResolved?.kind === "stream" ? fnResolved.dict : fnResolved?.kind === "dict" ? fnResolved : void 0;
-      const ftNode = fnDict ? doc.resolve(dictGet(fnDict, "FunctionType")) : void 0;
-      const tintFunctionType = ftNode?.kind === "number" ? ftNode.value : 2;
-      const c0Arr = fnDict ? doc.resolveArray(dictGet(fnDict, "C0")) : void 0;
-      const c1Arr = fnDict ? doc.resolveArray(dictGet(fnDict, "C1")) : void 0;
-      const nNode = fnDict ? doc.resolve(dictGet(fnDict, "N")) : void 0;
-      const c0 = c0Arr ? c0Arr.items.map((it) => {
-        const r = doc.resolve(it);
-        return r?.kind === "number" ? r.value : 0;
-      }) : altSpace === "cmyk" ? [0, 0, 0, 0] : altSpace === "gray" ? [1] : [1, 1, 1];
-      const c1 = c1Arr ? c1Arr.items.map((it) => {
-        const r = doc.resolve(it);
-        return r?.kind === "number" ? r.value : 0;
-      }) : altSpace === "cmyk" ? [0, 0, 0, 1] : altSpace === "gray" ? [0] : [0, 0, 0];
-      const sepN = nNode?.kind === "number" && nNode.value > 0 ? nNode.value : 1;
       return {
         colorSpace: altSpace,
         colorSpaceLabel: isDevN ? "devn" : "sep",
@@ -9774,12 +10033,9 @@ function resolveColorSpaceInfo(doc, csNode, resourcesDict) {
         isSeparation: !isDevN,
         isDeviceN: isDevN,
         separationAltSpace: altSpace,
-        separationC0: c0,
-        separationC1: c1,
-        separationN: sepN,
+        alternateCalibrated: altInfo.calibrated,
         tintFunctionDoc: doc,
-        tintFunctionNode: resolved.items[3],
-        tintFunctionType
+        tintFunctionNode: resolved.items[3]
       };
     }
   }
@@ -9929,141 +10185,55 @@ function decodeSamplesToRgba(rawSamples, width, height, bpc, csInfo, alphaSample
   const rgba = new Uint8Array(width * height * 4);
   const pixelCount = width * height;
   if (csInfo.isSeparation || csInfo.isDeviceN) {
-    const c0 = csInfo.separationC0 ?? [1, 1, 1];
-    const c1 = csInfo.separationC1 ?? [0, 0, 0];
-    const expN = csInfo.separationN ?? 1;
     const alt = csInfo.separationAltSpace ?? "rgb";
     const numCh = Math.max(1, csInfo.components);
     const step = bpc === 16 ? 2 : 1;
-    const useGenericTintFn = csInfo.tintFunctionDoc !== void 0 && csInfo.tintFunctionNode !== void 0 && (csInfo.tintFunctionType === 0 || csInfo.tintFunctionType === 3 || csInfo.tintFunctionType === 4);
     for (let p = 0; p < pixelCount; p++) {
       const chVals = [];
-      let wSum = 0;
       for (let ch3 = 0; ch3 < numCh; ch3++) {
         const sRaw = (rawSamples[(p * numCh + ch3) * step] ?? 0) / 255;
-        const tRemapped = remapUnitSampleWithDecode(sRaw, ch3, decodePairs);
-        chVals.push(tRemapped);
-        wSum += Math.pow(Math.max(0, Math.min(1, tRemapped)), expN);
-      }
-      if (useGenericTintFn) {
-        const outComps = evalShadingFunctionToComponents(
-          csInfo.tintFunctionDoc,
-          csInfo.tintFunctionNode,
-          chVals
-        );
-        if (alt === "cmyk") {
-          const c = outComps[0] ?? 0;
-          const m = outComps[1] ?? 0;
-          const y = outComps[2] ?? 0;
-          const k = outComps[3] ?? 0;
-          rgba[p * 4] = Math.round(Math.max(0, Math.min(1, (1 - c) * (1 - k))) * 255);
-          rgba[p * 4 + 1] = Math.round(Math.max(0, Math.min(1, (1 - m) * (1 - k))) * 255);
-          rgba[p * 4 + 2] = Math.round(Math.max(0, Math.min(1, (1 - y) * (1 - k))) * 255);
-        } else if (alt === "gray") {
-          const gByte = Math.round(Math.max(0, Math.min(1, outComps[0] ?? 0)) * 255);
-          rgba[p * 4] = gByte;
-          rgba[p * 4 + 1] = gByte;
-          rgba[p * 4 + 2] = gByte;
-        } else {
-          rgba[p * 4] = Math.round(Math.max(0, Math.min(1, outComps[0] ?? 0)) * 255);
-          rgba[p * 4 + 1] = Math.round(Math.max(0, Math.min(1, outComps[1] ?? 0)) * 255);
-          rgba[p * 4 + 2] = Math.round(Math.max(0, Math.min(1, outComps[2] ?? 0)) * 255);
-        }
-        rgba[p * 4 + 3] = 255;
-        continue;
+        chVals.push(remapUnitSampleWithDecode(sRaw, ch3, decodePairs));
       }
-      const w = Math.max(0, Math.min(1, wSum));
-      if (alt === "cmyk") {
-        const c = (c0[0] ?? 0) + w * ((c1[0] ?? 0) - (c0[0] ?? 0));
-        const m = (c0[1] ?? 0) + w * ((c1[1] ?? 0) - (c0[1] ?? 0));
-        const y = (c0[2] ?? 0) + w * ((c1[2] ?? 0) - (c0[2] ?? 0));
-        const k = (c0[3] ?? 0) + w * ((c1[3] ?? 1) - (c0[3] ?? 0));
-        rgba[p * 4] = Math.round(Math.max(0, Math.min(1, (1 - c) * (1 - k))) * 255);
-        rgba[p * 4 + 1] = Math.round(Math.max(0, Math.min(1, (1 - m) * (1 - k))) * 255);
-        rgba[p * 4 + 2] = Math.round(Math.max(0, Math.min(1, (1 - y) * (1 - k))) * 255);
+      const outComps = evalShadingFunctionToComponents(
+        csInfo.tintFunctionDoc,
+        csInfo.tintFunctionNode,
+        chVals
+      );
+      if (csInfo.alternateCalibrated) {
+        rgba.set(csInfo.alternateCalibrated.getRgb(outComps, 0), p * 4);
+      } else if (alt === "cmyk") {
+        rgba.set(cmykColorSpace.getRgb([outComps[0] ?? 0, outComps[1] ?? 0, outComps[2] ?? 0, outComps[3] ?? 0], 0), p * 4);
       } else if (alt === "gray") {
-        const gVal = (c0[0] ?? 1) + w * ((c1[0] ?? 0) - (c0[0] ?? 1));
-        const gByte = Math.round(Math.max(0, Math.min(1, gVal)) * 255);
+        const gByte = Math.round(Math.max(0, Math.min(1, outComps[0] ?? 0)) * 255);
         rgba[p * 4] = gByte;
         rgba[p * 4 + 1] = gByte;
         rgba[p * 4 + 2] = gByte;
       } else {
-        const rVal = (c0[0] ?? 1) + w * ((c1[0] ?? 0) - (c0[0] ?? 1));
-        const gVal = (c0[1] ?? 1) + w * ((c1[1] ?? 0) - (c0[1] ?? 1));
-        const bVal = (c0[2] ?? 1) + w * ((c1[2] ?? 0) - (c0[2] ?? 1));
-        rgba[p * 4] = Math.round(Math.max(0, Math.min(1, rVal)) * 255);
-        rgba[p * 4 + 1] = Math.round(Math.max(0, Math.min(1, gVal)) * 255);
-        rgba[p * 4 + 2] = Math.round(Math.max(0, Math.min(1, bVal)) * 255);
+        rgba[p * 4] = Math.round(Math.max(0, Math.min(1, outComps[0] ?? 0)) * 255);
+        rgba[p * 4 + 1] = Math.round(Math.max(0, Math.min(1, outComps[1] ?? 0)) * 255);
+        rgba[p * 4 + 2] = Math.round(Math.max(0, Math.min(1, outComps[2] ?? 0)) * 255);
       }
       rgba[p * 4 + 3] = 255;
     }
-  } else if (csInfo.isLab) {
-    const [amin, amax, bmin, bmax] = csInfo.labRange ?? [-100, 100, -100, 100];
-    const invF = (t) => t > 6 / 29 ? t * t * t : 3 * (6 / 29) * (6 / 29) * (t - 4 / 29);
-    const toSrgb = (u) => {
-      const c = u <= 31308e-7 ? 12.92 * u : 1.055 * Math.pow(u, 1 / 2.4) - 0.055;
-      return Math.round(Math.max(0, Math.min(1, c)) * 255);
-    };
+  } else if (csInfo.calibrated?.name === "Lab") {
+    const { amin, amax, bmin, bmax } = csInfo.calibrated;
+    const step = bpc === 16 ? 2 : 1;
     for (let p = 0; p < pixelCount; p++) {
-      const s0 = (rawSamples[p * 3] ?? 0) / 255;
-      const s1 = (rawSamples[p * 3 + 1] ?? 128) / 255;
-      const s2 = (rawSamples[p * 3 + 2] ?? 128) / 255;
-      const L = s0 * 100;
-      if (L <= 0.01) {
-        rgba[p * 4] = 0;
-        rgba[p * 4 + 1] = 0;
-        rgba[p * 4 + 2] = 0;
-        rgba[p * 4 + 3] = 255;
-        continue;
-      }
-      const a = amin + s1 * (amax - amin);
-      const b = bmin + s2 * (bmax - bmin);
-      const fy = (L + 16) / 116;
-      const fx = fy + a / 500;
-      const fz = fy - b / 200;
-      const X = 0.95047 * invF(fx);
-      const Y = 1 * invF(fy);
-      const Z = 1.08883 * invF(fz);
-      const linR = X * 3.2406 + Y * -1.5372 + Z * -0.4986;
-      const linG = X * -0.9689 + Y * 1.8758 + Z * 0.0415;
-      const linB = X * 0.0557 + Y * -0.204 + Z * 1.057;
-      rgba[p * 4] = toSrgb(linR);
-      rgba[p * 4 + 1] = toSrgb(linG);
-      rgba[p * 4 + 2] = toSrgb(linB);
+      const L = (rawSamples[p * 3 * step] ?? 0) / 255 * 100;
+      const a = amin + (rawSamples[(p * 3 + 1) * step] ?? 128) / 255 * (amax - amin);
+      const b = bmin + (rawSamples[(p * 3 + 2) * step] ?? 128) / 255 * (bmax - bmin);
+      rgba.set(csInfo.calibrated.getRgb([L, a, b], 0), p * 4);
       rgba[p * 4 + 3] = 255;
     }
   } else if (csInfo.colorSpace === "rgb") {
-    const hasCalRgb = Boolean(csInfo.calRgbGamma || csInfo.calRgbMatrix);
-    const toSrgbByte = (u) => {
-      const c = u <= 31308e-7 ? 12.92 * u : 1.055 * Math.pow(u, 1 / 2.4) - 0.055;
-      return Math.round(Math.max(0, Math.min(1, c)) * 255);
-    };
     const writeRgbPixel = (p, rByte, gByte, bByte) => {
-      let rU = remapUnitSampleWithDecode(rByte / 255, 0, decodePairs);
-      let gU = remapUnitSampleWithDecode(gByte / 255, 1, decodePairs);
-      let bU = remapUnitSampleWithDecode(bByte / 255, 2, decodePairs);
-      if (hasCalRgb) {
-        const [gr, gg, gb] = csInfo.calRgbGamma ?? [1, 1, 1];
-        const ag = Math.pow(rU, gr);
-        const bg = Math.pow(gU, gg);
-        const cg = Math.pow(bU, gb);
-        if (csInfo.calRgbMatrix && csInfo.calRgbMatrix.length >= 9) {
-          const m = csInfo.calRgbMatrix;
-          const X = m[0] * ag + m[3] * bg + m[6] * cg;
-          const Y = m[1] * ag + m[4] * bg + m[7] * cg;
-          const Z = m[2] * ag + m[5] * bg + m[8] * cg;
-          const linR = X * 3.2406 + Y * -1.5372 + Z * -0.4986;
-          const linG = X * -0.9689 + Y * 1.8758 + Z * 0.0415;
-          const linB = X * 0.0557 + Y * -0.204 + Z * 1.057;
-          rgba[p * 4] = toSrgbByte(linR);
-          rgba[p * 4 + 1] = toSrgbByte(linG);
-          rgba[p * 4 + 2] = toSrgbByte(linB);
-          rgba[p * 4 + 3] = 255;
-          return;
-        }
-        rU = ag;
-        gU = bg;
-        bU = cg;
+      const rU = remapUnitSampleWithDecode(rByte / 255, 0, decodePairs);
+      const gU = remapUnitSampleWithDecode(gByte / 255, 1, decodePairs);
+      const bU = remapUnitSampleWithDecode(bByte / 255, 2, decodePairs);
+      if (csInfo.calibrated) {
+        rgba.set(csInfo.calibrated.getRgb([rU, gU, bU], 0), p * 4);
+        rgba[p * 4 + 3] = 255;
+        return;
       }
       rgba[p * 4] = Math.round(rU * 255);
       rgba[p * 4 + 1] = Math.round(gU * 255);
@@ -10083,10 +10253,11 @@ function decodeSamplesToRgba(rawSamples, width, height, bpc, csInfo, alphaSample
     }
   } else if (csInfo.colorSpace === "gray") {
     const writeGrayPixel = (p, gByte) => {
-      let gU = remapUnitSampleWithDecode(gByte / 255, 0, decodePairs);
-      if (csInfo.calGrayGamma && csInfo.calGrayGamma !== 1) {
-        const lin = Math.pow(gU, csInfo.calGrayGamma);
-        gU = lin <= 31308e-7 ? 12.92 * lin : 1.055 * Math.pow(lin, 1 / 2.4) - 0.055;
+      const gU = remapUnitSampleWithDecode(gByte / 255, 0, decodePairs);
+      if (csInfo.calibrated) {
+        rgba.set(csInfo.calibrated.getRgb([gU], 0), p * 4);
+        rgba[p * 4 + 3] = 255;
+        return;
       }
       const outG = Math.round(Math.max(0, Math.min(1, gU)) * 255);
       rgba[p * 4] = outG;
@@ -10142,9 +10313,7 @@ function decodeSamplesToRgba(rawSamples, width, height, bpc, csInfo, alphaSample
       const m = remapUnitSampleWithDecode((rawSamples[p * stride + chStep] ?? 0) / 255, 1, decodePairs);
       const y = remapUnitSampleWithDecode((rawSamples[p * stride + chStep * 2] ?? 0) / 255, 2, decodePairs);
       const k = remapUnitSampleWithDecode((rawSamples[p * stride + chStep * 3] ?? 0) / 255, 3, decodePairs);
-      rgba[p * 4] = Math.round((1 - c) * (1 - k) * 255);
-      rgba[p * 4 + 1] = Math.round((1 - m) * (1 - k) * 255);
-      rgba[p * 4 + 2] = Math.round((1 - y) * (1 - k) * 255);
+      rgba.set(cmykColorSpace.getRgb([c, m, y, k], 0), p * 4);
       rgba[p * 4 + 3] = 255;
     }
   } else if (csInfo.colorSpace === "index") {
@@ -10182,9 +10351,7 @@ function decodeSamplesToRgba(rawSamples, width, height, bpc, csInfo, alphaSample
             const m = pal[idx * 4 + 1] / 255;
             const yel = pal[idx * 4 + 2] / 255;
             const k = pal[idx * 4 + 3] / 255;
-            rgba[p * 4] = Math.round((1 - c) * (1 - k) * 255);
-            rgba[p * 4 + 1] = Math.round((1 - m) * (1 - k) * 255);
-            rgba[p * 4 + 2] = Math.round((1 - yel) * (1 - k) * 255);
+            rgba.set(cmykColorSpace.getRgb([c, m, yel, k], 0), p * 4);
           } else {
             rgba[p * 4] = pal[idx * baseComp];
             rgba[p * 4 + 1] = pal[idx * baseComp + 1];
@@ -10655,193 +10822,6 @@ function resolvePageFonts(doc, resourcesDict) {
   }
   return fonts;
 }
-function evaluateType4PostScriptTokens(tokens, initialStack) {
-  const stack = [...initialStack];
-  const runRange = (start, end) => {
-    let i = start;
-    while (i < end) {
-      const tok = tokens[i];
-      if (tok === "{") {
-        let depth = 1;
-        let j = i + 1;
-        while (j < end && depth > 0) {
-          if (tokens[j] === "{") depth++;
-          else if (tokens[j] === "}") depth--;
-          j++;
-        }
-        const blockStart = i + 1;
-        const blockEnd = j - 1;
-        if (j < end && tokens[j] === "{") {
-          let depth2 = 1;
-          let k = j + 1;
-          while (k < end && depth2 > 0) {
-            if (tokens[k] === "{") depth2++;
-            else if (tokens[k] === "}") depth2--;
-            k++;
-          }
-          if (k < end && tokens[k] === "ifelse") {
-            const cond = stack.pop() ?? 0;
-            if (cond !== 0) runRange(blockStart, blockEnd);
-            else runRange(j + 1, k - 1);
-            i = k + 1;
-            continue;
-          }
-        }
-        if (j < end && tokens[j] === "if") {
-          const cond = stack.pop() ?? 0;
-          if (cond !== 0) runRange(blockStart, blockEnd);
-          i = j + 1;
-          continue;
-        }
-        runRange(blockStart, blockEnd);
-        i = j;
-        continue;
-      }
-      if (tok === "}") {
-        i++;
-        continue;
-      }
-      const numVal2 = Number(tok);
-      if (tok.length > 0 && !Number.isNaN(numVal2)) {
-        stack.push(numVal2);
-      } else if (tok === "true") {
-        stack.push(1);
-      } else if (tok === "false") {
-        stack.push(0);
-      } else if (tok === "add") {
-        const b = stack.pop() ?? 0, a = stack.pop() ?? 0;
-        stack.push(a + b);
-      } else if (tok === "sub") {
-        const b = stack.pop() ?? 0, a = stack.pop() ?? 0;
-        stack.push(a - b);
-      } else if (tok === "mul") {
-        const b = stack.pop() ?? 0, a = stack.pop() ?? 0;
-        stack.push(a * b);
-      } else if (tok === "div") {
-        const b = stack.pop() ?? 1, a = stack.pop() ?? 0;
-        stack.push(Math.abs(b) > 1e-12 ? a / b : 0);
-      } else if (tok === "idiv") {
-        const b = stack.pop() ?? 1, a = stack.pop() ?? 0;
-        stack.push(Math.abs(b) > 1e-12 ? Math.trunc(a / b) : 0);
-      } else if (tok === "mod") {
-        const b = stack.pop() ?? 1, a = stack.pop() ?? 0;
-        stack.push(Math.abs(b) > 1e-12 ? a % b : 0);
-      } else if (tok === "neg") {
-        stack.push(-(stack.pop() ?? 0));
-      } else if (tok === "abs") {
-        stack.push(Math.abs(stack.pop() ?? 0));
-      } else if (tok === "ceiling") {
-        stack.push(Math.ceil(stack.pop() ?? 0));
-      } else if (tok === "floor") {
-        stack.push(Math.floor(stack.pop() ?? 0));
-      } else if (tok === "round") {
-        stack.push(Math.round(stack.pop() ?? 0));
-      } else if (tok === "truncate" || tok === "cvi") {
-        stack.push(Math.trunc(stack.pop() ?? 0));
-      } else if (tok === "sqrt") {
-        stack.push(Math.sqrt(Math.max(0, stack.pop() ?? 0)));
-      } else if (tok === "sin") {
-        stack.push(Math.sin((stack.pop() ?? 0) * Math.PI / 180));
-      } else if (tok === "cos") {
-        stack.push(Math.cos((stack.pop() ?? 0) * Math.PI / 180));
-      } else if (tok === "atan") {
-        const dx = stack.pop() ?? 1, dy = stack.pop() ?? 0;
-        let deg = Math.atan2(dy, dx) * 180 / Math.PI;
-        if (deg < 0) deg += 360;
-        stack.push(deg);
-      } else if (tok === "exp") {
-        const exp = stack.pop() ?? 1, base = stack.pop() ?? 0;
-        stack.push(Math.pow(base, exp));
-      } else if (tok === "ln") {
-        stack.push(Math.log(Math.max(1e-12, stack.pop() ?? 1)));
-      } else if (tok === "log") {
-        stack.push(Math.log10(Math.max(1e-12, stack.pop() ?? 1)));
-      } else if (tok === "dup") {
-        if (stack.length > 0) stack.push(stack[stack.length - 1]);
-      } else if (tok === "exch") {
-        if (stack.length >= 2) {
-          const b = stack.pop(), a = stack.pop();
-          stack.push(b, a);
-        }
-      } else if (tok === "pop") {
-        stack.pop();
-      } else if (tok === "copy") {
-        const n = Math.max(0, Math.trunc(stack.pop() ?? 0));
-        const slice = stack.slice(Math.max(0, stack.length - n));
-        stack.push(...slice);
-      } else if (tok === "index") {
-        const n = Math.max(0, Math.trunc(stack.pop() ?? 0));
-        const idx = stack.length - 1 - n;
-        if (idx >= 0 && idx < stack.length) stack.push(stack[idx]);
-      } else if (tok === "roll") {
-        const jShift = Math.trunc(stack.pop() ?? 0);
-        const n = Math.max(0, Math.trunc(stack.pop() ?? 0));
-        if (n > 0 && stack.length >= n) {
-          const sub = stack.splice(stack.length - n, n);
-          const modShift = (jShift % n + n) % n;
-          const rolled = [...sub.slice(n - modShift), ...sub.slice(0, n - modShift)];
-          stack.push(...rolled);
-        }
-      } else if (tok === "eq") {
-        const b = stack.pop() ?? 0, a = stack.pop() ?? 0;
-        stack.push(Math.abs(a - b) < 1e-9 ? 1 : 0);
-      } else if (tok === "ne") {
-        const b = stack.pop() ?? 0, a = stack.pop() ?? 0;
-        stack.push(Math.abs(a - b) >= 1e-9 ? 1 : 0);
-      } else if (tok === "gt") {
-        const b = stack.pop() ?? 0, a = stack.pop() ?? 0;
-        stack.push(a > b ? 1 : 0);
-      } else if (tok === "ge") {
-        const b = stack.pop() ?? 0, a = stack.pop() ?? 0;
-        stack.push(a >= b ? 1 : 0);
-      } else if (tok === "lt") {
-        const b = stack.pop() ?? 0, a = stack.pop() ?? 0;
-        stack.push(a < b ? 1 : 0);
-      } else if (tok === "le") {
-        const b = stack.pop() ?? 0, a = stack.pop() ?? 0;
-        stack.push(a <= b ? 1 : 0);
-      } else if (tok === "and") {
-        const b = stack.pop() ?? 0, a = stack.pop() ?? 0;
-        stack.push(a !== 0 && b !== 0 ? 1 : 0);
-      } else if (tok === "or") {
-        const b = stack.pop() ?? 0, a = stack.pop() ?? 0;
-        stack.push(a !== 0 || b !== 0 ? 1 : 0);
-      } else if (tok === "not") {
-        const a = stack.pop() ?? 0;
-        stack.push(a === 0 ? 1 : 0);
-      }
-      i++;
-    }
-  };
-  runRange(0, tokens.length);
-  return stack;
-}
-function tokenizePostScriptCode(bytes) {
-  const tokens = [];
-  let cur = "";
-  for (let i = 0; i < bytes.length; i++) {
-    const ch3 = String.fromCharCode(bytes[i]);
-    if (ch3 === "{" || ch3 === "}") {
-      if (cur.length > 0) {
-        tokens.push(cur);
-        cur = "";
-      }
-      tokens.push(ch3);
-    } else if (ch3 === " " || ch3 === "	" || ch3 === "\n" || ch3 === "\r") {
-      if (cur.length > 0) {
-        tokens.push(cur);
-        cur = "";
-      }
-    } else {
-      cur += ch3;
-    }
-  }
-  if (cur.length > 0) tokens.push(cur);
-  if (tokens[0] === "{" && tokens[tokens.length - 1] === "}") {
-    return tokens.slice(1, -1);
-  }
-  return tokens;
-}
 function evalShadingFunctionToComponents(doc, fnNode, inputs) {
   const inArr = typeof inputs === "number" ? [inputs] : inputs;
   const t = inArr[0] ?? 0;
@@ -10888,35 +10868,50 @@ function evalShadingFunctionToComponents(doc, fnNode, inputs) {
     const decode = getNums("Decode", range);
     const nOut = Math.max(1, Math.floor((decode.length || range.length || 6) / 2));
     const mIn = Math.max(1, size.length);
-    let flatGridIndex = 0;
+    const streamBytes = doc.decodeStream(resolved);
+    let vertices = [{ index: 0, weight: 1 }];
     let stride = 1;
     for (let i = 0; i < mIn; i++) {
       const d02 = dom[i * 2] ?? 0;
       const d12 = dom[i * 2 + 1] ?? 1;
-      const sMax = Math.max(1, (size[i] ?? 2) - 1);
+      const sMax = Math.max(0, (size[i] ?? 2) - 1);
       const e0 = encode[i * 2] ?? 0;
       const e1 = encode[i * 2 + 1] ?? sMax;
       const x = Math.max(d02, Math.min(d12, inArr[i] ?? 0));
-      const u = Math.abs(d12 - d02) > 1e-8 ? (x - d02) / (d12 - d02) : 0;
-      const idx = Math.round(Math.max(0, Math.min(sMax, e0 + u * (e1 - e0))));
-      flatGridIndex += idx * stride;
+      const u = d12 === d02 ? 0 : (x - d02) / (d12 - d02);
+      const e = Math.max(0, Math.min(sMax, e0 + u * (e1 - e0)));
+      const low = Math.floor(e), fraction = e - low;
+      const next = [];
+      for (const vertex of vertices) {
+        const index = vertex.index + low * stride;
+        if (index * nOut * bps < streamBytes.length * 8) next.push({ index, weight: vertex.weight * (1 - fraction) });
+        if (fraction && (index + stride) * nOut * bps < streamBytes.length * 8) {
+          next.push({ index: index + stride, weight: vertex.weight * fraction });
+        }
+      }
+      vertices = next;
       stride *= size[i] ?? 2;
     }
-    const streamBytes = doc.decodeStream(resolved);
+    const maxSample = 2 ** bps - 1;
+    const readSample = (index) => {
+      let bitOffset = index * bps, remaining = bps, value = 0;
+      while (remaining > 0) {
+        const bitInByte = bitOffset % 8;
+        const take = Math.min(remaining, 8 - bitInByte);
+        const byte = streamBytes[Math.floor(bitOffset / 8)] ?? 0;
+        value = value * 2 ** take + (byte >> 8 - bitInByte - take & (1 << take) - 1);
+        bitOffset += take;
+        remaining -= take;
+      }
+      return value / maxSample;
+    };
     const out2 = [];
-    const maxSample = bps === 16 ? 65535 : 255;
     for (let j = 0; j < nOut; j++) {
-      const sampleIdx = flatGridIndex * nOut + j;
-      let rawVal = 0;
-      if (bps === 16) {
-        rawVal = (streamBytes[sampleIdx * 2] ?? 0) << 8 | (streamBytes[sampleIdx * 2 + 1] ?? 0);
-      } else {
-        rawVal = streamBytes[sampleIdx] ?? 0;
-      }
-      const frac = rawVal / maxSample;
+      let value = 0;
+      for (const vertex of vertices) value += readSample(vertex.index * nOut + j) * vertex.weight;
       const dec0 = decode[j * 2] ?? 0;
       const dec1 = decode[j * 2 + 1] ?? 1;
-      out2.push(dec0 + frac * (dec1 - dec0));
+      out2.push(dec0 + value * (dec1 - dec0));
     }
     return clampRange(out2);
   }
@@ -10926,34 +10921,40 @@ function evalShadingFunctionToComponents(doc, fnNode, inputs) {
       const d12 = dom[i * 2 + 1] ?? 1;
       return Math.max(d02, Math.min(d12, v));
     });
-    const tokens = tokenizePostScriptCode(doc.decodeStream(resolved));
-    const stackOut = evaluateType4PostScriptTokens(tokens, clampedInputs);
-    return clampRange(stackOut);
+    const source = bytesToString3(doc.decodeStream(resolved));
+    let cached = postScriptFunctions.get(resolved);
+    if (!cached || cached.source !== source || cached.domain.length !== dom.length || cached.domain.some((value, index) => value !== dom[index]) || cached.range.length !== range.length || cached.range.some((value, index) => value !== range[index])) {
+      cached = { source, domain: dom, range, evaluate: buildPostScriptJsFunction(source, dom, range) };
+      postScriptFunctions.set(resolved, cached);
+    }
+    const output = [];
+    cached.evaluate(clampedInputs, 0, output, 0);
+    return output;
   }
   if (ft === 3) {
     const fnsArr = doc.resolveArray(dictGet(fnDict, "Functions"));
     const bounds = getNums("Bounds", []);
     const encode = getNums("Encode", []);
     if (fnsArr && fnsArr.items.length > 0) {
+      const input = Math.max(dom[0] ?? 0, Math.min(dom[1] ?? 1, t));
       let segIdx = 0;
-      while (segIdx < bounds.length && t >= bounds[segIdx]) segIdx++;
+      while (segIdx < bounds.length && input >= bounds[segIdx]) segIdx++;
       segIdx = Math.min(fnsArr.items.length - 1, segIdx);
       const b0 = segIdx === 0 ? dom[0] ?? 0 : bounds[segIdx - 1];
       const b1 = segIdx < bounds.length ? bounds[segIdx] : dom[1] ?? 1;
       const e0 = encode[segIdx * 2] ?? 0;
       const e1 = encode[segIdx * 2 + 1] ?? 1;
-      const localT = Math.abs(b1 - b0) > 1e-8 ? e0 + (t - b0) / (b1 - b0) * (e1 - e0) : e0;
-      return evalShadingFunctionToComponents(doc, fnsArr.items[segIdx], Math.max(0, Math.min(1, localT)));
+      const localT = b1 !== b0 ? e0 + (input - b0) / (b1 - b0) * (e1 - e0) : e0;
+      return clampRange(evalShadingFunctionToComponents(doc, fnsArr.items[segIdx], localT));
     }
   }
-  const c0 = getNums("C0", [0, 0, 0]);
-  const c1 = getNums("C1", [1, 1, 1]);
+  const c0 = getNums("C0", [0]);
+  const c1 = getNums("C1", [1]);
   const nNode = doc.resolve(dictGet(fnDict, "N"));
-  const expN = nNode?.kind === "number" && nNode.value > 0 ? nNode.value : 1;
+  const expN = nNode?.kind === "number" ? nNode.value : 1;
   const d0 = dom[0] ?? 0;
   const d1 = dom[1] ?? 1;
-  const normT = Math.abs(d1 - d0) > 1e-8 ? (t - d0) / (d1 - d0) : t;
-  const w = Math.pow(Math.max(0, Math.min(1, normT)), expN);
+  const w = Math.pow(Math.max(d0, Math.min(d1, t)), expN);
   const len = Math.max(c0.length, c1.length);
   const out = [];
   for (let i = 0; i < len; i++) {
@@ -10969,30 +10970,14 @@ function shadingComponentsToRgb(csName, comps) {
     return [v, v, v];
   }
   if (csName === "DeviceCMYK" || csName === "CMYK" || comps.length >= 4) {
-    const cc = comps[0] ?? 0, cm = comps[1] ?? 0, cy = comps[2] ?? 0, ck = comps[3] ?? 0;
-    return [(1 - cc) * (1 - ck), (1 - cm) * (1 - kClamp(ck)), (1 - cy) * (1 - kClamp(ck))];
+    const rgb2 = cmykColorSpace2.getRgb([comps[0] ?? 0, comps[1] ?? 0, comps[2] ?? 0, comps[3] ?? 0], 0);
+    return [rgb2[0] / 255, rgb2[1] / 255, rgb2[2] / 255];
   }
   return [comps[0] ?? 0, comps[1] ?? 0, comps[2] ?? 0];
 }
 function kClamp(v) {
   return Math.max(0, Math.min(1, v));
 }
-function xyzToSrgb(X, Y, Z, Xw = 0.95047, Yw = 1, Zw = 1.08883) {
-  const scaleX = Xw > 1e-6 ? 0.95047 / Xw : 1;
-  const scaleY = Yw > 1e-6 ? 1 / Yw : 1;
-  const scaleZ = Zw > 1e-6 ? 1.08883 / Zw : 1;
-  const x = X * scaleX;
-  const y = Y * scaleY;
-  const z = Z * scaleZ;
-  const rl = 3.2404542 * x - 1.5371385 * y - 0.4985314 * z;
-  const gl = -0.969266 * x + 1.8760108 * y + 0.041556 * z;
-  const bl = 0.0556434 * x - 0.2040259 * y + 1.0572252 * z;
-  const toGamma = (u) => {
-    const c = Math.max(0, Math.min(1, u));
-    return c <= 31308e-7 ? 12.92 * c : 1.055 * Math.pow(c, 1 / 2.4) - 0.055;
-  };
-  return [toGamma(rl), toGamma(gl), toGamma(bl)];
-}
 function getColorSpaceComponentCount(doc, csNode, activeResources, depth = 0) {
   if (!csNode || depth > 4) return 3;
   const resolved = doc ? doc.resolve(csNode) : csNode;
@@ -11049,63 +11034,10 @@ function convertColorSpaceComponentsToRgb(doc, csNode, csNameFallback, comps, ac
   if (resolved.kind === "array" && resolved.items.length > 0 && doc) {
     const familyNode = doc.resolve(resolved.items[0]);
     const family = familyNode?.kind === "name" ? familyNode.decoded : "";
-    if (family === "CalGray") {
-      const paramDict = resolved.items[1] ? doc.resolveDict(resolved.items[1]) : void 0;
-      const gNode = paramDict ? doc.resolve(dictGet(paramDict, "Gamma")) : void 0;
-      const gamma = gNode?.kind === "number" && gNode.value > 0 ? gNode.value : 1;
-      const a = Math.pow(kClamp(comps[0] ?? 0), gamma);
-      return [a, a, a];
-    }
-    if (family === "CalRGB") {
-      const paramDict = resolved.items[1] ? doc.resolveDict(resolved.items[1]) : void 0;
-      const gammaArr = paramDict ? doc.resolveArray(dictGet(paramDict, "Gamma")) : void 0;
-      const getArrNum = (arr, idx, fb) => {
-        const r = arr && arr.items[idx] ? doc.resolve(arr.items[idx]) : void 0;
-        return r?.kind === "number" ? r.value : fb;
-      };
-      const gr = getArrNum(gammaArr, 0, 1);
-      const gg = getArrNum(gammaArr, 1, 1);
-      const gb = getArrNum(gammaArr, 2, 1);
-      const ag = Math.pow(kClamp(comps[0] ?? 0), gr > 0 ? gr : 1);
-      const bg = Math.pow(kClamp(comps[1] ?? 0), gg > 0 ? gg : 1);
-      const cg = Math.pow(kClamp(comps[2] ?? 0), gb > 0 ? gb : 1);
-      const matArr = paramDict ? doc.resolveArray(dictGet(paramDict, "Matrix")) : void 0;
-      if (matArr && matArr.items.length >= 9) {
-        const m = (i) => getArrNum(matArr, i, 0);
-        const X = m(0) * ag + m(3) * bg + m(6) * cg;
-        const Y = m(1) * ag + m(4) * bg + m(7) * cg;
-        const Z = m(2) * ag + m(5) * bg + m(8) * cg;
-        const wpArr = paramDict ? doc.resolveArray(dictGet(paramDict, "WhitePoint")) : void 0;
-        const Xw = getArrNum(wpArr, 0, 0.95047);
-        const Yw = getArrNum(wpArr, 1, 1);
-        const Zw = getArrNum(wpArr, 2, 1.08883);
-        return xyzToSrgb(X, Y, Z, Xw, Yw, Zw);
-      }
-      return [ag, bg, cg];
-    }
-    if (family === "Lab") {
-      const paramDict = resolved.items[1] ? doc.resolveDict(resolved.items[1]) : void 0;
-      const wpArr = paramDict ? doc.resolveArray(dictGet(paramDict, "WhitePoint")) : void 0;
-      const rangeArr = paramDict ? doc.resolveArray(dictGet(paramDict, "Range")) : void 0;
-      const getNum = (arr, idx, fb) => {
-        const r = arr && arr.items[idx] ? doc.resolve(arr.items[idx]) : void 0;
-        return r?.kind === "number" ? r.value : fb;
-      };
-      const Xw = getNum(wpArr, 0, 0.95047);
-      const Yw = getNum(wpArr, 1, 1);
-      const Zw = getNum(wpArr, 2, 1.08883);
-      const amin = getNum(rangeArr, 0, -100);
-      const amax = getNum(rangeArr, 1, 100);
-      const bmin = getNum(rangeArr, 2, -100);
-      const bmax = getNum(rangeArr, 3, 100);
-      const Lstar = Math.max(0, Math.min(100, comps[0] ?? 0));
-      const astar = Math.max(amin, Math.min(amax, comps[1] ?? 0));
-      const bstar = Math.max(bmin, Math.min(bmax, comps[2] ?? 0));
-      const M = (Lstar + 16) / 116;
-      const L = M + astar / 500;
-      const N = M - bstar / 200;
-      const gFn = (x) => x >= 6 / 29 ? x * x * x : 108 / 841 * (x - 4 / 29);
-      return xyzToSrgb(Xw * gFn(L), Yw * gFn(M), Zw * gFn(N), Xw, Yw, Zw);
+    if (family === "CalGray" || family === "CalRGB" || family === "Lab") {
+      const colorSpace = createCalibratedColorSpace(doc, family, resolved.items[1]);
+      const rgb2 = colorSpace.getRgb(comps, 0);
+      return [rgb2[0] / 255, rgb2[1] / 255, rgb2[2] / 255];
     }
     if (family === "ICCBased" && resolved.items[1]) {
       const iccNode = doc.resolve(resolved.items[1]);
@@ -11186,143 +11118,28 @@ function renderMeshShadingToImage(doc, shDict, shStream, shType, effectiveCtm, t
     const r = doc.resolve(it);
     return r?.kind === "number" ? r.value : 0;
   });
-  const xmin = decodeNums[0], xmax = decodeNums[1], ymin = decodeNums[2], ymax = decodeNums[3];
-  const numColorParams = Math.max(1, Math.floor((decodeNums.length - 4) / 2));
   const fnNode = dictGet(shDict, "Function");
   const csNode = doc.resolve(dictGet(shDict, "ColorSpace"));
   const csName = csNode?.kind === "name" ? csNode.decoded : "DeviceRGB";
-  let bitPos = 0;
-  const totalBits = bytes.length * 8;
-  const readBits = (n) => {
-    let val = 0;
-    for (let i = 0; i < n; i++) {
-      if (bitPos >= totalBits) return val;
-      const byteIdx = bitPos >> 3;
-      const bitIdx = 7 - (bitPos & 7);
-      val = val * 2 + (bytes[byteIdx] >> bitIdx & 1);
-      bitPos++;
-    }
-    return val;
-  };
-  const coordMax = Math.pow(2, bpcCoord) - 1 || 1;
-  const compMax = Math.pow(2, bpcComp) - 1 || 1;
-  const readCoord = () => {
-    const rx = readBits(bpcCoord) / coordMax;
-    const ry = readBits(bpcCoord) / coordMax;
-    return [xmin + rx * (xmax - xmin), ymin + ry * (ymax - ymin)];
-  };
-  const readColorRgb = () => {
-    const params = [];
-    for (let c = 0; c < numColorParams; c++) {
-      const rc = readBits(bpcComp) / compMax;
-      const cMin = decodeNums[4 + c * 2] ?? 0;
-      const cMax = decodeNums[4 + c * 2 + 1] ?? 1;
-      params.push(cMin + rc * (cMax - cMin));
-    }
-    const comps = fnNode ? evalShadingFunctionToComponents(doc, fnNode, params) : params;
-    return convertColorSpaceComponentsToRgb(doc, csNode, csName, comps);
-  };
-  const triangles = [];
-  if (shType === 4) {
-    const minBitsPerVert = bpcFlag + 2 * bpcCoord + numColorParams * bpcComp;
-    let triVerts;
-    while (bitPos + minBitsPerVert <= totalBits) {
-      const flag = readBits(bpcFlag) & 3;
-      const [x, y] = readCoord();
-      const rgb2 = readColorRgb();
-      const vNew = { x, y, rgb: rgb2 };
-      if (flag === 0 || !triVerts) {
-        if (bitPos + 2 * minBitsPerVert > totalBits) break;
-        readBits(bpcFlag);
-        const [x1, y1] = readCoord();
-        const rgb1 = readColorRgb();
-        readBits(bpcFlag);
-        const [x2, y2] = readCoord();
-        const rgb22 = readColorRgb();
-        triVerts = [vNew, { x: x1, y: y1, rgb: rgb1 }, { x: x2, y: y2, rgb: rgb22 }];
-        triangles.push(triVerts);
-      } else if (flag === 1) {
-        triVerts = [triVerts[1], triVerts[2], vNew];
-        triangles.push(triVerts);
-      } else if (flag === 2) {
-        triVerts = [triVerts[0], triVerts[2], vNew];
-        triangles.push(triVerts);
-      }
-    }
-  } else if (shType === 5) {
-    const minBitsPerVert = 2 * bpcCoord + numColorParams * bpcComp;
-    const verts = [];
-    while (bitPos + minBitsPerVert <= totalBits) {
-      const [x, y] = readCoord();
-      const rgb2 = readColorRgb();
-      verts.push({ x, y, rgb: rgb2 });
-    }
-    const numRows = Math.floor(verts.length / vPerRow);
-    for (let r = 0; r + 1 < numRows; r++) {
-      for (let c = 0; c + 1 < vPerRow; c++) {
-        const v00 = verts[r * vPerRow + c];
-        const v01 = verts[r * vPerRow + c + 1];
-        const v11 = verts[(r + 1) * vPerRow + c + 1];
-        const v10 = verts[(r + 1) * vPerRow + c];
-        triangles.push([v00, v01, v11], [v00, v11, v10]);
-      }
-    }
-  } else if (shType === 6 || shType === 7) {
-    const numCtrl = shType === 6 ? 12 : 16;
-    const minBitsPatch = bpcFlag + (numCtrl - 4) * 2 * bpcCoord + 2 * numColorParams * bpcComp;
-    let prevPts;
-    let prevColors;
-    while (bitPos + minBitsPatch <= totalBits) {
-      const flag = readBits(bpcFlag) & 3;
-      let pts = [];
-      let cols = [];
-      if (flag === 0 || !prevPts || !prevColors) {
-        for (let i = 0; i < numCtrl; i++) pts.push(readCoord());
-        for (let i = 0; i < 4; i++) cols.push(readColorRgb());
-      } else {
-        const extraCtrl = numCtrl - 4;
-        const readExtra = [];
-        for (let i = 0; i < extraCtrl; i++) readExtra.push(readCoord());
-        const c2 = readColorRgb();
-        const c3 = readColorRgb();
-        pts = [prevPts[3], prevPts[4], prevPts[5], prevPts[6], ...readExtra];
-        cols = [prevColors[1], prevColors[2], c2, c3];
-      }
-      prevPts = pts;
-      prevColors = cols;
-      const p00 = pts[0];
-      const p03 = pts[3];
-      const p33 = pts[6];
-      const p30 = pts[9];
-      const c00 = cols[0], c03 = cols[1], c33 = cols[2], c30 = cols[3];
-      const steps = 4;
-      const grid = [];
-      for (let iu = 0; iu <= steps; iu++) {
-        const u = iu / steps;
-        const row = [];
-        for (let iv = 0; iv <= steps; iv++) {
-          const v = iv / steps;
-          const x = (1 - u) * (1 - v) * p00[0] + (1 - u) * v * p03[0] + u * v * p33[0] + u * (1 - v) * p30[0];
-          const y = (1 - u) * (1 - v) * p00[1] + (1 - u) * v * p03[1] + u * v * p33[1] + u * (1 - v) * p30[1];
-          const r = (1 - u) * (1 - v) * c00[0] + (1 - u) * v * c03[0] + u * v * c33[0] + u * (1 - v) * c30[0];
-          const g = (1 - u) * (1 - v) * c00[1] + (1 - u) * v * c03[1] + u * v * c33[1] + u * (1 - v) * c30[1];
-          const b = (1 - u) * (1 - v) * c00[2] + (1 - u) * v * c03[2] + u * v * c33[2] + u * (1 - v) * c30[2];
-          row.push({ x, y, rgb: [r, g, b] });
-        }
-        grid.push(row);
-      }
-      for (let iu = 0; iu < steps; iu++) {
-        for (let iv = 0; iv < steps; iv++) {
-          const g00 = grid[iu][iv];
-          const g01 = grid[iu][iv + 1];
-          const g11 = grid[iu + 1][iv + 1];
-          const g10 = grid[iu + 1][iv];
-          triangles.push([g00, g01, g11], [g00, g11, g10]);
-        }
-      }
-    }
-  }
-  if (triangles.length === 0) return void 0;
+  const numComps = fnNode ? 1 : getColorSpaceComponentCount(doc, csNode);
+  const mesh = new MeshShading(shType, new Stream(bytes), {
+    bitsPerCoordinate: bpcCoord,
+    bitsPerComponent: bpcComp,
+    bitsPerFlag: bpcFlag,
+    decode: decodeNums,
+    numComps,
+    colorFn: null,
+    colorSpace: {
+      numComps,
+      getRgb(components) {
+        const params = Array.from(components);
+        const values = fnNode ? evalShadingFunctionToComponents(doc, fnNode, params) : params;
+        return new Uint8Array(convertColorSpaceComponentsToRgb(doc, csNode, csName, values).map((value) => Math.round(Math.max(0, Math.min(1, value)) * 255)));
+      }
+    }
+  }, vPerRow);
+  const [, , positions, colors, vertexCount] = mesh.getIR();
+  if (vertexCount === 0) return void 0;
   const [bx0, by0, bx1, by1] = targetBox;
   const boxW = Math.max(1, bx1 - bx0);
   const boxH = Math.max(1, by1 - by0);
@@ -11334,10 +11151,10 @@ function renderMeshShadingToImage(doc, shDict, shStream, shType, effectiveCtm, t
     const [px, py] = transformPoint(effectiveCtm, vx, vy);
     return [(px - bx0) / boxW * imgW, (by1 - py) / boxH * imgH];
   };
-  for (const [v0, v1, v2] of triangles) {
-    const [x0, y0] = toImgCoords(v0.x, v0.y);
-    const [x1, y1] = toImgCoords(v1.x, v1.y);
-    const [x2, y2] = toImgCoords(v2.x, v2.y);
+  for (let vertex = 0; vertex < vertexCount; vertex += 3) {
+    const [x0, y0] = toImgCoords(positions[vertex * 2], positions[vertex * 2 + 1]);
+    const [x1, y1] = toImgCoords(positions[vertex * 2 + 2], positions[vertex * 2 + 3]);
+    const [x2, y2] = toImgCoords(positions[vertex * 2 + 4], positions[vertex * 2 + 5]);
     const denom = (y1 - y2) * (x0 - x2) + (x2 - x1) * (y0 - y2);
     if (Math.abs(denom) < 1e-6) continue;
     const minX = Math.max(0, Math.floor(Math.min(x0, x1, x2)));
@@ -11352,13 +11169,12 @@ function renderMeshShadingToImage(doc, shDict, shStream, shType, effectiveCtm, t
         const w1 = ((y2 - y0) * (px - x2) + (x0 - x2) * (py - y2)) / denom;
         const w2 = 1 - w0 - w1;
         if (w0 >= -1e-4 && w1 >= -1e-4 && w2 >= -1e-4) {
-          const r = w0 * v0.rgb[0] + w1 * v1.rgb[0] + w2 * v2.rgb[0];
-          const g = w0 * v0.rgb[1] + w1 * v1.rgb[1] + w2 * v2.rgb[1];
-          const b = w0 * v0.rgb[2] + w1 * v1.rgb[2] + w2 * v2.rgb[2];
           const pIdx = (iy * imgW + ix) * 4;
-          rgba[pIdx] = Math.round(Math.max(0, Math.min(1, r)) * 255);
-          rgba[pIdx + 1] = Math.round(Math.max(0, Math.min(1, g)) * 255);
-          rgba[pIdx + 2] = Math.round(Math.max(0, Math.min(1, b)) * 255);
+          for (let channel = 0; channel < 3; channel++) {
+            rgba[pIdx + channel] = Math.round(
+              w0 * colors[vertex * 4 + channel] + w1 * colors[vertex * 4 + 4 + channel] + w2 * colors[vertex * 4 + 8 + channel]
+            );
+          }
           rgba[pIdx + 3] = a8;
         }
       }
@@ -11445,6 +11261,8 @@ function renderShadingDictToImage(doc, shDict, shadingCtm, targetBox, fillAlpha,
   const [a, b, c, d, e, f] = effectiveCtm;
   const det = a * d - b * c;
   if (Math.abs(det) <= 1e-8) return void 0;
+  const [sa, sb, sc, sd, se, sf] = shadingCtm;
+  const shadingDet = sa * sd - sb * sc;
   const t0Dom = shDomain[0] ?? 0;
   const t1Dom = shDomain[1] ?? 1;
   for (let iy = 0; iy < imgH; iy++) {
@@ -11455,8 +11273,10 @@ function renderShadingDictToImage(doc, shDict, shadingCtm, targetBox, fillAlpha,
       const dxPdf = xPdf - e;
       const xs = (d * dxPdf - c * dyPdf) / det;
       const ys = (-b * dxPdf + a * dyPdf) / det;
-      if (shBBox && (xs < shBBox[0] || xs > shBBox[2] || ys < shBBox[1] || ys > shBBox[3])) {
-        continue;
+      if (shBBox) {
+        const bboxX = (sd * (xPdf - se) - sc * (yPdf - sf)) / shadingDet;
+        const bboxY = (-sb * (xPdf - se) + sa * (yPdf - sf)) / shadingDet;
+        if (bboxX < shBBox[0] || bboxX > shBBox[2] || bboxY < shBBox[1] || bboxY > shBBox[3]) continue;
       }
       let comps;
       if (shType === 1) {
@@ -11756,7 +11576,8 @@ function evaluateContentStreamToDisplayList(params) {
       const shDict = shNode?.kind === "dict" ? shNode : shNode?.kind === "stream" ? shNode.dict : void 0;
       const shStream = shNode?.kind === "stream" ? shNode : void 0;
       if (shDict) {
-        const targetBox = st.clipRect ?? [0, 0, params.width, params.height];
+        const [originX, originY] = params.origin ?? [0, 0];
+        const targetBox = st.clipRect ?? [originX, originY, originX + params.width, originY + params.height];
         const img = renderShadingDictToImage(
           params.cosDoc,
           shDict,
@@ -11795,12 +11616,10 @@ function evaluateContentStreamToDisplayList(params) {
     } else if (operator === "RG" || operator === "SC" || operator === "SCN") {
       st.strokeColor = resolveScColorOperands(operator === "RG" ? "DeviceRGB" : st.strokeColorSpaceName, ops, activeResources);
     } else if (operator === "k") {
-      const c = num(0), m = num(1), y = num(2), k = num(3);
-      st.fillColor = { r: (1 - c) * (1 - k), g: (1 - m) * (1 - k), b: (1 - y) * (1 - k) };
+      st.fillColor = resolveScColorOperands("DeviceCMYK", ops, activeResources);
       st.fillPatternName = void 0;
     } else if (operator === "K") {
-      const c = num(0), m = num(1), y = num(2), k = num(3);
-      st.strokeColor = { r: (1 - c) * (1 - k), g: (1 - m) * (1 - k), b: (1 - y) * (1 - k) };
+      st.strokeColor = resolveScColorOperands("DeviceCMYK", ops, activeResources);
     } else if (operator === "gs" && params.cosDoc && activeResources && ops[0]?.kind === "name") {
       const extDict = params.cosDoc.resolveDict(dictGet(activeResources, "ExtGState"));
       const gsDict = extDict ? params.cosDoc.resolveDict(dictGet(extDict, ops[0].decoded)) : void 0;
@@ -12009,7 +11828,7 @@ function evaluateContentStreamToDisplayList(params) {
       stateStack.pop();
       capturedOperations = parentOperations;
     }
-    if (compositeGroup) emit({ kind: "group", value: { operations: children, alpha: st.fillAlpha, blendMode: st.blendMode, clipRect: st.clipRect } });
+    if (compositeGroup) emit({ kind: "group", value: { operations: children, alpha: st.fillAlpha, isolated, bboxClip: nextClipPaths?.[0], blendMode: st.blendMode, clipRect: st.clipRect } });
   };
   const walkNodes = (nodes, mcid, actualText, activeResources = params.resourcesDict, activeFonts = fonts, depth = 0) => {
     for (const node of nodes) {
@@ -12593,6 +12412,7 @@ function evaluateContentStreamToDisplayList(params) {
     pageIndex: params.pageIndex,
     width: params.width,
     height: params.height,
+    ...params.origin ? { origin: params.origin } : {},
     rotation: params.rotation ?? 0,
     glyphs,
     paths,
@@ -14718,7 +14538,7 @@ function prepareStroke(path, scale) {
   }
   return { matrix, width, dashArray, dashPhase };
 }
-function strokeContours(path, pageHeight, scale) {
+function strokeContours(path, pageHeight, scale, originX = 0, originY = 0) {
   const stroke = prepareStroke(path, scale);
   if (!stroke) return [];
   const inverse = inverseStrokeMatrix(stroke.matrix);
@@ -14730,8 +14550,8 @@ function strokeContours(path, pageHeight, scale) {
     (inverse[1] * x + inverse[3] * y + inverse[5]) * strokeScale
   ];
   const toScreen = ([x, y]) => [
-    (a * x / strokeScale + c * y / strokeScale + e) * scale,
-    (pageHeight - b * x / strokeScale - d * y / strokeScale - f) * scale
+    (a * x / strokeScale + c * y / strokeScale + e - originX) * scale,
+    (pageHeight + originY - b * x / strokeScale - d * y / strokeScale - f) * scale
   ];
   const contours = strokeOutlines(
     segmentsToScreenPaths(path.segments, pageHeight, scale, project),
@@ -14889,18 +14709,34 @@ function renderSoftMask(mask, displayList, scale) {
   }
   return bitmap;
 }
-function hasBlendModes(operations) {
-  return operations.some((operation) => !!operation.value.blendMode && operation.value.blendMode !== "Normal" && operation.value.blendMode !== "Compatible" || operation.kind === "group" && hasBlendModes(operation.value.operations));
+function getDisplayListCropBox(list) {
+  const full = [0, 0, list.width, list.height];
+  const box = list.cropBox;
+  if (!box || !box.every(Number.isFinite)) return full;
+  const x0 = Math.max(0, Math.min(box[0], box[2]));
+  const y0 = Math.max(0, Math.min(box[1], box[3]));
+  const x1 = Math.min(list.width, Math.max(box[0], box[2]));
+  const y1 = Math.min(list.height, Math.max(box[1], box[3]));
+  return x1 > x0 && y1 > y0 ? [x0, y0, x1, y1] : full;
+}
+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);
 }
 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;
+  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 deferBackground = !options.transparent && hasBlendModes(paintOperations(displayList));
+  const deferBackground = !options.transparent && hasCompositingEffects(paintOperations(displayList));
   const transparent = options.transparent || deferBackground;
   const bg = options.background ?? { r: 1, g: 1, b: 1 };
   const bgR = transparent ? 0 : Math.round(bg.r * 255);
@@ -14925,14 +14761,27 @@ function renderDisplayListToBitmap(displayList, options = {}) {
     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, dpiX: void 0, dpiY: void 0, cropRect: void 0, transparent: true });
+      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 });
       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 / scale, 0, 0, bitmap.height / scale, 0, displayList.height - bitmap.height / scale],
+        matrix: [bitmap.width / scale, 0, 0, bitmap.height / scale, originX, pageTop - bitmap.height / scale],
         colorSpace: "DeviceRGB",
         bitsPerComponent: 8,
         blendMode: group.blendMode,
@@ -14946,7 +14795,7 @@ function renderDisplayListToBitmap(displayList, options = {}) {
       for (const clip of clips) {
         const { segments, fillRule } = "segments" in clip ? clip : { segments: clip, fillRule: "nonzero" };
         const layer = new Uint8Array(width * height * 4);
-        fillEdgesScanline4x4(layer, width, height, pathsToEdges(segmentsToScreenPaths(segments, displayList.height, scale), true), { r: 1, g: 1, b: 1 }, 1, fillRule);
+        fillEdgesScanline4x4(layer, width, height, pathsToEdges(segmentsToScreenPaths(segments, displayList.height, scale, toScreen), 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;
@@ -14993,15 +14842,15 @@ function renderDisplayListToBitmap(displayList, options = {}) {
     if (operation.kind === "path") {
       const path = operation.value;
       if (path.fillColor) {
-        const edges = pathsToEdges(segmentsToScreenPaths(path.segments, displayList.height, scale), true);
-        const clipScreen = path.clipRect ? [path.clipRect[0] * scale, (displayList.height - path.clipRect[3]) * scale, path.clipRect[2] * scale, (displayList.height - path.clipRect[1]) * scale] : void 0;
+        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);
       }
       if (path.strokeColor) {
         const rawSw = path.strokeWidth * scale * (path.strokeMatrix ? Math.hypot(path.strokeMatrix[0], path.strokeMatrix[1]) : 1);
         const strokeAlpha = options.thinLineMode === "shape" && rawSw < 1 ? (path.strokeAlpha ?? 1) * Math.max(0.25, rawSw) : path.strokeAlpha ?? 1;
-        const edges = pathsToEdges(strokeContours(path, displayList.height, scale).map((points) => ({ points, closed: true })));
-        const clipScreen = path.clipRect ? [path.clipRect[0] * scale, (displayList.height - path.clipRect[3]) * scale, path.clipRect[2] * scale, (displayList.height - path.clipRect[1]) * scale] : void 0;
+        const edges = pathsToEdges(strokeContours(path, displayList.height, scale, originX, originY).map((points) => ({ points, closed: 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,
@@ -15024,12 +14873,12 @@ function renderDisplayListToBitmap(displayList, options = {}) {
       if (Math.abs(det) <= 1e-8) continue;
       const cornersPdfX = [e, a + e, a + c + e, c + e];
       const cornersPdfY = [f, b + f, b + d + f, d + f];
-      const cornersPx = cornersPdfX.map((cx) => cx * scale);
-      const cornersPy = cornersPdfY.map((cy) => (displayList.height - cy) * scale);
-      const clipMinPx = img.clipRect ? Math.floor(img.clipRect[0] * scale) : 0;
-      const clipMaxPx = img.clipRect ? Math.ceil(img.clipRect[2] * scale) - 1 : width - 1;
-      const clipMinPy = img.clipRect ? Math.floor((displayList.height - img.clipRect[3]) * scale) : 0;
-      const clipMaxPy = img.clipRect ? Math.ceil((displayList.height - img.clipRect[1]) * scale) - 1 : height - 1;
+      const cornersPx = cornersPdfX.map((cx) => (cx - originX) * scale);
+      const cornersPy = cornersPdfY.map((cy) => (pageTop - cy) * scale);
+      const clipMinPx = img.clipRect ? Math.floor((img.clipRect[0] - originX) * scale) : 0;
+      const clipMaxPx = img.clipRect ? Math.ceil((img.clipRect[2] - originX) * scale) - 1 : width - 1;
+      const clipMinPy = img.clipRect ? Math.floor((pageTop - img.clipRect[3]) * scale) : 0;
+      const clipMaxPy = img.clipRect ? Math.ceil((pageTop - img.clipRect[1]) * scale) - 1 : height - 1;
       const minPx = Math.max(0, clipMinPx, Math.floor(Math.min(...cornersPx)));
       const maxPx = Math.min(width - 1, clipMaxPx, Math.ceil(Math.max(...cornersPx)) - 1);
       const minPy = Math.max(0, clipMinPy, Math.floor(Math.min(...cornersPy)));
@@ -15046,11 +14895,11 @@ function renderDisplayListToBitmap(displayList, options = {}) {
       const smooth = Math.fround((s1 + s2 + Math.hypot(s1 - s2, 2 * cross)) / 2) <= 1;
       const sample = new Float64Array(4);
       for (let py = minPy; py <= maxPy; py++) {
-        const yPdf = displayList.height - (py + 0.5) / scale;
+        const yPdf = pageTop - (py + 0.5) / scale;
         if (img.clipRect && (yPdf < img.clipRect[1] || yPdf > img.clipRect[3])) continue;
         const dyPdf = yPdf - f;
         for (let px = minPx; px <= maxPx; px++) {
-          const xPdf = (px + 0.5) / scale;
+          const xPdf = originX + (px + 0.5) / scale;
           if (img.clipRect && (xPdf < img.clipRect[0] || xPdf > img.clipRect[2])) continue;
           const dxPdf = xPdf - e;
           const u = (d * dxPdf - c * dyPdf) / det;
@@ -15111,6 +14960,15 @@ function renderDisplayListToBitmap(displayList, options = {}) {
     }
     result = { width: targetW, height: targetH, data: resampled };
   }
+  if (options.useCropBox) {
+    const box = getDisplayListCropBox(displayList);
+    result = cropRgbaBitmap(result, {
+      x: box[0] * scaleX,
+      y: (displayList.height - box[3]) * scaleY,
+      width: (box[2] - box[0]) * scaleX,
+      height: (box[3] - box[1]) * scaleY
+    });
+  }
   result = rotateRgbaBitmapQuarterTurns(result, displayList.rotation ?? 0);
   if (options.cropRect) {
     result = cropRgbaBitmap(result, options.cropRect);
@@ -15470,6 +15328,7 @@ var FONT_IDENTITY_MATRIX;
 var LINE_FACTOR;
 var LINE_DESCENT_FACTOR;
 var BASELINE_FACTOR;
+var MeshFigureType;
 var VerbosityLevel;
 var DrawOPS;
 var PasswordResponses;
@@ -15571,6 +15430,41 @@ var fixedDistCodeTab;
 var FlateStream;
 var getMetrics;
 var getFontBasicMetrics;
+var ColorSpace;
+var DeviceCmykCS;
+var CalGrayCS;
+var CalRGBCS;
+var LabCS;
+var TOKEN;
+var Token;
+var Lexer;
+var PS_VALUE_TYPE;
+var PS_NODE;
+var PsNode;
+var PsProgram;
+var PsBlock;
+var PsNumber;
+var PsOperator;
+var PsIf;
+var PsIfElse;
+var PsArgNode;
+var PsConstNode;
+var PsUnaryNode;
+var PsBinaryNode;
+var PsTernaryNode;
+var Parser;
+var MAX_STACK_SIZE;
+var PSStackToTree;
+var OP;
+var _DEG_TO_RAD;
+var _RAD_TO_DEG;
+var PsJsCompiler;
+var PSStackBasedInterpreter;
+var ShadingType;
+var BaseShading;
+var MeshStreamReader;
+var bCache;
+var MeshShading;
 var PdfError;
 var DEFAULT_MAX_DECODED_BYTES;
 var BoundedFlateStream;
@@ -15689,6 +15583,9 @@ var __webpack_exports__JpxImage;
 var __webpack_exports__VerbosityLevel;
 var __webpack_exports__getVerbosityLevel;
 var __webpack_exports__setVerbosityLevel;
+var cmykColorSpace;
+var cmykColorSpace2;
+var postScriptFunctions;
 var ACROFORM_FONT_ALIAS_MAP;
 var PdfPage;
 var MAX_STROKE_VERTICES;
@@ -19057,6 +18954,11 @@ var init_dist = __esm({
     LINE_FACTOR = 1.35;
     LINE_DESCENT_FACTOR = 0.35;
     BASELINE_FACTOR = LINE_DESCENT_FACTOR / LINE_FACTOR;
+    MeshFigureType = {
+      TRIANGLES: 1,
+      LATTICE: 2,
+      PATCH: 3
+    };
     VerbosityLevel = {
       ERRORS: 0,
       WARNINGS: 1,
@@ -36794,6 +36696,3019 @@ var init_dist = __esm({
         xHeight: Math.NaN
       };
     });
+    ColorSpace = class _ColorSpace {
+      static #rgbBuf = new Uint8ClampedArray(3);
+      constructor(name, numComps) {
+        if ((typeof PDFJSDev === "undefined" || PDFJSDev.test("TESTING")) && this.constructor === _ColorSpace) {
+          unreachable2("Cannot initialize ColorSpace.");
+        }
+        this.name = name;
+        this.numComps = numComps;
+      }
+      /**
+       * Converts the color value to the RGB color. The color components are
+       * located in the src array starting from the srcOffset. Returns the array
+       * of the rgb components, each value ranging from [0,255].
+       */
+      getRgb(src, srcOffset, output = new Uint8ClampedArray(3)) {
+        this.getRgbItem(src, srcOffset, output, 0);
+        return output;
+      }
+      getRgbHex(src, srcOffset) {
+        const buffer = this.getRgb(src, srcOffset, _ColorSpace.#rgbBuf);
+        return Util.makeHexColor(buffer[0], buffer[1], buffer[2]);
+      }
+      /**
+       * Converts the color value to the RGB color, similar to the getRgb method.
+       * The result placed into the dest array starting from the destOffset.
+       */
+      getRgbItem(src, srcOffset, dest, destOffset) {
+        unreachable2("Should not call ColorSpace.getRgbItem");
+      }
+      /**
+       * Converts the specified number of the color values to the RGB colors.
+       * The colors are located in the src array starting from the srcOffset.
+       * The result is placed into the dest array starting from the destOffset.
+       * The src array items shall be in [0,2^bits) range, the dest array items
+       * will be in [0,255] range. alpha01 indicates how many alpha components
+       * there are in the dest array; it will be either 0 (RGB array) or 1 (RGBA
+       * array).
+       */
+      getRgbBuffer(src, srcOffset, count, dest, destOffset, bits, alpha01) {
+        unreachable2("Should not call ColorSpace.getRgbBuffer");
+      }
+      /**
+       * Converts `count` unscaled colors to RGB, starting at `destOffset`.
+       * Components use the native color-space ranges expected by `getRgbItem`,
+       * and each output has a `3 + alpha01` byte stride.
+       * Subclasses may override this to batch expensive conversions.
+       */
+      getRgbItems(src, count, dest, destOffset, alpha01) {
+        const { numComps } = this;
+        for (let i = 0, srcOffset = 0; i < count; i++, srcOffset += numComps) {
+          this.getRgbItem(src, srcOffset, dest, destOffset);
+          destOffset += 3 + alpha01;
+        }
+      }
+      /**
+       * Returns true if source data will be equal the result/output data.
+       */
+      isPassthrough(bits) {
+        return false;
+      }
+      /**
+       * Refer to the static `ColorSpace.isDefaultDecode` method below.
+       */
+      isDefaultDecode(decode, bpc) {
+        return _ColorSpace.isDefaultDecode(decode, this.numComps);
+      }
+      /**
+       * Fills in the RGB colors in the destination buffer.  alpha01 indicates
+       * how many alpha components there are in the dest array; it will be either
+       * 0 (RGB array) or 1 (RGBA array).
+       */
+      fillRgb(dest, originalWidth, originalHeight, width, height, actualHeight, bpc, comps, alpha01) {
+        if (typeof PDFJSDev === "undefined" || PDFJSDev.test("TESTING")) {
+          assert2(
+            dest instanceof Uint8ClampedArray,
+            'ColorSpace.fillRgb: Unsupported "dest" type.'
+          );
+        }
+        const count = originalWidth * originalHeight;
+        let rgbBuf = null;
+        const numComponentColors = 1 << bpc;
+        const needsResizing = originalHeight !== height || originalWidth !== width;
+        if (this.isPassthrough(bpc)) {
+          rgbBuf = comps;
+        } else if (this.numComps === 1 && count > numComponentColors && this.name !== "DeviceGray" && this.name !== "DeviceRGB") {
+          const allColors = bpc <= 8 ? new Uint8Array(numComponentColors) : new Uint16Array(numComponentColors);
+          for (let i = 0; i < numComponentColors; i++) {
+            allColors[i] = i;
+          }
+          const colorMap = new Uint8ClampedArray(numComponentColors * 3);
+          this.getRgbBuffer(
+            allColors,
+            0,
+            numComponentColors,
+            colorMap,
+            0,
+            bpc,
+            /* alpha01 = */
+            0
+          );
+          if (!needsResizing) {
+            let destPos = 0;
+            for (let i = 0; i < count; ++i) {
+              const key = comps[i] * 3;
+              dest[destPos++] = colorMap[key];
+              dest[destPos++] = colorMap[key + 1];
+              dest[destPos++] = colorMap[key + 2];
+              destPos += alpha01;
+            }
+          } else {
+            rgbBuf = new Uint8Array(count * 3);
+            let rgbPos = 0;
+            for (let i = 0; i < count; ++i) {
+              const key = comps[i] * 3;
+              rgbBuf[rgbPos++] = colorMap[key];
+              rgbBuf[rgbPos++] = colorMap[key + 1];
+              rgbBuf[rgbPos++] = colorMap[key + 2];
+            }
+          }
+        } else if (!needsResizing) {
+          this.getRgbBuffer(comps, 0, width * actualHeight, dest, 0, bpc, alpha01);
+        } else {
+          rgbBuf = new Uint8ClampedArray(count * 3);
+          this.getRgbBuffer(
+            comps,
+            0,
+            count,
+            rgbBuf,
+            0,
+            bpc,
+            /* alpha01 = */
+            0
+          );
+        }
+        if (rgbBuf) {
+          if (needsResizing) {
+            resizeRgbImage(
+              rgbBuf,
+              dest,
+              originalWidth,
+              originalHeight,
+              width,
+              height,
+              alpha01
+            );
+          } else {
+            let destPos = 0, rgbPos = 0;
+            for (let i = 0, ii = width * actualHeight; i < ii; i++) {
+              dest[destPos++] = rgbBuf[rgbPos++];
+              dest[destPos++] = rgbBuf[rgbPos++];
+              dest[destPos++] = rgbBuf[rgbPos++];
+              destPos += alpha01;
+            }
+          }
+        }
+      }
+      /**
+       * True if the colorspace has components in the default range of [0, 1].
+       * This should be true for all colorspaces except for lab color spaces
+       * which are [0,100], [-128, 127], [-128, 127].
+       */
+      get usesZeroToOneRange() {
+        return shadow2(this, "usesZeroToOneRange", true);
+      }
+      /**
+       * Checks if a decode map matches the default decode map for a color space.
+       * This handles the general decode maps where there are two values per
+       * component, e.g. [0, 1, 0, 1, 0, 1] for a RGB color.
+       * This does not handle Lab, Indexed, or Pattern decode maps since they are
+       * slightly different.
+       * @param {Array} decode - Decode map (usually from an image).
+       * @param {number} numComps - Number of components the color space has.
+       */
+      static isDefaultDecode(decode, numComps) {
+        if (isDefaultDecodeHelper(decode, numComps * 2)) {
+          return true;
+        }
+        for (let i = 0, ii = decode.length; i < ii; i += 2) {
+          if (decode[i] !== 0 || decode[i + 1] !== 1) {
+            return false;
+          }
+        }
+        return true;
+      }
+    };
+    DeviceCmykCS = class extends ColorSpace {
+      constructor() {
+        super("DeviceCMYK", 4);
+      }
+      // The coefficients below was found using numerical analysis: the method of
+      // steepest descent for the sum((f_i - color_value_i)^2) for r/g/b colors,
+      // where color_value is the tabular value from the table of sampled RGB colors
+      // from CMYK US Web Coated (SWOP) colorspace, and f_i is the corresponding
+      // CMYK color conversion using the estimation below:
+      //   f(A, B,.. N) = Acc+Bcm+Ccy+Dck+c+Fmm+Gmy+Hmk+Im+Jyy+Kyk+Ly+Mkk+Nk+255
+      #toRgb(src, srcOffset, srcScale, dest, destOffset) {
+        const c = src[srcOffset] * srcScale;
+        const m = src[srcOffset + 1] * srcScale;
+        const y = src[srcOffset + 2] * srcScale;
+        const k = src[srcOffset + 3] * srcScale;
+        dest[destOffset] = 255 + c * (-4.387332384609988 * c + 54.48615194189176 * m + 18.82290502165302 * y + 212.25662451639585 * k + -285.2331026137004) + m * (1.7149763477362134 * m - 5.6096736904047315 * y + -17.873870861415444 * k - 5.497006427196366) + y * (-2.5217340131683033 * y - 21.248923337353073 * k + 17.5119270841813) + k * (-21.86122147463605 * k - 189.48180835922747);
+        dest[destOffset + 1] = 255 + c * (8.841041422036149 * c + 60.118027045597366 * m + 6.871425592049007 * y + 31.159100130055922 * k + -79.2970844816548) + m * (-15.310361306967817 * m + 17.575251261109482 * y + 131.35250912493976 * k - 190.9453302588951) + y * (4.444339102852739 * y + 9.8632861493405 * k - 24.86741582555878) + k * (-20.737325471181034 * k - 187.80453709719578);
+        dest[destOffset + 2] = 255 + c * (0.8842522430003296 * c + 8.078677503112928 * m + 30.89978309703729 * y - 0.23883238689178934 * k + -14.183576799673286) + m * (10.49593273432072 * m + 63.02378494754052 * y + 50.606957656360734 * k - 112.23884253719248) + y * (0.03296041114873217 * y + 115.60384449646641 * k + -193.58209356861505) + k * (-22.33816807309886 * k - 180.12613974708367);
+      }
+      getRgbItem(src, srcOffset, dest, destOffset) {
+        if (typeof PDFJSDev === "undefined" || PDFJSDev.test("TESTING")) {
+          assert2(
+            dest instanceof Uint8ClampedArray,
+            'DeviceCmykCS.getRgbItem: Unsupported "dest" type.'
+          );
+        }
+        this.#toRgb(src, srcOffset, 1, dest, destOffset);
+      }
+      getRgbBuffer(src, srcOffset, count, dest, destOffset, bits, alpha01) {
+        if (typeof PDFJSDev === "undefined" || PDFJSDev.test("TESTING")) {
+          assert2(
+            dest instanceof Uint8ClampedArray,
+            'DeviceCmykCS.getRgbBuffer: Unsupported "dest" type.'
+          );
+        }
+        const scale = 1 / ((1 << bits) - 1);
+        for (let i = 0; i < count; i++) {
+          this.#toRgb(src, srcOffset, scale, dest, destOffset);
+          srcOffset += 4;
+          destOffset += 3 + alpha01;
+        }
+      }
+    };
+    CalGrayCS = class extends ColorSpace {
+      constructor(whitePoint, blackPoint, gamma) {
+        super("CalGray", 1);
+        if (!whitePoint) {
+          throw new FormatError(
+            "WhitePoint missing - required for color space CalGray"
+          );
+        }
+        [this.XW, this.YW, this.ZW] = whitePoint;
+        [this.XB, this.YB, this.ZB] = blackPoint || [0, 0, 0];
+        this.G = gamma || 1;
+        if (this.XW < 0 || this.ZW < 0 || this.YW !== 1) {
+          throw new FormatError(
+            `Invalid WhitePoint components for ${this.name}, no fallback available`
+          );
+        }
+        if (this.XB < 0 || this.YB < 0 || this.ZB < 0) {
+          info(`Invalid BlackPoint for ${this.name}, falling back to default.`);
+          this.XB = this.YB = this.ZB = 0;
+        }
+        if (this.XB !== 0 || this.YB !== 0 || this.ZB !== 0) {
+          warn2(
+            `${this.name}, BlackPoint: XB: ${this.XB}, YB: ${this.YB}, ZB: ${this.ZB}, only default values are supported.`
+          );
+        }
+        if (this.G < 1) {
+          info(
+            `Invalid Gamma: ${this.G} for ${this.name}, falling back to default.`
+          );
+          this.G = 1;
+        }
+      }
+      #toRgb(src, srcOffset, dest, destOffset, scale) {
+        const A = src[srcOffset] * scale;
+        const AG = A ** this.G;
+        const L = this.YW * AG;
+        const val = Math.max(295.8 * L ** 0.3333333333333333 - 40.8, 0);
+        dest[destOffset] = val;
+        dest[destOffset + 1] = val;
+        dest[destOffset + 2] = val;
+      }
+      getRgbItem(src, srcOffset, dest, destOffset) {
+        if (typeof PDFJSDev === "undefined" || PDFJSDev.test("TESTING")) {
+          assert2(
+            dest instanceof Uint8ClampedArray,
+            'CalGrayCS.getRgbItem: Unsupported "dest" type.'
+          );
+        }
+        this.#toRgb(src, srcOffset, dest, destOffset, 1);
+      }
+      getRgbBuffer(src, srcOffset, count, dest, destOffset, bits, alpha01) {
+        if (typeof PDFJSDev === "undefined" || PDFJSDev.test("TESTING")) {
+          assert2(
+            dest instanceof Uint8ClampedArray,
+            'CalGrayCS.getRgbBuffer: Unsupported "dest" type.'
+          );
+        }
+        const scale = 1 / ((1 << bits) - 1);
+        for (let i = 0; i < count; ++i) {
+          this.#toRgb(src, srcOffset, dest, destOffset, scale);
+          srcOffset += 1;
+          destOffset += 3 + alpha01;
+        }
+      }
+    };
+    CalRGBCS = class _CalRGBCS extends ColorSpace {
+      // See http://www.brucelindbloom.com/index.html?Eqn_ChromAdapt.html for these
+      // matrices.
+      // prettier-ignore
+      static #BRADFORD_SCALE_MATRIX = new Float32Array([
+        0.8951,
+        0.2664,
+        -0.1614,
+        -0.7502,
+        1.7135,
+        0.0367,
+        0.0389,
+        -0.0685,
+        1.0296
+      ]);
+      // prettier-ignore
+      static #BRADFORD_SCALE_INVERSE_MATRIX = new Float32Array([
+        0.9869929,
+        -0.1470543,
+        0.1599627,
+        0.4323053,
+        0.5183603,
+        0.0492912,
+        -85287e-7,
+        0.0400428,
+        0.9684867
+      ]);
+      // See http://www.brucelindbloom.com/index.html?Eqn_RGB_XYZ_Matrix.html.
+      // prettier-ignore
+      static #SRGB_D65_XYZ_TO_RGB_MATRIX = new Float32Array([
+        3.2404542,
+        -1.5371385,
+        -0.4985314,
+        -0.969266,
+        1.8760108,
+        0.041556,
+        0.0556434,
+        -0.2040259,
+        1.0572252
+      ]);
+      static #FLAT_WHITEPOINT_MATRIX = new Float32Array([1, 1, 1]);
+      static #tempNormalizeMatrix = new Float32Array(3);
+      static #tempConvertMatrix1 = new Float32Array(3);
+      static #tempConvertMatrix2 = new Float32Array(3);
+      static #DECODE_L_CONSTANT = ((8 + 16) / 116) ** 3 / 8;
+      constructor(whitePoint, blackPoint, gamma, matrix) {
+        super("CalRGB", 3);
+        if (!whitePoint) {
+          throw new FormatError(
+            "WhitePoint missing - required for color space CalRGB"
+          );
+        }
+        const [XW, YW, ZW] = this.whitePoint = whitePoint;
+        const [XB, YB, ZB] = this.blackPoint = blackPoint || new Float32Array(3);
+        [this.GR, this.GG, this.GB] = gamma || new Float32Array([1, 1, 1]);
+        [
+          this.MXA,
+          this.MYA,
+          this.MZA,
+          this.MXB,
+          this.MYB,
+          this.MZB,
+          this.MXC,
+          this.MYC,
+          this.MZC
+        ] = matrix || new Float32Array([1, 0, 0, 0, 1, 0, 0, 0, 1]);
+        if (XW < 0 || ZW < 0 || YW !== 1) {
+          throw new FormatError(
+            `Invalid WhitePoint components for ${this.name}, no fallback available`
+          );
+        }
+        if (XB < 0 || YB < 0 || ZB < 0) {
+          info(
+            `Invalid BlackPoint for ${this.name} [${XB}, ${YB}, ${ZB}], falling back to default.`
+          );
+          this.blackPoint = new Float32Array(3);
+        }
+        if (this.GR < 0 || this.GG < 0 || this.GB < 0) {
+          info(
+            `Invalid Gamma [${this.GR}, ${this.GG}, ${this.GB}] for ${this.name}, falling back to default.`
+          );
+          this.GR = this.GG = this.GB = 1;
+        }
+      }
+      #matrixProduct(a, b, result) {
+        result[0] = a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+        result[1] = a[3] * b[0] + a[4] * b[1] + a[5] * b[2];
+        result[2] = a[6] * b[0] + a[7] * b[1] + a[8] * b[2];
+      }
+      #toFlat(sourceWhitePoint, LMS, result) {
+        result[0] = LMS[0] * 1 / sourceWhitePoint[0];
+        result[1] = LMS[1] * 1 / sourceWhitePoint[1];
+        result[2] = LMS[2] * 1 / sourceWhitePoint[2];
+      }
+      #toD65(sourceWhitePoint, LMS, result) {
+        const D65X = 0.95047;
+        const D65Y = 1;
+        const D65Z = 1.08883;
+        result[0] = LMS[0] * D65X / sourceWhitePoint[0];
+        result[1] = LMS[1] * D65Y / sourceWhitePoint[1];
+        result[2] = LMS[2] * D65Z / sourceWhitePoint[2];
+      }
+      #sRGBTransferFunction(color) {
+        if (color <= 31308e-7) {
+          return MathClamp(12.92 * color, 0, 1);
+        }
+        return color >= 0.99554525 ? 1 : MathClamp((1 + 0.055) * color ** (1 / 2.4) - 0.055, 0, 1);
+      }
+      #decodeL(L) {
+        if (L < 0) {
+          return -this.#decodeL(-L);
+        }
+        return L > 8 ? ((L + 16) / 116) ** 3 : L * _CalRGBCS.#DECODE_L_CONSTANT;
+      }
+      #compensateBlackPoint(sourceBlackPoint, XYZ_Flat, result) {
+        if (sourceBlackPoint[0] === 0 && sourceBlackPoint[1] === 0 && sourceBlackPoint[2] === 0) {
+          result[0] = XYZ_Flat[0];
+          result[1] = XYZ_Flat[1];
+          result[2] = XYZ_Flat[2];
+          return;
+        }
+        const zeroDecodeL = this.#decodeL(0);
+        const X_DST = zeroDecodeL;
+        const X_SRC = this.#decodeL(sourceBlackPoint[0]);
+        const Y_DST = zeroDecodeL;
+        const Y_SRC = this.#decodeL(sourceBlackPoint[1]);
+        const Z_DST = zeroDecodeL;
+        const Z_SRC = this.#decodeL(sourceBlackPoint[2]);
+        const X_Scale = (1 - X_DST) / (1 - X_SRC);
+        const X_Offset = 1 - X_Scale;
+        const Y_Scale = (1 - Y_DST) / (1 - Y_SRC);
+        const Y_Offset = 1 - Y_Scale;
+        const Z_Scale = (1 - Z_DST) / (1 - Z_SRC);
+        const Z_Offset = 1 - Z_Scale;
+        result[0] = XYZ_Flat[0] * X_Scale + X_Offset;
+        result[1] = XYZ_Flat[1] * Y_Scale + Y_Offset;
+        result[2] = XYZ_Flat[2] * Z_Scale + Z_Offset;
+      }
+      #normalizeWhitePointToFlat(sourceWhitePoint, XYZ_In, result) {
+        if (sourceWhitePoint[0] === 1 && sourceWhitePoint[2] === 1) {
+          result[0] = XYZ_In[0];
+          result[1] = XYZ_In[1];
+          result[2] = XYZ_In[2];
+          return;
+        }
+        const LMS = result;
+        this.#matrixProduct(_CalRGBCS.#BRADFORD_SCALE_MATRIX, XYZ_In, LMS);
+        const LMS_Flat = _CalRGBCS.#tempNormalizeMatrix;
+        this.#toFlat(sourceWhitePoint, LMS, LMS_Flat);
+        this.#matrixProduct(
+          _CalRGBCS.#BRADFORD_SCALE_INVERSE_MATRIX,
+          LMS_Flat,
+          result
+        );
+      }
+      #normalizeWhitePointToD65(sourceWhitePoint, XYZ_In, result) {
+        const LMS = result;
+        this.#matrixProduct(_CalRGBCS.#BRADFORD_SCALE_MATRIX, XYZ_In, LMS);
+        const LMS_D65 = _CalRGBCS.#tempNormalizeMatrix;
+        this.#toD65(sourceWhitePoint, LMS, LMS_D65);
+        this.#matrixProduct(
+          _CalRGBCS.#BRADFORD_SCALE_INVERSE_MATRIX,
+          LMS_D65,
+          result
+        );
+      }
+      #toRgb(src, srcOffset, dest, destOffset, scale) {
+        const A = MathClamp(src[srcOffset] * scale, 0, 1);
+        const B = MathClamp(src[srcOffset + 1] * scale, 0, 1);
+        const C = MathClamp(src[srcOffset + 2] * scale, 0, 1);
+        const AGR = A === 1 ? 1 : A ** this.GR;
+        const BGG = B === 1 ? 1 : B ** this.GG;
+        const CGB = C === 1 ? 1 : C ** this.GB;
+        const X = this.MXA * AGR + this.MXB * BGG + this.MXC * CGB;
+        const Y = this.MYA * AGR + this.MYB * BGG + this.MYC * CGB;
+        const Z = this.MZA * AGR + this.MZB * BGG + this.MZC * CGB;
+        const XYZ = _CalRGBCS.#tempConvertMatrix1;
+        XYZ[0] = X;
+        XYZ[1] = Y;
+        XYZ[2] = Z;
+        const XYZ_Flat = _CalRGBCS.#tempConvertMatrix2;
+        this.#normalizeWhitePointToFlat(this.whitePoint, XYZ, XYZ_Flat);
+        const XYZ_Black = _CalRGBCS.#tempConvertMatrix1;
+        this.#compensateBlackPoint(this.blackPoint, XYZ_Flat, XYZ_Black);
+        const XYZ_D65 = _CalRGBCS.#tempConvertMatrix2;
+        this.#normalizeWhitePointToD65(
+          _CalRGBCS.#FLAT_WHITEPOINT_MATRIX,
+          XYZ_Black,
+          XYZ_D65
+        );
+        const SRGB = _CalRGBCS.#tempConvertMatrix1;
+        this.#matrixProduct(_CalRGBCS.#SRGB_D65_XYZ_TO_RGB_MATRIX, XYZ_D65, SRGB);
+        dest[destOffset] = this.#sRGBTransferFunction(SRGB[0]) * 255;
+        dest[destOffset + 1] = this.#sRGBTransferFunction(SRGB[1]) * 255;
+        dest[destOffset + 2] = this.#sRGBTransferFunction(SRGB[2]) * 255;
+      }
+      getRgbItem(src, srcOffset, dest, destOffset) {
+        if (typeof PDFJSDev === "undefined" || PDFJSDev.test("TESTING")) {
+          assert2(
+            dest instanceof Uint8ClampedArray,
+            'CalRGBCS.getRgbItem: Unsupported "dest" type.'
+          );
+        }
+        this.#toRgb(src, srcOffset, dest, destOffset, 1);
+      }
+      getRgbBuffer(src, srcOffset, count, dest, destOffset, bits, alpha01) {
+        if (typeof PDFJSDev === "undefined" || PDFJSDev.test("TESTING")) {
+          assert2(
+            dest instanceof Uint8ClampedArray,
+            'CalRGBCS.getRgbBuffer: Unsupported "dest" type.'
+          );
+        }
+        const scale = 1 / ((1 << bits) - 1);
+        for (let i = 0; i < count; ++i) {
+          this.#toRgb(src, srcOffset, dest, destOffset, scale);
+          srcOffset += 3;
+          destOffset += 3 + alpha01;
+        }
+      }
+    };
+    LabCS = class extends ColorSpace {
+      constructor(whitePoint, blackPoint, range) {
+        super("Lab", 3);
+        if (!whitePoint) {
+          throw new FormatError(
+            "WhitePoint missing - required for color space Lab"
+          );
+        }
+        [this.XW, this.YW, this.ZW] = whitePoint;
+        [this.amin, this.amax, this.bmin, this.bmax] = range || [
+          -100,
+          100,
+          -100,
+          100
+        ];
+        [this.XB, this.YB, this.ZB] = blackPoint || [0, 0, 0];
+        if (this.XW < 0 || this.ZW < 0 || this.YW !== 1) {
+          throw new FormatError(
+            "Invalid WhitePoint components, no fallback available"
+          );
+        }
+        if (this.XB < 0 || this.YB < 0 || this.ZB < 0) {
+          info("Invalid BlackPoint, falling back to default");
+          this.XB = this.YB = this.ZB = 0;
+        }
+        if (this.amin > this.amax || this.bmin > this.bmax) {
+          info("Invalid Range, falling back to defaults");
+          this.amin = -100;
+          this.amax = 100;
+          this.bmin = -100;
+          this.bmax = 100;
+        }
+      }
+      // Function g(x) from spec
+      #fn_g(x) {
+        return x >= 6 / 29 ? x ** 3 : 108 / 841 * (x - 4 / 29);
+      }
+      #decode(value, high1, low2, high2) {
+        return low2 + value * (high2 - low2) / high1;
+      }
+      // If decoding is needed maxVal should be 2^bits per component - 1.
+      #toRgb(src, srcOffset, maxVal, dest, destOffset) {
+        let Ls = src[srcOffset];
+        let as = src[srcOffset + 1];
+        let bs = src[srcOffset + 2];
+        if (maxVal !== false) {
+          Ls = this.#decode(Ls, maxVal, 0, 100);
+          as = this.#decode(as, maxVal, this.amin, this.amax);
+          bs = this.#decode(bs, maxVal, this.bmin, this.bmax);
+        }
+        if (as > this.amax) {
+          as = this.amax;
+        } else if (as < this.amin) {
+          as = this.amin;
+        }
+        if (bs > this.bmax) {
+          bs = this.bmax;
+        } else if (bs < this.bmin) {
+          bs = this.bmin;
+        }
+        const M = (Ls + 16) / 116;
+        const L = M + as / 500;
+        const N = M - bs / 200;
+        const X = this.XW * this.#fn_g(L);
+        const Y = this.YW * this.#fn_g(M);
+        const Z = this.ZW * this.#fn_g(N);
+        let r, g, b;
+        if (this.ZW < 1) {
+          r = X * 3.1339 + Y * -1.617 + Z * -0.4906;
+          g = X * -0.9785 + Y * 1.916 + Z * 0.0333;
+          b = X * 0.072 + Y * -0.229 + Z * 1.4057;
+        } else {
+          r = X * 3.2406 + Y * -1.5372 + Z * -0.4986;
+          g = X * -0.9689 + Y * 1.8758 + Z * 0.0415;
+          b = X * 0.0557 + Y * -0.204 + Z * 1.057;
+        }
+        dest[destOffset] = Math.sqrt(r) * 255;
+        dest[destOffset + 1] = Math.sqrt(g) * 255;
+        dest[destOffset + 2] = Math.sqrt(b) * 255;
+      }
+      getRgbItem(src, srcOffset, dest, destOffset) {
+        if (typeof PDFJSDev === "undefined" || PDFJSDev.test("TESTING")) {
+          assert2(
+            dest instanceof Uint8ClampedArray,
+            'LabCS.getRgbItem: Unsupported "dest" type.'
+          );
+        }
+        this.#toRgb(src, srcOffset, false, dest, destOffset);
+      }
+      getRgbBuffer(src, srcOffset, count, dest, destOffset, bits, alpha01) {
+        if (typeof PDFJSDev === "undefined" || PDFJSDev.test("TESTING")) {
+          assert2(
+            dest instanceof Uint8ClampedArray,
+            'LabCS.getRgbBuffer: Unsupported "dest" type.'
+          );
+        }
+        const maxVal = (1 << bits) - 1;
+        for (let i = 0; i < count; i++) {
+          this.#toRgb(src, srcOffset, maxVal, dest, destOffset);
+          srcOffset += 3;
+          destOffset += 3 + alpha01;
+        }
+      }
+      isDefaultDecode(decode, bpc) {
+        return true;
+      }
+      get usesZeroToOneRange() {
+        return shadow2(this, "usesZeroToOneRange", false);
+      }
+    };
+    TOKEN = {
+      // Structural tokens — not keyword operators
+      number: 0,
+      lbrace: 1,
+      rbrace: 2,
+      // Boolean literals
+      true: 3,
+      false: 4,
+      // Arithmetic binary operators
+      add: 5,
+      sub: 6,
+      mul: 7,
+      div: 8,
+      idiv: 9,
+      mod: 10,
+      exp: 11,
+      // Comparison binary operators
+      eq: 12,
+      ne: 13,
+      gt: 14,
+      ge: 15,
+      lt: 16,
+      le: 17,
+      // Bitwise / boolean binary operators
+      and: 18,
+      or: 19,
+      xor: 20,
+      bitshift: 21,
+      // Unary arithmetic operators
+      abs: 22,
+      neg: 23,
+      ceiling: 24,
+      floor: 25,
+      round: 26,
+      truncate: 27,
+      // Unary boolean / bitwise operator
+      not: 28,
+      // Mathematical functions — unary
+      sqrt: 29,
+      sin: 30,
+      cos: 31,
+      ln: 32,
+      log: 33,
+      // Mathematical function — binary
+      atan: 34,
+      // Type conversion operators
+      cvi: 35,
+      cvr: 36,
+      // Stack operators
+      dup: 37,
+      exch: 38,
+      pop: 39,
+      copy: 40,
+      index: 41,
+      roll: 42,
+      // Control flow
+      if: 43,
+      ifelse: 44,
+      // End of input
+      eof: 45,
+      // Synthetic: produced by the optimizer, never emitted by the lexer.
+      min: 46,
+      max: 47
+    };
+    Token = class {
+      constructor(id, value = null) {
+        this.id = id;
+        this.value = value;
+      }
+    };
+    Lexer = class _Lexer {
+      // Singletons for every non-number token, built lazily on first construction.
+      // Keyword operator tokens carry their name as `value`; structural tokens
+      // (lbrace, rbrace, eof) carry null.
+      static #singletons = null;
+      static #operatorSingletons = null;
+      static #initSingletons() {
+        const singletons = /* @__PURE__ */ Object.create(null);
+        const operatorSingletons = /* @__PURE__ */ Object.create(null);
+        for (const [name, id] of Object.entries(TOKEN)) {
+          if (name === "number") {
+            continue;
+          }
+          const isOperator = id >= TOKEN.true && id <= TOKEN.ifelse;
+          const token = new Token(id, isOperator ? name : null);
+          singletons[name] = token;
+          if (isOperator) {
+            operatorSingletons[name] = token;
+          }
+        }
+        this.#singletons = singletons;
+        this.#operatorSingletons = operatorSingletons;
+      }
+      constructor(data) {
+        if (!_Lexer.#singletons) {
+          _Lexer.#initSingletons();
+        }
+        this.data = data;
+        this.pos = 0;
+        this.len = data.length;
+        this._numberPattern = /[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?/iy;
+        this._identifierPattern = /[a-z]+/y;
+      }
+      // Skip a % comment, advancing past the next \n or \r (or to EOF).
+      _skipComment() {
+        const lf = this.data.indexOf("\n", this.pos);
+        const cr = this.data.indexOf("\r", this.pos);
+        const eol = Math.min(lf < 0 ? this.len : lf, cr < 0 ? this.len : cr);
+        this.pos = Math.min(eol + 1, this.len);
+      }
+      _getNumber() {
+        this._numberPattern.lastIndex = this.pos;
+        const match = this._numberPattern.exec(this.data);
+        if (!match) {
+          return new Token(TOKEN.number, 0);
+        }
+        const number = parseFloat(match[0]);
+        if (!Number.isFinite(number)) {
+          return new Token(TOKEN.number, 0);
+        }
+        this.pos = this._numberPattern.lastIndex;
+        return new Token(TOKEN.number, number);
+      }
+      _getOperator() {
+        this._identifierPattern.lastIndex = this.pos;
+        const match = this._identifierPattern.exec(this.data);
+        if (!match) {
+          return new Token(TOKEN.number, 0);
+        }
+        this.pos = this._identifierPattern.lastIndex;
+        const op = match[0];
+        const token = _Lexer.#operatorSingletons[op];
+        return token ?? new Token(TOKEN.number, 0);
+      }
+      // Return the next token, or Lexer.#singletons.eof at end of input.
+      next() {
+        while (this.pos < this.len) {
+          const ch3 = this.data.charCodeAt(this.pos++);
+          switch (ch3) {
+            // PostScript white-space characters (PDF32000 §7.2.2)
+            case 0:
+            case 9:
+            case 10:
+            case 12:
+            case 13:
+            case 32:
+              break;
+            case 37:
+              this._skipComment();
+              break;
+            case 123:
+              return _Lexer.#singletons.lbrace;
+            case 125:
+              return _Lexer.#singletons.rbrace;
+            case 43:
+            case 45:
+              this.pos--;
+              return this._getNumber();
+            case 46:
+              this.pos--;
+              return this._getNumber();
+            default:
+              if (ch3 >= 48 && ch3 <= 57) {
+                this.pos--;
+                return this._getNumber();
+              }
+              if (ch3 >= 97 && ch3 <= 122) {
+                this.pos--;
+                return this._getOperator();
+              }
+              return new Token(TOKEN.number, 0);
+          }
+        }
+        return _Lexer.#singletons.eof;
+      }
+    };
+    PS_VALUE_TYPE = {
+      numeric: 0,
+      // known to be a number (f64 in Wasm)
+      boolean: 1,
+      // known to be a boolean (0.0 = false, 1.0 = true in f64)
+      unknown: 2
+      // indeterminate at compile time
+    };
+    PS_NODE = {
+      // Parser AST node types (produced by Parser / parsePostScriptFunction)
+      program: 0,
+      block: 1,
+      number: 2,
+      operator: 3,
+      if: 4,
+      ifelse: 5,
+      // Tree AST node types (produced by PSStackToTree)
+      arg: 6,
+      const: 7,
+      unary: 8,
+      binary: 9,
+      ternary: 10
+    };
+    PsNode = class {
+      constructor(type) {
+        this.type = type;
+      }
+    };
+    PsProgram = class extends PsNode {
+      constructor(body) {
+        super(PS_NODE.program);
+        this.body = body;
+      }
+    };
+    PsBlock = class extends PsNode {
+      constructor(instructions) {
+        super(PS_NODE.block);
+        this.instructions = instructions;
+      }
+    };
+    PsNumber = class extends PsNode {
+      /** @param {number} value */
+      constructor(value) {
+        super(PS_NODE.number);
+        this.value = value;
+      }
+    };
+    PsOperator = class extends PsNode {
+      /** @param {number} op — one of the TOKEN.* constants from lexer.js */
+      constructor(op) {
+        super(PS_NODE.operator);
+        this.op = op;
+      }
+    };
+    PsIf = class extends PsNode {
+      /** @param {PsBlock} then */
+      constructor(then) {
+        super(PS_NODE.if);
+        this.then = then;
+      }
+    };
+    PsIfElse = class extends PsNode {
+      /**
+       * @param {PsBlock} then
+       * @param {PsBlock} otherwise
+       */
+      constructor(then, otherwise) {
+        super(PS_NODE.ifelse);
+        this.then = then;
+        this.otherwise = otherwise;
+      }
+    };
+    PsArgNode = class extends PsNode {
+      /** @param {number} index */
+      constructor(index) {
+        super(PS_NODE.arg);
+        this.index = index;
+        this.valueType = PS_VALUE_TYPE.numeric;
+      }
+    };
+    PsConstNode = class extends PsNode {
+      /** @param {number|boolean} value */
+      constructor(value) {
+        super(PS_NODE.const);
+        this.value = value;
+        this.valueType = typeof value === "boolean" ? PS_VALUE_TYPE.boolean : PS_VALUE_TYPE.numeric;
+      }
+    };
+    PsUnaryNode = class extends PsNode {
+      /**
+       * @param {number} op — TOKEN.* constant
+       * @param {PsNode} operand
+       * @param {number} [valueType]
+       */
+      constructor(op, operand, valueType = PS_VALUE_TYPE.unknown) {
+        super(PS_NODE.unary);
+        this.op = op;
+        this.operand = operand;
+        this.valueType = valueType;
+      }
+    };
+    PsBinaryNode = class extends PsNode {
+      /**
+       * @param {number} op — TOKEN.* constant
+       * @param {PsNode} first — was on top of stack
+       * @param {PsNode} second — was below top
+       * @param {number} [valueType]
+       */
+      constructor(op, first, second, valueType = PS_VALUE_TYPE.unknown) {
+        super(PS_NODE.binary);
+        this.op = op;
+        this.first = first;
+        this.second = second;
+        this.valueType = valueType;
+      }
+    };
+    PsTernaryNode = class extends PsNode {
+      /**
+       * @param {PsNode} cond
+       * @param {PsNode} then
+       * @param {PsNode} otherwise
+       * @param {number} [valueType]
+       */
+      constructor(cond, then, otherwise, valueType = PS_VALUE_TYPE.unknown) {
+        super(PS_NODE.ternary);
+        this.cond = cond;
+        this.then = then;
+        this.otherwise = otherwise;
+        this.valueType = valueType;
+      }
+    };
+    Parser = class _Parser {
+      constructor(lexer) {
+        this.lexer = lexer;
+        this._token = null;
+      }
+      static _isRegularOperator(id) {
+        return id >= TOKEN.true && id < TOKEN.if;
+      }
+      // Fetch the next token from the lexer.
+      _advance() {
+        this._token = this.lexer.next();
+      }
+      // Assert that the current token has the given id, consume it, and return it.
+      _expect(id) {
+        if (this._token.id !== id) {
+          throw new FormatError(
+            `PostScript function: expected token id ${id}, got ${this._token.id}.`
+          );
+        }
+        const tok = this._token;
+        this._advance();
+        return tok;
+      }
+      /**
+       * Parse the full Type 4 function body.
+       *
+       * Grammar (simplified):
+       *   program   ::= '{' block '}'
+       *   block     ::= instruction*
+       *   instruction ::= number
+       *                 | operator          (any PS_OPERATOR except if / ifelse)
+       *                 | '{' block '}' 'if'
+       *                 | '{' block '}' '{' block '}' 'ifelse'
+       * @returns {PsProgram}
+       */
+      parse() {
+        this._advance();
+        this._expect(TOKEN.lbrace);
+        const block = this._parseBlock();
+        this._expect(TOKEN.rbrace);
+        if (this._token.id !== TOKEN.eof) {
+          warn2("PostScript function: unexpected content after closing brace.");
+        }
+        return new PsProgram(block);
+      }
+      _parseBlock() {
+        const instructions = [];
+        while (true) {
+          const tok = this._token;
+          switch (tok.id) {
+            case TOKEN.number:
+              instructions.push(new PsNumber(tok.value));
+              this._advance();
+              break;
+            case TOKEN.lbrace: {
+              this._advance();
+              const thenBlock = this._parseBlock();
+              this._expect(TOKEN.rbrace);
+              if (this._token.id === TOKEN.if) {
+                this._advance();
+                instructions.push(new PsIf(thenBlock));
+              } else if (this._token.id === TOKEN.lbrace) {
+                this._advance();
+                const elseBlock = this._parseBlock();
+                this._expect(TOKEN.rbrace);
+                this._expect(TOKEN.ifelse);
+                instructions.push(new PsIfElse(thenBlock, elseBlock));
+              } else {
+                throw new FormatError(
+                  "PostScript function: a procedure block must be followed by 'if' or '{\u2026} ifelse'."
+                );
+              }
+              break;
+            }
+            case TOKEN.rbrace:
+            case TOKEN.eof:
+              return new PsBlock(instructions);
+            case TOKEN.if:
+            case TOKEN.ifelse:
+              throw new FormatError(
+                `PostScript function: unexpected '${tok.value}' operator.`
+              );
+            default:
+              if (_Parser._isRegularOperator(tok.id)) {
+                instructions.push(new PsOperator(tok.id));
+                this._advance();
+                break;
+              }
+              throw new FormatError(
+                `PostScript function: unexpected token id ${tok.id}.`
+              );
+          }
+        }
+      }
+    };
+    MAX_STACK_SIZE = 100;
+    PSStackToTree = class _PSStackToTree {
+      static #binaryOps = null;
+      static #unaryOps = null;
+      static #idempotentUnary = null;
+      static #negatedComparison = null;
+      static #init() {
+        this.#binaryOps = /* @__PURE__ */ new Set([
+          TOKEN.add,
+          TOKEN.sub,
+          TOKEN.mul,
+          TOKEN.div,
+          TOKEN.idiv,
+          TOKEN.mod,
+          TOKEN.exp,
+          TOKEN.atan,
+          TOKEN.eq,
+          TOKEN.ne,
+          TOKEN.gt,
+          TOKEN.ge,
+          TOKEN.lt,
+          TOKEN.le,
+          TOKEN.and,
+          TOKEN.or,
+          TOKEN.xor,
+          TOKEN.bitshift
+        ]);
+        this.#unaryOps = /* @__PURE__ */ new Set([
+          TOKEN.abs,
+          TOKEN.neg,
+          TOKEN.ceiling,
+          TOKEN.floor,
+          TOKEN.round,
+          TOKEN.truncate,
+          TOKEN.sqrt,
+          TOKEN.sin,
+          TOKEN.cos,
+          TOKEN.ln,
+          TOKEN.log,
+          TOKEN.cvi,
+          TOKEN.cvr,
+          TOKEN.not
+        ]);
+        this.#idempotentUnary = /* @__PURE__ */ new Set([
+          TOKEN.abs,
+          TOKEN.ceiling,
+          TOKEN.cvi,
+          TOKEN.cvr,
+          TOKEN.floor,
+          TOKEN.round,
+          TOKEN.truncate
+        ]);
+        this.#negatedComparison = /* @__PURE__ */ new Map([
+          [TOKEN.eq, TOKEN.ne],
+          [TOKEN.ne, TOKEN.eq],
+          [TOKEN.lt, TOKEN.ge],
+          [TOKEN.le, TOKEN.gt],
+          [TOKEN.gt, TOKEN.le],
+          [TOKEN.ge, TOKEN.lt]
+        ]);
+      }
+      /**
+       * @param {PsProgram} program
+       * @param {number} numInputs — number of domain values placed on the stack
+       *   before the program runs (i.e. the length of the domain array / 2).
+       * @returns {Array<PsNode>} — one tree node per output value.
+       */
+      evaluate(program, numInputs) {
+        if (!_PSStackToTree.#binaryOps) {
+          _PSStackToTree.#init();
+        }
+        this._failed = false;
+        if (numInputs > MAX_STACK_SIZE) {
+          return null;
+        }
+        const stack = [];
+        for (let i = 0; i < numInputs; i++) {
+          stack.push(new PsArgNode(i));
+        }
+        this._evalBlock(program.body, stack);
+        if (this._failed) {
+          return null;
+        }
+        _PSStackToTree.#markShared(stack);
+        return stack;
+      }
+      // Set node.shared / sharedCount on non-atomic nodes referenced more than
+      // once.  arg/const are excluded — they are cheap to re-emit inline.
+      static #markShared(outputs) {
+        const refCount = /* @__PURE__ */ new Map();
+        const visit = (node) => {
+          if (!node || node.type === PS_NODE.arg || node.type === PS_NODE.const) {
+            return;
+          }
+          const prev = refCount.get(node) ?? 0;
+          refCount.set(node, prev + 1);
+          if (prev > 0) {
+            return;
+          }
+          switch (node.type) {
+            case PS_NODE.unary:
+              visit(node.operand);
+              break;
+            case PS_NODE.binary:
+              visit(node.first);
+              visit(node.second);
+              break;
+            case PS_NODE.ternary:
+              visit(node.cond);
+              visit(node.then);
+              visit(node.otherwise);
+              break;
+          }
+        };
+        for (const output of outputs) {
+          visit(output);
+        }
+        for (const [node, count] of refCount) {
+          if (count > 1) {
+            node.shared = true;
+            node.sharedCount = count;
+          }
+        }
+      }
+      _evalBlock(block, stack) {
+        this._evalBlockFrom(block.instructions, 0, stack);
+      }
+      /**
+       * Core evaluation loop.  Processes `instructions[startIdx…]` in order,
+       * mutating `stack` as each instruction executes.
+       *
+       * When a `{ body } if` instruction grows the stack (the PostScript "early
+       * exit / guard" idiom), the remaining instructions in the current array are
+       * evaluated on **both** the true-branch stack and the false-branch stack,
+       * then the two results are merged into PsTernaryNodes.  This handles
+       * patterns like:
+       *
+       *   cond { pop R G B sentinel } if
+       *   … more guards …
+       *   sentinel 0 gt { defaultR defaultG defaultB } if
+       */
+      _evalBlockFrom(instructions, startIdx, stack) {
+        for (let idx = startIdx; idx < instructions.length; idx++) {
+          if (this._failed) {
+            break;
+          }
+          const instr = instructions[idx];
+          switch (instr.type) {
+            case PS_NODE.number:
+              stack.push(new PsConstNode(instr.value));
+              if (stack.length > MAX_STACK_SIZE) {
+                this._failed = true;
+              }
+              break;
+            case PS_NODE.operator:
+              this._evalOp(instr.op, stack);
+              break;
+            case PS_NODE.if: {
+              if (stack.length < 1) {
+                this._failed = true;
+                break;
+              }
+              const cond = stack.pop();
+              const saved = stack.slice();
+              this._evalBlock(instr.then, stack);
+              if (this._failed) {
+                break;
+              }
+              if (stack.length === saved.length) {
+                for (let i = 0; i < stack.length; i++) {
+                  if (stack[i] !== saved[i]) {
+                    stack[i] = this._makeTernary(cond, stack[i], saved[i]);
+                  }
+                }
+              } else if (stack.length > saved.length) {
+                if (cond.type === PS_NODE.const) {
+                  if (!cond.value) {
+                    stack.length = 0;
+                    stack.push(...saved);
+                  }
+                  break;
+                }
+                const trueStack = stack.slice();
+                this._evalBlockFrom(instructions, idx + 1, trueStack);
+                if (this._failed) {
+                  break;
+                }
+                const falseStack = saved;
+                this._evalBlockFrom(instructions, idx + 1, falseStack);
+                if (this._failed) {
+                  break;
+                }
+                if (trueStack.length !== falseStack.length) {
+                  const zero2 = new PsConstNode(0);
+                  while (trueStack.length < falseStack.length) {
+                    trueStack.push(zero2);
+                  }
+                  while (falseStack.length < trueStack.length) {
+                    falseStack.push(zero2);
+                  }
+                }
+                stack.length = 0;
+                for (let i = 0; i < trueStack.length; i++) {
+                  stack.push(this._makeTernary(cond, trueStack[i], falseStack[i]));
+                }
+                return;
+              } else {
+                this._failed = true;
+              }
+              break;
+            }
+            case PS_NODE.ifelse: {
+              if (stack.length < 1) {
+                this._failed = true;
+                break;
+              }
+              const cond = stack.pop();
+              const snapshot = stack.slice();
+              const thenStack = snapshot.slice();
+              this._evalBlock(instr.then, thenStack);
+              if (this._failed) {
+                break;
+              }
+              const elseStack = snapshot.slice();
+              this._evalBlock(instr.otherwise, elseStack);
+              if (this._failed) {
+                break;
+              }
+              if (thenStack.length !== elseStack.length) {
+                const zero2 = new PsConstNode(0);
+                while (thenStack.length < elseStack.length) {
+                  thenStack.push(zero2);
+                }
+                while (elseStack.length < thenStack.length) {
+                  elseStack.push(zero2);
+                }
+              }
+              stack.length = 0;
+              for (let i = 0; i < thenStack.length; i++) {
+                stack.push(this._makeTernary(cond, thenStack[i], elseStack[i]));
+              }
+              break;
+            }
+          }
+        }
+      }
+      _evalOp(op, stack) {
+        if (_PSStackToTree.#binaryOps.has(op)) {
+          if (stack.length < 2) {
+            this._failed = true;
+            return;
+          }
+          const first = stack.pop();
+          const second = stack.pop();
+          stack.push(this._makeBinary(op, first, second));
+          return;
+        }
+        if (_PSStackToTree.#unaryOps.has(op)) {
+          if (stack.length < 1) {
+            this._failed = true;
+            return;
+          }
+          stack.push(this._makeUnary(op, stack.pop()));
+          return;
+        }
+        switch (op) {
+          case TOKEN.true:
+            stack.push(new PsConstNode(true));
+            if (stack.length > MAX_STACK_SIZE) {
+              this._failed = true;
+            }
+            break;
+          case TOKEN.false:
+            stack.push(new PsConstNode(false));
+            if (stack.length > MAX_STACK_SIZE) {
+              this._failed = true;
+            }
+            break;
+          case TOKEN.dup:
+            if (stack.length < 1) {
+              this._failed = true;
+              break;
+            }
+            stack.push(stack.at(-1));
+            if (stack.length > MAX_STACK_SIZE) {
+              this._failed = true;
+            }
+            break;
+          case TOKEN.exch: {
+            if (stack.length < 2) {
+              this._failed = true;
+              break;
+            }
+            const a = stack.pop();
+            const b = stack.pop();
+            stack.push(a, b);
+            break;
+          }
+          case TOKEN.pop:
+            if (stack.length < 1) {
+              this._failed = true;
+              break;
+            }
+            stack.pop();
+            break;
+          case TOKEN.copy: {
+            if (stack.length < 1) {
+              this._failed = true;
+              break;
+            }
+            const nNode = stack.pop();
+            if (nNode.type === PS_NODE.const) {
+              const n = nNode.value | 0;
+              if (n === 0) {
+              } else if (n < 0 || n > stack.length) {
+                this._failed = true;
+              } else {
+                stack.push(...stack.slice(-n));
+                if (stack.length > MAX_STACK_SIZE) {
+                  this._failed = true;
+                }
+              }
+            } else {
+              this._failed = true;
+            }
+            break;
+          }
+          case TOKEN.index: {
+            if (stack.length < 1) {
+              this._failed = true;
+              break;
+            }
+            const nNode = stack.pop();
+            if (nNode.type === PS_NODE.const) {
+              const n = nNode.value | 0;
+              if (n < 0 || n >= stack.length) {
+                this._failed = true;
+              } else {
+                stack.push(stack.at(-n - 1));
+              }
+            } else {
+              this._failed = true;
+            }
+            break;
+          }
+          case TOKEN.roll: {
+            if (stack.length < 2) {
+              this._failed = true;
+              break;
+            }
+            const jNode = stack.pop();
+            const nNode = stack.pop();
+            if (nNode.type === PS_NODE.const && jNode.type === PS_NODE.const) {
+              const n = nNode.value | 0;
+              if (n === 0) {
+              } else if (n < 0 || n > stack.length) {
+                this._failed = true;
+              } else {
+                const j = ((jNode.value | 0) % n + n) % n;
+                if (j > 0) {
+                  const slice = stack.splice(-n, n);
+                  stack.push(...slice.slice(n - j), ...slice.slice(0, n - j));
+                }
+              }
+            } else {
+              this._failed = true;
+            }
+            break;
+          }
+          default:
+            this._failed = true;
+            break;
+        }
+      }
+      /**
+       * Create a binary tree node, applying optimizations eagerly:
+       *
+       * 1. Constant folding — both operands are PsConstNode → fold to PsConstNode.
+       * 2. Reflexive simplifications — x−x→0, x xor x→0, x eq x→true, etc.
+       * 3. Algebraic simplifications with one known operand — identity elements
+       *    (x+0→x, x*1→x, …), absorbing elements (x*0→0, x and false→false, …),
+       *    and strength reductions (x*-1→neg(x), x^0.5→sqrt(x), x^2→x*x, …).
+       *
+       * Recall: `first` was on top of the stack (right operand for non-commutative
+       * ops), `second` was below (left operand). So `a b sub` → second=a, first=b
+       * → a − b.
+       */
+      _makeBinary(op, first, second) {
+        if (first.type === PS_NODE.const && second.type === PS_NODE.const) {
+          const v = _evalBinaryConst(op, second.value, first.value);
+          if (v !== void 0) {
+            return new PsConstNode(v);
+          }
+        }
+        if (_nodesEqual(first, second)) {
+          switch (op) {
+            case TOKEN.sub:
+              return new PsConstNode(0);
+            // x − x → 0
+            case TOKEN.xor:
+              return new PsConstNode(
+                /* eslint-disable unicorn/prefer-logical-operator-over-ternary */
+                first.valueType === PS_VALUE_TYPE.boolean ? false : 0
+                /* eslint-enable unicorn/prefer-logical-operator-over-ternary */
+              );
+            // TOKEN.mod, TOKEN.div, TOKEN.idiv are NOT simplified here:
+            // x op x is undefined when x = 0, so we cannot fold without knowing
+            // that x is non-zero.
+            case TOKEN.and:
+            case TOKEN.or:
+              return first;
+            // x and x → x; x or x → x
+            case TOKEN.min:
+            case TOKEN.max:
+              return first;
+            // min(x,x) → x; max(x,x) → x
+            case TOKEN.eq:
+            case TOKEN.ge:
+            case TOKEN.le:
+              return new PsConstNode(true);
+            case TOKEN.ne:
+            case TOKEN.gt:
+            case TOKEN.lt:
+              return new PsConstNode(false);
+          }
+        }
+        if (first.type === PS_NODE.const) {
+          const b = first.value;
+          switch (op) {
+            case TOKEN.add:
+              if (b === 0) {
+                return second;
+              }
+              break;
+            case TOKEN.sub:
+              if (b === 0) {
+                return second;
+              }
+              break;
+            case TOKEN.mul:
+              if (b === 1) {
+                return second;
+              }
+              if (b === 0) {
+                return first;
+              }
+              if (b === -1) {
+                return this._makeUnary(TOKEN.neg, second);
+              }
+              break;
+            case TOKEN.div:
+              if (b !== 0) {
+                return this._makeBinary(TOKEN.mul, new PsConstNode(1 / b), second);
+              }
+              break;
+            case TOKEN.idiv:
+              if (b === 1) {
+                return second;
+              }
+              break;
+            case TOKEN.exp:
+              if (b === 1) {
+                return second;
+              }
+              if (b === -1) {
+                return this._makeBinary(TOKEN.div, second, new PsConstNode(1));
+              }
+              if (b === 0.5) {
+                return this._makeUnary(TOKEN.sqrt, second);
+              }
+              if (b === 0.25) {
+                const sqrtOnce = this._makeUnary(TOKEN.sqrt, second);
+                return this._makeUnary(TOKEN.sqrt, sqrtOnce);
+              }
+              if (b === 2) {
+                return this._makeBinary(TOKEN.mul, second, second);
+              }
+              if (b === 3) {
+                return this._makeBinary(
+                  TOKEN.mul,
+                  this._makeBinary(TOKEN.mul, second, second),
+                  second
+                );
+              }
+              if (b === 4) {
+                const square = this._makeBinary(TOKEN.mul, second, second);
+                return this._makeBinary(TOKEN.mul, square, square);
+              }
+              if (b === 0) {
+                return new PsConstNode(1);
+              }
+              break;
+            case TOKEN.and:
+              if (b === true) {
+                return second;
+              }
+              if (b === false) {
+                return first;
+              }
+              break;
+            case TOKEN.or:
+              if (b === false) {
+                return second;
+              }
+              if (b === true) {
+                return first;
+              }
+              break;
+            case TOKEN.min:
+              if (second.type === PS_NODE.binary && second.op === TOKEN.max && second.first.type === PS_NODE.const && second.first.value >= b) {
+                return first;
+              }
+              break;
+            case TOKEN.max:
+              if (second.type === PS_NODE.binary && second.op === TOKEN.min && second.first.type === PS_NODE.const && second.first.value <= b) {
+                return first;
+              }
+              break;
+          }
+        }
+        if (second.type === PS_NODE.const) {
+          const a = second.value;
+          switch (op) {
+            case TOKEN.add:
+              if (a === 0) {
+                return first;
+              }
+              break;
+            case TOKEN.sub:
+              if (a === 0) {
+                return this._makeUnary(TOKEN.neg, first);
+              }
+              break;
+            case TOKEN.mul:
+              if (a === 1) {
+                return first;
+              }
+              if (a === 0) {
+                return second;
+              }
+              if (a === -1) {
+                return this._makeUnary(TOKEN.neg, first);
+              }
+              break;
+            case TOKEN.and:
+              if (a === true) {
+                return first;
+              }
+              if (a === false) {
+                return second;
+              }
+              break;
+            case TOKEN.or:
+              if (a === false) {
+                return first;
+              }
+              if (a === true) {
+                return second;
+              }
+              break;
+          }
+        }
+        return new PsBinaryNode(
+          op,
+          first,
+          second,
+          _binaryValueType(op, first.valueType, second.valueType)
+        );
+      }
+      /**
+       * Create a unary tree node, applying optimizations eagerly:
+       *
+       * 1. Constant folding.
+       * 2. not(comparison) → negated comparison: not(a eq b) → a ne b, etc.
+       * 3. neg(a − b) → b − a.
+       * 4. Double-negation: neg(neg(x)) → x, not(not(x)) → x.
+       * 5. abs(neg(x)) → abs(x).
+       * 6. Idempotent: f(f(x)) → f(x) for abs, ceiling, floor, round, etc.
+       */
+      _makeUnary(op, operand) {
+        if (operand.type === PS_NODE.const) {
+          const v = _evalUnaryConst(op, operand.value);
+          if (v !== void 0) {
+            return new PsConstNode(v);
+          }
+        }
+        if (op === TOKEN.not && operand.type === PS_NODE.binary) {
+          const negated = _PSStackToTree.#negatedComparison.get(operand.op);
+          if (negated !== void 0) {
+            return new PsBinaryNode(
+              negated,
+              operand.first,
+              operand.second,
+              PS_VALUE_TYPE.boolean
+            );
+          }
+        }
+        if (op === TOKEN.neg && operand.type === PS_NODE.binary && operand.op === TOKEN.sub) {
+          return this._makeBinary(TOKEN.sub, operand.second, operand.first);
+        }
+        if (operand.type === PS_NODE.unary) {
+          if (op === TOKEN.neg && operand.op === TOKEN.neg || op === TOKEN.not && operand.op === TOKEN.not) {
+            return operand.operand;
+          }
+          if (op === TOKEN.abs && operand.op === TOKEN.neg) {
+            return this._makeUnary(TOKEN.abs, operand.operand);
+          }
+          if (_PSStackToTree.#idempotentUnary.has(op) && op === operand.op) {
+            return operand;
+          }
+        }
+        return new PsUnaryNode(op, operand, _unaryValueType(op, operand.valueType));
+      }
+      /**
+       * Create a ternary node, applying optimizations eagerly:
+       *
+       * 1. Constant condition — fold to the live branch.
+       * 2. Identical branches — the condition is irrelevant, return either branch.
+       * 3. Boolean branch constants — `cond ? true : false` → cond,
+       *    `cond ? false : true` → not(cond).
+       * 4. Ternary → branchless min/max when the condition compares two numeric
+       *    expressions that are also the two branches.
+       */
+      _makeTernary(cond, then, otherwise) {
+        if (cond.type === PS_NODE.const) {
+          return cond.value ? then : otherwise;
+        }
+        if (_nodesEqual(then, otherwise)) {
+          return then;
+        }
+        if (then.type === PS_NODE.const && otherwise.type === PS_NODE.const) {
+          if (then.value === true && otherwise.value === false) {
+            return cond;
+          }
+          if (then.value === false && otherwise.value === true) {
+            return this._makeUnary(TOKEN.not, cond);
+          }
+        }
+        if (cond.type === PS_NODE.binary) {
+          const { op: cop, first: cf, second: cs } = cond;
+          if (cop === TOKEN.gt || cop === TOKEN.ge) {
+            if (_nodesEqual(then, cf) && _nodesEqual(otherwise, cs)) {
+              return this._makeBinary(TOKEN.min, cf, cs);
+            }
+            if (_nodesEqual(then, cs) && _nodesEqual(otherwise, cf)) {
+              return this._makeBinary(TOKEN.max, cf, cs);
+            }
+          } else if (cop === TOKEN.lt || cop === TOKEN.le) {
+            if (_nodesEqual(then, cf) && _nodesEqual(otherwise, cs)) {
+              return this._makeBinary(TOKEN.max, cf, cs);
+            }
+            if (_nodesEqual(then, cs) && _nodesEqual(otherwise, cf)) {
+              return this._makeBinary(TOKEN.min, cf, cs);
+            }
+          }
+        }
+        return new PsTernaryNode(
+          cond,
+          then,
+          otherwise,
+          then.valueType === otherwise.valueType ? then.valueType : PS_VALUE_TYPE.unknown
+        );
+      }
+    };
+    OP = {
+      ARG: 0,
+      // [ARG, idx]
+      CONST: 1,
+      // [CONST, val]
+      STORE: 2,
+      // [STORE, slot, min, max]  clamp(pop()) → mem[slot]
+      IF: 3,
+      // [IF, target]  jump when top-of-stack === 0
+      JUMP: 4,
+      // [JUMP, target]  unconditional
+      ABS: 5,
+      NEG: 6,
+      CEIL: 7,
+      FLOOR: 8,
+      ROUND: 9,
+      // floor(x + 0.5)
+      TRUNC: 10,
+      NOT_B: 11,
+      // boolean NOT
+      NOT_N: 12,
+      // bitwise NOT
+      SQRT: 13,
+      SIN: 14,
+      // degrees in/out
+      COS: 15,
+      LN: 16,
+      LOG10: 17,
+      CVI: 18,
+      SHIFT: 19,
+      // [SHIFT, amount]  +ve = left, −ve = right
+      // Binary ops: second below, first on top; result = second OP first.
+      ADD: 20,
+      SUB: 21,
+      MUL: 22,
+      DIV: 23,
+      // 0 when divisor is 0
+      IDIV: 24,
+      // 0 when divisor is 0
+      MOD: 25,
+      // 0 when divisor is 0
+      POW: 26,
+      EQ: 27,
+      NE: 28,
+      GT: 29,
+      GE: 30,
+      LT: 31,
+      LE: 32,
+      AND: 33,
+      OR: 34,
+      XOR: 35,
+      ATAN: 36,
+      // atan2(second, first) → degrees [0, 360)
+      MIN: 37,
+      MAX: 38,
+      TEE_TMP: 39,
+      // [TEE_TMP, slot]  peek top of stack → tmp[slot], leave on stack
+      LOAD_TMP: 40
+      // [LOAD_TMP, slot]  push tmp[slot]
+    };
+    _DEG_TO_RAD = Math.PI / 180;
+    _RAD_TO_DEG = 180 / Math.PI;
+    PsJsCompiler = class {
+      // Safe because JS is single-threaded.
+      static #stack = new Float64Array(64);
+      static #tmp = new Float64Array(64);
+      constructor(domain, range) {
+        this.nIn = domain.length >> 1;
+        this.nOut = range.length >> 1;
+        this.range = range;
+        this.ir = [];
+        this._tmpMap = /* @__PURE__ */ new Map();
+        this._nextTmp = 0;
+      }
+      _compileNode(node) {
+        if (node.shared) {
+          const cached = this._tmpMap.get(node);
+          if (cached !== void 0) {
+            this.ir.push(OP.LOAD_TMP, cached);
+            return true;
+          }
+          if (!this._compileNodeImpl(node)) {
+            return false;
+          }
+          const slot = this._nextTmp++;
+          this._tmpMap.set(node, slot);
+          this.ir.push(OP.TEE_TMP, slot);
+          return true;
+        }
+        return this._compileNodeImpl(node);
+      }
+      _compileNodeImpl(node) {
+        switch (node.type) {
+          case PS_NODE.arg:
+            this.ir.push(OP.ARG, node.index);
+            return true;
+          case PS_NODE.const: {
+            const v = node.value;
+            this.ir.push(OP.CONST, typeof v === "boolean" ? Number(v) : v);
+            return true;
+          }
+          case PS_NODE.unary:
+            return this._compileUnary(node);
+          case PS_NODE.binary:
+            return this._compileBinary(node);
+          case PS_NODE.ternary:
+            return this._compileTernary(node);
+          default:
+            return false;
+        }
+      }
+      _compileUnary(node) {
+        const { op, operand, valueType } = node;
+        if (op === TOKEN.cvr) {
+          return this._compileNode(operand);
+        }
+        if (!this._compileNode(operand)) {
+          return false;
+        }
+        switch (op) {
+          case TOKEN.abs:
+            this.ir.push(OP.ABS);
+            break;
+          case TOKEN.neg:
+            this.ir.push(OP.NEG);
+            break;
+          case TOKEN.ceiling:
+            this.ir.push(OP.CEIL);
+            break;
+          case TOKEN.floor:
+            this.ir.push(OP.FLOOR);
+            break;
+          case TOKEN.round:
+            this.ir.push(OP.ROUND);
+            break;
+          case TOKEN.truncate:
+            this.ir.push(OP.TRUNC);
+            break;
+          case TOKEN.sqrt:
+            this.ir.push(OP.SQRT);
+            break;
+          case TOKEN.sin:
+            this.ir.push(OP.SIN);
+            break;
+          case TOKEN.cos:
+            this.ir.push(OP.COS);
+            break;
+          case TOKEN.ln:
+            this.ir.push(OP.LN);
+            break;
+          case TOKEN.log:
+            this.ir.push(OP.LOG10);
+            break;
+          case TOKEN.cvi:
+            this.ir.push(OP.CVI);
+            break;
+          case TOKEN.not:
+            if (valueType === PS_VALUE_TYPE.boolean) {
+              this.ir.push(OP.NOT_B);
+            } else if (valueType === PS_VALUE_TYPE.numeric) {
+              this.ir.push(OP.NOT_N);
+            } else {
+              return false;
+            }
+            break;
+          default:
+            return false;
+        }
+        return true;
+      }
+      _compileBinary(node) {
+        const { op, first, second } = node;
+        if (op === TOKEN.bitshift) {
+          if (first.type !== PS_NODE.const || !Number.isInteger(first.value) || !this._compileNode(second)) {
+            return false;
+          }
+          this.ir.push(OP.SHIFT, first.value);
+          return true;
+        }
+        if (!this._compileNode(second) || !this._compileNode(first)) {
+          return false;
+        }
+        switch (op) {
+          case TOKEN.add:
+            this.ir.push(OP.ADD);
+            break;
+          case TOKEN.sub:
+            this.ir.push(OP.SUB);
+            break;
+          case TOKEN.mul:
+            this.ir.push(OP.MUL);
+            break;
+          case TOKEN.div:
+            this.ir.push(OP.DIV);
+            break;
+          case TOKEN.idiv:
+            this.ir.push(OP.IDIV);
+            break;
+          case TOKEN.mod:
+            this.ir.push(OP.MOD);
+            break;
+          case TOKEN.exp:
+            this.ir.push(OP.POW);
+            break;
+          case TOKEN.eq:
+            this.ir.push(OP.EQ);
+            break;
+          case TOKEN.ne:
+            this.ir.push(OP.NE);
+            break;
+          case TOKEN.gt:
+            this.ir.push(OP.GT);
+            break;
+          case TOKEN.ge:
+            this.ir.push(OP.GE);
+            break;
+          case TOKEN.lt:
+            this.ir.push(OP.LT);
+            break;
+          case TOKEN.le:
+            this.ir.push(OP.LE);
+            break;
+          case TOKEN.and:
+            this.ir.push(OP.AND);
+            break;
+          case TOKEN.or:
+            this.ir.push(OP.OR);
+            break;
+          case TOKEN.xor:
+            this.ir.push(OP.XOR);
+            break;
+          case TOKEN.atan:
+            this.ir.push(OP.ATAN);
+            break;
+          case TOKEN.min:
+            this.ir.push(OP.MIN);
+            break;
+          case TOKEN.max:
+            this.ir.push(OP.MAX);
+            break;
+          default:
+            return false;
+        }
+        return true;
+      }
+      _compileTernary(node) {
+        if (!this._compileNode(node.cond)) {
+          return false;
+        }
+        this.ir.push(OP.IF, 0);
+        const ifPatch = this.ir.length - 1;
+        if (!this._compileNode(node.then)) {
+          return false;
+        }
+        this.ir.push(OP.JUMP, 0);
+        const jumpPatch = this.ir.length - 1;
+        this.ir[ifPatch] = this.ir.length;
+        if (!this._compileNode(node.otherwise)) {
+          return false;
+        }
+        this.ir[jumpPatch] = this.ir.length;
+        return true;
+      }
+      compile(program) {
+        const outputs = new PSStackToTree().evaluate(program, this.nIn);
+        if (!outputs || outputs.length < this.nOut) {
+          return null;
+        }
+        for (let i = 0; i < this.nOut; i++) {
+          if (!this._compileNode(outputs[i])) {
+            return null;
+          }
+          const min = this.range[i * 2];
+          const max = this.range[i * 2 + 1];
+          this.ir.push(OP.STORE, i, min, max);
+        }
+        return new Float64Array(this.ir);
+      }
+      static execute(ir, src, srcOffset, dest, destOffset) {
+        let ip = 0, sp = 0;
+        const n = ir.length;
+        const stack = this.#stack;
+        const tmp = this.#tmp;
+        while (ip < n) {
+          switch (ir[ip++] | 0) {
+            case OP.ARG:
+              stack[sp++] = src[srcOffset + (ir[ip++] | 0)];
+              break;
+            case OP.CONST:
+              stack[sp++] = ir[ip++];
+              break;
+            case OP.STORE: {
+              const slot = ir[ip++] | 0;
+              const min = ir[ip++];
+              const max = ir[ip++];
+              dest[destOffset + slot] = MathClamp(stack[--sp], min, max);
+              break;
+            }
+            case OP.IF: {
+              const tgt = ir[ip++];
+              if (stack[--sp] === 0) {
+                ip = tgt;
+              }
+              break;
+            }
+            case OP.JUMP:
+              ip = ir[ip];
+              break;
+            case OP.ABS:
+              stack[sp - 1] = Math.abs(stack[sp - 1]);
+              break;
+            case OP.NEG:
+              stack[sp - 1] = -stack[sp - 1];
+              break;
+            case OP.CEIL:
+              stack[sp - 1] = Math.ceil(stack[sp - 1]);
+              break;
+            case OP.FLOOR:
+              stack[sp - 1] = Math.floor(stack[sp - 1]);
+              break;
+            case OP.ROUND:
+              stack[sp - 1] = Math.floor(stack[sp - 1] + 0.5);
+              break;
+            case OP.TRUNC:
+              stack[sp - 1] = Math.trunc(stack[sp - 1]);
+              break;
+            case OP.NOT_B:
+              stack[sp - 1] = stack[sp - 1] !== 0 ? 0 : 1;
+              break;
+            case OP.NOT_N:
+              stack[sp - 1] = ~(stack[sp - 1] | 0);
+              break;
+            case OP.SQRT:
+              stack[sp - 1] = Math.sqrt(stack[sp - 1]);
+              break;
+            case OP.SIN:
+              stack[sp - 1] = Math.sin(stack[sp - 1] % 360 * _DEG_TO_RAD);
+              break;
+            case OP.COS:
+              stack[sp - 1] = Math.cos(stack[sp - 1] % 360 * _DEG_TO_RAD);
+              break;
+            case OP.LN:
+              stack[sp - 1] = Math.log(stack[sp - 1]);
+              break;
+            case OP.LOG10:
+              stack[sp - 1] = Math.log10(stack[sp - 1]);
+              break;
+            case OP.CVI:
+              stack[sp - 1] = Math.trunc(stack[sp - 1]) | 0;
+              break;
+            case OP.SHIFT: {
+              const amt = ir[ip++];
+              const v = stack[sp - 1] | 0;
+              if (amt > 0) {
+                stack[sp - 1] = v << amt;
+              } else if (amt < 0) {
+                stack[sp - 1] = v >> -amt;
+              } else {
+                stack[sp - 1] = v;
+              }
+              break;
+            }
+            case OP.ADD: {
+              const b = stack[--sp];
+              stack[sp - 1] += b;
+              break;
+            }
+            case OP.SUB: {
+              const b = stack[--sp];
+              stack[sp - 1] -= b;
+              break;
+            }
+            case OP.MUL: {
+              const b = stack[--sp];
+              stack[sp - 1] *= b;
+              break;
+            }
+            case OP.DIV: {
+              const b = stack[--sp];
+              stack[sp - 1] = b !== 0 ? stack[sp - 1] / b : 0;
+              break;
+            }
+            case OP.IDIV: {
+              const b = stack[--sp];
+              stack[sp - 1] = b !== 0 ? Math.trunc(stack[sp - 1] / b) : 0;
+              break;
+            }
+            case OP.MOD: {
+              const b = stack[--sp];
+              stack[sp - 1] = b !== 0 ? stack[sp - 1] % b : 0;
+              break;
+            }
+            case OP.POW: {
+              const b = stack[--sp];
+              stack[sp - 1] **= b;
+              break;
+            }
+            case OP.EQ: {
+              const b = stack[--sp];
+              stack[sp - 1] = stack[sp - 1] === b ? 1 : 0;
+              break;
+            }
+            case OP.NE: {
+              const b = stack[--sp];
+              stack[sp - 1] = stack[sp - 1] !== b ? 1 : 0;
+              break;
+            }
+            case OP.GT: {
+              const b = stack[--sp];
+              stack[sp - 1] = stack[sp - 1] > b ? 1 : 0;
+              break;
+            }
+            case OP.GE: {
+              const b = stack[--sp];
+              stack[sp - 1] = stack[sp - 1] >= b ? 1 : 0;
+              break;
+            }
+            case OP.LT: {
+              const b = stack[--sp];
+              stack[sp - 1] = stack[sp - 1] < b ? 1 : 0;
+              break;
+            }
+            case OP.LE: {
+              const b = stack[--sp];
+              stack[sp - 1] = stack[sp - 1] <= b ? 1 : 0;
+              break;
+            }
+            case OP.AND: {
+              const b = stack[--sp] | 0;
+              stack[sp - 1] = (stack[sp - 1] | 0) & b;
+              break;
+            }
+            case OP.OR: {
+              const b = stack[--sp] | 0;
+              stack[sp - 1] = stack[sp - 1] | 0 | b;
+              break;
+            }
+            case OP.XOR: {
+              const b = stack[--sp] | 0;
+              stack[sp - 1] = (stack[sp - 1] | 0) ^ b;
+              break;
+            }
+            case OP.ATAN: {
+              const b = stack[--sp];
+              const deg = Math.atan2(stack[sp - 1], b) * _RAD_TO_DEG;
+              stack[sp - 1] = deg < 0 ? deg + 360 : deg;
+              break;
+            }
+            case OP.MIN: {
+              const b = stack[--sp];
+              stack[sp - 1] = Math.min(stack[sp - 1], b);
+              break;
+            }
+            case OP.MAX: {
+              const b = stack[--sp];
+              stack[sp - 1] = Math.max(stack[sp - 1], b);
+              break;
+            }
+            case OP.TEE_TMP:
+              tmp[ir[ip++] | 0] = stack[sp - 1];
+              break;
+            case OP.LOAD_TMP:
+              stack[sp++] = tmp[ir[ip++] | 0];
+              break;
+          }
+        }
+      }
+    };
+    PSStackBasedInterpreter = class {
+      // Safe: JS is single-threaded.
+      static #stack = new Float64Array(100);
+      static #sp = 0;
+      static #push(v) {
+        if (this.#sp < this.#stack.length) {
+          this.#stack[this.#sp++] = v;
+        }
+      }
+      static #execOp(op) {
+        const stack = this.#stack;
+        switch (op) {
+          case TOKEN.true:
+            this.#push(1);
+            break;
+          case TOKEN.false:
+            this.#push(0);
+            break;
+          case TOKEN.abs:
+            stack[this.#sp - 1] = Math.abs(stack[this.#sp - 1]);
+            break;
+          case TOKEN.neg:
+            stack[this.#sp - 1] = -stack[this.#sp - 1];
+            break;
+          case TOKEN.ceiling:
+            stack[this.#sp - 1] = Math.ceil(stack[this.#sp - 1]);
+            break;
+          case TOKEN.floor:
+            stack[this.#sp - 1] = Math.floor(stack[this.#sp - 1]);
+            break;
+          case TOKEN.round:
+            stack[this.#sp - 1] = Math.floor(stack[this.#sp - 1] + 0.5);
+            break;
+          case TOKEN.truncate:
+            stack[this.#sp - 1] = Math.trunc(stack[this.#sp - 1]);
+            break;
+          case TOKEN.sqrt:
+            stack[this.#sp - 1] = Math.sqrt(stack[this.#sp - 1]);
+            break;
+          case TOKEN.sin:
+            stack[this.#sp - 1] = Math.sin(
+              stack[this.#sp - 1] % 360 * _DEG_TO_RAD
+            );
+            break;
+          case TOKEN.cos:
+            stack[this.#sp - 1] = Math.cos(
+              stack[this.#sp - 1] % 360 * _DEG_TO_RAD
+            );
+            break;
+          case TOKEN.ln:
+            stack[this.#sp - 1] = Math.log(stack[this.#sp - 1]);
+            break;
+          case TOKEN.log:
+            stack[this.#sp - 1] = Math.log10(stack[this.#sp - 1]);
+            break;
+          case TOKEN.cvi:
+            stack[this.#sp - 1] = Math.trunc(stack[this.#sp - 1]) | 0;
+            break;
+          case TOKEN.cvr:
+            break;
+          // values are already f64
+          case TOKEN.not: {
+            const v = stack[this.#sp - 1];
+            stack[this.#sp - 1] = v === 0 || v === 1 ? 1 - v : ~(v | 0);
+            break;
+          }
+          case TOKEN.add: {
+            const b = stack[--this.#sp];
+            stack[this.#sp - 1] += b;
+            break;
+          }
+          case TOKEN.sub: {
+            const b = stack[--this.#sp];
+            stack[this.#sp - 1] -= b;
+            break;
+          }
+          case TOKEN.mul: {
+            const b = stack[--this.#sp];
+            stack[this.#sp - 1] *= b;
+            break;
+          }
+          case TOKEN.div: {
+            const b = stack[--this.#sp];
+            stack[this.#sp - 1] = b !== 0 ? stack[this.#sp - 1] / b : 0;
+            break;
+          }
+          case TOKEN.idiv: {
+            const b = stack[--this.#sp];
+            stack[this.#sp - 1] = b !== 0 ? Math.trunc(stack[this.#sp - 1] / b) : 0;
+            break;
+          }
+          case TOKEN.mod: {
+            const b = stack[--this.#sp];
+            stack[this.#sp - 1] = b !== 0 ? stack[this.#sp - 1] % b : 0;
+            break;
+          }
+          case TOKEN.exp: {
+            const b = stack[--this.#sp];
+            stack[this.#sp - 1] **= b;
+            break;
+          }
+          case TOKEN.atan: {
+            const dx = stack[--this.#sp];
+            const deg = Math.atan2(stack[this.#sp - 1], dx) * _RAD_TO_DEG;
+            stack[this.#sp - 1] = deg < 0 ? deg + 360 : deg;
+            break;
+          }
+          case TOKEN.eq: {
+            const b = stack[--this.#sp];
+            stack[this.#sp - 1] = stack[this.#sp - 1] === b ? 1 : 0;
+            break;
+          }
+          case TOKEN.ne: {
+            const b = stack[--this.#sp];
+            stack[this.#sp - 1] = stack[this.#sp - 1] !== b ? 1 : 0;
+            break;
+          }
+          case TOKEN.gt: {
+            const b = stack[--this.#sp];
+            stack[this.#sp - 1] = stack[this.#sp - 1] > b ? 1 : 0;
+            break;
+          }
+          case TOKEN.ge: {
+            const b = stack[--this.#sp];
+            stack[this.#sp - 1] = stack[this.#sp - 1] >= b ? 1 : 0;
+            break;
+          }
+          case TOKEN.lt: {
+            const b = stack[--this.#sp];
+            stack[this.#sp - 1] = stack[this.#sp - 1] < b ? 1 : 0;
+            break;
+          }
+          case TOKEN.le: {
+            const b = stack[--this.#sp];
+            stack[this.#sp - 1] = stack[this.#sp - 1] <= b ? 1 : 0;
+            break;
+          }
+          case TOKEN.and: {
+            const b = stack[--this.#sp] | 0;
+            stack[this.#sp - 1] = (stack[this.#sp - 1] | 0) & b;
+            break;
+          }
+          case TOKEN.or: {
+            const b = stack[--this.#sp] | 0;
+            stack[this.#sp - 1] = stack[this.#sp - 1] | 0 | b;
+            break;
+          }
+          case TOKEN.xor: {
+            const b = stack[--this.#sp] | 0;
+            stack[this.#sp - 1] = (stack[this.#sp - 1] | 0) ^ b;
+            break;
+          }
+          case TOKEN.bitshift: {
+            const amt = stack[--this.#sp] | 0;
+            const v = stack[this.#sp - 1] | 0;
+            stack[this.#sp - 1] = amt > 0 ? v << amt : v >> -amt;
+            break;
+          }
+          case TOKEN.min: {
+            const b = stack[--this.#sp];
+            stack[this.#sp - 1] = Math.min(stack[this.#sp - 1], b);
+            break;
+          }
+          case TOKEN.max: {
+            const b = stack[--this.#sp];
+            stack[this.#sp - 1] = Math.max(stack[this.#sp - 1], b);
+            break;
+          }
+          case TOKEN.dup:
+            this.#push(stack[this.#sp - 1]);
+            break;
+          case TOKEN.exch: {
+            const a = stack[--this.#sp];
+            const b = stack[--this.#sp];
+            this.#push(a);
+            this.#push(b);
+            break;
+          }
+          case TOKEN.pop:
+            this.#sp--;
+            break;
+          case TOKEN.copy: {
+            const n = Math.trunc(stack[--this.#sp]);
+            const base = this.#sp - n;
+            for (let k = 0; k < n; k++) {
+              this.#push(stack[base + k]);
+            }
+            break;
+          }
+          case TOKEN.index: {
+            const i = Math.trunc(stack[--this.#sp]);
+            this.#push(stack[this.#sp - 1 - i]);
+            break;
+          }
+          case TOKEN.roll: {
+            const j = Math.trunc(stack[--this.#sp]);
+            const n = Math.trunc(stack[--this.#sp]);
+            if (n > 1 && j !== 0) {
+              const mod = (j % n + n) % n;
+              if (mod !== 0) {
+                const base = this.#sp - n;
+                const sub = stack.slice(base, this.#sp);
+                for (let k = 0; k < n; k++) {
+                  stack[base + k] = sub[(k - mod + n) % n];
+                }
+              }
+            }
+            break;
+          }
+        }
+      }
+      static #execBlock(instructions) {
+        for (const instr of instructions) {
+          switch (instr.type) {
+            case PS_NODE.number:
+              this.#push(instr.value);
+              break;
+            case PS_NODE.operator:
+              this.#execOp(instr.op);
+              break;
+            case PS_NODE.if:
+              if (this.#stack[--this.#sp] !== 0) {
+                this.#execBlock(instr.then.instructions);
+              }
+              break;
+            case PS_NODE.ifelse:
+              if (this.#stack[--this.#sp] !== 0) {
+                this.#execBlock(instr.then.instructions);
+              } else {
+                this.#execBlock(instr.otherwise.instructions);
+              }
+              break;
+          }
+        }
+      }
+      /**
+       * @param {import("./ast.js").PsProgram} program
+       * @param {number[]} domain  – flat [min0,max0, …]
+       * @param {number[]} range   – flat [min0,max0, …]
+       * @returns {Function}  – `(src, srcOffset, dest, destOffset) => void`
+       */
+      static build(program, domain, range) {
+        const nIn = domain.length >> 1;
+        const nOut = range.length >> 1;
+        const { instructions } = program.body;
+        return (src, srcOffset, dest, destOffset) => {
+          this.#sp = 0;
+          for (let i = 0; i < nIn; i++) {
+            this.#push(src[srcOffset + i]);
+          }
+          this.#execBlock(instructions);
+          const base = this.#sp - nOut;
+          for (let i = 0; i < nOut; i++) {
+            const v = base + i >= 0 ? this.#stack[base + i] : 0;
+            dest[destOffset + i] = MathClamp(v, range[i * 2], range[i * 2 + 1]);
+          }
+        };
+      }
+    };
+    ShadingType = {
+      FUNCTION_BASED: 1,
+      AXIAL: 2,
+      RADIAL: 3,
+      FREE_FORM_MESH: 4,
+      LATTICE_FORM_MESH: 5,
+      COONS_PATCH_MESH: 6,
+      TENSOR_PATCH_MESH: 7
+    };
+    BaseShading = class _BaseShading {
+      // A small number to offset the first/last color stops so we can insert ones
+      // to support extend. Number.MIN_VALUE is too small and breaks the extend.
+      static SMALL_NUMBER = 1e-6;
+      constructor() {
+        if ((typeof PDFJSDev === "undefined" || PDFJSDev.test("TESTING")) && this.constructor === _BaseShading) {
+          unreachable2("Cannot initialize BaseShading.");
+        }
+      }
+      getIR() {
+        unreachable2("Abstract method `getIR` called.");
+      }
+    };
+    MeshStreamReader = class {
+      constructor(stream, context) {
+        this.stream = stream;
+        this.context = context;
+        this.buffer = 0;
+        this.bufferLength = 0;
+        const numComps = context.numComps;
+        this.tmpCompsBuf = new Float32Array(numComps);
+        const csNumComps = context.colorSpace.numComps;
+        this.tmpCsCompsBuf = context.colorFn ? new Float32Array(csNumComps) : this.tmpCompsBuf;
+      }
+      get hasData() {
+        if (this.stream.end) {
+          return this.stream.pos < this.stream.end;
+        }
+        if (this.bufferLength > 0) {
+          return true;
+        }
+        const nextByte = this.stream.getByte();
+        if (nextByte < 0) {
+          return false;
+        }
+        this.buffer = nextByte;
+        this.bufferLength = 8;
+        return true;
+      }
+      readBits(n) {
+        const { stream } = this;
+        let { buffer, bufferLength } = this;
+        if (n === 32) {
+          if (bufferLength === 0) {
+            return stream.getInt32() >>> 0;
+          }
+          buffer = buffer << 24 | stream.getByte() << 16 | stream.getByte() << 8 | stream.getByte();
+          const nextByte = stream.getByte();
+          this.buffer = nextByte & (1 << bufferLength) - 1;
+          return (buffer << 8 - bufferLength | (nextByte & 255) >> bufferLength) >>> 0;
+        }
+        if (n === 8 && bufferLength === 0) {
+          return stream.getByte();
+        }
+        while (bufferLength < n) {
+          buffer = buffer << 8 | stream.getByte();
+          bufferLength += 8;
+        }
+        bufferLength -= n;
+        this.bufferLength = bufferLength;
+        this.buffer = buffer & (1 << bufferLength) - 1;
+        return buffer >> bufferLength;
+      }
+      align() {
+        this.buffer = 0;
+        this.bufferLength = 0;
+      }
+      readFlag() {
+        return this.readBits(this.context.bitsPerFlag);
+      }
+      readCoordinate() {
+        const { bitsPerCoordinate, decode } = this.context;
+        const xi = this.readBits(bitsPerCoordinate);
+        const yi = this.readBits(bitsPerCoordinate);
+        const scale = bitsPerCoordinate < 32 ? 1 / ((1 << bitsPerCoordinate) - 1) : 23283064365386963e-26;
+        return [
+          xi * scale * (decode[1] - decode[0]) + decode[0],
+          yi * scale * (decode[3] - decode[2]) + decode[2]
+        ];
+      }
+      readComponents() {
+        const { bitsPerComponent, colorFn, colorSpace, decode, numComps } = this.context;
+        const scale = bitsPerComponent < 32 ? 1 / ((1 << bitsPerComponent) - 1) : 23283064365386963e-26;
+        const components = this.tmpCompsBuf;
+        for (let i = 0, j = 4; i < numComps; i++, j += 2) {
+          const ci = this.readBits(bitsPerComponent);
+          components[i] = ci * scale * (decode[j + 1] - decode[j]) + decode[j];
+        }
+        const color = this.tmpCsCompsBuf;
+        colorFn?.(components, 0, color, 0);
+        return colorSpace.getRgb(color, 0);
+      }
+    };
+    bCache = null;
+    MeshShading = class _MeshShading extends BaseShading {
+      static MIN_SPLIT_PATCH_CHUNKS_AMOUNT = 3;
+      static MAX_SPLIT_PATCH_CHUNKS_AMOUNT = 20;
+      // Count of triangles per entire mesh bounds.
+      static TRIANGLE_DENSITY = 20;
+      constructor(shadingType, stream, context, rowVertices) {
+        super();
+        this.shadingType = shadingType;
+        this.bbox = this.background = null;
+        this.coords = [];
+        this.colors = [];
+        this.figures = [];
+        const reader = new MeshStreamReader(stream, context);
+        let patchMesh = false;
+        switch (this.shadingType) {
+          case ShadingType.FREE_FORM_MESH:
+            this._decodeType4Shading(reader);
+            break;
+          case ShadingType.LATTICE_FORM_MESH:
+            const verticesPerRow = rowVertices | 0;
+            if (verticesPerRow < 2) {
+              throw new FormatError("Invalid VerticesPerRow");
+            }
+            this._decodeType5Shading(reader, verticesPerRow);
+            break;
+          case ShadingType.COONS_PATCH_MESH:
+            this._decodeType6Shading(reader);
+            patchMesh = true;
+            break;
+          case ShadingType.TENSOR_PATCH_MESH:
+            this._decodeType7Shading(reader);
+            patchMesh = true;
+            break;
+          default:
+            unreachable2("Unsupported mesh type.");
+            break;
+        }
+        if (patchMesh) {
+          this._updateBounds();
+          for (let i = 0, ii = this.figures.length; i < ii; i++) {
+            this._buildFigureFromPatch(i);
+          }
+        }
+        this._updateBounds();
+        this._packData();
+      }
+      _decodeType4Shading(reader) {
+        const coords = this.coords;
+        const colors = this.colors;
+        const operators = [];
+        const ps = [];
+        let verticesLeft = 0;
+        while (reader.hasData) {
+          const f = reader.readFlag();
+          const coord = reader.readCoordinate();
+          const color = reader.readComponents();
+          if (verticesLeft === 0) {
+            if (!(0 <= f && f <= 2)) {
+              throw new FormatError("Unknown type4 flag");
+            }
+            switch (f) {
+              case 0:
+                verticesLeft = 3;
+                break;
+              case 1:
+                ps.push(ps.at(-2), ps.at(-1));
+                verticesLeft = 1;
+                break;
+              case 2:
+                ps.push(ps.at(-3), ps.at(-1));
+                verticesLeft = 1;
+                break;
+            }
+            operators.push(f);
+          }
+          ps.push(coords.length);
+          coords.push(coord);
+          colors.push(color);
+          verticesLeft--;
+          reader.align();
+        }
+        this.figures.push({
+          type: MeshFigureType.TRIANGLES,
+          coords: new Int32Array(ps),
+          colors: new Int32Array(ps)
+        });
+      }
+      _decodeType5Shading(reader, verticesPerRow) {
+        const coords = this.coords;
+        const colors = this.colors;
+        const ps = [];
+        while (reader.hasData) {
+          const coord = reader.readCoordinate();
+          const color = reader.readComponents();
+          ps.push(coords.length);
+          coords.push(coord);
+          colors.push(color);
+        }
+        this.figures.push({
+          type: MeshFigureType.LATTICE,
+          coords: new Int32Array(ps),
+          colors: new Int32Array(ps),
+          verticesPerRow
+        });
+      }
+      _decodeType6Shading(reader) {
+        const coords = this.coords;
+        const colors = this.colors;
+        const ps = new Int32Array(16);
+        const cs = new Int32Array(4);
+        while (reader.hasData) {
+          const f = reader.readFlag();
+          if (!(0 <= f && f <= 3)) {
+            throw new FormatError("Unknown type6 flag");
+          }
+          const pi = coords.length;
+          for (let i = 0, ii = f !== 0 ? 8 : 12; i < ii; i++) {
+            coords.push(reader.readCoordinate());
+          }
+          const ci = colors.length;
+          for (let i = 0, ii = f !== 0 ? 2 : 4; i < ii; i++) {
+            colors.push(reader.readComponents());
+          }
+          let tmp1, tmp2, tmp3, tmp4;
+          switch (f) {
+            // prettier-ignore
+            case 0:
+              ps[12] = pi + 3;
+              ps[13] = pi + 4;
+              ps[14] = pi + 5;
+              ps[15] = pi + 6;
+              ps[8] = pi + 2;
+              ps[11] = pi + 7;
+              ps[4] = pi + 1;
+              ps[7] = pi + 8;
+              ps[0] = pi;
+              ps[1] = pi + 11;
+              ps[2] = pi + 10;
+              ps[3] = pi + 9;
+              cs[2] = ci + 1;
+              cs[3] = ci + 2;
+              cs[0] = ci;
+              cs[1] = ci + 3;
+              break;
+            // prettier-ignore
+            case 1:
+              tmp1 = ps[12];
+              tmp2 = ps[13];
+              tmp3 = ps[14];
+              tmp4 = ps[15];
+              ps[12] = tmp4;
+              ps[13] = pi + 0;
+              ps[14] = pi + 1;
+              ps[15] = pi + 2;
+              ps[8] = tmp3;
+              ps[11] = pi + 3;
+              ps[4] = tmp2;
+              ps[7] = pi + 4;
+              ps[0] = tmp1;
+              ps[1] = pi + 7;
+              ps[2] = pi + 6;
+              ps[3] = pi + 5;
+              tmp1 = cs[2];
+              tmp2 = cs[3];
+              cs[2] = tmp2;
+              cs[3] = ci;
+              cs[0] = tmp1;
+              cs[1] = ci + 1;
+              break;
+            // prettier-ignore
+            case 2:
+              tmp1 = ps[15];
+              tmp2 = ps[11];
+              ps[12] = ps[3];
+              ps[13] = pi + 0;
+              ps[14] = pi + 1;
+              ps[15] = pi + 2;
+              ps[8] = ps[7];
+              ps[11] = pi + 3;
+              ps[4] = tmp2;
+              ps[7] = pi + 4;
+              ps[0] = tmp1;
+              ps[1] = pi + 7;
+              ps[2] = pi + 6;
+              ps[3] = pi + 5;
+              tmp1 = cs[3];
+              cs[2] = cs[1];
+              cs[3] = ci;
+              cs[0] = tmp1;
+              cs[1] = ci + 1;
+              break;
+            // prettier-ignore
+            case 3:
+              ps[12] = ps[0];
+              ps[13] = pi + 0;
+              ps[14] = pi + 1;
+              ps[15] = pi + 2;
+              ps[8] = ps[1];
+              ps[11] = pi + 3;
+              ps[4] = ps[2];
+              ps[7] = pi + 4;
+              ps[0] = ps[3];
+              ps[1] = pi + 7;
+              ps[2] = pi + 6;
+              ps[3] = pi + 5;
+              cs[2] = cs[0];
+              cs[3] = ci;
+              cs[0] = cs[1];
+              cs[1] = ci + 1;
+              break;
+          }
+          ps[5] = coords.length;
+          coords.push([
+            (-4 * coords[ps[0]][0] - coords[ps[15]][0] + 6 * (coords[ps[4]][0] + coords[ps[1]][0]) - 2 * (coords[ps[12]][0] + coords[ps[3]][0]) + 3 * (coords[ps[13]][0] + coords[ps[7]][0])) / 9,
+            (-4 * coords[ps[0]][1] - coords[ps[15]][1] + 6 * (coords[ps[4]][1] + coords[ps[1]][1]) - 2 * (coords[ps[12]][1] + coords[ps[3]][1]) + 3 * (coords[ps[13]][1] + coords[ps[7]][1])) / 9
+          ]);
+          ps[6] = coords.length;
+          coords.push([
+            (-4 * coords[ps[3]][0] - coords[ps[12]][0] + 6 * (coords[ps[2]][0] + coords[ps[7]][0]) - 2 * (coords[ps[0]][0] + coords[ps[15]][0]) + 3 * (coords[ps[4]][0] + coords[ps[14]][0])) / 9,
+            (-4 * coords[ps[3]][1] - coords[ps[12]][1] + 6 * (coords[ps[2]][1] + coords[ps[7]][1]) - 2 * (coords[ps[0]][1] + coords[ps[15]][1]) + 3 * (coords[ps[4]][1] + coords[ps[14]][1])) / 9
+          ]);
+          ps[9] = coords.length;
+          coords.push([
+            (-4 * coords[ps[12]][0] - coords[ps[3]][0] + 6 * (coords[ps[8]][0] + coords[ps[13]][0]) - 2 * (coords[ps[0]][0] + coords[ps[15]][0]) + 3 * (coords[ps[11]][0] + coords[ps[1]][0])) / 9,
+            (-4 * coords[ps[12]][1] - coords[ps[3]][1] + 6 * (coords[ps[8]][1] + coords[ps[13]][1]) - 2 * (coords[ps[0]][1] + coords[ps[15]][1]) + 3 * (coords[ps[11]][1] + coords[ps[1]][1])) / 9
+          ]);
+          ps[10] = coords.length;
+          coords.push([
+            (-4 * coords[ps[15]][0] - coords[ps[0]][0] + 6 * (coords[ps[11]][0] + coords[ps[14]][0]) - 2 * (coords[ps[12]][0] + coords[ps[3]][0]) + 3 * (coords[ps[2]][0] + coords[ps[8]][0])) / 9,
+            (-4 * coords[ps[15]][1] - coords[ps[0]][1] + 6 * (coords[ps[11]][1] + coords[ps[14]][1]) - 2 * (coords[ps[12]][1] + coords[ps[3]][1]) + 3 * (coords[ps[2]][1] + coords[ps[8]][1])) / 9
+          ]);
+          this.figures.push({
+            type: MeshFigureType.PATCH,
+            coords: new Int32Array(ps),
+            // making copies of ps and cs
+            colors: new Int32Array(cs)
+          });
+        }
+      }
+      _decodeType7Shading(reader) {
+        const coords = this.coords;
+        const colors = this.colors;
+        const ps = new Int32Array(16);
+        const cs = new Int32Array(4);
+        while (reader.hasData) {
+          const f = reader.readFlag();
+          if (!(0 <= f && f <= 3)) {
+            throw new FormatError("Unknown type7 flag");
+          }
+          const pi = coords.length;
+          for (let i = 0, ii = f !== 0 ? 12 : 16; i < ii; i++) {
+            coords.push(reader.readCoordinate());
+          }
+          const ci = colors.length;
+          for (let i = 0, ii = f !== 0 ? 2 : 4; i < ii; i++) {
+            colors.push(reader.readComponents());
+          }
+          let tmp1, tmp2, tmp3, tmp4;
+          switch (f) {
+            // prettier-ignore
+            case 0:
+              ps[12] = pi + 3;
+              ps[13] = pi + 4;
+              ps[14] = pi + 5;
+              ps[15] = pi + 6;
+              ps[8] = pi + 2;
+              ps[9] = pi + 13;
+              ps[10] = pi + 14;
+              ps[11] = pi + 7;
+              ps[4] = pi + 1;
+              ps[5] = pi + 12;
+              ps[6] = pi + 15;
+              ps[7] = pi + 8;
+              ps[0] = pi;
+              ps[1] = pi + 11;
+              ps[2] = pi + 10;
+              ps[3] = pi + 9;
+              cs[2] = ci + 1;
+              cs[3] = ci + 2;
+              cs[0] = ci;
+              cs[1] = ci + 3;
+              break;
+            // prettier-ignore
+            case 1:
+              tmp1 = ps[12];
+              tmp2 = ps[13];
+              tmp3 = ps[14];
+              tmp4 = ps[15];
+              ps[12] = tmp4;
+              ps[13] = pi + 0;
+              ps[14] = pi + 1;
+              ps[15] = pi + 2;
+              ps[8] = tmp3;
+              ps[9] = pi + 9;
+              ps[10] = pi + 10;
+              ps[11] = pi + 3;
+              ps[4] = tmp2;
+              ps[5] = pi + 8;
+              ps[6] = pi + 11;
+              ps[7] = pi + 4;
+              ps[0] = tmp1;
+              ps[1] = pi + 7;
+              ps[2] = pi + 6;
+              ps[3] = pi + 5;
+              tmp1 = cs[2];
+              tmp2 = cs[3];
+              cs[2] = tmp2;
+              cs[3] = ci;
+              cs[0] = tmp1;
+              cs[1] = ci + 1;
+              break;
+            // prettier-ignore
+            case 2:
+              tmp1 = ps[15];
+              tmp2 = ps[11];
+              ps[12] = ps[3];
+              ps[13] = pi + 0;
+              ps[14] = pi + 1;
+              ps[15] = pi + 2;
+              ps[8] = ps[7];
+              ps[9] = pi + 9;
+              ps[10] = pi + 10;
+              ps[11] = pi + 3;
+              ps[4] = tmp2;
+              ps[5] = pi + 8;
+              ps[6] = pi + 11;
+              ps[7] = pi + 4;
+              ps[0] = tmp1;
+              ps[1] = pi + 7;
+              ps[2] = pi + 6;
+              ps[3] = pi + 5;
+              tmp1 = cs[3];
+              cs[2] = cs[1];
+              cs[3] = ci;
+              cs[0] = tmp1;
+              cs[1] = ci + 1;
+              break;
+            // prettier-ignore
+            case 3:
+              ps[12] = ps[0];
+              ps[13] = pi + 0;
+              ps[14] = pi + 1;
+              ps[15] = pi + 2;
+              ps[8] = ps[1];
+              ps[9] = pi + 9;
+              ps[10] = pi + 10;
+              ps[11] = pi + 3;
+              ps[4] = ps[2];
+              ps[5] = pi + 8;
+              ps[6] = pi + 11;
+              ps[7] = pi + 4;
+              ps[0] = ps[3];
+              ps[1] = pi + 7;
+              ps[2] = pi + 6;
+              ps[3] = pi + 5;
+              cs[2] = cs[0];
+              cs[3] = ci;
+              cs[0] = cs[1];
+              cs[1] = ci + 1;
+              break;
+          }
+          this.figures.push({
+            type: MeshFigureType.PATCH,
+            coords: new Int32Array(ps),
+            // making copies of ps and cs
+            colors: new Int32Array(cs)
+          });
+        }
+      }
+      _buildFigureFromPatch(index) {
+        const figure = this.figures[index];
+        assert2(
+          figure.type === MeshFigureType.PATCH,
+          "Unexpected patch mesh figure"
+        );
+        const coords = this.coords, colors = this.colors;
+        const pi = figure.coords;
+        const ci = figure.colors;
+        const figureMinX = Math.min(
+          coords[pi[0]][0],
+          coords[pi[3]][0],
+          coords[pi[12]][0],
+          coords[pi[15]][0]
+        );
+        const figureMinY = Math.min(
+          coords[pi[0]][1],
+          coords[pi[3]][1],
+          coords[pi[12]][1],
+          coords[pi[15]][1]
+        );
+        const figureMaxX = Math.max(
+          coords[pi[0]][0],
+          coords[pi[3]][0],
+          coords[pi[12]][0],
+          coords[pi[15]][0]
+        );
+        const figureMaxY = Math.max(
+          coords[pi[0]][1],
+          coords[pi[3]][1],
+          coords[pi[12]][1],
+          coords[pi[15]][1]
+        );
+        let splitXBy = Math.ceil(
+          (figureMaxX - figureMinX) * _MeshShading.TRIANGLE_DENSITY / (this.bounds[2] - this.bounds[0])
+        );
+        splitXBy = MathClamp(
+          splitXBy,
+          _MeshShading.MIN_SPLIT_PATCH_CHUNKS_AMOUNT,
+          _MeshShading.MAX_SPLIT_PATCH_CHUNKS_AMOUNT
+        );
+        let splitYBy = Math.ceil(
+          (figureMaxY - figureMinY) * _MeshShading.TRIANGLE_DENSITY / (this.bounds[3] - this.bounds[1])
+        );
+        splitYBy = MathClamp(
+          splitYBy,
+          _MeshShading.MIN_SPLIT_PATCH_CHUNKS_AMOUNT,
+          _MeshShading.MAX_SPLIT_PATCH_CHUNKS_AMOUNT
+        );
+        const verticesPerRow = splitXBy + 1;
+        const figureCoords = new Int32Array((splitYBy + 1) * verticesPerRow);
+        const figureColors = new Int32Array((splitYBy + 1) * verticesPerRow);
+        let k = 0;
+        const cl = new Uint8Array(3), cr = new Uint8Array(3);
+        const c0 = colors[ci[0]], c1 = colors[ci[1]], c2 = colors[ci[2]], c3 = colors[ci[3]];
+        const bRow = getB(splitYBy), bCol = getB(splitXBy);
+        for (let row = 0; row <= splitYBy; row++) {
+          cl[0] = (c0[0] * (splitYBy - row) + c2[0] * row) / splitYBy | 0;
+          cl[1] = (c0[1] * (splitYBy - row) + c2[1] * row) / splitYBy | 0;
+          cl[2] = (c0[2] * (splitYBy - row) + c2[2] * row) / splitYBy | 0;
+          cr[0] = (c1[0] * (splitYBy - row) + c3[0] * row) / splitYBy | 0;
+          cr[1] = (c1[1] * (splitYBy - row) + c3[1] * row) / splitYBy | 0;
+          cr[2] = (c1[2] * (splitYBy - row) + c3[2] * row) / splitYBy | 0;
+          for (let col = 0; col <= splitXBy; col++, k++) {
+            if ((row === 0 || row === splitYBy) && (col === 0 || col === splitXBy)) {
+              continue;
+            }
+            let x = 0, y = 0;
+            let q = 0;
+            for (let i = 0; i <= 3; i++) {
+              for (let j = 0; j <= 3; j++, q++) {
+                const m = bRow[row][i] * bCol[col][j];
+                x += coords[pi[q]][0] * m;
+                y += coords[pi[q]][1] * m;
+              }
+            }
+            figureCoords[k] = coords.length;
+            coords.push([x, y]);
+            figureColors[k] = colors.length;
+            const newColor = new Uint8Array(3);
+            newColor[0] = (cl[0] * (splitXBy - col) + cr[0] * col) / splitXBy | 0;
+            newColor[1] = (cl[1] * (splitXBy - col) + cr[1] * col) / splitXBy | 0;
+            newColor[2] = (cl[2] * (splitXBy - col) + cr[2] * col) / splitXBy | 0;
+            colors.push(newColor);
+          }
+        }
+        figureCoords[0] = pi[0];
+        figureColors[0] = ci[0];
+        figureCoords[splitXBy] = pi[3];
+        figureColors[splitXBy] = ci[1];
+        figureCoords[verticesPerRow * splitYBy] = pi[12];
+        figureColors[verticesPerRow * splitYBy] = ci[2];
+        figureCoords[verticesPerRow * splitYBy + splitXBy] = pi[15];
+        figureColors[verticesPerRow * splitYBy + splitXBy] = ci[3];
+        this.figures[index] = {
+          type: MeshFigureType.LATTICE,
+          coords: figureCoords,
+          colors: figureColors,
+          verticesPerRow
+        };
+      }
+      _updateBounds() {
+        meshUpdateBounds(this);
+      }
+      _packData() {
+        meshPackData(this);
+      }
+      getIR() {
+        const { posData, colData, vertexCount } = buildMeshVertexData(
+          this.coords,
+          this.colors,
+          this.figures
+        );
+        return [
+          "Mesh",
+          this.shadingType,
+          posData,
+          colData,
+          vertexCount,
+          this.bounds,
+          this.bbox,
+          this.background
+        ];
+      }
+    };
     PdfError = class extends Error {
       constructor(code, message) {
         super(message);
@@ -40840,6 +43755,9 @@ var init_dist = __esm({
     __webpack_exports__VerbosityLevel = __webpack_exports__.VerbosityLevel;
     __webpack_exports__getVerbosityLevel = __webpack_exports__.getVerbosityLevel;
     __webpack_exports__setVerbosityLevel = __webpack_exports__.setVerbosityLevel;
+    cmykColorSpace = new DeviceCmykCS();
+    cmykColorSpace2 = new DeviceCmykCS();
+    postScriptFunctions = /* @__PURE__ */ new WeakMap();
     ACROFORM_FONT_ALIAS_MAP = {
       Helv: "Helvetica",
       HeBo: "Helvetica-Bold",
@@ -40919,7 +43837,7 @@ var init_dist = __esm({
             return [n0.value, n1.value, n2.value, n3.value];
           }
         }
-        return [0, 0, 612, 792];
+        return key === "MediaBox" ? [0, 0, 612, 792] : this.resolveBox("MediaBox");
       }
       getMediaBox() {
         return this.resolveBox("MediaBox");
@@ -41592,16 +44510,19 @@ var init_dist = __esm({
             });
           }
         }
-        return evaluateContentStreamToDisplayList({
+        const mediaBox = this.getMediaBox(), cropBox = this.getCropBox();
+        const originX = Math.min(mediaBox[0], mediaBox[2]), originY = Math.min(mediaBox[1], mediaBox[3]);
+        return { ...evaluateContentStreamToDisplayList({
           pageIndex: this.index,
           width,
           height,
+          origin: [originX, originY],
           rotation: this.getRotation(),
           nodes: baseNodes,
           cosDoc: this.cosDoc,
           resourcesDict: evalResourcesDict,
           annotations: extractPageAnnotations(this.cosDoc, this.pageDict)
-        });
+        }), cropBox: [cropBox[0] - originX, cropBox[1] - originY, cropBox[2] - originX, cropBox[3] - originY] };
       }
       extractPage(options) {
         const dl = this.evaluateDisplayList();
@@ -41619,10 +44540,10 @@ var init_dist = __esm({
         return extractTablesFromDisplayList(this.evaluateDisplayList());
       }
       renderToBitmap(options) {
-        return renderDisplayListToBitmap(this.evaluateDisplayList(), options);
+        return renderDisplayListToBitmap(this.evaluateDisplayList({ hideAnnotations: options?.hideAnnotations }), options);
       }
       renderToPng(options) {
-        return renderDisplayListToPng(this.evaluateDisplayList(), options);
+        return renderDisplayListToPng(this.evaluateDisplayList({ hideAnnotations: options?.hideAnnotations }), options);
       }
     };
     MAX_STROKE_VERTICES = 1e6;