Initial

resources/app/node_modules/@pixi/math/lib/shapes/Rectangle.js

@@ -0,0 +1,141 @@
+"use strict";
+var _const = require("../const.js"), Point = require("../Point.js");
+const tempPoints = [new Point.Point(), new Point.Point(), new Point.Point(), new Point.Point()];
+class Rectangle {
+  /**
+   * @param x - The X coordinate of the upper-left corner of the rectangle
+   * @param y - The Y coordinate of the upper-left corner of the rectangle
+   * @param width - The overall width of the rectangle
+   * @param height - The overall height of the rectangle
+   */
+  constructor(x = 0, y = 0, width = 0, height = 0) {
+    this.x = Number(x), this.y = Number(y), this.width = Number(width), this.height = Number(height), this.type = _const.SHAPES.RECT;
+  }
+  /** Returns the left edge of the rectangle. */
+  get left() {
+    return this.x;
+  }
+  /** Returns the right edge of the rectangle. */
+  get right() {
+    return this.x + this.width;
+  }
+  /** Returns the top edge of the rectangle. */
+  get top() {
+    return this.y;
+  }
+  /** Returns the bottom edge of the rectangle. */
+  get bottom() {
+    return this.y + this.height;
+  }
+  /** A constant empty rectangle. */
+  static get EMPTY() {
+    return new Rectangle(0, 0, 0, 0);
+  }
+  /**
+   * Creates a clone of this Rectangle
+   * @returns a copy of the rectangle
+   */
+  clone() {
+    return new Rectangle(this.x, this.y, this.width, this.height);
+  }
+  /**
+   * Copies another rectangle to this one.
+   * @param rectangle - The rectangle to copy from.
+   * @returns Returns itself.
+   */
+  copyFrom(rectangle) {
+    return this.x = rectangle.x, this.y = rectangle.y, this.width = rectangle.width, this.height = rectangle.height, this;
+  }
+  /**
+   * Copies this rectangle to another one.
+   * @param rectangle - The rectangle to copy to.
+   * @returns Returns given parameter.
+   */
+  copyTo(rectangle) {
+    return rectangle.x = this.x, rectangle.y = this.y, rectangle.width = this.width, rectangle.height = this.height, rectangle;
+  }
+  /**
+   * Checks whether the x and y coordinates given are contained within this Rectangle
+   * @param x - The X coordinate of the point to test
+   * @param y - The Y coordinate of the point to test
+   * @returns Whether the x/y coordinates are within this Rectangle
+   */
+  contains(x, y) {
+    return this.width <= 0 || this.height <= 0 ? !1 : x >= this.x && x < this.x + this.width && y >= this.y && y < this.y + this.height;
+  }
+  /**
+   * Determines whether the `other` Rectangle transformed by `transform` intersects with `this` Rectangle object.
+   * Returns true only if the area of the intersection is >0, this means that Rectangles
+   * sharing a side are not overlapping. Another side effect is that an arealess rectangle
+   * (width or height equal to zero) can't intersect any other rectangle.
+   * @param {Rectangle} other - The Rectangle to intersect with `this`.
+   * @param {Matrix} transform - The transformation matrix of `other`.
+   * @returns {boolean} A value of `true` if the transformed `other` Rectangle intersects with `this`; otherwise `false`.
+   */
+  intersects(other, transform) {
+    if (!transform) {
+      const x02 = this.x < other.x ? other.x : this.x;
+      if ((this.right > other.right ? other.right : this.right) <= x02)
+        return !1;
+      const y02 = this.y < other.y ? other.y : this.y;
+      return (this.bottom > other.bottom ? other.bottom : this.bottom) > y02;
+    }
+    const x0 = this.left, x1 = this.right, y0 = this.top, y1 = this.bottom;
+    if (x1 <= x0 || y1 <= y0)
+      return !1;
+    const lt = tempPoints[0].set(other.left, other.top), lb = tempPoints[1].set(other.left, other.bottom), rt = tempPoints[2].set(other.right, other.top), rb = tempPoints[3].set(other.right, other.bottom);
+    if (rt.x <= lt.x || lb.y <= lt.y)
+      return !1;
+    const s = Math.sign(transform.a * transform.d - transform.b * transform.c);
+    if (s === 0 || (transform.apply(lt, lt), transform.apply(lb, lb), transform.apply(rt, rt), transform.apply(rb, rb), Math.max(lt.x, lb.x, rt.x, rb.x) <= x0 || Math.min(lt.x, lb.x, rt.x, rb.x) >= x1 || Math.max(lt.y, lb.y, rt.y, rb.y) <= y0 || Math.min(lt.y, lb.y, rt.y, rb.y) >= y1))
+      return !1;
+    const nx = s * (lb.y - lt.y), ny = s * (lt.x - lb.x), n00 = nx * x0 + ny * y0, n10 = nx * x1 + ny * y0, n01 = nx * x0 + ny * y1, n11 = nx * x1 + ny * y1;
+    if (Math.max(n00, n10, n01, n11) <= nx * lt.x + ny * lt.y || Math.min(n00, n10, n01, n11) >= nx * rb.x + ny * rb.y)
+      return !1;
+    const mx = s * (lt.y - rt.y), my = s * (rt.x - lt.x), m00 = mx * x0 + my * y0, m10 = mx * x1 + my * y0, m01 = mx * x0 + my * y1, m11 = mx * x1 + my * y1;
+    return !(Math.max(m00, m10, m01, m11) <= mx * lt.x + my * lt.y || Math.min(m00, m10, m01, m11) >= mx * rb.x + my * rb.y);
+  }
+  /**
+   * Pads the rectangle making it grow in all directions.
+   * If paddingY is omitted, both paddingX and paddingY will be set to paddingX.
+   * @param paddingX - The horizontal padding amount.
+   * @param paddingY - The vertical padding amount.
+   * @returns Returns itself.
+   */
+  pad(paddingX = 0, paddingY = paddingX) {
+    return this.x -= paddingX, this.y -= paddingY, this.width += paddingX * 2, this.height += paddingY * 2, this;
+  }
+  /**
+   * Fits this rectangle around the passed one.
+   * @param rectangle - The rectangle to fit.
+   * @returns Returns itself.
+   */
+  fit(rectangle) {
+    const x1 = Math.max(this.x, rectangle.x), x2 = Math.min(this.x + this.width, rectangle.x + rectangle.width), y1 = Math.max(this.y, rectangle.y), y2 = Math.min(this.y + this.height, rectangle.y + rectangle.height);
+    return this.x = x1, this.width = Math.max(x2 - x1, 0), this.y = y1, this.height = Math.max(y2 - y1, 0), this;
+  }
+  /**
+   * Enlarges rectangle that way its corners lie on grid
+   * @param resolution - resolution
+   * @param eps - precision
+   * @returns Returns itself.
+   */
+  ceil(resolution = 1, eps = 1e-3) {
+    const x2 = Math.ceil((this.x + this.width - eps) * resolution) / resolution, y2 = Math.ceil((this.y + this.height - eps) * resolution) / resolution;
+    return this.x = Math.floor((this.x + eps) * resolution) / resolution, this.y = Math.floor((this.y + eps) * resolution) / resolution, this.width = x2 - this.x, this.height = y2 - this.y, this;
+  }
+  /**
+   * Enlarges this rectangle to include the passed rectangle.
+   * @param rectangle - The rectangle to include.
+   * @returns Returns itself.
+   */
+  enlarge(rectangle) {
+    const x1 = Math.min(this.x, rectangle.x), x2 = Math.max(this.x + this.width, rectangle.x + rectangle.width), y1 = Math.min(this.y, rectangle.y), y2 = Math.max(this.y + this.height, rectangle.y + rectangle.height);
+    return this.x = x1, this.width = x2 - x1, this.y = y1, this.height = y2 - y1, this;
+  }
+}
+Rectangle.prototype.toString = function() {
+  return `[@pixi/math:Rectangle x=${this.x} y=${this.y} width=${this.width} height=${this.height}]`;
+};
+exports.Rectangle = Rectangle;
+//# sourceMappingURL=Rectangle.js.map