holostaff-widget 2.0.0

package/dist/CanvasRenderer-DVQieOII.js

@@ -0,0 +1,976 @@
+import { D as E, C as ee, c as D, d as Re, m as ce, M as F, e as R, G as je, w as Xe, T as He, f as ze, s as Je, h as Ke, F as Qe, i as Ze, j as et, A as tt, R as nt, k as he } from "./index-DjIeNhPr.js";
+import { R as at, S as st, B as ot, a as rt, b as it, c as ct, A as lt, C as ht } from "./RenderTargetSystem-B-GzTxxb.js";
+let Z;
+function Ae(o) {
+  const e = E.get().createCanvas(6, 1), t = e.getContext("2d");
+  return t.fillStyle = o, t.fillRect(0, 0, 6, 1), e;
+}
+function Be() {
+  if (Z !== void 0)
+    return Z;
+  try {
+    const o = Ae("#ff00ff"), e = Ae("#ffff00"), a = E.get().createCanvas(6, 1).getContext("2d");
+    a.globalCompositeOperation = "multiply", a.drawImage(o, 0, 0), a.drawImage(e, 2, 0);
+    const n = a.getImageData(2, 0, 1, 1);
+    if (!n)
+      Z = !1;
+    else {
+      const s = n.data;
+      Z = s[0] === 255 && s[1] === 0 && s[2] === 0;
+    }
+  } catch {
+    Z = !1;
+  }
+  return Z;
+}
+const d = {
+  canvas: null,
+  convertTintToImage: !1,
+  cacheStepsPerColorChannel: 8,
+  canUseMultiply: Be(),
+  tintMethod: null,
+  _canvasSourceCache: /* @__PURE__ */ new WeakMap(),
+  _unpremultipliedCache: /* @__PURE__ */ new WeakMap(),
+  getCanvasSource: (o) => {
+    const e = o.source, t = e == null ? void 0 : e.resource;
+    if (!t)
+      return null;
+    const a = e.alphaMode === "premultiplied-alpha", n = e.resourceWidth ?? e.pixelWidth, s = e.resourceHeight ?? e.pixelHeight, r = n !== e.pixelWidth || s !== e.pixelHeight;
+    if (a) {
+      if ((t instanceof HTMLCanvasElement || typeof OffscreenCanvas < "u" && t instanceof OffscreenCanvas) && !r)
+        return t;
+      const i = d._unpremultipliedCache.get(e);
+      if ((i == null ? void 0 : i.resourceId) === e._resourceId)
+        return i.canvas;
+    }
+    if (t instanceof Uint8Array || t instanceof Uint8ClampedArray || t instanceof Int8Array || t instanceof Uint16Array || t instanceof Int16Array || t instanceof Uint32Array || t instanceof Int32Array || t instanceof Float32Array || t instanceof ArrayBuffer) {
+      const i = d._canvasSourceCache.get(e);
+      if ((i == null ? void 0 : i.resourceId) === e._resourceId)
+        return i.canvas;
+      const c = E.get().createCanvas(e.pixelWidth, e.pixelHeight), h = c.getContext("2d"), l = h.createImageData(e.pixelWidth, e.pixelHeight), f = l.data, x = t instanceof ArrayBuffer ? new Uint8Array(t) : new Uint8Array(t.buffer, t.byteOffset, t.byteLength);
+      if (e.format === "bgra8unorm")
+        for (let p = 0; p < f.length && p + 3 < x.length; p += 4)
+          f[p] = x[p + 2], f[p + 1] = x[p + 1], f[p + 2] = x[p], f[p + 3] = x[p + 3];
+      else
+        f.set(x.subarray(0, f.length));
+      return h.putImageData(l, 0, 0), d._canvasSourceCache.set(e, { canvas: c, resourceId: e._resourceId }), c;
+    }
+    if (a) {
+      const i = E.get().createCanvas(e.pixelWidth, e.pixelHeight), c = i.getContext("2d", { willReadFrequently: !0 });
+      i.width = e.pixelWidth, i.height = e.pixelHeight, c.drawImage(t, 0, 0);
+      const h = c.getImageData(0, 0, i.width, i.height), l = h.data;
+      for (let f = 0; f < l.length; f += 4) {
+        const x = l[f + 3];
+        if (x > 0) {
+          const p = 255 / x;
+          l[f] = Math.min(255, l[f] * p + 0.5), l[f + 1] = Math.min(255, l[f + 1] * p + 0.5), l[f + 2] = Math.min(255, l[f + 2] * p + 0.5);
+        }
+      }
+      return c.putImageData(h, 0, 0), d._unpremultipliedCache.set(e, { canvas: i, resourceId: e._resourceId }), i;
+    }
+    if (r) {
+      const i = d._canvasSourceCache.get(e);
+      if ((i == null ? void 0 : i.resourceId) === e._resourceId)
+        return i.canvas;
+      const c = E.get().createCanvas(e.pixelWidth, e.pixelHeight), h = c.getContext("2d");
+      return c.width = e.pixelWidth, c.height = e.pixelHeight, h.drawImage(t, 0, 0), d._canvasSourceCache.set(e, { canvas: c, resourceId: e._resourceId }), c;
+    }
+    return t;
+  },
+  getTintedCanvas: (o, e) => {
+    const t = o.texture, a = ee.shared.setValue(e).toHex(), n = t.tintCache || (t.tintCache = {}), s = n[a], r = t.source._resourceId;
+    if ((s == null ? void 0 : s.tintId) === r)
+      return s;
+    const i = s && "getContext" in s ? s : E.get().createCanvas();
+    return d.tintMethod(t, e, i), i.tintId = r, n[a] = i, n[a];
+  },
+  getTintedPattern: (o, e) => {
+    const t = ee.shared.setValue(e).toHex(), a = o.patternCache || (o.patternCache = {}), n = o.source._resourceId;
+    let s = a[t];
+    return (s == null ? void 0 : s.tintId) === n || (d.canvas || (d.canvas = E.get().createCanvas()), d.tintMethod(o, e, d.canvas), s = d.canvas.getContext("2d").createPattern(d.canvas, "repeat"), s.tintId = n, a[t] = s), s;
+  },
+  /**
+   * Applies a transform to a CanvasPattern.
+   * @param pattern - The pattern to apply the transform to.
+   * @param matrix - The matrix to apply.
+   * @param matrix.a
+   * @param matrix.b
+   * @param matrix.c
+   * @param matrix.d
+   * @param matrix.tx
+   * @param matrix.ty
+   * @param invert
+   */
+  applyPatternTransform: (o, e, t = !0) => {
+    if (!e) return;
+    const a = o;
+    if (!a.setTransform) return;
+    const n = globalThis.DOMMatrix;
+    if (!n) return;
+    const s = new n([e.a, e.b, e.c, e.d, e.tx, e.ty]);
+    a.setTransform(t ? s.inverse() : s);
+  },
+  tintWithMultiply: (o, e, t) => {
+    const a = t.getContext("2d"), n = o.frame.clone(), s = o.source._resolution ?? o.source.resolution ?? 1, r = o.rotate;
+    n.x *= s, n.y *= s, n.width *= s, n.height *= s;
+    const i = D.isVertical(r), c = i ? n.height : n.width, h = i ? n.width : n.height;
+    t.width = Math.ceil(c), t.height = Math.ceil(h), a.save(), a.fillStyle = ee.shared.setValue(e).toHex(), a.fillRect(0, 0, c, h), a.globalCompositeOperation = "multiply";
+    const l = d.getCanvasSource(o);
+    if (!l) {
+      a.restore();
+      return;
+    }
+    r && d._applyInverseRotation(a, r, n.width, n.height), a.drawImage(
+      l,
+      n.x,
+      n.y,
+      n.width,
+      n.height,
+      0,
+      0,
+      n.width,
+      n.height
+    ), a.globalCompositeOperation = "destination-atop", a.drawImage(
+      l,
+      n.x,
+      n.y,
+      n.width,
+      n.height,
+      0,
+      0,
+      n.width,
+      n.height
+    ), a.restore();
+  },
+  tintWithOverlay: (o, e, t) => {
+    const a = t.getContext("2d"), n = o.frame.clone(), s = o.source._resolution ?? o.source.resolution ?? 1, r = o.rotate;
+    n.x *= s, n.y *= s, n.width *= s, n.height *= s;
+    const i = D.isVertical(r), c = i ? n.height : n.width, h = i ? n.width : n.height;
+    t.width = Math.ceil(c), t.height = Math.ceil(h), a.save(), a.globalCompositeOperation = "copy", a.fillStyle = ee.shared.setValue(e).toHex(), a.fillRect(0, 0, c, h), a.globalCompositeOperation = "destination-atop";
+    const l = d.getCanvasSource(o);
+    if (!l) {
+      a.restore();
+      return;
+    }
+    r && d._applyInverseRotation(a, r, n.width, n.height), a.drawImage(
+      l,
+      n.x,
+      n.y,
+      n.width,
+      n.height,
+      0,
+      0,
+      n.width,
+      n.height
+    ), a.restore();
+  },
+  tintWithPerPixel: (o, e, t) => {
+    const a = t.getContext("2d"), n = o.frame.clone(), s = o.source._resolution ?? o.source.resolution ?? 1, r = o.rotate;
+    n.x *= s, n.y *= s, n.width *= s, n.height *= s;
+    const i = D.isVertical(r), c = i ? n.height : n.width, h = i ? n.width : n.height;
+    t.width = Math.ceil(c), t.height = Math.ceil(h), a.save(), a.globalCompositeOperation = "copy";
+    const l = d.getCanvasSource(o);
+    if (!l) {
+      a.restore();
+      return;
+    }
+    r && d._applyInverseRotation(a, r, n.width, n.height), a.drawImage(
+      l,
+      n.x,
+      n.y,
+      n.width,
+      n.height,
+      0,
+      0,
+      n.width,
+      n.height
+    ), a.restore();
+    const f = e >> 16 & 255, x = e >> 8 & 255, p = e & 255, y = a.getImageData(0, 0, c, h), T = y.data;
+    for (let v = 0; v < T.length; v += 4)
+      T[v] = T[v] * f / 255, T[v + 1] = T[v + 1] * x / 255, T[v + 2] = T[v + 2] * p / 255;
+    a.putImageData(y, 0, 0);
+  },
+  /**
+   * Applies inverse rotation transform to context for texture packer rotation compensation.
+   * Supports all 16 groupD8 symmetries (rotations and reflections).
+   * @param context - Canvas 2D context
+   * @param rotate - The groupD8 rotation value
+   * @param srcWidth - Source crop width (before rotation)
+   * @param srcHeight - Source crop height (before rotation)
+   */
+  _applyInverseRotation: (o, e, t, a) => {
+    const n = D.inv(e), s = D.uX(n), r = D.uY(n), i = D.vX(n), c = D.vY(n), h = -Math.min(0, s * t, i * a, s * t + i * a), l = -Math.min(0, r * t, c * a, r * t + c * a);
+    o.transform(s, r, i, c, h, l);
+  }
+};
+d.tintMethod = d.canUseMultiply ? d.tintWithMultiply : d.tintWithPerPixel;
+const xe = class z {
+  static _getPatternRepeat(e, t) {
+    const a = e && e !== "clamp-to-edge", n = t && t !== "clamp-to-edge";
+    return a && n ? "repeat" : a ? "repeat-x" : n ? "repeat-y" : "no-repeat";
+  }
+  start(e, t, a) {
+  }
+  execute(e, t) {
+    var i, c, h, l;
+    const a = t.elements;
+    if (!a || !a.length) return;
+    const n = e.renderer, s = n.canvasContext, r = s.activeContext;
+    for (let f = 0; f < a.length; f++) {
+      const x = a[f];
+      if (!x.packAsQuad) continue;
+      const p = x, y = p.texture, T = y ? d.getCanvasSource(y) : null;
+      if (!T) continue;
+      const v = y.source.style, H = s.smoothProperty, V = v.scaleMode !== "nearest";
+      r[H] !== V && (r[H] = V), s.setBlendMode(t.blendMode);
+      const G = ((i = n.globalUniforms.globalUniformData) == null ? void 0 : i.worldColor) ?? 4294967295, b = p.color, P = (G >>> 24 & 255) / 255, j = (b >>> 24 & 255) / 255, se = ((c = n.filter) == null ? void 0 : c.alphaMultiplier) ?? 1, te = P * j * se;
+      if (te <= 0) continue;
+      r.globalAlpha = te;
+      const ne = G & 16777215, J = b & 16777215, w = Re(ce(J, ne)), S = y.frame, I = v.addressModeU ?? v.addressMode, de = v.addressModeV ?? v.addressMode, ae = z._getPatternRepeat(I, de), q = y.source._resolution ?? y.source.resolution ?? 1, X = (l = (h = p.renderable) == null ? void 0 : h.renderGroup) == null ? void 0 : l.isCachedAsTexture, m = S.x * q, C = S.y * q, _ = S.width * q, L = S.height * q, A = p.bounds, k = n.renderTarget.renderTarget.isRoot, U = A.minX, O = A.minY, B = A.maxX - A.minX, W = A.maxY - A.minY, $ = y.rotate, u = y.uvs, N = Math.min(u.x0, u.x1, u.x2, u.x3, u.y0, u.y1, u.y2, u.y3), Y = Math.max(u.x0, u.x1, u.x2, u.x3, u.y0, u.y1, u.y2, u.y3), M = ae !== "no-repeat" && (N < 0 || Y > 1), pe = $ && !(!M && (w !== 16777215 || $));
+      pe ? (z._tempPatternMatrix.copyFrom(p.transform), D.matrixAppendRotationInv(
+        z._tempPatternMatrix,
+        $,
+        U,
+        O,
+        B,
+        W
+      ), s.setContextTransform(
+        z._tempPatternMatrix,
+        p.roundPixels === 1,
+        void 0,
+        X && k
+      )) : s.setContextTransform(
+        p.transform,
+        p.roundPixels === 1,
+        void 0,
+        X && k
+      );
+      const oe = pe ? 0 : U, re = pe ? 0 : O, ue = B, fe = W;
+      if (M) {
+        let ge = T;
+        const K = w !== 16777215 && !$, Q = S.width <= y.source.width && S.height <= y.source.height;
+        K && Q && (ge = d.getTintedCanvas({ texture: y }, w));
+        const me = r.createPattern(ge, ae);
+        if (!me) continue;
+        const _e = ue, Pe = fe;
+        if (_e === 0 || Pe === 0) continue;
+        const Me = 1 / _e, be = 1 / Pe, we = (u.x1 - u.x0) * Me, ke = (u.y1 - u.y0) * Me, Se = (u.x3 - u.x0) * be, Ie = (u.y3 - u.y0) * be, Ne = u.x0 - we * oe - Se * re, Ye = u.y0 - ke * oe - Ie * re, ve = y.source.pixelWidth, ye = y.source.pixelHeight;
+        z._tempPatternMatrix.set(
+          we * ve,
+          ke * ye,
+          Se * ve,
+          Ie * ye,
+          Ne * ve,
+          Ye * ye
+        ), d.applyPatternTransform(me, z._tempPatternMatrix), r.fillStyle = me, r.fillRect(oe, re, ue, fe);
+      } else {
+        const K = w !== 16777215 || $ ? d.getTintedCanvas({ texture: y }, w) : T, Q = K !== T;
+        r.drawImage(
+          K,
+          Q ? 0 : m,
+          Q ? 0 : C,
+          Q ? K.width : _,
+          Q ? K.height : L,
+          oe,
+          re,
+          ue,
+          fe
+        );
+      }
+    }
+  }
+};
+xe._tempPatternMatrix = new F();
+xe.extension = {
+  type: [
+    R.CanvasPipesAdaptor
+  ],
+  name: "batch"
+};
+let dt = xe;
+class We {
+  constructor(e) {
+    this._colorStack = [], this._colorStackIndex = 0, this._currentColor = 0, this._renderer = e;
+  }
+  buildStart() {
+    this._colorStack[0] = 15, this._colorStackIndex = 1, this._currentColor = 15;
+  }
+  push(e, t, a) {
+    this._renderer.renderPipes.batch.break(a);
+    const n = this._colorStack;
+    n[this._colorStackIndex] = n[this._colorStackIndex - 1] & e.mask;
+    const s = this._colorStack[this._colorStackIndex];
+    s !== this._currentColor && (this._currentColor = s, a.add({
+      renderPipeId: "colorMask",
+      colorMask: s,
+      canBundle: !1
+    })), this._colorStackIndex++;
+  }
+  pop(e, t, a) {
+    this._renderer.renderPipes.batch.break(a);
+    const n = this._colorStack;
+    this._colorStackIndex--;
+    const s = n[this._colorStackIndex - 1];
+    s !== this._currentColor && (this._currentColor = s, a.add({
+      renderPipeId: "colorMask",
+      colorMask: s,
+      canBundle: !1
+    }));
+  }
+  execute(e) {
+  }
+  destroy() {
+    this._renderer = null, this._colorStack = null;
+  }
+}
+We.extension = {
+  type: [
+    R.CanvasPipes
+  ],
+  name: "colorMask"
+};
+function pt(o, e, t, a, n, s) {
+  s = Math.max(0, Math.min(s, Math.min(a, n) / 2)), o.moveTo(e + s, t), o.lineTo(e + a - s, t), o.quadraticCurveTo(e + a, t, e + a, t + s), o.lineTo(e + a, t + n - s), o.quadraticCurveTo(e + a, t + n, e + a - s, t + n), o.lineTo(e + s, t + n), o.quadraticCurveTo(e, t + n, e, t + n - s), o.lineTo(e, t + s), o.quadraticCurveTo(e, t, e + s, t);
+}
+function De(o, e) {
+  switch (e.type) {
+    case "rectangle": {
+      const t = e;
+      o.rect(t.x, t.y, t.width, t.height);
+      break;
+    }
+    case "roundedRectangle": {
+      const t = e;
+      pt(o, t.x, t.y, t.width, t.height, t.radius);
+      break;
+    }
+    case "circle": {
+      const t = e;
+      o.moveTo(t.x + t.radius, t.y), o.arc(t.x, t.y, t.radius, 0, Math.PI * 2);
+      break;
+    }
+    case "ellipse": {
+      const t = e;
+      o.ellipse ? (o.moveTo(t.x + t.halfWidth, t.y), o.ellipse(t.x, t.y, t.halfWidth, t.halfHeight, 0, 0, Math.PI * 2)) : (o.save(), o.translate(t.x, t.y), o.scale(t.halfWidth, t.halfHeight), o.moveTo(1, 0), o.arc(0, 0, 1, 0, Math.PI * 2), o.restore());
+      break;
+    }
+    case "triangle": {
+      const t = e;
+      o.moveTo(t.x, t.y), o.lineTo(t.x2, t.y2), o.lineTo(t.x3, t.y3), o.closePath();
+      break;
+    }
+    case "polygon":
+    default: {
+      const t = e, a = t.points;
+      if (!(a != null && a.length)) break;
+      o.moveTo(a[0], a[1]);
+      for (let n = 2; n < a.length; n += 2)
+        o.lineTo(a[n], a[n + 1]);
+      t.closePath && o.closePath();
+      break;
+    }
+  }
+}
+function ut(o, e) {
+  if (!(e != null && e.length)) return !1;
+  for (let t = 0; t < e.length; t++) {
+    const a = e[t];
+    if (!(a != null && a.shape)) continue;
+    const n = a.transform, s = n && !n.isIdentity();
+    s && (o.save(), o.transform(n.a, n.b, n.c, n.d, n.tx, n.ty)), De(o, a.shape), s && o.restore();
+  }
+  return !0;
+}
+class Ge {
+  constructor(e) {
+    this._warnedMaskTypes = /* @__PURE__ */ new Set(), this._canvasMaskStack = [], this._renderer = e;
+  }
+  push(e, t, a) {
+    this._renderer.renderPipes.batch.break(a), a.add({
+      renderPipeId: "stencilMask",
+      action: "pushMaskBegin",
+      mask: e,
+      inverse: t._maskOptions.inverse,
+      canBundle: !1
+    });
+  }
+  pop(e, t, a) {
+    this._renderer.renderPipes.batch.break(a), a.add({
+      renderPipeId: "stencilMask",
+      action: "popMaskEnd",
+      mask: e,
+      inverse: t._maskOptions.inverse,
+      canBundle: !1
+    });
+  }
+  execute(e) {
+    var l, f, x;
+    if (e.action !== "pushMaskBegin" && e.action !== "popMaskEnd")
+      return;
+    const t = this._renderer, a = t.canvasContext, n = a == null ? void 0 : a.activeContext;
+    if (!n) return;
+    if (e.action === "popMaskEnd") {
+      this._canvasMaskStack.pop() && n.restore();
+      return;
+    }
+    e.inverse && this._warnOnce(
+      "inverse",
+      "CanvasRenderer: inverse masks are not supported on Canvas2D; ignoring inverse flag."
+    );
+    const s = e.mask.mask;
+    if (!(s instanceof je)) {
+      this._warnOnce(
+        "nonGraphics",
+        "CanvasRenderer: only Graphics masks are supported in Canvas2D; skipping mask."
+      ), this._canvasMaskStack.push(!1);
+      return;
+    }
+    const r = s, i = (l = r.context) == null ? void 0 : l.instructions;
+    if (!(i != null && i.length)) {
+      this._canvasMaskStack.push(!1);
+      return;
+    }
+    n.save(), a.setContextTransform(
+      r.groupTransform,
+      (t._roundPixels | r._roundPixels) === 1
+    ), n.beginPath();
+    let c = !1, h = !1;
+    for (let p = 0; p < i.length; p++) {
+      const y = i[p], T = y.action;
+      if (T !== "fill" && T !== "stroke") continue;
+      const v = y.data, H = (f = v == null ? void 0 : v.path) == null ? void 0 : f.shapePath;
+      if (!((x = H == null ? void 0 : H.shapePrimitives) != null && x.length)) continue;
+      const V = H.shapePrimitives;
+      for (let G = 0; G < V.length; G++) {
+        const b = V[G];
+        if (!(b != null && b.shape)) continue;
+        const P = b.transform, j = P && !P.isIdentity();
+        j && (n.save(), n.transform(P.a, P.b, P.c, P.d, P.tx, P.ty)), De(n, b.shape), h = ut(n, b.holes) || h, c = !0, j && n.restore();
+      }
+    }
+    if (!c) {
+      n.restore(), this._canvasMaskStack.push(!1);
+      return;
+    }
+    h ? n.clip("evenodd") : n.clip(), this._canvasMaskStack.push(!0);
+  }
+  destroy() {
+    this._renderer = null, this._warnedMaskTypes = null, this._canvasMaskStack = null;
+  }
+  _warnOnce(e, t) {
+    this._warnedMaskTypes.has(e) || (this._warnedMaskTypes.add(e), Xe(t));
+  }
+}
+Ge.extension = {
+  type: [
+    R.CanvasPipes
+  ],
+  name: "stencilMask"
+};
+const g = "source-over";
+function ft() {
+  const o = Be(), e = /* @__PURE__ */ Object.create(null);
+  return e.inherit = g, e.none = g, e.normal = "source-over", e.add = "lighter", e.multiply = o ? "multiply" : g, e.screen = o ? "screen" : g, e.overlay = o ? "overlay" : g, e.darken = o ? "darken" : g, e.lighten = o ? "lighten" : g, e["color-dodge"] = o ? "color-dodge" : g, e["color-burn"] = o ? "color-burn" : g, e["hard-light"] = o ? "hard-light" : g, e["soft-light"] = o ? "soft-light" : g, e.difference = o ? "difference" : g, e.exclusion = o ? "exclusion" : g, e.saturation = o ? "saturation" : g, e.color = o ? "color" : g, e.luminosity = o ? "luminosity" : g, e["linear-burn"] = o ? "color-burn" : g, e["linear-dodge"] = o ? "color-dodge" : g, e["linear-light"] = o ? "hard-light" : g, e["pin-light"] = o ? "hard-light" : g, e["vivid-light"] = o ? "hard-light" : g, e["hard-mix"] = g, e.negation = o ? "difference" : g, e["normal-npm"] = e.normal, e["add-npm"] = e.add, e["screen-npm"] = e.screen, e.erase = "destination-out", e.subtract = g, e.divide = g, e.min = g, e.max = g, e;
+}
+const gt = new F();
+class Ue {
+  /**
+   * @param renderer - The owning CanvasRenderer.
+   */
+  constructor(e) {
+    this.activeResolution = 1, this.smoothProperty = "imageSmoothingEnabled", this.blendModes = ft(), this._activeBlendMode = "normal", this._projTransform = null, this._outerBlend = !1, this._warnedBlendModes = /* @__PURE__ */ new Set(), this._renderer = e;
+  }
+  resolutionChange(e) {
+    this.activeResolution = e;
+  }
+  /** Initializes the root context and smoothing flag selection. */
+  init() {
+    const e = this._renderer.background.alpha < 1;
+    if (this.rootContext = this._renderer.canvas.getContext(
+      "2d",
+      { alpha: e }
+    ), this.activeContext = this.rootContext, this.activeResolution = this._renderer.resolution, !this.rootContext.imageSmoothingEnabled) {
+      const t = this.rootContext;
+      t.webkitImageSmoothingEnabled ? this.smoothProperty = "webkitImageSmoothingEnabled" : t.mozImageSmoothingEnabled ? this.smoothProperty = "mozImageSmoothingEnabled" : t.oImageSmoothingEnabled ? this.smoothProperty = "oImageSmoothingEnabled" : t.msImageSmoothingEnabled && (this.smoothProperty = "msImageSmoothingEnabled");
+    }
+  }
+  /**
+   * Sets the current transform on the active context.
+   * @param transform - Transform to apply.
+   * @param roundPixels - Whether to round translation to integers.
+   * @param localResolution - Optional local resolution multiplier.
+   * @param skipGlobalTransform - If true, skip applying the global world transform matrix.
+   */
+  setContextTransform(e, t, a, n) {
+    var h;
+    const s = n ? F.IDENTITY : ((h = this._renderer.globalUniforms.globalUniformData) == null ? void 0 : h.worldTransformMatrix) || F.IDENTITY;
+    let r = gt;
+    r.copyFrom(s), r.append(e);
+    const i = this._projTransform, c = this.activeResolution;
+    if (a = a || c, i) {
+      const l = F.shared;
+      l.copyFrom(r), l.prepend(i), r = l;
+    }
+    t ? this.activeContext.setTransform(
+      r.a * a,
+      r.b * a,
+      r.c * a,
+      r.d * a,
+      r.tx * c | 0,
+      r.ty * c | 0
+    ) : this.activeContext.setTransform(
+      r.a * a,
+      r.b * a,
+      r.c * a,
+      r.d * a,
+      r.tx * c,
+      r.ty * c
+    );
+  }
+  /**
+   * Clears the current render target, optionally filling with a color.
+   * @param clearColor - Color to fill after clearing.
+   * @param alpha - Alpha override for the clear color.
+   */
+  clear(e, t) {
+    const a = this.activeContext, n = this._renderer;
+    if (a.clearRect(0, 0, n.width, n.height), e) {
+      const s = ee.shared.setValue(e);
+      a.globalAlpha = t ?? s.alpha, a.fillStyle = s.toHex(), a.fillRect(0, 0, n.width, n.height), a.globalAlpha = 1;
+    }
+  }
+  /**
+   * Sets the active blend mode.
+   * @param blendMode - Pixi blend mode.
+   */
+  setBlendMode(e) {
+    if (this._activeBlendMode === e) return;
+    this._activeBlendMode = e, this._outerBlend = !1;
+    const t = this.blendModes[e];
+    if (!t) {
+      this._warnedBlendModes.has(e) || (console.warn(
+        `CanvasRenderer: blend mode "${e}" is not supported in Canvas2D; falling back to "source-over".`
+      ), this._warnedBlendModes.add(e)), this.activeContext.globalCompositeOperation = "source-over";
+      return;
+    }
+    this.activeContext.globalCompositeOperation = t;
+  }
+  /** Releases context references. */
+  destroy() {
+    this.rootContext = null, this.activeContext = null, this._warnedBlendModes.clear();
+  }
+}
+Ue.extension = {
+  type: [
+    R.CanvasSystem
+  ],
+  name: "canvasContext"
+};
+class Oe {
+  constructor() {
+    this.maxTextures = 16, this.maxBatchableTextures = 16, this.maxUniformBindings = 0;
+  }
+  init() {
+  }
+}
+Oe.extension = {
+  type: [
+    R.CanvasSystem
+  ],
+  name: "limits"
+};
+const mt = "#808080", ie = new F(), vt = new F(), yt = new F(), Ce = new F();
+function Ct(o, e, t) {
+  o.beginPath();
+  for (let a = 0; a < t.length; a += 3) {
+    const n = t[a] * 2, s = t[a + 1] * 2, r = t[a + 2] * 2;
+    o.moveTo(e[n], e[n + 1]), o.lineTo(e[s], e[s + 1]), o.lineTo(e[r], e[r + 1]), o.closePath();
+  }
+  o.fill();
+}
+function xt(o) {
+  return `#${(o & 16777215).toString(16).padStart(6, "0")}`;
+}
+function Tt(o, e, t, a, n, s) {
+  s = Math.max(0, Math.min(s, Math.min(a, n) / 2)), o.moveTo(e + s, t), o.lineTo(e + a - s, t), o.quadraticCurveTo(e + a, t, e + a, t + s), o.lineTo(e + a, t + n - s), o.quadraticCurveTo(e + a, t + n, e + a - s, t + n), o.lineTo(e + s, t + n), o.quadraticCurveTo(e, t + n, e, t + n - s), o.lineTo(e, t + s), o.quadraticCurveTo(e, t, e + s, t);
+}
+function le(o, e) {
+  switch (e.type) {
+    case "rectangle": {
+      const t = e;
+      o.rect(t.x, t.y, t.width, t.height);
+      break;
+    }
+    case "roundedRectangle": {
+      const t = e;
+      Tt(o, t.x, t.y, t.width, t.height, t.radius);
+      break;
+    }
+    case "circle": {
+      const t = e;
+      o.arc(t.x, t.y, t.radius, 0, Math.PI * 2);
+      break;
+    }
+    case "ellipse": {
+      const t = e;
+      o.ellipse ? o.ellipse(t.x, t.y, t.halfWidth, t.halfHeight, 0, 0, Math.PI * 2) : (o.save(), o.translate(t.x, t.y), o.scale(t.halfWidth, t.halfHeight), o.arc(0, 0, 1, 0, Math.PI * 2), o.restore());
+      break;
+    }
+    case "triangle": {
+      const t = e;
+      o.moveTo(t.x, t.y), o.lineTo(t.x2, t.y2), o.lineTo(t.x3, t.y3), o.closePath();
+      break;
+    }
+    case "polygon":
+    default: {
+      const t = e, a = t.points;
+      if (!(a != null && a.length)) break;
+      o.moveTo(a[0], a[1]);
+      for (let n = 2; n < a.length; n += 2)
+        o.lineTo(a[n], a[n + 1]);
+      t.closePath && o.closePath();
+      break;
+    }
+  }
+}
+function _t(o, e) {
+  if (!(e != null && e.length)) return !1;
+  for (let t = 0; t < e.length; t++) {
+    const a = e[t];
+    if (!(a != null && a.shape)) continue;
+    const n = a.transform, s = n && !n.isIdentity();
+    s && (o.save(), o.transform(n.a, n.b, n.c, n.d, n.tx, n.ty)), le(o, a.shape), s && o.restore();
+  }
+  return !0;
+}
+function Pt(o, e, t, a) {
+  const n = o.fill;
+  if (n instanceof Qe) {
+    n.buildGradient();
+    const r = n.texture;
+    if (r) {
+      const i = d.getTintedPattern(r, e), c = t ? Ce.copyFrom(t).scale(r.source.pixelWidth, r.source.pixelHeight) : Ce.copyFrom(n.transform);
+      return a && !o.textureSpace && c.append(a), d.applyPatternTransform(i, c), i;
+    }
+  }
+  if (n instanceof Ze) {
+    const r = d.getTintedPattern(n.texture, e);
+    return d.applyPatternTransform(r, n.transform), r;
+  }
+  const s = o.texture;
+  if (s && s !== He.WHITE) {
+    if (!s.source.resource)
+      return mt;
+    const r = d.getTintedPattern(s, e), i = t ? Ce.copyFrom(t).scale(s.source.pixelWidth, s.source.pixelHeight) : o.matrix;
+    return d.applyPatternTransform(r, i), r;
+  }
+  return xt(e);
+}
+class Ee {
+  constructor() {
+    this.shader = null;
+  }
+  contextChange(e) {
+  }
+  execute(e, t) {
+    var V, G, b, P, j, se, te;
+    const a = e.renderer, n = a.canvasContext, s = n.activeContext, r = t.groupTransform, i = ((V = a.globalUniforms.globalUniformData) == null ? void 0 : V.worldColor) ?? 4294967295, c = t.groupColorAlpha, h = (i >>> 24 & 255) / 255, l = (c >>> 24 & 255) / 255, f = ((G = a.filter) == null ? void 0 : G.alphaMultiplier) ?? 1, x = h * l * f;
+    if (x <= 0) return;
+    const p = i & 16777215, y = c & 16777215, T = Re(ce(y, p)), v = a._roundPixels | t._roundPixels;
+    s.save(), n.setContextTransform(r, v === 1), n.setBlendMode(t.groupBlendMode);
+    const H = t.context.instructions;
+    for (let ne = 0; ne < H.length; ne++) {
+      const J = H[ne];
+      if (J.action === "texture") {
+        const m = J.data, C = m.image, _ = C ? d.getCanvasSource(C) : null;
+        if (!_) continue;
+        const L = m.alpha * x;
+        if (L <= 0) continue;
+        const A = ce(m.style, T);
+        s.globalAlpha = L;
+        let k = _;
+        A !== 16777215 && (k = d.getTintedCanvas({ texture: C }, A));
+        const U = C.frame, O = C.source._resolution ?? C.source.resolution ?? 1;
+        let B = U.x * O, W = U.y * O;
+        const $ = U.width * O, u = U.height * O;
+        k !== _ && (B = 0, W = 0);
+        const N = m.transform, Y = N && !N.isIdentity(), M = C.rotate;
+        Y || M ? (ie.copyFrom(r), Y && ie.append(N), M && D.matrixAppendRotationInv(ie, M, m.dx, m.dy, m.dw, m.dh), n.setContextTransform(ie, v === 1)) : n.setContextTransform(r, v === 1), s.drawImage(
+          k,
+          B,
+          W,
+          k === _ ? $ : k.width,
+          k === _ ? u : k.height,
+          M ? 0 : m.dx,
+          M ? 0 : m.dy,
+          m.dw,
+          m.dh
+        ), (Y || M) && n.setContextTransform(r, v === 1);
+        continue;
+      }
+      const w = J.data, S = (b = w == null ? void 0 : w.path) == null ? void 0 : b.shapePath;
+      if (!((P = S == null ? void 0 : S.shapePrimitives) != null && P.length)) continue;
+      const I = w.style, de = ce(I.color, T), ae = I.alpha * x;
+      if (ae <= 0) continue;
+      const q = J.action === "stroke";
+      if (s.globalAlpha = ae, q) {
+        const m = I;
+        s.lineWidth = m.width, s.lineCap = m.cap, s.lineJoin = m.join, s.miterLimit = m.miterLimit;
+      }
+      const X = S.shapePrimitives;
+      if (!q && ((te = (se = (j = w.hole) == null ? void 0 : j.shapePath) == null ? void 0 : se.shapePrimitives) != null && te.length)) {
+        const m = X[X.length - 1];
+        m.holes = w.hole.shapePath.shapePrimitives;
+      }
+      for (let m = 0; m < X.length; m++) {
+        const C = X[m];
+        if (!(C != null && C.shape)) continue;
+        const _ = C.transform, L = _ && !_.isIdentity(), A = I.texture && I.texture !== He.WHITE, k = I.textureSpace === "global" ? _ : null, U = A ? ze(vt, I, C.shape, k) : null, O = L ? yt.copyFrom(r).append(_) : r, B = Pt(
+          I,
+          de,
+          U,
+          O
+        );
+        if (L && (s.save(), s.transform(_.a, _.b, _.c, _.d, _.tx, _.ty)), q) {
+          const W = I;
+          if (W.alignment !== 0.5 && !W.pixelLine) {
+            const u = [], N = [], Y = [], M = Je[C.shape.type];
+            if (M != null && M.build(C.shape, u)) {
+              const Te = C.shape.closePath ?? !0;
+              Ke(u, W, !1, Te, N, Y), s.fillStyle = B, Ct(s, N, Y);
+            } else
+              s.strokeStyle = B, s.beginPath(), le(s, C.shape), s.stroke();
+          } else
+            s.strokeStyle = B, s.beginPath(), le(s, C.shape), s.stroke();
+        } else
+          s.fillStyle = B, s.beginPath(), le(s, C.shape), _t(s, C.holes) ? s.fill("evenodd") : s.fill();
+        L && s.restore();
+      }
+    }
+    s.restore();
+  }
+  destroy() {
+    this.shader = null;
+  }
+}
+Ee.extension = {
+  type: [
+    R.CanvasPipesAdaptor
+  ],
+  name: "graphics"
+};
+class Mt {
+  /**
+   * Initializes the adaptor.
+   * @param renderer - Canvas renderer instance.
+   * @param renderTargetSystem - The render target system.
+   * @advanced
+   */
+  init(e, t) {
+    this._renderer = e, this._renderTargetSystem = t;
+  }
+  /**
+   * Creates a GPU render target for canvas.
+   * @param renderTarget - Render target to initialize.
+   * @advanced
+   */
+  initGpuRenderTarget(e) {
+    const t = e.colorTexture, { canvas: a, context: n } = this._ensureCanvas(t);
+    return {
+      canvas: a,
+      context: n,
+      width: a.width,
+      height: a.height
+    };
+  }
+  /**
+   * Resizes the backing canvas for a render target.
+   * @param renderTarget - Render target to resize.
+   * @advanced
+   */
+  resizeGpuRenderTarget(e) {
+    const t = e.colorTexture, { canvas: a } = this._ensureCanvas(t);
+    a.width = e.pixelWidth, a.height = e.pixelHeight;
+  }
+  /**
+   * Starts a render pass on the canvas target.
+   * @param renderTarget - Target to render to.
+   * @param clear - Clear mode.
+   * @param clearColor - Optional clear color.
+   * @param viewport - Optional viewport.
+   * @advanced
+   */
+  startRenderPass(e, t, a, n) {
+    const s = this._renderTargetSystem.getGpuRenderTarget(e);
+    this._renderer.canvasContext.activeContext = s.context, this._renderer.canvasContext.activeResolution = e.resolution, t && this.clear(e, t, a, n);
+  }
+  /**
+   * Clears the render target.
+   * @param renderTarget - Target to clear.
+   * @param _clear - Clear mode (unused).
+   * @param clearColor - Optional clear color.
+   * @param viewport - Optional viewport rectangle.
+   * @advanced
+   */
+  clear(e, t, a, n) {
+    const r = this._renderTargetSystem.getGpuRenderTarget(e).context, i = n || { x: 0, y: 0, width: e.pixelWidth, height: e.pixelHeight };
+    if (r.setTransform(1, 0, 0, 1, 0, 0), r.clearRect(i.x, i.y, i.width, i.height), a) {
+      const c = ee.shared.setValue(a);
+      c.alpha > 0 && (r.globalAlpha = c.alpha, r.fillStyle = c.toHex(), r.fillRect(i.x, i.y, i.width, i.height), r.globalAlpha = 1);
+    }
+  }
+  /**
+   * Finishes the render pass (no-op for canvas).
+   * @advanced
+   */
+  finishRenderPass() {
+  }
+  /**
+   * Copies a render target into a texture source.
+   * @param {RenderTarget} sourceRenderSurfaceTexture - Source render target.
+   * @param {Texture} destinationTexture - Destination texture.
+   * @param {object} originSrc - Source origin.
+   * @param {number} originSrc.x - Source x origin.
+   * @param {number} originSrc.y - Source y origin.
+   * @param {object} size - Copy size.
+   * @param {number} size.width - Copy width.
+   * @param {number} size.height - Copy height.
+   * @param {object} [originDest] - Destination origin.
+   * @param {number} originDest.x - Destination x origin.
+   * @param {number} originDest.y - Destination y origin.
+   * @advanced
+   */
+  copyToTexture(e, t, a, n, s) {
+    const i = this._renderTargetSystem.getGpuRenderTarget(e).canvas, c = t.source, { context: h } = this._ensureCanvas(c), l = (s == null ? void 0 : s.x) ?? 0, f = (s == null ? void 0 : s.y) ?? 0;
+    return h.drawImage(
+      i,
+      a.x,
+      a.y,
+      n.width,
+      n.height,
+      l,
+      f,
+      n.width,
+      n.height
+    ), c.update(), t;
+  }
+  /**
+   * Destroys a GPU render target (no-op for canvas).
+   * @param _gpuRenderTarget - Target to destroy.
+   * @advanced
+   */
+  destroyGpuRenderTarget(e) {
+  }
+  _ensureCanvas(e) {
+    let t = e.resource;
+    (!t || !et.test(t)) && (t = E.get().createCanvas(e.pixelWidth, e.pixelHeight), e.resource = t), (t.width !== e.pixelWidth || t.height !== e.pixelHeight) && (t.width = e.pixelWidth, t.height = e.pixelHeight);
+    const a = t.getContext("2d");
+    return { canvas: t, context: a };
+  }
+}
+class Fe extends at {
+  constructor(e) {
+    super(e), this.adaptor = new Mt(), this.adaptor.init(e, this);
+  }
+}
+Fe.extension = {
+  type: [R.CanvasSystem],
+  name: "renderTarget"
+};
+class Ve {
+  /**
+   * @param renderer - The owning CanvasRenderer.
+   */
+  constructor(e) {
+  }
+  /** Initializes the system (no-op for canvas). */
+  init() {
+  }
+  /**
+   * Initializes a texture source (no-op for canvas).
+   * @param _source - Texture source.
+   */
+  initSource(e) {
+  }
+  /**
+   * Creates a canvas containing the texture's frame.
+   * @param texture - Texture to render.
+   */
+  generateCanvas(e) {
+    const t = E.get().createCanvas(), a = t.getContext("2d"), n = d.getCanvasSource(e);
+    if (!n)
+      return t;
+    const s = e.frame, r = e.source._resolution ?? e.source.resolution ?? 1, i = s.x * r, c = s.y * r, h = s.width * r, l = s.height * r;
+    return t.width = Math.ceil(h), t.height = Math.ceil(l), a.drawImage(
+      n,
+      i,
+      c,
+      h,
+      l,
+      0,
+      0,
+      h,
+      l
+    ), t;
+  }
+  /**
+   * Reads pixel data from a texture.
+   * @param texture - Texture to read.
+   */
+  getPixels(e) {
+    const t = this.generateCanvas(e);
+    return {
+      pixels: t.getContext("2d", { willReadFrequently: !0 }).getImageData(0, 0, t.width, t.height).data,
+      width: t.width,
+      height: t.height
+    };
+  }
+  /** Destroys the system (no-op for canvas). */
+  destroy() {
+  }
+}
+Ve.extension = {
+  type: [
+    R.CanvasSystem
+  ],
+  name: "texture"
+};
+const bt = [
+  ...st,
+  Ue,
+  Oe,
+  Ve,
+  Fe
+], wt = [
+  ot,
+  rt,
+  it,
+  ct,
+  lt,
+  Ge,
+  We,
+  ht
+], kt = [
+  dt,
+  Ee
+], qe = [], Le = [], $e = [];
+he.handleByNamedList(R.CanvasSystem, qe);
+he.handleByNamedList(R.CanvasPipes, Le);
+he.handleByNamedList(R.CanvasPipesAdaptor, $e);
+he.add(...bt, ...wt, ...kt);
+class At extends tt {
+  constructor() {
+    const e = {
+      name: "canvas",
+      type: nt.CANVAS,
+      systems: qe,
+      renderPipes: Le,
+      renderPipeAdaptors: $e
+    };
+    super(e);
+  }
+}
+export {
+  At as CanvasRenderer
+};
+//# sourceMappingURL=CanvasRenderer-DVQieOII.js.map