@poe-platform/safe-bash 0.1.773 → 0.1.774

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

@@ -3588,6 +3588,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,
@@ -25120,6 +25125,700 @@ function buildPostScriptJsFunction(source, domain, range, forceInterpreter = fal
   }
   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
+    ];
+  }
+};
 var PdfError = class extends Error {
   constructor(code, message) {
     super(message);
@@ -28025,11 +28724,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) {
@@ -37397,143 +38101,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);
@@ -37545,10 +38134,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)));
@@ -37563,13 +38152,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;
         }
       }
@@ -37656,6 +38244,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++) {
@@ -37666,8 +38256,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) {