@qy_better_lib/hooks 0.1.2 → 0.1.3

package/lib/packages/hooks/node_modules/@antv/x6-geometry/es/line.js

@@ -1,286 +0,0 @@
-import { Point as i } from "./point.js";
-import { Geometry as u } from "./geometry.js";
-import { Rectangle as l } from "./rectangle.js";
-class h extends u {
-  get center() {
-    return new i((this.start.x + this.end.x) / 2, (this.start.y + this.end.y) / 2);
-  }
-  constructor(t, e, s, n) {
-    super(), typeof t == "number" && typeof e == "number" ? (this.start = new i(t, e), this.end = new i(s, n)) : (this.start = i.create(t), this.end = i.create(e));
-  }
-  getCenter() {
-    return this.center;
-  }
-  /**
-   * Rounds the line to the given `precision`.
-   */
-  round(t = 0) {
-    return this.start.round(t), this.end.round(t), this;
-  }
-  translate(t, e) {
-    return typeof t == "number" ? (this.start.translate(t, e), this.end.translate(t, e)) : (this.start.translate(t), this.end.translate(t)), this;
-  }
-  /**
-   * Rotate the line by `angle` around `origin`.
-   */
-  rotate(t, e) {
-    return this.start.rotate(t, e), this.end.rotate(t, e), this;
-  }
-  /**
-   * Scale the line by `sx` and `sy` about the given `origin`. If origin is not
-   * specified, the line is scaled around `0,0`.
-   */
-  scale(t, e, s) {
-    return this.start.scale(t, e, s), this.end.scale(t, e, s), this;
-  }
-  /**
-   * Returns the length of the line.
-   */
-  length() {
-    return Math.sqrt(this.squaredLength());
-  }
-  /**
-   * Useful for distance comparisons in which real length is not necessary
-   * (saves one `Math.sqrt()` operation).
-   */
-  squaredLength() {
-    const t = this.start.x - this.end.x, e = this.start.y - this.end.y;
-    return t * t + e * e;
-  }
-  /**
-   * Scale the line so that it has the requested length. The start point of
-   * the line is preserved.
-   */
-  setLength(t) {
-    const e = this.length();
-    if (!e)
-      return this;
-    const s = t / e;
-    return this.scale(s, s, this.start);
-  }
-  parallel(t) {
-    const e = this.clone();
-    if (!e.isDifferentiable())
-      return e;
-    const { start: s, end: n } = e, r = s.clone().rotate(270, n), a = n.clone().rotate(90, s);
-    return s.move(a, t), n.move(r, t), e;
-  }
-  /**
-   * Returns the vector of the line with length equal to length of the line.
-   */
-  vector() {
-    return new i(this.end.x - this.start.x, this.end.y - this.start.y);
-  }
-  /**
-   * Returns the angle of incline of the line.
-   *
-   * The function returns `NaN` if the start and end endpoints of the line
-   * both lie at the same coordinates(it is impossible to determine the angle
-   * of incline of a line that appears to be a point). The
-   * `line.isDifferentiable()` function may be used in advance to determine
-   * whether the angle of incline can be computed for a given line.
-   */
-  angle() {
-    const t = new i(this.start.x + 1, this.start.y);
-    return this.start.angleBetween(this.end, t);
-  }
-  /**
-   * Returns a rectangle that is the bounding box of the line.
-   */
-  bbox() {
-    const t = Math.min(this.start.x, this.end.x), e = Math.min(this.start.y, this.end.y), s = Math.max(this.start.x, this.end.x), n = Math.max(this.start.y, this.end.y);
-    return new l(t, e, s - t, n - e);
-  }
-  /**
-   * Returns the bearing (cardinal direction) of the line.
-   *
-   * The return value is one of the following strings:
-   * 'NE', 'E', 'SE', 'S', 'SW', 'W', 'NW' and 'N'.
-   *
-   * The function returns 'N' if the two endpoints of the line are coincident.
-   */
-  bearing() {
-    return this.start.bearing(this.end);
-  }
-  /**
-   * Returns the point on the line that lies closest to point `p`.
-   */
-  closestPoint(t) {
-    return this.pointAt(this.closestPointNormalizedLength(t));
-  }
-  /**
-   * Returns the length of the line up to the point that lies closest to point `p`.
-   */
-  closestPointLength(t) {
-    return this.closestPointNormalizedLength(t) * this.length();
-  }
-  /**
-   * Returns a line that is tangent to the line at the point that lies closest
-   * to point `p`.
-   */
-  closestPointTangent(t) {
-    return this.tangentAt(this.closestPointNormalizedLength(t));
-  }
-  /**
-   * Returns the normalized length (distance from the start of the line / total
-   * line length) of the line up to the point that lies closest to point.
-   */
-  closestPointNormalizedLength(t) {
-    const e = this.vector().dot(new h(this.start, t).vector()), s = Math.min(1, Math.max(0, e / this.squaredLength()));
-    return Number.isNaN(s) ? 0 : s;
-  }
-  /**
-   * Returns a point on the line that lies `rate` (normalized length) away from
-   * the beginning of the line.
-   */
-  pointAt(t) {
-    const e = this.start, s = this.end;
-    return t <= 0 ? e.clone() : t >= 1 ? s.clone() : e.lerp(s, t);
-  }
-  /**
-   * Returns a point on the line that lies length away from the beginning of
-   * the line.
-   */
-  pointAtLength(t) {
-    const e = this.start, s = this.end;
-    let n = !0;
-    t < 0 && (n = !1, t = -t);
-    const r = this.length();
-    if (t >= r)
-      return n ? s.clone() : e.clone();
-    const a = (n ? t : r - t) / r;
-    return this.pointAt(a);
-  }
-  /**
-   * Divides the line into two lines at the point that lies `rate` (normalized
-   * length) away from the beginning of the line.
-   */
-  divideAt(t) {
-    const e = this.pointAt(t);
-    return [
-      new h(this.start, e),
-      new h(e, this.end)
-    ];
-  }
-  /**
-   * Divides the line into two lines at the point that lies length away from
-   * the beginning of the line.
-   */
-  divideAtLength(t) {
-    const e = this.pointAtLength(t);
-    return [
-      new h(this.start, e),
-      new h(e, this.end)
-    ];
-  }
-  /**
-   * Returns `true` if the point `p` lies on the line. Return `false` otherwise.
-   */
-  containsPoint(t) {
-    const e = this.start, s = this.end;
-    if (e.cross(t, s) !== 0)
-      return !1;
-    const n = this.length();
-    return !(new h(e, t).length() > n || new h(t, s).length() > n);
-  }
-  intersect(t, e) {
-    const s = t.intersectsWithLine(this, e);
-    return s ? Array.isArray(s) ? s : [s] : null;
-  }
-  /**
-   * Returns the intersection point of the line with another line. Returns
-   * `null` if no intersection exists.
-   */
-  intersectsWithLine(t) {
-    const e = new i(this.end.x - this.start.x, this.end.y - this.start.y), s = new i(t.end.x - t.start.x, t.end.y - t.start.y), n = e.x * s.y - e.y * s.x, r = new i(t.start.x - this.start.x, t.start.y - this.start.y), a = r.x * s.y - r.y * s.x, o = r.x * e.y - r.y * e.x;
-    if (n === 0 || a * n < 0 || o * n < 0)
-      return null;
-    if (n > 0) {
-      if (a > n || o > n)
-        return null;
-    } else if (a < n || o < n)
-      return null;
-    return new i(this.start.x + a * e.x / n, this.start.y + a * e.y / n);
-  }
-  /**
-   * Returns `true` if a tangent line can be found for the line.
-   *
-   * Tangents cannot be found if both of the line endpoints are coincident
-   * (the line appears to be a point).
-   */
-  isDifferentiable() {
-    return !this.start.equals(this.end);
-  }
-  /**
-   * Returns the perpendicular distance between the line and point. The
-   * distance is positive if the point lies to the right of the line, negative
-   * if the point lies to the left of the line, and `0` if the point lies on
-   * the line.
-   */
-  pointOffset(t) {
-    const e = i.clone(t), s = this.start, n = this.end;
-    return ((n.x - s.x) * (e.y - s.y) - (n.y - s.y) * (e.x - s.x)) / this.length();
-  }
-  pointSquaredDistance(t, e) {
-    const s = i.create(t, e);
-    return this.closestPoint(s).squaredDistance(s);
-  }
-  pointDistance(t, e) {
-    const s = i.create(t, e);
-    return this.closestPoint(s).distance(s);
-  }
-  /**
-   * Returns a line tangent to the line at point that lies `rate` (normalized
-   * length) away from the beginning of the line.
-   */
-  tangentAt(t) {
-    if (!this.isDifferentiable())
-      return null;
-    const e = this.start, s = this.end, n = this.pointAt(t), r = new h(e, s);
-    return r.translate(n.x - e.x, n.y - e.y), r;
-  }
-  /**
-   * Returns a line tangent to the line at point that lies `length` away from
-   * the beginning of the line.
-   */
-  tangentAtLength(t) {
-    if (!this.isDifferentiable())
-      return null;
-    const e = this.start, s = this.end, n = this.pointAtLength(t), r = new h(e, s);
-    return r.translate(n.x - e.x, n.y - e.y), r;
-  }
-  relativeCcw(t, e) {
-    const s = i.create(t, e);
-    let n = s.x - this.start.x, r = s.y - this.start.y;
-    const a = this.end.x - this.start.x, o = this.end.y - this.start.y;
-    let c = n * o - r * a;
-    return c === 0 && (c = n * a + r * o, c > 0 && (n -= a, r -= o, c = n * a + r * o, c < 0 && (c = 0))), c < 0 ? -1 : c > 0 ? 1 : 0;
-  }
-  /**
-   * Return `true` if the line equals the other line.
-   */
-  equals(t) {
-    return t != null && this.start.x === t.start.x && this.start.y === t.start.y && this.end.x === t.end.x && this.end.y === t.end.y;
-  }
-  /**
-   * Returns another line which is a clone of the line.
-   */
-  clone() {
-    return new h(this.start, this.end);
-  }
-  toJSON() {
-    return { start: this.start.toJSON(), end: this.end.toJSON() };
-  }
-  serialize() {
-    return [this.start.serialize(), this.end.serialize()].join(" ");
-  }
-}
-(function(d) {
-  function t(e) {
-    return e != null && e instanceof d;
-  }
-  d.isLine = t;
-})(h || (h = {}));
-export {
-  h as Line
-};

