@poe-platform/safe-bash 0.1.773 → 0.1.774

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

@@ -2787,6 +2787,103 @@ function buildPostScriptJsFunction(source, domain, range, forceInterpreter = fal
   }
   return PSStackBasedInterpreter.build(program, domain, range);
 }
+function meshUpdateBounds(self) {
+  let minX = self.coords[0][0], minY = self.coords[0][1], maxX = minX, maxY = minY;
+  for (let i = 1, ii = self.coords.length; i < ii; i++) {
+    const x = self.coords[i][0], y = self.coords[i][1];
+    minX = minX > x ? x : minX;
+    minY = minY > y ? y : minY;
+    maxX = maxX < x ? x : maxX;
+    maxY = maxY < y ? y : maxY;
+  }
+  self.bounds = [minX, minY, maxX, maxY];
+}
+function meshPackData(self) {
+  let i, j, ii;
+  const coords = self.coords;
+  const coordsPacked = new Float32Array(coords.length * 2);
+  for (i = 0, j = 0, ii = coords.length; i < ii; i++) {
+    const xy = coords[i];
+    coordsPacked[j++] = xy[0];
+    coordsPacked[j++] = xy[1];
+  }
+  self.coords = coordsPacked;
+  const colors = self.colors;
+  const colorsPacked = new Uint8Array(colors.length * 4);
+  for (i = 0, j = 0, ii = colors.length; i < ii; i++) {
+    const c = colors[i];
+    colorsPacked[j++] = c[0];
+    colorsPacked[j++] = c[1];
+    colorsPacked[j++] = c[2];
+    j++;
+  }
+  self.colors = colorsPacked;
+  for (const figure of self.figures) {
+    figure.coords = new Uint32Array(figure.coords);
+    figure.colors = new Uint32Array(figure.colors);
+  }
+}
+function buildMeshVertexData(coords, colors, figures) {
+  let vertexCount = 0;
+  for (const figure of figures) {
+    if (figure.type === MeshFigureType.TRIANGLES) {
+      vertexCount += figure.coords.length;
+    } else if (figure.type === MeshFigureType.LATTICE) {
+      const vpr = figure.verticesPerRow;
+      vertexCount += (Math.floor(figure.coords.length / vpr) - 1) * (vpr - 1) * 6;
+    }
+  }
+  const posData = new Float32Array(vertexCount * 2);
+  const colData = new Uint8Array(vertexCount * 4);
+  let pOff = 0, cOff = 0;
+  const addVertex = (pi, ci) => {
+    posData[pOff++] = coords[pi * 2];
+    posData[pOff++] = coords[pi * 2 + 1];
+    colData[cOff++] = colors[ci * 4];
+    colData[cOff++] = colors[ci * 4 + 1];
+    colData[cOff++] = colors[ci * 4 + 2];
+    cOff++;
+  };
+  for (const figure of figures) {
+    const ps = figure.coords;
+    const cs = figure.colors;
+    if (figure.type === MeshFigureType.TRIANGLES) {
+      for (let i = 0, ii = ps.length; i < ii; i++) {
+        addVertex(ps[i], cs[i]);
+      }
+    } else if (figure.type === MeshFigureType.LATTICE) {
+      const vpr = figure.verticesPerRow;
+      const rows = Math.floor(ps.length / vpr) - 1;
+      const cols = vpr - 1;
+      for (let i = 0; i < rows; i++) {
+        let q = i * vpr;
+        for (let j = 0; j < cols; j++, q++) {
+          addVertex(ps[q], cs[q]);
+          addVertex(ps[q + 1], cs[q + 1]);
+          addVertex(ps[q + vpr], cs[q + vpr]);
+          addVertex(ps[q + vpr + 1], cs[q + vpr + 1]);
+          addVertex(ps[q + 1], cs[q + 1]);
+          addVertex(ps[q + vpr], cs[q + vpr]);
+        }
+      }
+    }
+  }
+  return { posData, colData, vertexCount };
+}
+function getB(count) {
+  if (bCache?.has(count)) return bCache.get(count);
+  const values = Array.from({ length: count + 1 }, (_, i) => {
+    const t = i / count, t_ = 1 - t;
+    return new Float32Array([
+      t_ ** 3,
+      3 * t * t_ ** 2,
+      3 * t ** 2 * t_,
+      t ** 3
+    ]);
+  });
+  (bCache ??= /* @__PURE__ */ new Map()).set(count, values);
+  return values;
+}
 function encodeFlate(bytes) {
   return deflate(bytes);
 }
