@poe-platform/safe-bash 0.1.772 → 0.1.774

package/dist/pdf-ast/index.js

@@ -3578,6 +3578,11 @@ var FONT_IDENTITY_MATRIX = [1e-3, 0, 0, 1e-3, 0, 0];
 var LINE_FACTOR = 1.35;
 var LINE_DESCENT_FACTOR = 0.35;
 var BASELINE_FACTOR = LINE_DESCENT_FACTOR / LINE_FACTOR;
+var MeshFigureType = {
+  TRIANGLES: 1,
+  LATTICE: 2,
+  PATCH: 3
+};
 var VerbosityLevel = {
   ERRORS: 0,
   WARNINGS: 1,
@@ -22696,6 +22701,3308 @@ var PageViewport = class _PageViewport {
     return p;
   }
 };
+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;
+}
+var 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;
+  }
+};
+var 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;
+    }
+  }
+};
+var 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;
+    }
+  }
+};
+var 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;
+    }
+  }
+};
+var 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);
+  }
+};
+var 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
+};
+var Token = class {
+  constructor(id, value = null) {
+    this.id = id;
+    this.value = value;
+  }
+};
+var 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;
+  }
+};
+var 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
+};
+var 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
+};
+var PsNode = class {
+  constructor(type) {
+    this.type = type;
+  }
+};
+var PsProgram = class extends PsNode {
+  constructor(body) {
+    super(PS_NODE.program);
+    this.body = body;
+  }
+};
+var PsBlock = class extends PsNode {
+  constructor(instructions) {
+    super(PS_NODE.block);
+    this.instructions = instructions;
+  }
+};
+var PsNumber = class extends PsNode {
+  /** @param {number} value */
+  constructor(value) {
+    super(PS_NODE.number);
+    this.value = value;
+  }
+};
+var PsOperator = class extends PsNode {
+  /** @param {number} op — one of the TOKEN.* constants from lexer.js */
+  constructor(op) {
+    super(PS_NODE.operator);
+    this.op = op;
+  }
+};
+var PsIf = class extends PsNode {
+  /** @param {PsBlock} then */
+  constructor(then) {
+    super(PS_NODE.if);
+    this.then = then;
+  }
+};
+var PsIfElse = class extends PsNode {
+  /**
+   * @param {PsBlock} then
+   * @param {PsBlock} otherwise
+   */
+  constructor(then, otherwise) {
+    super(PS_NODE.ifelse);
+    this.then = then;
+    this.otherwise = otherwise;
+  }
+};
+var PsArgNode = class extends PsNode {
+  /** @param {number} index */
+  constructor(index) {
+    super(PS_NODE.arg);
+    this.index = index;
+    this.valueType = PS_VALUE_TYPE.numeric;
+  }
+};
+var 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;
+  }
+};
+var 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;
+  }
+};
+var 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;
+  }
+};
+var 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;
+  }
+};
+var 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}.`
+          );
+      }
+    }
+  }
+};
+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;
+  }
+}
+var MAX_STACK_SIZE = 100;
+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;
+  }
+}
+var 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
+    );
+  }
+};
+var 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]
+};
+var _DEG_TO_RAD = Math.PI / 180;
+var _RAD_TO_DEG = 180 / Math.PI;
+var 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;
+      }
+    }
+  }
+};
+var 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]);
+      }
+    };
+  }
+};
+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);
+}
+var ShadingType = {
+  FUNCTION_BASED: 1,
+  AXIAL: 2,
+  RADIAL: 3,
+  FREE_FORM_MESH: 4,
+  LATTICE_FORM_MESH: 5,
+  COONS_PATCH_MESH: 6,
+  TENSOR_PATCH_MESH: 7
+};
+var 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.");
+  }
+};
+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 };
+}
+var 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);
+  }
+};
+var bCache = null;
+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;
+}
+var 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
+    ];
+  }
+};
 
 // src/errors.ts
 var PdfError = class extends Error {
@@ -25746,11 +29053,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) {
@@ -33948,7 +37260,28 @@ var __webpack_exports__VerbosityLevel = __webpack_exports__.VerbosityLevel;
 var __webpack_exports__getVerbosityLevel = __webpack_exports__.getVerbosityLevel;
 var __webpack_exports__setVerbosityLevel = __webpack_exports__.setVerbosityLevel;
 
+// src/content/calibrated-color.ts
+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"));
+}
+
 // src/extract/images.ts
+var cmykColorSpace = new DeviceCmykCS();
 function collectPageLeaves(doc, node, inheritedResources, out = [], visited = /* @__PURE__ */ new Set()) {
   if (!node) return out;
   if (node.kind === "ref") {
@@ -34037,7 +37370,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);
@@ -34067,74 +37400,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",
@@ -34142,12 +37422,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]
       };
     }
   }
@@ -34305,141 +37582,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);
@@ -34459,10 +37650,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;
@@ -34518,9 +37710,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") {
@@ -34558,9 +37748,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];
@@ -35114,6 +38302,7 @@ function extractDocumentImages(doc, options = {}) {
 }
 
 // src/content/evaluator.ts
+var cmykColorSpace2 = new DeviceCmykCS();
 function multiplyMatrices(m1, m2) {
   return [
     m1[0] * m2[0] + m1[1] * m2[2],
@@ -35330,193 +38519,7 @@ 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;
-}
+var postScriptFunctions = /* @__PURE__ */ new WeakMap();
 function evalShadingFunctionToComponents(doc, fnNode, inputs) {
   const inArr = typeof inputs === "number" ? [inputs] : inputs;
   const t = inArr[0] ?? 0;
@@ -35563,35 +38566,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);
   }
@@ -35601,34 +38619,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++) {
@@ -35644,30 +38668,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;
@@ -35724,63 +38732,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]);
@@ -35861,143 +38816,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);
@@ -36009,10 +38849,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)));
@@ -36027,13 +38867,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;
         }
       }
@@ -36120,6 +38959,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++) {
@@ -36130,8 +38971,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) {
@@ -36431,7 +39274,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,
@@ -36470,12 +39314,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;
@@ -36684,7 +39526,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) {
@@ -37268,6 +40110,7 @@ function evaluateContentStreamToDisplayList(params) {
     pageIndex: params.pageIndex,
     width: params.width,
     height: params.height,
+    ...params.origin ? { origin: params.origin } : {},
     rotation: params.rotation ?? 0,
     glyphs,
     paths,
@@ -39427,7 +42270,7 @@ var PdfPage = class {
         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");
@@ -40100,16 +42943,19 @@ var PdfPage = class {
         });
       }
     }
-    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();
@@ -40127,10 +42973,10 @@ var PdfPage = class {
     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);
   }
 };
 function createStandardFontHandle(standardName) {
@@ -41584,7 +44430,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);
@@ -41596,8 +44442,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),
@@ -41755,18 +44601,37 @@ 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 containsBackdropGroup(operations) {
+  return operations.some((operation) => operation.kind === "group" && (needsGroupBackdrop(operation.value) || containsBackdropGroup(operation.value.operations)));
 }
 function renderDisplayListToBitmap(displayList, options = {}) {
   const baseScale = options.scale ?? (options.dpi ? options.dpi / 72 : 1.5);
   const scaleX = options.dpiX !== void 0 ? options.dpiX / 72 : baseScale;
   const scaleY = options.dpiY !== void 0 ? options.dpiY / 72 : baseScale;
   const scale = scaleX;
+  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);
@@ -41791,14 +44656,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,
@@ -41812,7 +44690,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;
@@ -41859,15 +44737,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,
@@ -41890,12 +44768,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)));
@@ -41912,11 +44790,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;
@@ -41977,6 +44855,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);
@@ -42046,18 +44933,44 @@ function svgPathData(segments, height, matrix) {
 }
 function renderDisplayListToSvg(displayList, options = {}) {
   const baseScale = options.scale ?? (options.dpi ? options.dpi / 72 : 1);
+  if (containsBackdropGroup(paintOperations(displayList))) {
+    const bitmap = renderDisplayListToBitmap(displayList, { ...options, scale: baseScale });
+    const embedded = svgImage({
+      name: "PageComposite",
+      width: bitmap.width,
+      height: bitmap.height,
+      decodedRgba: bitmap.data,
+      matrix: [bitmap.width, 0, 0, bitmap.height, 0, 0],
+      colorSpace: "DeviceRGB",
+      bitsPerComponent: 8
+    }, bitmap.height);
+    return `<svg xmlns="http://www.w3.org/2000/svg" width="${bitmap.width}" height="${bitmap.height}" viewBox="0 0 ${bitmap.width} ${bitmap.height}">${embedded}</svg>
+`;
+  }
   const scaleX = options.dpiX !== void 0 ? options.dpiX / 72 : baseScale;
   const scaleY = options.dpiY !== void 0 ? options.dpiY / 72 : baseScale;
-  const viewport = new PageViewport({ viewBox: [0, 0, displayList.width, displayList.height], userUnit: 1, scale: 1, rotation: displayList.rotation ?? 0 });
+  const [originX, originY] = displayList.origin ?? [0, 0];
+  const viewport = new PageViewport({ viewBox: [originX, originY, originX + displayList.width, originY + displayList.height], userUnit: 1, scale: 1, rotation: displayList.rotation ?? 0 });
   const quarterTurn = displayList.rotation === 90 || displayList.rotation === 270;
   const outputScaleX = quarterTurn ? scaleY : scaleX;
   const outputScaleY = quarterTurn ? scaleX : scaleY;
-  const fullW = Math.max(1, Math.round(viewport.width * outputScaleX));
-  const fullH = Math.max(1, Math.round(viewport.height * outputScaleY));
-  const vbX = options.cropRect ? options.cropRect.x / outputScaleX : 0;
-  const vbY = options.cropRect ? options.cropRect.y / outputScaleY : 0;
-  const vbW = options.cropRect && options.cropRect.width > 0 ? options.cropRect.width / outputScaleX : Math.max(1, viewport.width - vbX);
-  const vbH = options.cropRect && options.cropRect.height > 0 ? options.cropRect.height / outputScaleY : Math.max(1, viewport.height - vbY);
+  let bounds = [0, 0, viewport.width, viewport.height];
+  if (options.useCropBox) {
+    const box = getDisplayListCropBox(displayList);
+    const [x0, y0, x1, y1] = [box[0] + originX, box[1] + originY, box[2] + originX, box[3] + originY];
+    const [a, b, c, d, e, f] = viewport.transform;
+    bounds = [a * x0 + c * y0 + e, b * x0 + d * y0 + f, a * x1 + c * y1 + e, b * x1 + d * y1 + f];
+  }
+  const viewX = Math.min(bounds[0], bounds[2]), viewY = Math.min(bounds[1], bounds[3]);
+  const viewWidth = Math.abs(bounds[2] - bounds[0]), viewHeight = Math.abs(bounds[3] - bounds[1]);
+  const fullW = Math.max(1, Math.round(viewWidth * outputScaleX));
+  const fullH = Math.max(1, Math.round(viewHeight * outputScaleY));
+  const cropX = options.cropRect ? options.cropRect.x / outputScaleX : 0;
+  const vbX = viewX + cropX;
+  const cropY = options.cropRect ? options.cropRect.y / outputScaleY : 0;
+  const vbY = viewY + cropY;
+  const vbW = options.cropRect && options.cropRect.width > 0 ? options.cropRect.width / outputScaleX : Math.max(1, viewWidth - cropX);
+  const vbH = options.cropRect && options.cropRect.height > 0 ? options.cropRect.height / outputScaleY : Math.max(1, viewHeight - cropY);
   const outW = options.cropRect && options.cropRect.width > 0 ? Math.round(options.cropRect.width) : Math.max(1, fullW - Math.round(options.cropRect?.x ?? 0));
   const outH = options.cropRect && options.cropRect.height > 0 ? Math.round(options.cropRect.height) : Math.max(1, fullH - Math.round(options.cropRect?.y ?? 0));
   const parts = [
@@ -42067,7 +44980,7 @@ function renderDisplayListToSvg(displayList, options = {}) {
     parts.push(`  <rect x="${vbX}" y="${vbY}" width="${vbW}" height="${vbH}" fill="#ffffff"/>`);
   }
   parts.push('<g style="isolation:isolate">');
-  if (displayList.rotation) {
+  if (displayList.rotation || originX || originY) {
     const [a, b, c, d, e, f] = viewport.transform;
     parts.push(`<g transform="matrix(${a} ${b} ${-c} ${-d} ${e + c * displayList.height} ${f + d * displayList.height})">`);
   }
@@ -42093,11 +45006,11 @@ function renderDisplayListToSvg(displayList, options = {}) {
             width: bitmap.width,
             height: bitmap.height,
             decodedRgba: bitmap.data,
-            matrix: [displayList.width, 0, 0, displayList.height, 0, 0],
+            matrix: [displayList.width, 0, 0, displayList.height, originX, originY],
             colorSpace: "DeviceGray",
             bitsPerComponent: 8
           };
-          parts.push(`<defs><mask id="${id}" maskUnits="userSpaceOnUse" x="0" y="0" width="${displayList.width}" height="${displayList.height}" style="mask-type:alpha">${svgImage(image, displayList.height)}</mask></defs>`);
+          parts.push(`<defs><mask id="${id}" maskUnits="userSpaceOnUse" x="${originX}" y="${-originY}" width="${displayList.width}" height="${displayList.height}" style="mask-type:alpha">${svgImage(image, displayList.height)}</mask></defs>`);
         }
         parts.push(`<g mask="url(#${id})">`);
       }
@@ -42109,7 +45022,7 @@ function renderDisplayListToSvg(displayList, options = {}) {
       }
       for (const image of imageClips) {
         const id = `image-clip-${clipId++}`;
-        parts.push(`<defs><mask id="${id}" maskUnits="userSpaceOnUse" x="0" y="0" width="${displayList.width}" height="${displayList.height}" style="mask-type:alpha">${svgImage(image, displayList.height)}</mask></defs><g mask="url(#${id})">`);
+        parts.push(`<defs><mask id="${id}" maskUnits="userSpaceOnUse" x="${originX}" y="${-originY}" width="${displayList.width}" height="${displayList.height}" style="mask-type:alpha">${svgImage(image, displayList.height)}</mask></defs><g mask="url(#${id})">`);
       }
       if (operation.kind === "group") {
         parts.push(`<g opacity="${operation.value.alpha}" style="isolation:isolate">`);
@@ -42153,7 +45066,7 @@ function renderDisplayListToSvg(displayList, options = {}) {
     }
   };
   appendOperations(paintOperations(displayList));
-  if (displayList.rotation) parts.push("</g>");
+  if (displayList.rotation || originX || originY) parts.push("</g>");
   parts.push("</g>");
   parts.push("</svg>\n");
   return parts.join("\n");
@@ -42176,23 +45089,6 @@ function collectLeavesForRaster(cosDoc, node, out = [], visited = /* @__PURE__ *
   }
   return out;
 }
-function extractBoxArray(cosDoc, dict, key) {
-  let cur = dict;
-  const visited = /* @__PURE__ */ new Set();
-  while (cur && !visited.has(cur)) {
-    visited.add(cur);
-    const arr = cosDoc.resolveArray(dictGet(cur, key));
-    if (arr && arr.items.length >= 4) {
-      const nums = arr.items.slice(0, 4).map((item) => {
-        const r = cosDoc.resolve(item);
-        return r?.kind === "number" ? r.value : 0;
-      });
-      return [nums[0], nums[1], nums[2], nums[3]];
-    }
-    cur = cosDoc.resolveDict(dictGet(cur, "Parent"));
-  }
-  return void 0;
-}
 function renderPdfPageToBitmap(pdfBytes, pageIndex = 0, options) {
   const cos = pdfBytes instanceof Uint8Array ? parseCosDocument(pdfBytes) : pdfBytes;
   const catalog = cos.resolveDict(cos.rootRef);
@@ -42201,35 +45097,7 @@ function renderPdfPageToBitmap(pdfBytes, pageIndex = 0, options) {
   if (!leaf) throw new Error(`Page index ${pageIndex} out of bounds`);
   const resolvedIndex = leaves.indexOf(leaf);
   const page = new PdfPage(cos, leaf.ref, leaf.dict, resolvedIndex);
-  const { cropRect, ...restOptions } = options ?? {};
-  let bitmap = renderDisplayListToBitmap(
-    // CropBox is in unrotated page coordinates. Apply page rotation after it.
-    { ...page.evaluateDisplayList({ hideAnnotations: options?.hideAnnotations }), rotation: 0 },
-    restOptions
-  );
-  if (options?.useCropBox) {
-    const cropBox = extractBoxArray(cos, leaf.dict, "CropBox");
-    if (cropBox) {
-      const mediaBox = extractBoxArray(cos, leaf.dict, "MediaBox") ?? [0, 0, page.getSize().width, page.getSize().height];
-      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 mediaH = mediaBox[3] - mediaBox[1];
-      const bx = Math.round((cropBox[0] - mediaBox[0]) * scaleX);
-      const by = Math.round((mediaH - (cropBox[3] - mediaBox[1])) * scaleY);
-      const bw = Math.max(1, Math.round(Math.abs(cropBox[2] - cropBox[0]) * scaleX));
-      const bh = Math.max(1, Math.round(Math.abs(cropBox[3] - cropBox[1]) * scaleY));
-      bitmap = cropRgbaBitmap(bitmap, { x: bx, y: by, width: bw, height: bh });
-    }
-  }
-  const rotation = page.getRotation();
-  if (rotation === 90 || rotation === 180 || rotation === 270) {
-    bitmap = rotateRgbaBitmapQuarterTurns(bitmap, rotation);
-  }
-  if (cropRect) {
-    bitmap = cropRgbaBitmap(bitmap, cropRect);
-  }
-  return bitmap;
+  return page.renderToBitmap(options);
 }
 function renderPdfPageToPng(pdfBytes, pageIndex = 0, options) {
   const bmp = renderPdfPageToBitmap(pdfBytes, pageIndex, options);
@@ -43063,6 +45931,7 @@ export {
   formatPdfNumber,
   generateDocumentFormAppearances,
   generateToUnicodeCMap,
+  getDisplayListCropBox,
   getDocumentFormFields,
   glyphNameToUnicode,
   isOptionalContentVisible,