package/lib/packages/hooks/node_modules/@antv/x6-geometry/es/path/close.js

@@ -1,101 +0,0 @@
-import { Line as s } from "../line.js";
-import { LineTo as n } from "./lineto.js";
-import { Segment as h } from "./segment.js";
-class i extends h {
-  get end() {
-    if (!this.subpathStartSegment)
-      throw new Error("Missing subpath start segment. (This segment needs a subpath start segment (e.g. MoveTo), or segment has not yet been added to a path.)");
-    return this.subpathStartSegment.end;
-  }
-  get type() {
-    return "Z";
-  }
-  get line() {
-    return new s(this.start, this.end);
-  }
-  bbox() {
-    return this.line.bbox();
-  }
-  closestPoint(t) {
-    return this.line.closestPoint(t);
-  }
-  closestPointLength(t) {
-    return this.line.closestPointLength(t);
-  }
-  closestPointNormalizedLength(t) {
-    return this.line.closestPointNormalizedLength(t);
-  }
-  closestPointTangent(t) {
-    return this.line.closestPointTangent(t);
-  }
-  length() {
-    return this.line.length();
-  }
-  divideAt(t) {
-    const e = this.line.divideAt(t);
-    return [
-      // do not actually cut into the segment, first divided part can stay as Z
-      e[1].isDifferentiable() ? new n(e[0]) : this.clone(),
-      new n(e[1])
-    ];
-  }
-  divideAtLength(t) {
-    const e = this.line.divideAtLength(t);
-    return [
-      e[1].isDifferentiable() ? new n(e[0]) : this.clone(),
-      new n(e[1])
-    ];
-  }
-  getSubdivisions() {
-    return [];
-  }
-  pointAt(t) {
-    return this.line.pointAt(t);
-  }
-  pointAtLength(t) {
-    return this.line.pointAtLength(t);
-  }
-  tangentAt(t) {
-    return this.line.tangentAt(t);
-  }
-  tangentAtLength(t) {
-    return this.line.tangentAtLength(t);
-  }
-  isDifferentiable() {
-    return !this.previousSegment || !this.subpathStartSegment ? !1 : !this.start.equals(this.end);
-  }
-  scale() {
-    return this;
-  }
-  rotate() {
-    return this;
-  }
-  translate() {
-    return this;
-  }
-  equals(t) {
-    return this.type === t.type && this.start.equals(t.start) && this.end.equals(t.end);
-  }
-  clone() {
-    return new i();
-  }
-  toJSON() {
-    return {
-      type: this.type,
-      start: this.start.toJSON(),
-      end: this.end.toJSON()
-    };
-  }
-  serialize() {
-    return this.type;
-  }
-}
-(function(r) {
-  function t() {
-    return new r();
-  }
-  r.create = t;
-})(i || (i = {}));
-export {
-  i as Close
-};

