@pol-studios/db 1.0.8 → 1.0.10

package/dist/canvas-75Y7XMF3.js

@@ -0,0 +1,1541 @@
+import {
+  __commonJS,
+  __esm,
+  __require
+} from "./chunk-P4UZ7IXC.js";
+
+// ../../../node_modules/.pnpm/canvas@2.11.2_encoding@0.1.13/node_modules/canvas/build/Release/canvas.node
+var canvas_default;
+var init_canvas = __esm({
+  "../../../node_modules/.pnpm/canvas@2.11.2_encoding@0.1.13/node_modules/canvas/build/Release/canvas.node"() {
+    canvas_default = "./canvas-UVNDA54X.node";
+  }
+});
+
+// node-file:/Users/jpsaccount/Repos/POL-One/node_modules/.pnpm/canvas@2.11.2_encoding@0.1.13/node_modules/canvas/build/Release/canvas.node
+var require_canvas = __commonJS({
+  "node-file:/Users/jpsaccount/Repos/POL-One/node_modules/.pnpm/canvas@2.11.2_encoding@0.1.13/node_modules/canvas/build/Release/canvas.node"(exports, module) {
+    init_canvas();
+    try {
+      module.exports = __require(canvas_default);
+    } catch {
+    }
+  }
+});
+
+// ../../../node_modules/.pnpm/canvas@2.11.2_encoding@0.1.13/node_modules/canvas/lib/bindings.js
+var require_bindings = __commonJS({
+  "../../../node_modules/.pnpm/canvas@2.11.2_encoding@0.1.13/node_modules/canvas/lib/bindings.js"(exports, module) {
+    "use strict";
+    var bindings = require_canvas();
+    module.exports = bindings;
+    bindings.ImageData.prototype.toString = function() {
+      return "[object ImageData]";
+    };
+    bindings.CanvasGradient.prototype.toString = function() {
+      return "[object CanvasGradient]";
+    };
+  }
+});
+
+// ../../../node_modules/.pnpm/canvas@2.11.2_encoding@0.1.13/node_modules/canvas/lib/parse-font.js
+var require_parse_font = __commonJS({
+  "../../../node_modules/.pnpm/canvas@2.11.2_encoding@0.1.13/node_modules/canvas/lib/parse-font.js"(exports, module) {
+    "use strict";
+    var weights = "bold|bolder|lighter|[1-9]00";
+    var styles = "italic|oblique";
+    var variants = "small-caps";
+    var stretches = "ultra-condensed|extra-condensed|condensed|semi-condensed|semi-expanded|expanded|extra-expanded|ultra-expanded";
+    var units = "px|pt|pc|in|cm|mm|%|em|ex|ch|rem|q";
+    var string = `'([^']+)'|"([^"]+)"|[\\w\\s-]+`;
+    var weightRe = new RegExp(`(${weights}) +`, "i");
+    var styleRe = new RegExp(`(${styles}) +`, "i");
+    var variantRe = new RegExp(`(${variants}) +`, "i");
+    var stretchRe = new RegExp(`(${stretches}) +`, "i");
+    var sizeFamilyRe = new RegExp(
+      `([\\d\\.]+)(${units}) *((?:${string})( *, *(?:${string}))*)`
+    );
+    var cache = {};
+    var defaultHeight = 16;
+    module.exports = (str) => {
+      if (cache[str]) return cache[str];
+      const sizeFamily = sizeFamilyRe.exec(str);
+      if (!sizeFamily) return;
+      const font = {
+        weight: "normal",
+        style: "normal",
+        stretch: "normal",
+        variant: "normal",
+        size: parseFloat(sizeFamily[1]),
+        unit: sizeFamily[2],
+        family: sizeFamily[3].replace(/["']/g, "").replace(/ *, */g, ",")
+      };
+      let weight, style, variant, stretch;
+      const substr = str.substring(0, sizeFamily.index);
+      if (weight = weightRe.exec(substr)) font.weight = weight[1];
+      if (style = styleRe.exec(substr)) font.style = style[1];
+      if (variant = variantRe.exec(substr)) font.variant = variant[1];
+      if (stretch = stretchRe.exec(substr)) font.stretch = stretch[1];
+      switch (font.unit) {
+        case "pt":
+          font.size /= 0.75;
+          break;
+        case "pc":
+          font.size *= 16;
+          break;
+        case "in":
+          font.size *= 96;
+          break;
+        case "cm":
+          font.size *= 96 / 2.54;
+          break;
+        case "mm":
+          font.size *= 96 / 25.4;
+          break;
+        case "%":
+          break;
+        case "em":
+        case "rem":
+          font.size *= defaultHeight / 0.75;
+          break;
+        case "q":
+          font.size *= 96 / 25.4 / 4;
+          break;
+      }
+      return cache[str] = font;
+    };
+  }
+});
+
+// ../../../node_modules/.pnpm/canvas@2.11.2_encoding@0.1.13/node_modules/canvas/lib/DOMMatrix.js
+var require_DOMMatrix = __commonJS({
+  "../../../node_modules/.pnpm/canvas@2.11.2_encoding@0.1.13/node_modules/canvas/lib/DOMMatrix.js"(exports, module) {
+    "use strict";
+    var util = __require("util");
+    var DOMPoint = class {
+      constructor(x, y, z, w) {
+        if (typeof x === "object" && x !== null) {
+          w = x.w;
+          z = x.z;
+          y = x.y;
+          x = x.x;
+        }
+        this.x = typeof x === "number" ? x : 0;
+        this.y = typeof y === "number" ? y : 0;
+        this.z = typeof z === "number" ? z : 0;
+        this.w = typeof w === "number" ? w : 1;
+      }
+    };
+    var M11 = 0;
+    var M12 = 1;
+    var M13 = 2;
+    var M14 = 3;
+    var M21 = 4;
+    var M22 = 5;
+    var M23 = 6;
+    var M24 = 7;
+    var M31 = 8;
+    var M32 = 9;
+    var M33 = 10;
+    var M34 = 11;
+    var M41 = 12;
+    var M42 = 13;
+    var M43 = 14;
+    var M44 = 15;
+    var DEGREE_PER_RAD = 180 / Math.PI;
+    var RAD_PER_DEGREE = Math.PI / 180;
+    function parseMatrix(init) {
+      let parsed = init.replace("matrix(", "");
+      parsed = parsed.split(",", 7);
+      if (parsed.length !== 6) throw new Error(`Failed to parse ${init}`);
+      parsed = parsed.map(parseFloat);
+      return [
+        parsed[0],
+        parsed[1],
+        0,
+        0,
+        parsed[2],
+        parsed[3],
+        0,
+        0,
+        0,
+        0,
+        1,
+        0,
+        parsed[4],
+        parsed[5],
+        0,
+        1
+      ];
+    }
+    function parseMatrix3d(init) {
+      let parsed = init.replace("matrix3d(", "");
+      parsed = parsed.split(",", 17);
+      if (parsed.length !== 16) throw new Error(`Failed to parse ${init}`);
+      return parsed.map(parseFloat);
+    }
+    function parseTransform(tform) {
+      const type = tform.split("(", 1)[0];
+      switch (type) {
+        case "matrix":
+          return parseMatrix(tform);
+        case "matrix3d":
+          return parseMatrix3d(tform);
+        // TODO This is supposed to support any CSS transform value.
+        default:
+          throw new Error(`${type} parsing not implemented`);
+      }
+    }
+    var DOMMatrix = class _DOMMatrix {
+      constructor(init) {
+        this._is2D = true;
+        this._values = new Float64Array([
+          1,
+          0,
+          0,
+          0,
+          0,
+          1,
+          0,
+          0,
+          0,
+          0,
+          1,
+          0,
+          0,
+          0,
+          0,
+          1
+        ]);
+        let i;
+        if (typeof init === "string") {
+          if (init === "") return;
+          const tforms = init.split(/\)\s+/, 20).map(parseTransform);
+          if (tforms.length === 0) return;
+          init = tforms[0];
+          for (i = 1; i < tforms.length; i++) init = multiply(tforms[i], init);
+        }
+        i = 0;
+        if (init && init.length === 6) {
+          setNumber2D(this, M11, init[i++]);
+          setNumber2D(this, M12, init[i++]);
+          setNumber2D(this, M21, init[i++]);
+          setNumber2D(this, M22, init[i++]);
+          setNumber2D(this, M41, init[i++]);
+          setNumber2D(this, M42, init[i++]);
+        } else if (init && init.length === 16) {
+          setNumber2D(this, M11, init[i++]);
+          setNumber2D(this, M12, init[i++]);
+          setNumber3D(this, M13, init[i++]);
+          setNumber3D(this, M14, init[i++]);
+          setNumber2D(this, M21, init[i++]);
+          setNumber2D(this, M22, init[i++]);
+          setNumber3D(this, M23, init[i++]);
+          setNumber3D(this, M24, init[i++]);
+          setNumber3D(this, M31, init[i++]);
+          setNumber3D(this, M32, init[i++]);
+          setNumber3D(this, M33, init[i++]);
+          setNumber3D(this, M34, init[i++]);
+          setNumber2D(this, M41, init[i++]);
+          setNumber2D(this, M42, init[i++]);
+          setNumber3D(this, M43, init[i++]);
+          setNumber3D(this, M44, init[i]);
+        } else if (init !== void 0) {
+          throw new TypeError("Expected string or array.");
+        }
+      }
+      toString() {
+        return this.is2D ? `matrix(${this.a}, ${this.b}, ${this.c}, ${this.d}, ${this.e}, ${this.f})` : `matrix3d(${this._values.join(", ")})`;
+      }
+      multiply(other) {
+        return newInstance(this._values).multiplySelf(other);
+      }
+      multiplySelf(other) {
+        this._values = multiply(other._values, this._values);
+        if (!other.is2D) this._is2D = false;
+        return this;
+      }
+      preMultiplySelf(other) {
+        this._values = multiply(this._values, other._values);
+        if (!other.is2D) this._is2D = false;
+        return this;
+      }
+      translate(tx, ty, tz) {
+        return newInstance(this._values).translateSelf(tx, ty, tz);
+      }
+      translateSelf(tx, ty, tz) {
+        if (typeof tx !== "number") tx = 0;
+        if (typeof ty !== "number") ty = 0;
+        if (typeof tz !== "number") tz = 0;
+        this._values = multiply([
+          1,
+          0,
+          0,
+          0,
+          0,
+          1,
+          0,
+          0,
+          0,
+          0,
+          1,
+          0,
+          tx,
+          ty,
+          tz,
+          1
+        ], this._values);
+        if (tz !== 0) this._is2D = false;
+        return this;
+      }
+      scale(scaleX, scaleY, scaleZ, originX, originY, originZ) {
+        return newInstance(this._values).scaleSelf(scaleX, scaleY, scaleZ, originX, originY, originZ);
+      }
+      scale3d(scale, originX, originY, originZ) {
+        return newInstance(this._values).scale3dSelf(scale, originX, originY, originZ);
+      }
+      scale3dSelf(scale, originX, originY, originZ) {
+        return this.scaleSelf(scale, scale, scale, originX, originY, originZ);
+      }
+      scaleSelf(scaleX, scaleY, scaleZ, originX, originY, originZ) {
+        if (typeof originX !== "number") originX = 0;
+        if (typeof originY !== "number") originY = 0;
+        if (typeof originZ !== "number") originZ = 0;
+        this.translateSelf(originX, originY, originZ);
+        if (typeof scaleX !== "number") scaleX = 1;
+        if (typeof scaleY !== "number") scaleY = scaleX;
+        if (typeof scaleZ !== "number") scaleZ = 1;
+        this._values = multiply([
+          scaleX,
+          0,
+          0,
+          0,
+          0,
+          scaleY,
+          0,
+          0,
+          0,
+          0,
+          scaleZ,
+          0,
+          0,
+          0,
+          0,
+          1
+        ], this._values);
+        this.translateSelf(-originX, -originY, -originZ);
+        if (scaleZ !== 1 || originZ !== 0) this._is2D = false;
+        return this;
+      }
+      rotateFromVector(x, y) {
+        return newInstance(this._values).rotateFromVectorSelf(x, y);
+      }
+      rotateFromVectorSelf(x, y) {
+        if (typeof x !== "number") x = 0;
+        if (typeof y !== "number") y = 0;
+        const theta = x === 0 && y === 0 ? 0 : Math.atan2(y, x) * DEGREE_PER_RAD;
+        return this.rotateSelf(theta);
+      }
+      rotate(rotX, rotY, rotZ) {
+        return newInstance(this._values).rotateSelf(rotX, rotY, rotZ);
+      }
+      rotateSelf(rotX, rotY, rotZ) {
+        if (rotY === void 0 && rotZ === void 0) {
+          rotZ = rotX;
+          rotX = rotY = 0;
+        }
+        if (typeof rotY !== "number") rotY = 0;
+        if (typeof rotZ !== "number") rotZ = 0;
+        if (rotX !== 0 || rotY !== 0) this._is2D = false;
+        rotX *= RAD_PER_DEGREE;
+        rotY *= RAD_PER_DEGREE;
+        rotZ *= RAD_PER_DEGREE;
+        let c, s;
+        c = Math.cos(rotZ);
+        s = Math.sin(rotZ);
+        this._values = multiply([
+          c,
+          s,
+          0,
+          0,
+          -s,
+          c,
+          0,
+          0,
+          0,
+          0,
+          1,
+          0,
+          0,
+          0,
+          0,
+          1
+        ], this._values);
+        c = Math.cos(rotY);
+        s = Math.sin(rotY);
+        this._values = multiply([
+          c,
+          0,
+          -s,
+          0,
+          0,
+          1,
+          0,
+          0,
+          s,
+          0,
+          c,
+          0,
+          0,
+          0,
+          0,
+          1
+        ], this._values);
+        c = Math.cos(rotX);
+        s = Math.sin(rotX);
+        this._values = multiply([
+          1,
+          0,
+          0,
+          0,
+          0,
+          c,
+          s,
+          0,
+          0,
+          -s,
+          c,
+          0,
+          0,
+          0,
+          0,
+          1
+        ], this._values);
+        return this;
+      }
+      rotateAxisAngle(x, y, z, angle) {
+        return newInstance(this._values).rotateAxisAngleSelf(x, y, z, angle);
+      }
+      rotateAxisAngleSelf(x, y, z, angle) {
+        if (typeof x !== "number") x = 0;
+        if (typeof y !== "number") y = 0;
+        if (typeof z !== "number") z = 0;
+        const length = Math.sqrt(x * x + y * y + z * z);
+        if (length === 0) return this;
+        if (length !== 1) {
+          x /= length;
+          y /= length;
+          z /= length;
+        }
+        angle *= RAD_PER_DEGREE;
+        const c = Math.cos(angle);
+        const s = Math.sin(angle);
+        const t = 1 - c;
+        const tx = t * x;
+        const ty = t * y;
+        this._values = multiply([
+          tx * x + c,
+          tx * y + s * z,
+          tx * z - s * y,
+          0,
+          tx * y - s * z,
+          ty * y + c,
+          ty * z + s * x,
+          0,
+          tx * z + s * y,
+          ty * z - s * x,
+          t * z * z + c,
+          0,
+          0,
+          0,
+          0,
+          1
+        ], this._values);
+        if (x !== 0 || y !== 0) this._is2D = false;
+        return this;
+      }
+      skewX(sx) {
+        return newInstance(this._values).skewXSelf(sx);
+      }
+      skewXSelf(sx) {
+        if (typeof sx !== "number") return this;
+        const t = Math.tan(sx * RAD_PER_DEGREE);
+        this._values = multiply([
+          1,
+          0,
+          0,
+          0,
+          t,
+          1,
+          0,
+          0,
+          0,
+          0,
+          1,
+          0,
+          0,
+          0,
+          0,
+          1
+        ], this._values);
+        return this;
+      }
+      skewY(sy) {
+        return newInstance(this._values).skewYSelf(sy);
+      }
+      skewYSelf(sy) {
+        if (typeof sy !== "number") return this;
+        const t = Math.tan(sy * RAD_PER_DEGREE);
+        this._values = multiply([
+          1,
+          t,
+          0,
+          0,
+          0,
+          1,
+          0,
+          0,
+          0,
+          0,
+          1,
+          0,
+          0,
+          0,
+          0,
+          1
+        ], this._values);
+        return this;
+      }
+      flipX() {
+        return newInstance(multiply([
+          -1,
+          0,
+          0,
+          0,
+          0,
+          1,
+          0,
+          0,
+          0,
+          0,
+          1,
+          0,
+          0,
+          0,
+          0,
+          1
+        ], this._values));
+      }
+      flipY() {
+        return newInstance(multiply([
+          1,
+          0,
+          0,
+          0,
+          0,
+          -1,
+          0,
+          0,
+          0,
+          0,
+          1,
+          0,
+          0,
+          0,
+          0,
+          1
+        ], this._values));
+      }
+      inverse() {
+        return newInstance(this._values).invertSelf();
+      }
+      invertSelf() {
+        const m = this._values;
+        const inv = m.map((v) => 0);
+        inv[0] = m[5] * m[10] * m[15] - m[5] * m[11] * m[14] - m[9] * m[6] * m[15] + m[9] * m[7] * m[14] + m[13] * m[6] * m[11] - m[13] * m[7] * m[10];
+        inv[4] = -m[4] * m[10] * m[15] + m[4] * m[11] * m[14] + m[8] * m[6] * m[15] - m[8] * m[7] * m[14] - m[12] * m[6] * m[11] + m[12] * m[7] * m[10];
+        inv[8] = m[4] * m[9] * m[15] - m[4] * m[11] * m[13] - m[8] * m[5] * m[15] + m[8] * m[7] * m[13] + m[12] * m[5] * m[11] - m[12] * m[7] * m[9];
+        inv[12] = -m[4] * m[9] * m[14] + m[4] * m[10] * m[13] + m[8] * m[5] * m[14] - m[8] * m[6] * m[13] - m[12] * m[5] * m[10] + m[12] * m[6] * m[9];
+        const det = m[0] * inv[0] + m[1] * inv[4] + m[2] * inv[8] + m[3] * inv[12];
+        if (det === 0) {
+          this._values = m.map((v) => NaN);
+          this._is2D = false;
+          return this;
+        }
+        inv[1] = -m[1] * m[10] * m[15] + m[1] * m[11] * m[14] + m[9] * m[2] * m[15] - m[9] * m[3] * m[14] - m[13] * m[2] * m[11] + m[13] * m[3] * m[10];
+        inv[5] = m[0] * m[10] * m[15] - m[0] * m[11] * m[14] - m[8] * m[2] * m[15] + m[8] * m[3] * m[14] + m[12] * m[2] * m[11] - m[12] * m[3] * m[10];
+        inv[9] = -m[0] * m[9] * m[15] + m[0] * m[11] * m[13] + m[8] * m[1] * m[15] - m[8] * m[3] * m[13] - m[12] * m[1] * m[11] + m[12] * m[3] * m[9];
+        inv[13] = m[0] * m[9] * m[14] - m[0] * m[10] * m[13] - m[8] * m[1] * m[14] + m[8] * m[2] * m[13] + m[12] * m[1] * m[10] - m[12] * m[2] * m[9];
+        inv[2] = m[1] * m[6] * m[15] - m[1] * m[7] * m[14] - m[5] * m[2] * m[15] + m[5] * m[3] * m[14] + m[13] * m[2] * m[7] - m[13] * m[3] * m[6];
+        inv[6] = -m[0] * m[6] * m[15] + m[0] * m[7] * m[14] + m[4] * m[2] * m[15] - m[4] * m[3] * m[14] - m[12] * m[2] * m[7] + m[12] * m[3] * m[6];
+        inv[10] = m[0] * m[5] * m[15] - m[0] * m[7] * m[13] - m[4] * m[1] * m[15] + m[4] * m[3] * m[13] + m[12] * m[1] * m[7] - m[12] * m[3] * m[5];
+        inv[14] = -m[0] * m[5] * m[14] + m[0] * m[6] * m[13] + m[4] * m[1] * m[14] - m[4] * m[2] * m[13] - m[12] * m[1] * m[6] + m[12] * m[2] * m[5];
+        inv[3] = -m[1] * m[6] * m[11] + m[1] * m[7] * m[10] + m[5] * m[2] * m[11] - m[5] * m[3] * m[10] - m[9] * m[2] * m[7] + m[9] * m[3] * m[6];
+        inv[7] = m[0] * m[6] * m[11] - m[0] * m[7] * m[10] - m[4] * m[2] * m[11] + m[4] * m[3] * m[10] + m[8] * m[2] * m[7] - m[8] * m[3] * m[6];
+        inv[11] = -m[0] * m[5] * m[11] + m[0] * m[7] * m[9] + m[4] * m[1] * m[11] - m[4] * m[3] * m[9] - m[8] * m[1] * m[7] + m[8] * m[3] * m[5];
+        inv[15] = m[0] * m[5] * m[10] - m[0] * m[6] * m[9] - m[4] * m[1] * m[10] + m[4] * m[2] * m[9] + m[8] * m[1] * m[6] - m[8] * m[2] * m[5];
+        inv.forEach((v, i) => {
+          inv[i] = v / det;
+        });
+        this._values = inv;
+        return this;
+      }
+      setMatrixValue(transformList) {
+        const temp = new _DOMMatrix(transformList);
+        this._values = temp._values;
+        this._is2D = temp._is2D;
+        return this;
+      }
+      transformPoint(point) {
+        point = new DOMPoint(point);
+        const x = point.x;
+        const y = point.y;
+        const z = point.z;
+        const w = point.w;
+        const values = this._values;
+        const nx = values[M11] * x + values[M21] * y + values[M31] * z + values[M41] * w;
+        const ny = values[M12] * x + values[M22] * y + values[M32] * z + values[M42] * w;
+        const nz = values[M13] * x + values[M23] * y + values[M33] * z + values[M43] * w;
+        const nw = values[M14] * x + values[M24] * y + values[M34] * z + values[M44] * w;
+        return new DOMPoint(nx, ny, nz, nw);
+      }
+      toFloat32Array() {
+        return Float32Array.from(this._values);
+      }
+      toFloat64Array() {
+        return this._values.slice(0);
+      }
+      static fromMatrix(init) {
+        if (!(init instanceof _DOMMatrix)) throw new TypeError("Expected DOMMatrix");
+        return new _DOMMatrix(init._values);
+      }
+      static fromFloat32Array(init) {
+        if (!(init instanceof Float32Array)) throw new TypeError("Expected Float32Array");
+        return new _DOMMatrix(init);
+      }
+      static fromFloat64Array(init) {
+        if (!(init instanceof Float64Array)) throw new TypeError("Expected Float64Array");
+        return new _DOMMatrix(init);
+      }
+      [util.inspect.custom || "inspect"](depth, options) {
+        if (depth < 0) return "[DOMMatrix]";
+        return `DOMMatrix [
+      a: ${this.a}
+      b: ${this.b}
+      c: ${this.c}
+      d: ${this.d}
+      e: ${this.e}
+      f: ${this.f}
+      m11: ${this.m11}
+      m12: ${this.m12}
+      m13: ${this.m13}
+      m14: ${this.m14}
+      m21: ${this.m21}
+      m22: ${this.m22}
+      m23: ${this.m23}
+      m23: ${this.m23}
+      m31: ${this.m31}
+      m32: ${this.m32}
+      m33: ${this.m33}
+      m34: ${this.m34}
+      m41: ${this.m41}
+      m42: ${this.m42}
+      m43: ${this.m43}
+      m44: ${this.m44}
+      is2D: ${this.is2D}
+      isIdentity: ${this.isIdentity} ]`;
+      }
+    };
+    function setNumber2D(receiver, index, value) {
+      if (typeof value !== "number") throw new TypeError("Expected number");
+      return receiver._values[index] = value;
+    }
+    function setNumber3D(receiver, index, value) {
+      if (typeof value !== "number") throw new TypeError("Expected number");
+      if (index === M33 || index === M44) {
+        if (value !== 1) receiver._is2D = false;
+      } else if (value !== 0) receiver._is2D = false;
+      return receiver._values[index] = value;
+    }
+    Object.defineProperties(DOMMatrix.prototype, {
+      m11: { get() {
+        return this._values[M11];
+      }, set(v) {
+        return setNumber2D(this, M11, v);
+      } },
+      m12: { get() {
+        return this._values[M12];
+      }, set(v) {
+        return setNumber2D(this, M12, v);
+      } },
+      m13: { get() {
+        return this._values[M13];
+      }, set(v) {
+        return setNumber3D(this, M13, v);
+      } },
+      m14: { get() {
+        return this._values[M14];
+      }, set(v) {
+        return setNumber3D(this, M14, v);
+      } },
+      m21: { get() {
+        return this._values[M21];
+      }, set(v) {
+        return setNumber2D(this, M21, v);
+      } },
+      m22: { get() {
+        return this._values[M22];
+      }, set(v) {
+        return setNumber2D(this, M22, v);
+      } },
+      m23: { get() {
+        return this._values[M23];
+      }, set(v) {
+        return setNumber3D(this, M23, v);
+      } },
+      m24: { get() {
+        return this._values[M24];
+      }, set(v) {
+        return setNumber3D(this, M24, v);
+      } },
+      m31: { get() {
+        return this._values[M31];
+      }, set(v) {
+        return setNumber3D(this, M31, v);
+      } },
+      m32: { get() {
+        return this._values[M32];
+      }, set(v) {
+        return setNumber3D(this, M32, v);
+      } },
+      m33: { get() {
+        return this._values[M33];
+      }, set(v) {
+        return setNumber3D(this, M33, v);
+      } },
+      m34: { get() {
+        return this._values[M34];
+      }, set(v) {
+        return setNumber3D(this, M34, v);
+      } },
+      m41: { get() {
+        return this._values[M41];
+      }, set(v) {
+        return setNumber2D(this, M41, v);
+      } },
+      m42: { get() {
+        return this._values[M42];
+      }, set(v) {
+        return setNumber2D(this, M42, v);
+      } },
+      m43: { get() {
+        return this._values[M43];
+      }, set(v) {
+        return setNumber3D(this, M43, v);
+      } },
+      m44: { get() {
+        return this._values[M44];
+      }, set(v) {
+        return setNumber3D(this, M44, v);
+      } },
+      a: { get() {
+        return this.m11;
+      }, set(v) {
+        return this.m11 = v;
+      } },
+      b: { get() {
+        return this.m12;
+      }, set(v) {
+        return this.m12 = v;
+      } },
+      c: { get() {
+        return this.m21;
+      }, set(v) {
+        return this.m21 = v;
+      } },
+      d: { get() {
+        return this.m22;
+      }, set(v) {
+        return this.m22 = v;
+      } },
+      e: { get() {
+        return this.m41;
+      }, set(v) {
+        return this.m41 = v;
+      } },
+      f: { get() {
+        return this.m42;
+      }, set(v) {
+        return this.m42 = v;
+      } },
+      is2D: { get() {
+        return this._is2D;
+      } },
+      // read-only
+      isIdentity: {
+        get() {
+          const values = this._values;
+          return values[M11] === 1 && values[M12] === 0 && values[M13] === 0 && values[M14] === 0 && values[M21] === 0 && values[M22] === 1 && values[M23] === 0 && values[M24] === 0 && values[M31] === 0 && values[M32] === 0 && values[M33] === 1 && values[M34] === 0 && values[M41] === 0 && values[M42] === 0 && values[M43] === 0 && values[M44] === 1;
+        }
+      }
+    });
+    function newInstance(values) {
+      const instance = Object.create(DOMMatrix.prototype);
+      instance.constructor = DOMMatrix;
+      instance._is2D = true;
+      instance._values = values;
+      return instance;
+    }
+    function multiply(A, B) {
+      const dest = new Float64Array(16);
+      for (let i = 0; i < 4; i++) {
+        for (let j = 0; j < 4; j++) {
+          let sum = 0;
+          for (let k = 0; k < 4; k++) {
+            sum += A[i * 4 + k] * B[k * 4 + j];
+          }
+          dest[i * 4 + j] = sum;
+        }
+      }
+      return dest;
+    }
+    module.exports = { DOMMatrix, DOMPoint };
+  }
+});
+
+// ../../../node_modules/.pnpm/canvas@2.11.2_encoding@0.1.13/node_modules/canvas/lib/context2d.js
+var require_context2d = __commonJS({
+  "../../../node_modules/.pnpm/canvas@2.11.2_encoding@0.1.13/node_modules/canvas/lib/context2d.js"(exports, module) {
+    "use strict";
+    var bindings = require_bindings();
+    var parseFont = require_parse_font();
+    var { DOMMatrix } = require_DOMMatrix();
+    bindings.CanvasRenderingContext2dInit(DOMMatrix, parseFont);
+    module.exports = bindings.CanvasRenderingContext2d;
+  }
+});
+
+// ../../../node_modules/.pnpm/canvas@2.11.2_encoding@0.1.13/node_modules/canvas/lib/pngstream.js
+var require_pngstream = __commonJS({
+  "../../../node_modules/.pnpm/canvas@2.11.2_encoding@0.1.13/node_modules/canvas/lib/pngstream.js"(exports, module) {
+    "use strict";
+    var { Readable } = __require("stream");
+    function noop() {
+    }
+    var PNGStream = class extends Readable {
+      constructor(canvas, options) {
+        super();
+        if (options && options.palette instanceof Uint8ClampedArray && options.palette.length % 4 !== 0) {
+          throw new Error("Palette length must be a multiple of 4.");
+        }
+        this.canvas = canvas;
+        this.options = options || {};
+      }
+      _read() {
+        this._read = noop;
+        this.canvas.streamPNGSync((err, chunk, len) => {
+          if (err) {
+            this.emit("error", err);
+          } else if (len) {
+            this.push(chunk);
+          } else {
+            this.push(null);
+          }
+        }, this.options);
+      }
+    };
+    module.exports = PNGStream;
+  }
+});
+
+// ../../../node_modules/.pnpm/canvas@2.11.2_encoding@0.1.13/node_modules/canvas/lib/pdfstream.js
+var require_pdfstream = __commonJS({
+  "../../../node_modules/.pnpm/canvas@2.11.2_encoding@0.1.13/node_modules/canvas/lib/pdfstream.js"(exports, module) {
+    "use strict";
+    var { Readable } = __require("stream");
+    function noop() {
+    }
+    var PDFStream = class extends Readable {
+      constructor(canvas, options) {
+        super();
+        this.canvas = canvas;
+        this.options = options;
+      }
+      _read() {
+        this._read = noop;
+        this.canvas.streamPDFSync((err, chunk, len) => {
+          if (err) {
+            this.emit("error", err);
+          } else if (len) {
+            this.push(chunk);
+          } else {
+            this.push(null);
+          }
+        }, this.options);
+      }
+    };
+    module.exports = PDFStream;
+  }
+});
+
+// ../../../node_modules/.pnpm/canvas@2.11.2_encoding@0.1.13/node_modules/canvas/lib/jpegstream.js
+var require_jpegstream = __commonJS({
+  "../../../node_modules/.pnpm/canvas@2.11.2_encoding@0.1.13/node_modules/canvas/lib/jpegstream.js"(exports, module) {
+    "use strict";
+    var { Readable } = __require("stream");
+    function noop() {
+    }
+    var JPEGStream = class extends Readable {
+      constructor(canvas, options) {
+        super();
+        if (canvas.streamJPEGSync === void 0) {
+          throw new Error("node-canvas was built without JPEG support.");
+        }
+        this.options = options;
+        this.canvas = canvas;
+      }
+      _read() {
+        this._read = noop;
+        this.canvas.streamJPEGSync(this.options, (err, chunk) => {
+          if (err) {
+            this.emit("error", err);
+          } else if (chunk) {
+            this.push(chunk);
+          } else {
+            this.push(null);
+          }
+        });
+      }
+    };
+    module.exports = JPEGStream;
+  }
+});
+
+// ../../../node_modules/.pnpm/canvas@2.11.2_encoding@0.1.13/node_modules/canvas/lib/canvas.js
+var require_canvas2 = __commonJS({
+  "../../../node_modules/.pnpm/canvas@2.11.2_encoding@0.1.13/node_modules/canvas/lib/canvas.js"(exports, module) {
+    "use strict";
+    var bindings = require_bindings();
+    var Canvas = module.exports = bindings.Canvas;
+    var Context2d = require_context2d();
+    var PNGStream = require_pngstream();
+    var PDFStream = require_pdfstream();
+    var JPEGStream = require_jpegstream();
+    var FORMATS = ["image/png", "image/jpeg"];
+    var util = __require("util");
+    Canvas.prototype[util.inspect.custom || "inspect"] = function() {
+      return `[Canvas ${this.width}x${this.height}]`;
+    };
+    Canvas.prototype.getContext = function(contextType, contextAttributes) {
+      if (contextType == "2d") {
+        const ctx = this._context2d || (this._context2d = new Context2d(this, contextAttributes));
+        this.context = ctx;
+        ctx.canvas = this;
+        return ctx;
+      }
+    };
+    Canvas.prototype.pngStream = Canvas.prototype.createPNGStream = function(options) {
+      return new PNGStream(this, options);
+    };
+    Canvas.prototype.pdfStream = Canvas.prototype.createPDFStream = function(options) {
+      return new PDFStream(this, options);
+    };
+    Canvas.prototype.jpegStream = Canvas.prototype.createJPEGStream = function(options) {
+      return new JPEGStream(this, options);
+    };
+    Canvas.prototype.toDataURL = function(a1, a2, a3) {
+      let type = "image/png";
+      let opts = {};
+      let fn;
+      if (typeof a1 === "function") {
+        fn = a1;
+      } else {
+        if (typeof a1 === "string" && FORMATS.includes(a1.toLowerCase())) {
+          type = a1.toLowerCase();
+        }
+        if (typeof a2 === "function") {
+          fn = a2;
+        } else {
+          if (typeof a2 === "object") {
+            opts = a2;
+          } else if (typeof a2 === "number") {
+            opts = { quality: Math.max(0, Math.min(1, a2)) };
+          }
+          if (typeof a3 === "function") {
+            fn = a3;
+          } else if (void 0 !== a3) {
+            throw new TypeError(`${typeof a3} is not a function`);
+          }
+        }
+      }
+      if (this.width === 0 || this.height === 0) {
+        const str = "data:,";
+        if (fn) {
+          setTimeout(() => fn(null, str));
+          return;
+        } else {
+          return str;
+        }
+      }
+      if (fn) {
+        this.toBuffer((err, buf) => {
+          if (err) return fn(err);
+          fn(null, `data:${type};base64,${buf.toString("base64")}`);
+        }, type, opts);
+      } else {
+        return `data:${type};base64,${this.toBuffer(type, opts).toString("base64")}`;
+      }
+    };
+  }
+});
+
+// ../../../node_modules/.pnpm/simple-concat@1.0.1/node_modules/simple-concat/index.js
+var require_simple_concat = __commonJS({
+  "../../../node_modules/.pnpm/simple-concat@1.0.1/node_modules/simple-concat/index.js"(exports, module) {
+    module.exports = function(stream, cb) {
+      var chunks = [];
+      stream.on("data", function(chunk) {
+        chunks.push(chunk);
+      });
+      stream.once("end", function() {
+        if (cb) cb(null, Buffer.concat(chunks));
+        cb = null;
+      });
+      stream.once("error", function(err) {
+        if (cb) cb(err);
+        cb = null;
+      });
+    };
+  }
+});
+
+// ../../../node_modules/.pnpm/mimic-response@2.1.0/node_modules/mimic-response/index.js
+var require_mimic_response = __commonJS({
+  "../../../node_modules/.pnpm/mimic-response@2.1.0/node_modules/mimic-response/index.js"(exports, module) {
+    "use strict";
+    var knownProperties = [
+      "aborted",
+      "complete",
+      "destroy",
+      "headers",
+      "httpVersion",
+      "httpVersionMinor",
+      "httpVersionMajor",
+      "method",
+      "rawHeaders",
+      "rawTrailers",
+      "setTimeout",
+      "socket",
+      "statusCode",
+      "statusMessage",
+      "trailers",
+      "url"
+    ];
+    module.exports = (fromStream, toStream) => {
+      const fromProperties = new Set(Object.keys(fromStream).concat(knownProperties));
+      for (const property of fromProperties) {
+        if (property in toStream) {
+          continue;
+        }
+        toStream[property] = typeof fromStream[property] === "function" ? fromStream[property].bind(fromStream) : fromStream[property];
+      }
+      return toStream;
+    };
+  }
+});
+
+// ../../../node_modules/.pnpm/decompress-response@4.2.1/node_modules/decompress-response/index.js
+var require_decompress_response = __commonJS({
+  "../../../node_modules/.pnpm/decompress-response@4.2.1/node_modules/decompress-response/index.js"(exports, module) {
+    "use strict";
+    var { PassThrough: PassThroughStream } = __require("stream");
+    var zlib = __require("zlib");
+    var mimicResponse = require_mimic_response();
+    var decompressResponse = (response) => {
+      const contentEncoding = (response.headers["content-encoding"] || "").toLowerCase();
+      if (!["gzip", "deflate", "br"].includes(contentEncoding)) {
+        return response;
+      }
+      const isBrotli = contentEncoding === "br";
+      if (isBrotli && typeof zlib.createBrotliDecompress !== "function") {
+        return response;
+      }
+      const decompress = isBrotli ? zlib.createBrotliDecompress() : zlib.createUnzip();
+      const stream = new PassThroughStream();
+      mimicResponse(response, stream);
+      decompress.on("error", (error) => {
+        if (error.code === "Z_BUF_ERROR") {
+          stream.end();
+          return;
+        }
+        stream.emit("error", error);
+      });
+      response.pipe(decompress).pipe(stream);
+      return stream;
+    };
+    module.exports = decompressResponse;
+    module.exports.default = decompressResponse;
+  }
+});
+
+// ../../../node_modules/.pnpm/wrappy@1.0.2/node_modules/wrappy/wrappy.js
+var require_wrappy = __commonJS({
+  "../../../node_modules/.pnpm/wrappy@1.0.2/node_modules/wrappy/wrappy.js"(exports, module) {
+    module.exports = wrappy;
+    function wrappy(fn, cb) {
+      if (fn && cb) return wrappy(fn)(cb);
+      if (typeof fn !== "function")
+        throw new TypeError("need wrapper function");
+      Object.keys(fn).forEach(function(k) {
+        wrapper[k] = fn[k];
+      });
+      return wrapper;
+      function wrapper() {
+        var args = new Array(arguments.length);
+        for (var i = 0; i < args.length; i++) {
+          args[i] = arguments[i];
+        }
+        var ret = fn.apply(this, args);
+        var cb2 = args[args.length - 1];
+        if (typeof ret === "function" && ret !== cb2) {
+          Object.keys(cb2).forEach(function(k) {
+            ret[k] = cb2[k];
+          });
+        }
+        return ret;
+      }
+    }
+  }
+});
+
+// ../../../node_modules/.pnpm/once@1.4.0/node_modules/once/once.js
+var require_once = __commonJS({
+  "../../../node_modules/.pnpm/once@1.4.0/node_modules/once/once.js"(exports, module) {
+    var wrappy = require_wrappy();
+    module.exports = wrappy(once);
+    module.exports.strict = wrappy(onceStrict);
+    once.proto = once(function() {
+      Object.defineProperty(Function.prototype, "once", {
+        value: function() {
+          return once(this);
+        },
+        configurable: true
+      });
+      Object.defineProperty(Function.prototype, "onceStrict", {
+        value: function() {
+          return onceStrict(this);
+        },
+        configurable: true
+      });
+    });
+    function once(fn) {
+      var f = function() {
+        if (f.called) return f.value;
+        f.called = true;
+        return f.value = fn.apply(this, arguments);
+      };
+      f.called = false;
+      return f;
+    }
+    function onceStrict(fn) {
+      var f = function() {
+        if (f.called)
+          throw new Error(f.onceError);
+        f.called = true;
+        return f.value = fn.apply(this, arguments);
+      };
+      var name = fn.name || "Function wrapped with `once`";
+      f.onceError = name + " shouldn't be called more than once";
+      f.called = false;
+      return f;
+    }
+  }
+});
+
+// ../../../node_modules/.pnpm/simple-get@3.1.1/node_modules/simple-get/index.js
+var require_simple_get = __commonJS({
+  "../../../node_modules/.pnpm/simple-get@3.1.1/node_modules/simple-get/index.js"(exports, module) {
+    module.exports = simpleGet;
+    var concat = require_simple_concat();
+    var decompressResponse = require_decompress_response();
+    var http = __require("http");
+    var https = __require("https");
+    var once = require_once();
+    var querystring = __require("querystring");
+    var url = __require("url");
+    var isStream = (o) => o !== null && typeof o === "object" && typeof o.pipe === "function";
+    function simpleGet(opts, cb) {
+      opts = Object.assign({ maxRedirects: 10 }, typeof opts === "string" ? { url: opts } : opts);
+      cb = once(cb);
+      if (opts.url) {
+        const { hostname, port, protocol: protocol2, auth, path } = url.parse(opts.url);
+        delete opts.url;
+        if (!hostname && !port && !protocol2 && !auth) opts.path = path;
+        else Object.assign(opts, { hostname, port, protocol: protocol2, auth, path });
+      }
+      const headers = { "accept-encoding": "gzip, deflate" };
+      if (opts.headers) Object.keys(opts.headers).forEach((k) => headers[k.toLowerCase()] = opts.headers[k]);
+      opts.headers = headers;
+      let body;
+      if (opts.body) {
+        body = opts.json && !isStream(opts.body) ? JSON.stringify(opts.body) : opts.body;
+      } else if (opts.form) {
+        body = typeof opts.form === "string" ? opts.form : querystring.stringify(opts.form);
+        opts.headers["content-type"] = "application/x-www-form-urlencoded";
+      }
+      if (body) {
+        if (!opts.method) opts.method = "POST";
+        if (!isStream(body)) opts.headers["content-length"] = Buffer.byteLength(body);
+        if (opts.json && !opts.form) opts.headers["content-type"] = "application/json";
+      }
+      delete opts.body;
+      delete opts.form;
+      if (opts.json) opts.headers.accept = "application/json";
+      if (opts.method) opts.method = opts.method.toUpperCase();
+      const originalHost = opts.hostname;
+      const protocol = opts.protocol === "https:" ? https : http;
+      const req = protocol.request(opts, (res) => {
+        if (opts.followRedirects !== false && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+          opts.url = res.headers.location;
+          delete opts.headers.host;
+          res.resume();
+          const redirectHost = url.parse(opts.url).hostname;
+          if (redirectHost !== null && redirectHost !== originalHost) {
+            delete opts.headers.cookie;
+            delete opts.headers.authorization;
+          }
+          if (opts.method === "POST" && [301, 302].includes(res.statusCode)) {
+            opts.method = "GET";
+            delete opts.headers["content-length"];
+            delete opts.headers["content-type"];
+          }
+          if (opts.maxRedirects-- === 0) return cb(new Error("too many redirects"));
+          else return simpleGet(opts, cb);
+        }
+        const tryUnzip = typeof decompressResponse === "function" && opts.method !== "HEAD";
+        cb(null, tryUnzip ? decompressResponse(res) : res);
+      });
+      req.on("timeout", () => {
+        req.abort();
+        cb(new Error("Request timed out"));
+      });
+      req.on("error", cb);
+      if (isStream(body)) body.on("error", cb).pipe(req);
+      else req.end(body);
+      return req;
+    }
+    simpleGet.concat = (opts, cb) => {
+      return simpleGet(opts, (err, res) => {
+        if (err) return cb(err);
+        concat(res, (err2, data) => {
+          if (err2) return cb(err2);
+          if (opts.json) {
+            try {
+              data = JSON.parse(data.toString());
+            } catch (err3) {
+              return cb(err3, res, data);
+            }
+          }
+          cb(null, res, data);
+        });
+      });
+    };
+    ["get", "post", "put", "patch", "head", "delete"].forEach((method) => {
+      simpleGet[method] = (opts, cb) => {
+        if (typeof opts === "string") opts = { url: opts };
+        return simpleGet(Object.assign({ method: method.toUpperCase() }, opts), cb);
+      };
+    });
+  }
+});
+
+// ../../../node_modules/.pnpm/canvas@2.11.2_encoding@0.1.13/node_modules/canvas/lib/image.js
+var require_image = __commonJS({
+  "../../../node_modules/.pnpm/canvas@2.11.2_encoding@0.1.13/node_modules/canvas/lib/image.js"(exports, module) {
+    "use strict";
+    var bindings = require_bindings();
+    var Image = module.exports = bindings.Image;
+    var util = __require("util");
+    var get;
+    var { GetSource, SetSource } = bindings;
+    Object.defineProperty(Image.prototype, "src", {
+      /**
+       * src setter. Valid values:
+       *  * `data:` URI
+       *  * Local file path
+       *  * HTTP or HTTPS URL
+       *  * Buffer containing image data (i.e. not a `data:` URI stored in a Buffer)
+       *
+       * @param {String|Buffer} val filename, buffer, data URI, URL
+       * @api public
+       */
+      set(val) {
+        if (typeof val === "string") {
+          if (/^\s*data:/.test(val)) {
+            const commaI = val.indexOf(",");
+            const isBase64 = val.lastIndexOf("base64", commaI) !== -1;
+            const content = val.slice(commaI + 1);
+            setSource(this, Buffer.from(content, isBase64 ? "base64" : "utf8"), val);
+          } else if (/^\s*https?:\/\//.test(val)) {
+            const onerror = (err) => {
+              if (typeof this.onerror === "function") {
+                this.onerror(err);
+              } else {
+                throw err;
+              }
+            };
+            if (!get) get = require_simple_get();
+            get.concat({
+              url: val,
+              headers: { "User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/102.0.0.0 Safari/537.36" }
+            }, (err, res, data) => {
+              if (err) return onerror(err);
+              if (res.statusCode < 200 || res.statusCode >= 300) {
+                return onerror(new Error(`Server responded with ${res.statusCode}`));
+              }
+              setSource(this, data);
+            });
+          } else {
+            setSource(this, val);
+          }
+        } else if (Buffer.isBuffer(val)) {
+          setSource(this, val);
+        }
+      },
+      get() {
+        return getSource(this);
+      },
+      configurable: true
+    });
+    Image.prototype[util.inspect.custom || "inspect"] = function() {
+      return "[Image" + (this.complete ? ":" + this.width + "x" + this.height : "") + (this.src ? " " + this.src : "") + (this.complete ? " complete" : "") + "]";
+    };
+    function getSource(img) {
+      return img._originalSource || GetSource.call(img);
+    }
+    function setSource(img, src, origSrc) {
+      SetSource.call(img, src);
+      img._originalSource = origSrc;
+    }
+  }
+});
+
+// ../../../node_modules/.pnpm/canvas@2.11.2_encoding@0.1.13/node_modules/canvas/lib/pattern.js
+var require_pattern = __commonJS({
+  "../../../node_modules/.pnpm/canvas@2.11.2_encoding@0.1.13/node_modules/canvas/lib/pattern.js"(exports, module) {
+    "use strict";
+    var bindings = require_bindings();
+    var { DOMMatrix } = require_DOMMatrix();
+    bindings.CanvasPatternInit(DOMMatrix);
+    module.exports = bindings.CanvasPattern;
+    bindings.CanvasPattern.prototype.toString = function() {
+      return "[object CanvasPattern]";
+    };
+  }
+});
+
+// ../../../node_modules/.pnpm/canvas@2.11.2_encoding@0.1.13/node_modules/canvas/package.json
+var require_package = __commonJS({
+  "../../../node_modules/.pnpm/canvas@2.11.2_encoding@0.1.13/node_modules/canvas/package.json"(exports, module) {
+    module.exports = {
+      name: "canvas",
+      description: "Canvas graphics API backed by Cairo",
+      version: "2.11.2",
+      author: "TJ Holowaychuk <tj@learnboost.com>",
+      main: "index.js",
+      browser: "browser.js",
+      contributors: [
+        "Nathan Rajlich <nathan@tootallnate.net>",
+        "Rod Vagg <r@va.gg>",
+        "Juriy Zaytsev <kangax@gmail.com>"
+      ],
+      keywords: [
+        "canvas",
+        "graphic",
+        "graphics",
+        "pixman",
+        "cairo",
+        "image",
+        "images",
+        "pdf"
+      ],
+      homepage: "https://github.com/Automattic/node-canvas",
+      repository: "git://github.com/Automattic/node-canvas.git",
+      scripts: {
+        prebenchmark: "node-gyp build",
+        benchmark: "node benchmarks/run.js",
+        lint: "standard examples/*.js test/server.js test/public/*.js benchmarks/run.js lib/context2d.js util/has_lib.js browser.js index.js",
+        test: "mocha test/*.test.js",
+        "pretest-server": "node-gyp build",
+        "test-server": "node test/server.js",
+        "generate-wpt": "node ./test/wpt/generate.js",
+        "test-wpt": "mocha test/wpt/generated/*.js",
+        install: "node-pre-gyp install --fallback-to-build --update-binary",
+        dtslint: "dtslint types"
+      },
+      binary: {
+        module_name: "canvas",
+        module_path: "build/Release",
+        host: "https://github.com/Automattic/node-canvas/releases/download/",
+        remote_path: "v{version}",
+        package_name: "{module_name}-v{version}-{node_abi}-{platform}-{libc}-{arch}.tar.gz"
+      },
+      files: [
+        "binding.gyp",
+        "lib/",
+        "src/",
+        "util/",
+        "types/index.d.ts"
+      ],
+      types: "types/index.d.ts",
+      dependencies: {
+        "@mapbox/node-pre-gyp": "^1.0.0",
+        nan: "^2.17.0",
+        "simple-get": "^3.0.3"
+      },
+      devDependencies: {
+        "@types/node": "^10.12.18",
+        "assert-rejects": "^1.0.0",
+        dtslint: "^4.0.7",
+        express: "^4.16.3",
+        "js-yaml": "^4.1.0",
+        mocha: "^5.2.0",
+        pixelmatch: "^4.0.2",
+        standard: "^12.0.1",
+        typescript: "^4.2.2"
+      },
+      engines: {
+        node: ">=6"
+      },
+      license: "MIT"
+    };
+  }
+});
+
+// ../../../node_modules/.pnpm/canvas@2.11.2_encoding@0.1.13/node_modules/canvas/index.js
+var require_canvas3 = __commonJS({
+  "../../../node_modules/.pnpm/canvas@2.11.2_encoding@0.1.13/node_modules/canvas/index.js"(exports) {
+    var Canvas = require_canvas2();
+    var Image = require_image();
+    var CanvasRenderingContext2D = require_context2d();
+    var CanvasPattern = require_pattern();
+    var parseFont = require_parse_font();
+    var packageJson = require_package();
+    var bindings = require_bindings();
+    var fs = __require("fs");
+    var PNGStream = require_pngstream();
+    var PDFStream = require_pdfstream();
+    var JPEGStream = require_jpegstream();
+    var { DOMPoint, DOMMatrix } = require_DOMMatrix();
+    function createCanvas(width, height, type) {
+      return new Canvas(width, height, type);
+    }
+    function createImageData(array, width, height) {
+      return new bindings.ImageData(array, width, height);
+    }
+    function loadImage(src) {
+      return new Promise((resolve, reject) => {
+        const image = new Image();
+        function cleanup() {
+          image.onload = null;
+          image.onerror = null;
+        }
+        image.onload = () => {
+          cleanup();
+          resolve(image);
+        };
+        image.onerror = (err) => {
+          cleanup();
+          reject(err);
+        };
+        image.src = src;
+      });
+    }
+    function registerFont(src, fontFace) {
+      return Canvas._registerFont(fs.realpathSync(src), fontFace);
+    }
+    function deregisterAllFonts() {
+      return Canvas._deregisterAllFonts();
+    }
+    exports.Canvas = Canvas;
+    exports.Context2d = CanvasRenderingContext2D;
+    exports.CanvasRenderingContext2D = CanvasRenderingContext2D;
+    exports.CanvasGradient = bindings.CanvasGradient;
+    exports.CanvasPattern = CanvasPattern;
+    exports.Image = Image;
+    exports.ImageData = bindings.ImageData;
+    exports.PNGStream = PNGStream;
+    exports.PDFStream = PDFStream;
+    exports.JPEGStream = JPEGStream;
+    exports.DOMMatrix = DOMMatrix;
+    exports.DOMPoint = DOMPoint;
+    exports.registerFont = registerFont;
+    exports.deregisterAllFonts = deregisterAllFonts;
+    exports.parseFont = parseFont;
+    exports.createCanvas = createCanvas;
+    exports.createImageData = createImageData;
+    exports.loadImage = loadImage;
+    exports.backends = bindings.Backends;
+    exports.version = packageJson.version;
+    exports.cairoVersion = bindings.cairoVersion;
+    exports.jpegVersion = bindings.jpegVersion;
+    exports.gifVersion = bindings.gifVersion ? bindings.gifVersion.replace(/[^.\d]/g, "") : void 0;
+    exports.freetypeVersion = bindings.freetypeVersion;
+    exports.rsvgVersion = bindings.rsvgVersion;
+    exports.pangoVersion = bindings.pangoVersion;
+  }
+});
+export default require_canvas3();
+/*! Bundled license information:
+
+canvas/lib/context2d.js:
+  (*!
+   * Canvas - Context2d
+   * Copyright (c) 2010 LearnBoost <tj@learnboost.com>
+   * MIT Licensed
+   *)
+
+canvas/lib/pngstream.js:
+  (*!
+   * Canvas - PNGStream
+   * Copyright (c) 2010 LearnBoost <tj@learnboost.com>
+   * MIT Licensed
+   *)
+
+canvas/lib/pdfstream.js:
+  (*!
+   * Canvas - PDFStream
+   *)
+
+canvas/lib/jpegstream.js:
+  (*!
+   * Canvas - JPEGStream
+   * Copyright (c) 2010 LearnBoost <tj@learnboost.com>
+   * MIT Licensed
+   *)
+
+canvas/lib/canvas.js:
+  (*!
+   * Canvas
+   * Copyright (c) 2010 LearnBoost <tj@learnboost.com>
+   * MIT Licensed
+   *)
+
+simple-concat/index.js:
+  (*! simple-concat. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> *)
+
+canvas/lib/image.js:
+  (*!
+   * Canvas - Image
+   * Copyright (c) 2010 LearnBoost <tj@learnboost.com>
+   * MIT Licensed
+   *)
+
+canvas/lib/pattern.js:
+  (*!
+   * Canvas - CanvasPattern
+   * Copyright (c) 2010 LearnBoost <tj@learnboost.com>
+   * MIT Licensed
+   *)
+*/
+//# sourceMappingURL=canvas-75Y7XMF3.js.map