shadow$provide.module$node_modules$pixi_DOT_js$lib$scene$graphics$shared$GraphicsContext = function(global, require, module, exports) {
  module = require("module$node_modules$eventemitter3$index");
  var Color = require("module$node_modules$pixi_DOT_js$lib$color$Color"), Matrix = require("module$node_modules$pixi_DOT_js$lib$maths$matrix$Matrix"), Point = require("module$node_modules$pixi_DOT_js$lib$maths$point$Point");
  global = require("module$node_modules$pixi_DOT_js$lib$rendering$renderers$shared$texture$Texture");
  var uid = require("module$node_modules$pixi_DOT_js$lib$utils$data$uid"), deprecation = require("module$node_modules$pixi_DOT_js$lib$utils$logging$deprecation"), Bounds = require("module$node_modules$pixi_DOT_js$lib$scene$container$bounds$Bounds"), GraphicsPath = require("module$node_modules$pixi_DOT_js$lib$scene$graphics$shared$path$GraphicsPath"), SVGParser = require("module$node_modules$pixi_DOT_js$lib$scene$graphics$shared$svg$SVGParser"), convertFillInputToFillStyle = require("module$node_modules$pixi_DOT_js$lib$scene$graphics$shared$utils$convertFillInputToFillStyle"), 
  getMaxMiterRatio = require("module$node_modules$pixi_DOT_js$lib$scene$graphics$shared$utils$getMaxMiterRatio");
  "use strict";
  const tmpPoint = new Point.Point(), tempMatrix = new Matrix.Matrix(), node_modules$pixi_DOT_js$lib$scene$graphics$shared$GraphicsContext$classdecl$var31 = class extends module {
    constructor() {
      super(...arguments);
      this._gpuData = Object.create(null);
      this.autoGarbageCollect = !0;
      this._gcLastUsed = -1;
      this.uid = uid.uid("graphicsContext");
      this.dirty = !0;
      this.batchMode = "auto";
      this.instructions = [];
      this.destroyed = !1;
      this._activePath = new GraphicsPath.GraphicsPath();
      this._transform = new Matrix.Matrix();
      this._fillStyle = {...node_modules$pixi_DOT_js$lib$scene$graphics$shared$GraphicsContext$classdecl$var31.defaultFillStyle};
      this._strokeStyle = {...node_modules$pixi_DOT_js$lib$scene$graphics$shared$GraphicsContext$classdecl$var31.defaultStrokeStyle};
      this._stateStack = [];
      this._tick = 0;
      this._bounds = new Bounds.Bounds();
      this._boundsDirty = !0;
    }
    clone() {
      const clone = new node_modules$pixi_DOT_js$lib$scene$graphics$shared$GraphicsContext$classdecl$var31();
      clone.batchMode = this.batchMode;
      clone.instructions = this.instructions.slice();
      clone._activePath = this._activePath.clone();
      clone._transform = this._transform.clone();
      clone._fillStyle = {...this._fillStyle};
      clone._strokeStyle = {...this._strokeStyle};
      clone._stateStack = this._stateStack.slice();
      clone._bounds = this._bounds.clone();
      clone._boundsDirty = !0;
      return clone;
    }
    get fillStyle() {
      return this._fillStyle;
    }
    set fillStyle(value) {
      this._fillStyle = convertFillInputToFillStyle.toFillStyle(value, node_modules$pixi_DOT_js$lib$scene$graphics$shared$GraphicsContext$classdecl$var31.defaultFillStyle);
    }
    get strokeStyle() {
      return this._strokeStyle;
    }
    set strokeStyle(value) {
      this._strokeStyle = convertFillInputToFillStyle.toStrokeStyle(value, node_modules$pixi_DOT_js$lib$scene$graphics$shared$GraphicsContext$classdecl$var31.defaultStrokeStyle);
    }
    setFillStyle(style) {
      this._fillStyle = convertFillInputToFillStyle.toFillStyle(style, node_modules$pixi_DOT_js$lib$scene$graphics$shared$GraphicsContext$classdecl$var31.defaultFillStyle);
      return this;
    }
    setStrokeStyle(style) {
      this._strokeStyle = convertFillInputToFillStyle.toFillStyle(style, node_modules$pixi_DOT_js$lib$scene$graphics$shared$GraphicsContext$classdecl$var31.defaultStrokeStyle);
      return this;
    }
    texture(texture, tint, dx, dy, dw, dh) {
      this.instructions.push({action:"texture", data:{image:texture, dx:dx || 0, dy:dy || 0, dw:dw || texture.frame.width, dh:dh || texture.frame.height, transform:this._transform.clone(), alpha:this._fillStyle.alpha, style:tint || 0 === tint ? Color.Color.shared.setValue(tint).toNumber() : 16777215}});
      this.onUpdate();
      return this;
    }
    beginPath() {
      this._activePath = new GraphicsPath.GraphicsPath();
      return this;
    }
    fill(style, alpha) {
      var path = this.instructions[this.instructions.length - 1];
      path = 0 === this._tick && "stroke" === path?.action ? path.data.path : this._activePath.clone();
      if (!path) {
        return this;
      }
      null != style && (void 0 !== alpha && "number" === typeof style && (deprecation.deprecation(deprecation.v8_0_0, "GraphicsContext.fill(color, alpha) is deprecated, use GraphicsContext.fill({ color, alpha }) instead"), style = {color:style, alpha}), this._fillStyle = convertFillInputToFillStyle.toFillStyle(style, node_modules$pixi_DOT_js$lib$scene$graphics$shared$GraphicsContext$classdecl$var31.defaultFillStyle));
      this.instructions.push({action:"fill", data:{style:this.fillStyle, path}});
      this.onUpdate();
      this._initNextPathLocation();
      this._tick = 0;
      return this;
    }
    _initNextPathLocation() {
      const {x, y} = this._activePath.getLastPoint(Point.Point.shared);
      this._activePath.clear();
      this._activePath.moveTo(x, y);
    }
    stroke(style) {
      var path = this.instructions[this.instructions.length - 1];
      path = 0 === this._tick && "fill" === path?.action ? path.data.path : this._activePath.clone();
      if (!path) {
        return this;
      }
      null != style && (this._strokeStyle = convertFillInputToFillStyle.toStrokeStyle(style, node_modules$pixi_DOT_js$lib$scene$graphics$shared$GraphicsContext$classdecl$var31.defaultStrokeStyle));
      this.instructions.push({action:"stroke", data:{style:this.strokeStyle, path}});
      this.onUpdate();
      this._initNextPathLocation();
      this._tick = 0;
      return this;
    }
    cut() {
      for (let i = 0; 2 > i; i++) {
        const lastInstruction = this.instructions[this.instructions.length - 1 - i], holePath = this._activePath.clone();
        if (lastInstruction && ("stroke" === lastInstruction.action || "fill" === lastInstruction.action)) {
          if (lastInstruction.data.hole) {
            lastInstruction.data.hole.addPath(holePath);
          } else {
            lastInstruction.data.hole = holePath;
            break;
          }
        }
      }
      this._initNextPathLocation();
      return this;
    }
    arc(x, y, radius, startAngle, endAngle, counterclockwise) {
      this._tick++;
      const t = this._transform;
      this._activePath.arc(t.a * x + t.c * y + t.tx, t.b * x + t.d * y + t.ty, radius, startAngle, endAngle, counterclockwise);
      return this;
    }
    arcTo(x1, y1, x2, y2, radius) {
      this._tick++;
      const t = this._transform;
      this._activePath.arcTo(t.a * x1 + t.c * y1 + t.tx, t.b * x1 + t.d * y1 + t.ty, t.a * x2 + t.c * y2 + t.tx, t.b * x2 + t.d * y2 + t.ty, radius);
      return this;
    }
    arcToSvg(rx, ry, xAxisRotation, largeArcFlag, sweepFlag, x, y) {
      this._tick++;
      const t = this._transform;
      this._activePath.arcToSvg(rx, ry, xAxisRotation, largeArcFlag, sweepFlag, t.a * x + t.c * y + t.tx, t.b * x + t.d * y + t.ty);
      return this;
    }
    bezierCurveTo(cp1x, cp1y, cp2x, cp2y, x, y, smoothness) {
      this._tick++;
      const t = this._transform;
      this._activePath.bezierCurveTo(t.a * cp1x + t.c * cp1y + t.tx, t.b * cp1x + t.d * cp1y + t.ty, t.a * cp2x + t.c * cp2y + t.tx, t.b * cp2x + t.d * cp2y + t.ty, t.a * x + t.c * y + t.tx, t.b * x + t.d * y + t.ty, smoothness);
      return this;
    }
    closePath() {
      this._tick++;
      this._activePath?.closePath();
      return this;
    }
    ellipse(x, y, radiusX, radiusY) {
      this._tick++;
      this._activePath.ellipse(x, y, radiusX, radiusY, this._transform.clone());
      return this;
    }
    circle(x, y, radius) {
      this._tick++;
      this._activePath.circle(x, y, radius, this._transform.clone());
      return this;
    }
    path(path) {
      this._tick++;
      this._activePath.addPath(path, this._transform.clone());
      return this;
    }
    lineTo(x, y) {
      this._tick++;
      const t = this._transform;
      this._activePath.lineTo(t.a * x + t.c * y + t.tx, t.b * x + t.d * y + t.ty);
      return this;
    }
    moveTo(x, y) {
      this._tick++;
      const t = this._transform, instructions = this._activePath.instructions, transformedX = t.a * x + t.c * y + t.tx;
      x = t.b * x + t.d * y + t.ty;
      if (1 === instructions.length && "moveTo" === instructions[0].action) {
        return instructions[0].data[0] = transformedX, instructions[0].data[1] = x, this;
      }
      this._activePath.moveTo(transformedX, x);
      return this;
    }
    quadraticCurveTo(cpx, cpy, x, y, smoothness) {
      this._tick++;
      const t = this._transform;
      this._activePath.quadraticCurveTo(t.a * cpx + t.c * cpy + t.tx, t.b * cpx + t.d * cpy + t.ty, t.a * x + t.c * y + t.tx, t.b * x + t.d * y + t.ty, smoothness);
      return this;
    }
    rect(x, y, w, h) {
      this._tick++;
      this._activePath.rect(x, y, w, h, this._transform.clone());
      return this;
    }
    roundRect(x, y, w, h, radius) {
      this._tick++;
      this._activePath.roundRect(x, y, w, h, radius, this._transform.clone());
      return this;
    }
    poly(points, close) {
      this._tick++;
      this._activePath.poly(points, close, this._transform.clone());
      return this;
    }
    regularPoly(x, y, radius, sides, rotation = 0, transform) {
      this._tick++;
      this._activePath.regularPoly(x, y, radius, sides, rotation, transform);
      return this;
    }
    roundPoly(x, y, radius, sides, corner, rotation) {
      this._tick++;
      this._activePath.roundPoly(x, y, radius, sides, corner, rotation);
      return this;
    }
    roundShape(points, radius, useQuadratic, smoothness) {
      this._tick++;
      this._activePath.roundShape(points, radius, useQuadratic, smoothness);
      return this;
    }
    filletRect(x, y, width, height, fillet) {
      this._tick++;
      this._activePath.filletRect(x, y, width, height, fillet);
      return this;
    }
    chamferRect(x, y, width, height, chamfer, transform) {
      this._tick++;
      this._activePath.chamferRect(x, y, width, height, chamfer, transform);
      return this;
    }
    star(x, y, points, radius, innerRadius = 0, rotation = 0) {
      this._tick++;
      this._activePath.star(x, y, points, radius, innerRadius, rotation, this._transform.clone());
      return this;
    }
    svg(svg) {
      this._tick++;
      SVGParser.SVGParser(svg, this);
      return this;
    }
    restore() {
      const state = this._stateStack.pop();
      state && (this._transform = state.transform, this._fillStyle = state.fillStyle, this._strokeStyle = state.strokeStyle);
      return this;
    }
    save() {
      this._stateStack.push({transform:this._transform.clone(), fillStyle:{...this._fillStyle}, strokeStyle:{...this._strokeStyle}});
      return this;
    }
    getTransform() {
      return this._transform;
    }
    resetTransform() {
      this._transform.identity();
      return this;
    }
    rotate(angle) {
      this._transform.rotate(angle);
      return this;
    }
    scale(x, y = x) {
      this._transform.scale(x, y);
      return this;
    }
    setTransform(a, b, c, d, dx, dy) {
      if (a instanceof Matrix.Matrix) {
        return this._transform.set(a.a, a.b, a.c, a.d, a.tx, a.ty), this;
      }
      this._transform.set(a, b, c, d, dx, dy);
      return this;
    }
    transform(a, b, c, d, dx, dy) {
      if (a instanceof Matrix.Matrix) {
        return this._transform.append(a), this;
      }
      tempMatrix.set(a, b, c, d, dx, dy);
      this._transform.append(tempMatrix);
      return this;
    }
    translate(x, y = x) {
      this._transform.translate(x, y);
      return this;
    }
    clear() {
      this._activePath.clear();
      this.instructions.length = 0;
      this.resetTransform();
      this.onUpdate();
      return this;
    }
    onUpdate() {
      this.dirty = this._boundsDirty = !0;
      this.emit("update", this, 16);
    }
    get bounds() {
      if (!this._boundsDirty) {
        return this._bounds;
      }
      this._boundsDirty = !1;
      const bounds = this._bounds;
      bounds.clear();
      for (let i = 0; i < this.instructions.length; i++) {
        var instruction = this.instructions[i], action = instruction.action;
        if ("fill" === action) {
          bounds.addBounds(instruction.data.path.bounds);
        } else if ("texture" === action) {
          const data = instruction.data;
          bounds.addFrame(data.dx, data.dy, data.dx + data.dw, data.dy + data.dh, data.transform);
        }
        "stroke" === action && (action = instruction.data, instruction = action.style.width * (1 - action.style.alignment), "miter" === action.style.join && (instruction *= getMaxMiterRatio.getMaxMiterRatio(action.path, action.style.miterLimit)), action = action.path.bounds, bounds.addFrame(action.minX - instruction, action.minY - instruction, action.maxX + instruction, action.maxY + instruction));
      }
      bounds.isValid || bounds.set(0, 0, 0, 0);
      return bounds;
    }
    containsPoint(point) {
      if (!this.bounds.containsPoint(point.x, point.y)) {
        return !1;
      }
      const instructions = this.instructions;
      var hasHit = !1;
      for (let k = 0; k < instructions.length; k++) {
        const instruction = instructions[k], data = instruction.data;
        var path = data.path;
        if (!instruction.action || !path) {
          continue;
        }
        const style = data.style;
        path = path.shapePath.shapePrimitives;
        for (let i = 0; i < path.length; i++) {
          var shape = path[i].shape;
          if (!style || !shape) {
            continue;
          }
          const transformedPoint = (hasHit = path[i].transform) ? hasHit.applyInverse(point, tmpPoint) : point;
          "fill" === instruction.action ? hasHit = shape.contains(transformedPoint.x, transformedPoint.y) : (hasHit = style, hasHit = shape.strokeContains(transformedPoint.x, transformedPoint.y, hasHit.width, hasHit.alignment));
          if (shape = data.hole) {
            if (shape = shape.shapePath?.shapePrimitives) {
              for (let j = 0; j < shape.length; j++) {
                shape[j].shape.contains(transformedPoint.x, transformedPoint.y) && (hasHit = !1);
              }
            }
          }
          if (hasHit) {
            return !0;
          }
        }
      }
      return hasHit;
    }
    unload() {
      this.emit("unload", this);
      for (const key in this._gpuData) {
        this._gpuData[key]?.destroy();
      }
      this._gpuData = Object.create(null);
    }
    destroy(options = !1) {
      if (!this.destroyed) {
        this.destroyed = !0;
        this._stateStack.length = 0;
        this._transform = null;
        this.unload();
        this.emit("destroy", this);
        this.removeAllListeners();
        if ("boolean" === typeof options ? options : options?.texture) {
          options = "boolean" === typeof options ? options : options?.textureSource, this._fillStyle.texture && (this._fillStyle.fill && "uid" in this._fillStyle.fill ? this._fillStyle.fill.destroy() : this._fillStyle.texture.destroy(options)), this._strokeStyle.texture && (this._strokeStyle.fill && "uid" in this._strokeStyle.fill ? this._strokeStyle.fill.destroy() : this._strokeStyle.texture.destroy(options));
        }
        this._transform = this.customShader = this._stateStack = this._bounds = this._activePath = this.instructions = this._strokeStyle = this._fillStyle = null;
      }
    }
  };
  require = node_modules$pixi_DOT_js$lib$scene$graphics$shared$GraphicsContext$classdecl$var31;
  require.defaultFillStyle = {color:16777215, alpha:1, texture:global.Texture.WHITE, matrix:null, fill:null, textureSpace:"local"};
  require.defaultStrokeStyle = {width:1, color:16777215, alpha:1, alignment:0.5, miterLimit:10, cap:"butt", join:"miter", texture:global.Texture.WHITE, matrix:null, fill:null, textureSpace:"local", pixelLine:!1};
  exports.GraphicsContext = require;
};

//# sourceMappingURL=module$node_modules$pixi_DOT_js$lib$scene$graphics$shared$GraphicsContext.js.map