package/lib/packages/hooks/node_modules/@antv/x6-geometry/es/path/curveto.js

@@ -1,118 +0,0 @@
-import { Curve as u } from "../curve.js";
-import { Point as s } from "../point.js";
-import { Segment as d } from "./segment.js";
-class i extends d {
-  constructor(t, n, e, r, h, o) {
-    super(), u.isCurve(t) ? (this.controlPoint1 = t.controlPoint1.clone().round(2), this.controlPoint2 = t.controlPoint2.clone().round(2), this.endPoint = t.end.clone().round(2)) : typeof t == "number" ? (this.controlPoint1 = new s(t, n).round(2), this.controlPoint2 = new s(e, r).round(2), this.endPoint = new s(h, o).round(2)) : (this.controlPoint1 = s.create(t).round(2), this.controlPoint2 = s.create(n).round(2), this.endPoint = s.create(e).round(2));
-  }
-  get type() {
-    return "C";
-  }
-  get curve() {
-    return new u(this.start, this.controlPoint1, this.controlPoint2, this.end);
-  }
-  bbox() {
-    return this.curve.bbox();
-  }
-  closestPoint(t) {
-    return this.curve.closestPoint(t);
-  }
-  closestPointLength(t) {
-    return this.curve.closestPointLength(t);
-  }
-  closestPointNormalizedLength(t) {
-    return this.curve.closestPointNormalizedLength(t);
-  }
-  closestPointTangent(t) {
-    return this.curve.closestPointTangent(t);
-  }
-  length() {
-    return this.curve.length();
-  }
-  divideAt(t, n = {}) {
-    const e = this.curve.divideAt(t, n);
-    return [new i(e[0]), new i(e[1])];
-  }
-  divideAtLength(t, n = {}) {
-    const e = this.curve.divideAtLength(t, n);
-    return [new i(e[0]), new i(e[1])];
-  }
-  divideAtT(t) {
-    const n = this.curve.divideAtT(t);
-    return [new i(n[0]), new i(n[1])];
-  }
-  getSubdivisions() {
-    return [];
-  }
-  pointAt(t) {
-    return this.curve.pointAt(t);
-  }
-  pointAtLength(t) {
-    return this.curve.pointAtLength(t);
-  }
-  tangentAt(t) {
-    return this.curve.tangentAt(t);
-  }
-  tangentAtLength(t) {
-    return this.curve.tangentAtLength(t);
-  }
-  isDifferentiable() {
-    if (!this.previousSegment)
-      return !1;
-    const t = this.start, n = this.controlPoint1, e = this.controlPoint2, r = this.end;
-    return !(t.equals(n) && n.equals(e) && e.equals(r));
-  }
-  scale(t, n, e) {
-    return this.controlPoint1.scale(t, n, e), this.controlPoint2.scale(t, n, e), this.end.scale(t, n, e), this;
-  }
-  rotate(t, n) {
-    return this.controlPoint1.rotate(t, n), this.controlPoint2.rotate(t, n), this.end.rotate(t, n), this;
-  }
-  translate(t, n) {
-    return typeof t == "number" ? (this.controlPoint1.translate(t, n), this.controlPoint2.translate(t, n), this.end.translate(t, n)) : (this.controlPoint1.translate(t), this.controlPoint2.translate(t), this.end.translate(t)), this;
-  }
-  equals(t) {
-    return this.start.equals(t.start) && this.end.equals(t.end) && this.controlPoint1.equals(t.controlPoint1) && this.controlPoint2.equals(t.controlPoint2);
-  }
-  clone() {
-    return new i(this.controlPoint1, this.controlPoint2, this.end);
-  }
-  toJSON() {
-    return {
-      type: this.type,
-      start: this.start.toJSON(),
-      controlPoint1: this.controlPoint1.toJSON(),
-      controlPoint2: this.controlPoint2.toJSON(),
-      end: this.end.toJSON()
-    };
-  }
-  serialize() {
-    const t = this.controlPoint1, n = this.controlPoint2, e = this.end;
-    return [this.type, t.x, t.y, n.x, n.y, e.x, e.y].join(" ");
-  }
-}
-(function(c) {
-  function t(...n) {
-    const e = n.length, r = n[0];
-    if (u.isCurve(r))
-      return new c(r);
-    if (s.isPointLike(r)) {
-      if (e === 3)
-        return new c(n[0], n[1], n[2]);
-      const o = [];
-      for (let l = 0; l < e; l += 3)
-        o.push(new c(n[l], n[l + 1], n[l + 2]));
-      return o;
-    }
-    if (e === 6)
-      return new c(n[0], n[1], n[2], n[3], n[4], n[5]);
-    const h = [];
-    for (let o = 0; o < e; o += 6)
-      h.push(new c(n[o], n[o + 1], n[o + 2], n[o + 3], n[o + 4], n[o + 5]));
-    return h;
-  }
-  c.create = t;
-})(i || (i = {}));
-export {
-  i as CurveTo
-};