@@ -4874,11 +4971,16 @@ function parseDictionaryStream(dictNode, lexer, bytes) {
     let streamEnd = streamStart;
     if (resolvedLength !== void 0 && resolvedLength >= 0 && streamStart + resolvedLength <= bytes.length) {
       const candidateEnd = streamStart + resolvedLength;
-      const tailSlice = bytes.subarray(candidateEnd, Math.min(bytes.length, candidateEnd + 32));
-      const tailStr = new TextDecoder("latin1").decode(tailSlice);
-      if (tailStr.includes("endstream")) {
+      const tailLexer = new CosByteLexer(bytes, candidateEnd);
+      let endToken;
+      try {
+        endToken = tailLexer.nextToken();
+      } catch (error) {
+        if (!(error instanceof PdfError) || error.code !== "E_PARSE") throw error;
+      }
+      if (endToken?.kind === "keyword" && endToken.value === "endstream") {
         rawStreamBytes = bytes.subarray(streamStart, candidateEnd);
-        streamEnd = candidateEnd + tailStr.indexOf("endstream") + "endstream".length;
+        streamEnd = tailLexer.offset;
       }
     }
     if (!rawStreamBytes) {
@@ -11016,143 +11118,28 @@ function renderMeshShadingToImage(doc, shDict, shStream, shType, effectiveCtm, t
     const r = doc.resolve(it);
     return r?.kind === "number" ? r.value : 0;
   });
-  const xmin = decodeNums[0], xmax = decodeNums[1], ymin = decodeNums[2], ymax = decodeNums[3];
-  const numColorParams = Math.max(1, Math.floor((decodeNums.length - 4) / 2));
   const fnNode = dictGet(shDict, "Function");
   const csNode = doc.resolve(dictGet(shDict, "ColorSpace"));
   const csName = csNode?.kind === "name" ? csNode.decoded : "DeviceRGB";
-  let bitPos = 0;
-  const totalBits = bytes.length * 8;
-  const readBits = (n) => {
-    let val = 0;
-    for (let i = 0; i < n; i++) {
-      if (bitPos >= totalBits) return val;
-      const byteIdx = bitPos >> 3;
-      const bitIdx = 7 - (bitPos & 7);
-      val = val * 2 + (bytes[byteIdx] >> bitIdx & 1);
-      bitPos++;
-    }
-    return val;
-  };
-  const coordMax = Math.pow(2, bpcCoord) - 1 || 1;
-  const compMax = Math.pow(2, bpcComp) - 1 || 1;
-  const readCoord = () => {
-    const rx = readBits(bpcCoord) / coordMax;
-    const ry = readBits(bpcCoord) / coordMax;
-    return [xmin + rx * (xmax - xmin), ymin + ry * (ymax - ymin)];
-  };
-  const readColorRgb = () => {
-    const params = [];
-    for (let c = 0; c < numColorParams; c++) {
-      const rc = readBits(bpcComp) / compMax;
-      const cMin = decodeNums[4 + c * 2] ?? 0;
-      const cMax = decodeNums[4 + c * 2 + 1] ?? 1;
-      params.push(cMin + rc * (cMax - cMin));
-    }
-    const comps = fnNode ? evalShadingFunctionToComponents(doc, fnNode, params) : params;
-    return convertColorSpaceComponentsToRgb(doc, csNode, csName, comps);
-  };
-  const triangles = [];
-  if (shType === 4) {
-    const minBitsPerVert = bpcFlag + 2 * bpcCoord + numColorParams * bpcComp;
-    let triVerts;
-    while (bitPos + minBitsPerVert <= totalBits) {
-      const flag = readBits(bpcFlag) & 3;
-      const [x, y] = readCoord();
-      const rgb2 = readColorRgb();
-      const vNew = { x, y, rgb: rgb2 };
-      if (flag === 0 || !triVerts) {
-        if (bitPos + 2 * minBitsPerVert > totalBits) break;
-        readBits(bpcFlag);
-        const [x1, y1] = readCoord();
-        const rgb1 = readColorRgb();
-        readBits(bpcFlag);
-        const [x2, y2] = readCoord();
-        const rgb22 = readColorRgb();
-        triVerts = [vNew, { x: x1, y: y1, rgb: rgb1 }, { x: x2, y: y2, rgb: rgb22 }];
-        triangles.push(triVerts);
-      } else if (flag === 1) {
-        triVerts = [triVerts[1], triVerts[2], vNew];
-        triangles.push(triVerts);
-      } else if (flag === 2) {
-        triVerts = [triVerts[0], triVerts[2], vNew];
-        triangles.push(triVerts);
-      }
-    }
-  } else if (shType === 5) {
-    const minBitsPerVert = 2 * bpcCoord + numColorParams * bpcComp;
-    const verts = [];
-    while (bitPos + minBitsPerVert <= totalBits) {
-      const [x, y] = readCoord();
-      const rgb2 = readColorRgb();
-      verts.push({ x, y, rgb: rgb2 });
-    }
-    const numRows = Math.floor(verts.length / vPerRow);
-    for (let r = 0; r + 1 < numRows; r++) {
-      for (let c = 0; c + 1 < vPerRow; c++) {
-        const v00 = verts[r * vPerRow + c];
-        const v01 = verts[r * vPerRow + c + 1];
-        const v11 = verts[(r + 1) * vPerRow + c + 1];
-        const v10 = verts[(r + 1) * vPerRow + c];
-        triangles.push([v00, v01, v11], [v00, v11, v10]);
-      }
-    }
-  } else if (shType === 6 || shType === 7) {
-    const numCtrl = shType === 6 ? 12 : 16;
-    const minBitsPatch = bpcFlag + (numCtrl - 4) * 2 * bpcCoord + 2 * numColorParams * bpcComp;
-    let prevPts;
-    let prevColors;
-    while (bitPos + minBitsPatch <= totalBits) {
-      const flag = readBits(bpcFlag) & 3;
-      let pts = [];
-      let cols = [];
-      if (flag === 0 || !prevPts || !prevColors) {
-        for (let i = 0; i < numCtrl; i++) pts.push(readCoord());
-        for (let i = 0; i < 4; i++) cols.push(readColorRgb());
-      } else {
-        const extraCtrl = numCtrl - 4;
-        const readExtra = [];
-        for (let i = 0; i < extraCtrl; i++) readExtra.push(readCoord());
-        const c2 = readColorRgb();
-        const c3 = readColorRgb();
-        pts = [prevPts[3], prevPts[4], prevPts[5], prevPts[6], ...readExtra];
-        cols = [prevColors[1], prevColors[2], c2, c3];
-      }
-      prevPts = pts;
-      prevColors = cols;
-      const p00 = pts[0];
-      const p03 = pts[3];
-      const p33 = pts[6];
-      const p30 = pts[9];
-      const c00 = cols[0], c03 = cols[1], c33 = cols[2], c30 = cols[3];
-      const steps = 4;
-      const grid = [];
-      for (let iu = 0; iu <= steps; iu++) {
-        const u = iu / steps;
-        const row = [];
-        for (let iv = 0; iv <= steps; iv++) {
-          const v = iv / steps;
-          const x = (1 - u) * (1 - v) * p00[0] + (1 - u) * v * p03[0] + u * v * p33[0] + u * (1 - v) * p30[0];
-          const y = (1 - u) * (1 - v) * p00[1] + (1 - u) * v * p03[1] + u * v * p33[1] + u * (1 - v) * p30[1];
-          const r = (1 - u) * (1 - v) * c00[0] + (1 - u) * v * c03[0] + u * v * c33[0] + u * (1 - v) * c30[0];
-          const g = (1 - u) * (1 - v) * c00[1] + (1 - u) * v * c03[1] + u * v * c33[1] + u * (1 - v) * c30[1];
-          const b = (1 - u) * (1 - v) * c00[2] + (1 - u) * v * c03[2] + u * v * c33[2] + u * (1 - v) * c30[2];
-          row.push({ x, y, rgb: [r, g, b] });
-        }
-        grid.push(row);
-      }
-      for (let iu = 0; iu < steps; iu++) {
-        for (let iv = 0; iv < steps; iv++) {
-          const g00 = grid[iu][iv];
-          const g01 = grid[iu][iv + 1];
-          const g11 = grid[iu + 1][iv + 1];
-          const g10 = grid[iu + 1][iv];
-          triangles.push([g00, g01, g11], [g00, g11, g10]);
-        }
-      }
-    }
-  }
-  if (triangles.length === 0) return void 0;
+  const numComps = fnNode ? 1 : getColorSpaceComponentCount(doc, csNode);
+  const mesh = new MeshShading(shType, new Stream(bytes), {
+    bitsPerCoordinate: bpcCoord,
+    bitsPerComponent: bpcComp,
+    bitsPerFlag: bpcFlag,
+    decode: decodeNums,
+    numComps,
+    colorFn: null,
+    colorSpace: {
+      numComps,
+      getRgb(components) {
+        const params = Array.from(components);
+        const values = fnNode ? evalShadingFunctionToComponents(doc, fnNode, params) : params;
+        return new Uint8Array(convertColorSpaceComponentsToRgb(doc, csNode, csName, values).map((value) => Math.round(Math.max(0, Math.min(1, value)) * 255)));
+      }
+    }
+  }, vPerRow);
+  const [, , positions, colors, vertexCount] = mesh.getIR();
+  if (vertexCount === 0) return void 0;
   const [bx0, by0, bx1, by1] = targetBox;
   const boxW = Math.max(1, bx1 - bx0);
   const boxH = Math.max(1, by1 - by0);
@@ -11164,10 +11151,10 @@ function renderMeshShadingToImage(doc, shDict, shStream, shType, effectiveCtm, t
     const [px, py] = transformPoint(effectiveCtm, vx, vy);
     return [(px - bx0) / boxW * imgW, (by1 - py) / boxH * imgH];
   };
-  for (const [v0, v1, v2] of triangles) {
-    const [x0, y0] = toImgCoords(v0.x, v0.y);
-    const [x1, y1] = toImgCoords(v1.x, v1.y);
-    const [x2, y2] = toImgCoords(v2.x, v2.y);
+  for (let vertex = 0; vertex < vertexCount; vertex += 3) {
+    const [x0, y0] = toImgCoords(positions[vertex * 2], positions[vertex * 2 + 1]);
+    const [x1, y1] = toImgCoords(positions[vertex * 2 + 2], positions[vertex * 2 + 3]);
+    const [x2, y2] = toImgCoords(positions[vertex * 2 + 4], positions[vertex * 2 + 5]);
     const denom = (y1 - y2) * (x0 - x2) + (x2 - x1) * (y0 - y2);
     if (Math.abs(denom) < 1e-6) continue;
     const minX = Math.max(0, Math.floor(Math.min(x0, x1, x2)));
@@ -11182,13 +11169,12 @@ function renderMeshShadingToImage(doc, shDict, shStream, shType, effectiveCtm, t
         const w1 = ((y2 - y0) * (px - x2) + (x0 - x2) * (py - y2)) / denom;
         const w2 = 1 - w0 - w1;
         if (w0 >= -1e-4 && w1 >= -1e-4 && w2 >= -1e-4) {
-          const r = w0 * v0.rgb[0] + w1 * v1.rgb[0] + w2 * v2.rgb[0];
-          const g = w0 * v0.rgb[1] + w1 * v1.rgb[1] + w2 * v2.rgb[1];
-          const b = w0 * v0.rgb[2] + w1 * v1.rgb[2] + w2 * v2.rgb[2];
           const pIdx = (iy * imgW + ix) * 4;
-          rgba[pIdx] = Math.round(Math.max(0, Math.min(1, r)) * 255);
-          rgba[pIdx + 1] = Math.round(Math.max(0, Math.min(1, g)) * 255);
-          rgba[pIdx + 2] = Math.round(Math.max(0, Math.min(1, b)) * 255);
+          for (let channel = 0; channel < 3; channel++) {
+            rgba[pIdx + channel] = Math.round(
+              w0 * colors[vertex * 4 + channel] + w1 * colors[vertex * 4 + 4 + channel] + w2 * colors[vertex * 4 + 8 + channel]
+            );
+          }
           rgba[pIdx + 3] = a8;
         }
       }
@@ -11275,6 +11261,8 @@ function renderShadingDictToImage(doc, shDict, shadingCtm, targetBox, fillAlpha,
   const [a, b, c, d, e, f] = effectiveCtm;
   const det = a * d - b * c;
   if (Math.abs(det) <= 1e-8) return void 0;
+  const [sa, sb, sc, sd, se, sf] = shadingCtm;
+  const shadingDet = sa * sd - sb * sc;
   const t0Dom = shDomain[0] ?? 0;
   const t1Dom = shDomain[1] ?? 1;
   for (let iy = 0; iy < imgH; iy++) {
@@ -11285,8 +11273,10 @@ function renderShadingDictToImage(doc, shDict, shadingCtm, targetBox, fillAlpha,
       const dxPdf = xPdf - e;
       const xs = (d * dxPdf - c * dyPdf) / det;
       const ys = (-b * dxPdf + a * dyPdf) / det;
-      if (shBBox && (xs < shBBox[0] || xs > shBBox[2] || ys < shBBox[1] || ys > shBBox[3])) {
-        continue;
+      if (shBBox) {
+        const bboxX = (sd * (xPdf - se) - sc * (yPdf - sf)) / shadingDet;
+        const bboxY = (-sb * (xPdf - se) + sa * (yPdf - sf)) / shadingDet;
+        if (bboxX < shBBox[0] || bboxX > shBBox[2] || bboxY < shBBox[1] || bboxY > shBBox[3]) continue;
       }
       let comps;
       if (shType === 1) {
@@ -15338,6 +15328,7 @@ var FONT_IDENTITY_MATRIX;
 var LINE_FACTOR;
 var LINE_DESCENT_FACTOR;
 var BASELINE_FACTOR;
+var MeshFigureType;
 var VerbosityLevel;
 var DrawOPS;
 var PasswordResponses;
@@ -15469,6 +15460,11 @@ var _DEG_TO_RAD;
 var _RAD_TO_DEG;
 var PsJsCompiler;
 var PSStackBasedInterpreter;
+var ShadingType;
+var BaseShading;
+var MeshStreamReader;
+var bCache;
+var MeshShading;
 var PdfError;
 var DEFAULT_MAX_DECODED_BYTES;
 var BoundedFlateStream;
@@ -18958,6 +18954,11 @@ var init_dist = __esm({
     LINE_FACTOR = 1.35;
     LINE_DESCENT_FACTOR = 0.35;
     BASELINE_FACTOR = LINE_DESCENT_FACTOR / LINE_FACTOR;
+    MeshFigureType = {
+      TRIANGLES: 1,
+      LATTICE: 2,
+      PATCH: 3
+    };
     VerbosityLevel = {
       ERRORS: 0,
       WARNINGS: 1,
@@ -39111,6 +39112,603 @@ var init_dist = __esm({
         };
       }
     };
+    ShadingType = {
+      FUNCTION_BASED: 1,
+      AXIAL: 2,
+      RADIAL: 3,
+      FREE_FORM_MESH: 4,
+      LATTICE_FORM_MESH: 5,
+      COONS_PATCH_MESH: 6,
+      TENSOR_PATCH_MESH: 7
+    };
+    BaseShading = class _BaseShading {
+      // A small number to offset the first/last color stops so we can insert ones
+      // to support extend. Number.MIN_VALUE is too small and breaks the extend.
+      static SMALL_NUMBER = 1e-6;
+      constructor() {
+        if ((typeof PDFJSDev === "undefined" || PDFJSDev.test("TESTING")) && this.constructor === _BaseShading) {
+          unreachable2("Cannot initialize BaseShading.");
+        }
+      }
+      getIR() {
+        unreachable2("Abstract method `getIR` called.");
+      }
+    };
+    MeshStreamReader = class {
+      constructor(stream, context) {
+        this.stream = stream;
+        this.context = context;
+        this.buffer = 0;
+        this.bufferLength = 0;
+        const numComps = context.numComps;
+        this.tmpCompsBuf = new Float32Array(numComps);
+        const csNumComps = context.colorSpace.numComps;
+        this.tmpCsCompsBuf = context.colorFn ? new Float32Array(csNumComps) : this.tmpCompsBuf;
+      }
+      get hasData() {
+        if (this.stream.end) {
+          return this.stream.pos < this.stream.end;
+        }
+        if (this.bufferLength > 0) {
+          return true;
+        }
+        const nextByte = this.stream.getByte();
+        if (nextByte < 0) {
+          return false;
+        }
+        this.buffer = nextByte;
+        this.bufferLength = 8;
+        return true;
+      }
+      readBits(n) {
+        const { stream } = this;
+        let { buffer, bufferLength } = this;
+        if (n === 32) {
+          if (bufferLength === 0) {
+            return stream.getInt32() >>> 0;
+          }
+          buffer = buffer << 24 | stream.getByte() << 16 | stream.getByte() << 8 | stream.getByte();
+          const nextByte = stream.getByte();
+          this.buffer = nextByte & (1 << bufferLength) - 1;
+          return (buffer << 8 - bufferLength | (nextByte & 255) >> bufferLength) >>> 0;
+        }
+        if (n === 8 && bufferLength === 0) {
+          return stream.getByte();
+        }
+        while (bufferLength < n) {
+          buffer = buffer << 8 | stream.getByte();
+          bufferLength += 8;
+        }
+        bufferLength -= n;
+        this.bufferLength = bufferLength;
+        this.buffer = buffer & (1 << bufferLength) - 1;
+        return buffer >> bufferLength;
+      }
+      align() {
+        this.buffer = 0;
+        this.bufferLength = 0;
+      }
+      readFlag() {
+        return this.readBits(this.context.bitsPerFlag);
+      }
+      readCoordinate() {
+        const { bitsPerCoordinate, decode } = this.context;
+        const xi = this.readBits(bitsPerCoordinate);
+        const yi = this.readBits(bitsPerCoordinate);
+        const scale = bitsPerCoordinate < 32 ? 1 / ((1 << bitsPerCoordinate) - 1) : 23283064365386963e-26;
+        return [
+          xi * scale * (decode[1] - decode[0]) + decode[0],
+          yi * scale * (decode[3] - decode[2]) + decode[2]
+        ];
+      }
+      readComponents() {
+        const { bitsPerComponent, colorFn, colorSpace, decode, numComps } = this.context;
+        const scale = bitsPerComponent < 32 ? 1 / ((1 << bitsPerComponent) - 1) : 23283064365386963e-26;
+        const components = this.tmpCompsBuf;
+        for (let i = 0, j = 4; i < numComps; i++, j += 2) {
+          const ci = this.readBits(bitsPerComponent);
+          components[i] = ci * scale * (decode[j + 1] - decode[j]) + decode[j];
+        }
+        const color = this.tmpCsCompsBuf;
+        colorFn?.(components, 0, color, 0);
+        return colorSpace.getRgb(color, 0);
+      }
+    };
+    bCache = null;
+    MeshShading = class _MeshShading extends BaseShading {
+      static MIN_SPLIT_PATCH_CHUNKS_AMOUNT = 3;
+      static MAX_SPLIT_PATCH_CHUNKS_AMOUNT = 20;
+      // Count of triangles per entire mesh bounds.
+      static TRIANGLE_DENSITY = 20;
+      constructor(shadingType, stream, context, rowVertices) {
+        super();
+        this.shadingType = shadingType;
+        this.bbox = this.background = null;
+        this.coords = [];
+        this.colors = [];
+        this.figures = [];
+        const reader = new MeshStreamReader(stream, context);
+        let patchMesh = false;
+        switch (this.shadingType) {
+          case ShadingType.FREE_FORM_MESH:
+            this._decodeType4Shading(reader);
+            break;
+          case ShadingType.LATTICE_FORM_MESH:
+            const verticesPerRow = rowVertices | 0;
+            if (verticesPerRow < 2) {
+              throw new FormatError("Invalid VerticesPerRow");
+            }
+            this._decodeType5Shading(reader, verticesPerRow);
+            break;
+          case ShadingType.COONS_PATCH_MESH:
+            this._decodeType6Shading(reader);
+            patchMesh = true;
+            break;
+          case ShadingType.TENSOR_PATCH_MESH:
+            this._decodeType7Shading(reader);
+            patchMesh = true;
+            break;
+          default:
+            unreachable2("Unsupported mesh type.");
+            break;
+        }
+        if (patchMesh) {
+          this._updateBounds();
+          for (let i = 0, ii = this.figures.length; i < ii; i++) {
+            this._buildFigureFromPatch(i);
+          }
+        }
+        this._updateBounds();
+        this._packData();
+      }
+      _decodeType4Shading(reader) {
+        const coords = this.coords;
+        const colors = this.colors;
+        const operators = [];
+        const ps = [];
+        let verticesLeft = 0;
+        while (reader.hasData) {
+          const f = reader.readFlag();
+          const coord = reader.readCoordinate();
+          const color = reader.readComponents();
+          if (verticesLeft === 0) {
+            if (!(0 <= f && f <= 2)) {
+              throw new FormatError("Unknown type4 flag");
+            }
+            switch (f) {
+              case 0:
+                verticesLeft = 3;
+                break;
+              case 1:
+                ps.push(ps.at(-2), ps.at(-1));
+                verticesLeft = 1;
+                break;
+              case 2:
+                ps.push(ps.at(-3), ps.at(-1));
+                verticesLeft = 1;
+                break;
+            }
+            operators.push(f);
+          }
+          ps.push(coords.length);
+          coords.push(coord);
+          colors.push(color);
+          verticesLeft--;
+          reader.align();
+        }
+        this.figures.push({
+          type: MeshFigureType.TRIANGLES,
+          coords: new Int32Array(ps),
+          colors: new Int32Array(ps)
+        });
+      }
+      _decodeType5Shading(reader, verticesPerRow) {
+        const coords = this.coords;
+        const colors = this.colors;
+        const ps = [];
+        while (reader.hasData) {
+          const coord = reader.readCoordinate();
+          const color = reader.readComponents();
+          ps.push(coords.length);
+          coords.push(coord);
+          colors.push(color);
+        }
+        this.figures.push({
+          type: MeshFigureType.LATTICE,
+          coords: new Int32Array(ps),
+          colors: new Int32Array(ps),
+          verticesPerRow
+        });
+      }
+      _decodeType6Shading(reader) {
+        const coords = this.coords;
+        const colors = this.colors;
+        const ps = new Int32Array(16);
+        const cs = new Int32Array(4);
+        while (reader.hasData) {
+          const f = reader.readFlag();
+          if (!(0 <= f && f <= 3)) {
+            throw new FormatError("Unknown type6 flag");
+          }
+          const pi = coords.length;
+          for (let i = 0, ii = f !== 0 ? 8 : 12; i < ii; i++) {
+            coords.push(reader.readCoordinate());
+          }
+          const ci = colors.length;
+          for (let i = 0, ii = f !== 0 ? 2 : 4; i < ii; i++) {
+            colors.push(reader.readComponents());
+          }
+          let tmp1, tmp2, tmp3, tmp4;
+          switch (f) {
+            // prettier-ignore
+            case 0:
+              ps[12] = pi + 3;
+              ps[13] = pi + 4;
+              ps[14] = pi + 5;
+              ps[15] = pi + 6;
+              ps[8] = pi + 2;
+              ps[11] = pi + 7;
+              ps[4] = pi + 1;
+              ps[7] = pi + 8;
+              ps[0] = pi;
+              ps[1] = pi + 11;
+              ps[2] = pi + 10;
+              ps[3] = pi + 9;
+              cs[2] = ci + 1;
+              cs[3] = ci + 2;
+              cs[0] = ci;
+              cs[1] = ci + 3;
+              break;
+            // prettier-ignore
+            case 1:
+              tmp1 = ps[12];
+              tmp2 = ps[13];
+              tmp3 = ps[14];
+              tmp4 = ps[15];
+              ps[12] = tmp4;
+              ps[13] = pi + 0;
+              ps[14] = pi + 1;
+              ps[15] = pi + 2;
+              ps[8] = tmp3;
+              ps[11] = pi + 3;
+              ps[4] = tmp2;
+              ps[7] = pi + 4;
+              ps[0] = tmp1;
+              ps[1] = pi + 7;
+              ps[2] = pi + 6;
+              ps[3] = pi + 5;
+              tmp1 = cs[2];
+              tmp2 = cs[3];
+              cs[2] = tmp2;
+              cs[3] = ci;
+              cs[0] = tmp1;
+              cs[1] = ci + 1;
+              break;
+            // prettier-ignore
+            case 2:
+              tmp1 = ps[15];
+              tmp2 = ps[11];
+              ps[12] = ps[3];
+              ps[13] = pi + 0;
+              ps[14] = pi + 1;
+              ps[15] = pi + 2;
+              ps[8] = ps[7];
+              ps[11] = pi + 3;
+              ps[4] = tmp2;
+              ps[7] = pi + 4;
+              ps[0] = tmp1;
+              ps[1] = pi + 7;
+              ps[2] = pi + 6;
+              ps[3] = pi + 5;
+              tmp1 = cs[3];
+              cs[2] = cs[1];
+              cs[3] = ci;
+              cs[0] = tmp1;
+              cs[1] = ci + 1;
+              break;
+            // prettier-ignore
+            case 3:
+              ps[12] = ps[0];
+              ps[13] = pi + 0;
+              ps[14] = pi + 1;
+              ps[15] = pi + 2;
+              ps[8] = ps[1];
+              ps[11] = pi + 3;
+              ps[4] = ps[2];
+              ps[7] = pi + 4;
+              ps[0] = ps[3];
+              ps[1] = pi + 7;
+              ps[2] = pi + 6;
+              ps[3] = pi + 5;
+              cs[2] = cs[0];
+              cs[3] = ci;
+              cs[0] = cs[1];
+              cs[1] = ci + 1;
+              break;
+          }
+          ps[5] = coords.length;
+          coords.push([
+            (-4 * coords[ps[0]][0] - coords[ps[15]][0] + 6 * (coords[ps[4]][0] + coords[ps[1]][0]) - 2 * (coords[ps[12]][0] + coords[ps[3]][0]) + 3 * (coords[ps[13]][0] + coords[ps[7]][0])) / 9,
+            (-4 * coords[ps[0]][1] - coords[ps[15]][1] + 6 * (coords[ps[4]][1] + coords[ps[1]][1]) - 2 * (coords[ps[12]][1] + coords[ps[3]][1]) + 3 * (coords[ps[13]][1] + coords[ps[7]][1])) / 9
+          ]);
+          ps[6] = coords.length;
+          coords.push([
+            (-4 * coords[ps[3]][0] - coords[ps[12]][0] + 6 * (coords[ps[2]][0] + coords[ps[7]][0]) - 2 * (coords[ps[0]][0] + coords[ps[15]][0]) + 3 * (coords[ps[4]][0] + coords[ps[14]][0])) / 9,
+            (-4 * coords[ps[3]][1] - coords[ps[12]][1] + 6 * (coords[ps[2]][1] + coords[ps[7]][1]) - 2 * (coords[ps[0]][1] + coords[ps[15]][1]) + 3 * (coords[ps[4]][1] + coords[ps[14]][1])) / 9
+          ]);
+          ps[9] = coords.length;
+          coords.push([
+            (-4 * coords[ps[12]][0] - coords[ps[3]][0] + 6 * (coords[ps[8]][0] + coords[ps[13]][0]) - 2 * (coords[ps[0]][0] + coords[ps[15]][0]) + 3 * (coords[ps[11]][0] + coords[ps[1]][0])) / 9,
+            (-4 * coords[ps[12]][1] - coords[ps[3]][1] + 6 * (coords[ps[8]][1] + coords[ps[13]][1]) - 2 * (coords[ps[0]][1] + coords[ps[15]][1]) + 3 * (coords[ps[11]][1] + coords[ps[1]][1])) / 9
+          ]);
+          ps[10] = coords.length;
+          coords.push([
+            (-4 * coords[ps[15]][0] - coords[ps[0]][0] + 6 * (coords[ps[11]][0] + coords[ps[14]][0]) - 2 * (coords[ps[12]][0] + coords[ps[3]][0]) + 3 * (coords[ps[2]][0] + coords[ps[8]][0])) / 9,
+            (-4 * coords[ps[15]][1] - coords[ps[0]][1] + 6 * (coords[ps[11]][1] + coords[ps[14]][1]) - 2 * (coords[ps[12]][1] + coords[ps[3]][1]) + 3 * (coords[ps[2]][1] + coords[ps[8]][1])) / 9
+          ]);
+          this.figures.push({
+            type: MeshFigureType.PATCH,
+            coords: new Int32Array(ps),
+            // making copies of ps and cs
+            colors: new Int32Array(cs)
+          });
+        }
+      }
+      _decodeType7Shading(reader) {
+        const coords = this.coords;
+        const colors = this.colors;
+        const ps = new Int32Array(16);
+        const cs = new Int32Array(4);
+        while (reader.hasData) {
+          const f = reader.readFlag();
+          if (!(0 <= f && f <= 3)) {
+            throw new FormatError("Unknown type7 flag");
+          }
+          const pi = coords.length;
+          for (let i = 0, ii = f !== 0 ? 12 : 16; i < ii; i++) {
+            coords.push(reader.readCoordinate());
+          }
+          const ci = colors.length;
+          for (let i = 0, ii = f !== 0 ? 2 : 4; i < ii; i++) {
+            colors.push(reader.readComponents());
+          }
+          let tmp1, tmp2, tmp3, tmp4;
+          switch (f) {
+            // prettier-ignore
+            case 0:
+              ps[12] = pi + 3;
+              ps[13] = pi + 4;
+              ps[14] = pi + 5;
+              ps[15] = pi + 6;
+              ps[8] = pi + 2;
+              ps[9] = pi + 13;
+              ps[10] = pi + 14;
+              ps[11] = pi + 7;
+              ps[4] = pi + 1;
+              ps[5] = pi + 12;
+              ps[6] = pi + 15;
+              ps[7] = pi + 8;
+              ps[0] = pi;
+              ps[1] = pi + 11;
+              ps[2] = pi + 10;
+              ps[3] = pi + 9;
+              cs[2] = ci + 1;
+              cs[3] = ci + 2;
+              cs[0] = ci;
+              cs[1] = ci + 3;
+              break;
+            // prettier-ignore
+            case 1:
+              tmp1 = ps[12];
+              tmp2 = ps[13];
+              tmp3 = ps[14];
+              tmp4 = ps[15];
+              ps[12] = tmp4;
+              ps[13] = pi + 0;
+              ps[14] = pi + 1;
+              ps[15] = pi + 2;
+              ps[8] = tmp3;
+              ps[9] = pi + 9;
+              ps[10] = pi + 10;
+              ps[11] = pi + 3;
+              ps[4] = tmp2;
+              ps[5] = pi + 8;
+              ps[6] = pi + 11;
+              ps[7] = pi + 4;
+              ps[0] = tmp1;
+              ps[1] = pi + 7;
+              ps[2] = pi + 6;
+              ps[3] = pi + 5;
+              tmp1 = cs[2];
+              tmp2 = cs[3];
+              cs[2] = tmp2;
+              cs[3] = ci;
+              cs[0] = tmp1;
+              cs[1] = ci + 1;
+              break;
+            // prettier-ignore
+            case 2:
+              tmp1 = ps[15];
+              tmp2 = ps[11];
+              ps[12] = ps[3];
+              ps[13] = pi + 0;
+              ps[14] = pi + 1;
+              ps[15] = pi + 2;
+              ps[8] = ps[7];
+              ps[9] = pi + 9;
+              ps[10] = pi + 10;
+              ps[11] = pi + 3;
+              ps[4] = tmp2;
+              ps[5] = pi + 8;
+              ps[6] = pi + 11;
+              ps[7] = pi + 4;
+              ps[0] = tmp1;
+              ps[1] = pi + 7;
+              ps[2] = pi + 6;
+              ps[3] = pi + 5;
+              tmp1 = cs[3];
+              cs[2] = cs[1];
+              cs[3] = ci;
+              cs[0] = tmp1;
+              cs[1] = ci + 1;
+              break;
+            // prettier-ignore
+            case 3:
+              ps[12] = ps[0];
+              ps[13] = pi + 0;
+              ps[14] = pi + 1;
+              ps[15] = pi + 2;
+              ps[8] = ps[1];
+              ps[9] = pi + 9;
+              ps[10] = pi + 10;
+              ps[11] = pi + 3;
+              ps[4] = ps[2];
+              ps[5] = pi + 8;
+              ps[6] = pi + 11;
+              ps[7] = pi + 4;
+              ps[0] = ps[3];
+              ps[1] = pi + 7;
+              ps[2] = pi + 6;
+              ps[3] = pi + 5;
+              cs[2] = cs[0];
+              cs[3] = ci;
+              cs[0] = cs[1];
+              cs[1] = ci + 1;
+              break;
+          }
+          this.figures.push({
+            type: MeshFigureType.PATCH,
+            coords: new Int32Array(ps),
+            // making copies of ps and cs
+            colors: new Int32Array(cs)
+          });
+        }
+      }
+      _buildFigureFromPatch(index) {
+        const figure = this.figures[index];
+        assert2(
+          figure.type === MeshFigureType.PATCH,
+          "Unexpected patch mesh figure"
+        );
+        const coords = this.coords, colors = this.colors;
+        const pi = figure.coords;
+        const ci = figure.colors;
+        const figureMinX = Math.min(
+          coords[pi[0]][0],
+          coords[pi[3]][0],
+          coords[pi[12]][0],
+          coords[pi[15]][0]
+        );
+        const figureMinY = Math.min(
+          coords[pi[0]][1],
+          coords[pi[3]][1],
+          coords[pi[12]][1],
+          coords[pi[15]][1]
+        );
+        const figureMaxX = Math.max(
+          coords[pi[0]][0],
+          coords[pi[3]][0],
+          coords[pi[12]][0],
+          coords[pi[15]][0]
+        );
+        const figureMaxY = Math.max(
+          coords[pi[0]][1],
+          coords[pi[3]][1],
+          coords[pi[12]][1],
+          coords[pi[15]][1]
+        );
+        let splitXBy = Math.ceil(
+          (figureMaxX - figureMinX) * _MeshShading.TRIANGLE_DENSITY / (this.bounds[2] - this.bounds[0])
+        );
+        splitXBy = MathClamp(
+          splitXBy,
+          _MeshShading.MIN_SPLIT_PATCH_CHUNKS_AMOUNT,
+          _MeshShading.MAX_SPLIT_PATCH_CHUNKS_AMOUNT
+        );
+        let splitYBy = Math.ceil(
+          (figureMaxY - figureMinY) * _MeshShading.TRIANGLE_DENSITY / (this.bounds[3] - this.bounds[1])
+        );
+        splitYBy = MathClamp(
+          splitYBy,
+          _MeshShading.MIN_SPLIT_PATCH_CHUNKS_AMOUNT,
+          _MeshShading.MAX_SPLIT_PATCH_CHUNKS_AMOUNT
+        );
+        const verticesPerRow = splitXBy + 1;
+        const figureCoords = new Int32Array((splitYBy + 1) * verticesPerRow);
+        const figureColors = new Int32Array((splitYBy + 1) * verticesPerRow);
+        let k = 0;
+        const cl = new Uint8Array(3), cr = new Uint8Array(3);
+        const c0 = colors[ci[0]], c1 = colors[ci[1]], c2 = colors[ci[2]], c3 = colors[ci[3]];
+        const bRow = getB(splitYBy), bCol = getB(splitXBy);
+        for (let row = 0; row <= splitYBy; row++) {
+          cl[0] = (c0[0] * (splitYBy - row) + c2[0] * row) / splitYBy | 0;
+          cl[1] = (c0[1] * (splitYBy - row) + c2[1] * row) / splitYBy | 0;
+          cl[2] = (c0[2] * (splitYBy - row) + c2[2] * row) / splitYBy | 0;
+          cr[0] = (c1[0] * (splitYBy - row) + c3[0] * row) / splitYBy | 0;
+          cr[1] = (c1[1] * (splitYBy - row) + c3[1] * row) / splitYBy | 0;
+          cr[2] = (c1[2] * (splitYBy - row) + c3[2] * row) / splitYBy | 0;
+          for (let col = 0; col <= splitXBy; col++, k++) {
+            if ((row === 0 || row === splitYBy) && (col === 0 || col === splitXBy)) {
+              continue;
+            }
+            let x = 0, y = 0;
+            let q = 0;
+            for (let i = 0; i <= 3; i++) {
+              for (let j = 0; j <= 3; j++, q++) {
+                const m = bRow[row][i] * bCol[col][j];
+                x += coords[pi[q]][0] * m;
+                y += coords[pi[q]][1] * m;
+              }
+            }
+            figureCoords[k] = coords.length;
+            coords.push([x, y]);
+            figureColors[k] = colors.length;
+            const newColor = new Uint8Array(3);
+            newColor[0] = (cl[0] * (splitXBy - col) + cr[0] * col) / splitXBy | 0;
+            newColor[1] = (cl[1] * (splitXBy - col) + cr[1] * col) / splitXBy | 0;
+            newColor[2] = (cl[2] * (splitXBy - col) + cr[2] * col) / splitXBy | 0;
+            colors.push(newColor);
+          }
+        }
+        figureCoords[0] = pi[0];
+        figureColors[0] = ci[0];
+        figureCoords[splitXBy] = pi[3];
+        figureColors[splitXBy] = ci[1];
+        figureCoords[verticesPerRow * splitYBy] = pi[12];
+        figureColors[verticesPerRow * splitYBy] = ci[2];
+        figureCoords[verticesPerRow * splitYBy + splitXBy] = pi[15];
+        figureColors[verticesPerRow * splitYBy + splitXBy] = ci[3];
+        this.figures[index] = {
+          type: MeshFigureType.LATTICE,
+          coords: figureCoords,
+          colors: figureColors,
+          verticesPerRow
+        };
+      }
+      _updateBounds() {
+        meshUpdateBounds(this);
+      }
+      _packData() {
+        meshPackData(this);
+      }
+      getIR() {
+        const { posData, colData, vertexCount } = buildMeshVertexData(
+          this.coords,
+          this.colors,
+          this.figures
+        );
+        return [
+          "Mesh",
+          this.shadingType,
+          posData,
+          colData,
+          vertexCount,
+          this.bounds,
+          this.bbox,
+          this.background
+        ];
+      }
+    };
     PdfError = class extends Error {
       constructor(code, message) {
         super(message);