package/lib/packages/hooks/node_modules/@antv/x6-geometry/es/path/lineto.js

@@ -1,105 +0,0 @@
-import { Line as h } from "../line.js";
-import { Point as u } from "../point.js";
-import { Segment as c } from "./segment.js";
-class n extends c {
-  constructor(t, e) {
-    super(), h.isLine(t) ? this.endPoint = t.end.clone().round(2) : this.endPoint = u.create(t, e).round(2);
-  }
-  get type() {
-    return "L";
-  }
-  get line() {
-    return new h(this.start, this.end);
-  }
-  bbox() {
-    return this.line.bbox();
-  }
-  closestPoint(t) {
-    return this.line.closestPoint(t);
-  }
-  closestPointLength(t) {
-    return this.line.closestPointLength(t);
-  }
-  closestPointNormalizedLength(t) {
-    return this.line.closestPointNormalizedLength(t);
-  }
-  closestPointTangent(t) {
-    return this.line.closestPointTangent(t);
-  }
-  length() {
-    return this.line.length();
-  }
-  divideAt(t) {
-    const e = this.line.divideAt(t);
-    return [new n(e[0]), new n(e[1])];
-  }
-  divideAtLength(t) {
-    const e = this.line.divideAtLength(t);
-    return [new n(e[0]), new n(e[1])];
-  }
-  getSubdivisions() {
-    return [];
-  }
-  pointAt(t) {
-    return this.line.pointAt(t);
-  }
-  pointAtLength(t) {
-    return this.line.pointAtLength(t);
-  }
-  tangentAt(t) {
-    return this.line.tangentAt(t);
-  }
-  tangentAtLength(t) {
-    return this.line.tangentAtLength(t);
-  }
-  isDifferentiable() {
-    return this.previousSegment == null ? !1 : !this.start.equals(this.end);
-  }
-  clone() {
-    return new n(this.end);
-  }
-  scale(t, e, s) {
-    return this.end.scale(t, e, s), this;
-  }
-  rotate(t, e) {
-    return this.end.rotate(t, e), this;
-  }
-  translate(t, e) {
-    return typeof t == "number" ? this.end.translate(t, e) : this.end.translate(t), this;
-  }
-  equals(t) {
-    return this.type === t.type && this.start.equals(t.start) && this.end.equals(t.end);
-  }
-  toJSON() {
-    return {
-      type: this.type,
-      start: this.start.toJSON(),
-      end: this.end.toJSON()
-    };
-  }
-  serialize() {
-    const t = this.end;
-    return `${this.type} ${t.x} ${t.y}`;
-  }
-}
-(function(i) {
-  function t(...e) {
-    const s = e.length, o = e[0];
-    if (h.isLine(o))
-      return new i(o);
-    if (u.isPointLike(o))
-      return s === 1 ? new i(o) : e.map((r) => new i(r));
-    if (s === 2)
-      return new i(+e[0], +e[1]);
-    const l = [];
-    for (let r = 0; r < s; r += 2) {
-      const d = +e[r], a = +e[r + 1];
-      l.push(new i(d, a));
-    }
-    return l;
-  }
-  i.create = t;
-})(n || (n = {}));
-export {
-  n as LineTo
-};