@qy_better_lib/hooks 0.0.15 → 0.1.1

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

@@ -0,0 +1,570 @@
+import { GeometryUtil as d } from "../util.js";
+import { isValid as B, drawArc as G, drawPoints as O, arcToCurves as P } from "./util.js";
+import { Line as y } from "../line.js";
+import { Point as C } from "../point.js";
+import { Curve as L } from "../curve.js";
+import { Polyline as E } from "../polyline.js";
+import { Rectangle as J } from "../rectangle.js";
+import { Geometry as Q } from "../geometry.js";
+import { Close as q } from "./close.js";
+import { LineTo as z } from "./lineto.js";
+import { MoveTo as D } from "./moveto.js";
+import { CurveTo as M } from "./curveto.js";
+import { normalizePathData as k } from "./normalize.js";
+class h extends Q {
+  constructor(t) {
+    if (super(), this.PRECISION = 3, this.segments = [], Array.isArray(t))
+      if (y.isLine(t[0]) || L.isCurve(t[0])) {
+        let n = null;
+        t.forEach((s, i) => {
+          i === 0 && this.appendSegment(h.createSegment("M", s.start)), n != null && !n.end.equals(s.start) && this.appendSegment(h.createSegment("M", s.start)), y.isLine(s) ? this.appendSegment(h.createSegment("L", s.end)) : L.isCurve(s) && this.appendSegment(h.createSegment("C", s.controlPoint1, s.controlPoint2, s.end)), n = s;
+        });
+      } else
+        t.forEach((e) => {
+          e.isSegment && this.appendSegment(e);
+        });
+    else t != null && (y.isLine(t) ? (this.appendSegment(h.createSegment("M", t.start)), this.appendSegment(h.createSegment("L", t.end))) : L.isCurve(t) ? (this.appendSegment(h.createSegment("M", t.start)), this.appendSegment(h.createSegment("C", t.controlPoint1, t.controlPoint2, t.end))) : E.isPolyline(t) ? t.points && t.points.length && t.points.forEach((n, e) => {
+      const s = e === 0 ? h.createSegment("M", n) : h.createSegment("L", n);
+      this.appendSegment(s);
+    }) : t.isSegment && this.appendSegment(t));
+  }
+  get start() {
+    const t = this.segments, n = t.length;
+    if (n === 0)
+      return null;
+    for (let e = 0; e < n; e += 1) {
+      const s = t[e];
+      if (s.isVisible)
+        return s.start;
+    }
+    return t[n - 1].end;
+  }
+  get end() {
+    const t = this.segments, n = t.length;
+    if (n === 0)
+      return null;
+    for (let e = n - 1; e >= 0; e -= 1) {
+      const s = t[e];
+      if (s.isVisible)
+        return s.end;
+    }
+    return t[n - 1].end;
+  }
+  moveTo(...t) {
+    return this.appendSegment(D.create.call(null, ...t));
+  }
+  lineTo(...t) {
+    return this.appendSegment(z.create.call(null, ...t));
+  }
+  curveTo(...t) {
+    return this.appendSegment(M.create.call(null, ...t));
+  }
+  arcTo(t, n, e, s, i, r, o) {
+    const l = this.end || new C(), g = typeof r == "number" ? P(l.x, l.y, t, n, e, s, i, r, o) : P(l.x, l.y, t, n, e, s, i, r.x, r.y);
+    if (g != null)
+      for (let c = 0, u = g.length; c < u; c += 6)
+        this.curveTo(g[c], g[c + 1], g[c + 2], g[c + 3], g[c + 4], g[c + 5]);
+    return this;
+  }
+  quadTo(t, n, e, s) {
+    const i = this.end || new C(), r = ["M", i.x, i.y];
+    if (typeof t == "number")
+      r.push("Q", t, n, e, s);
+    else {
+      const l = n;
+      r.push("Q", t.x, t.y, l.x, l.y);
+    }
+    const o = h.parse(r.join(" "));
+    return this.appendSegment(o.segments.slice(1)), this;
+  }
+  close() {
+    return this.appendSegment(q.create());
+  }
+  drawPoints(t, n = {}) {
+    const e = O(t, n), s = h.parse(e);
+    s && s.segments && this.appendSegment(s.segments);
+  }
+  bbox() {
+    const t = this.segments, n = t.length;
+    if (n === 0)
+      return null;
+    let e;
+    for (let i = 0; i < n; i += 1) {
+      const r = t[i];
+      if (r.isVisible) {
+        const o = r.bbox();
+        o != null && (e = e ? e.union(o) : o);
+      }
+    }
+    if (e != null)
+      return e;
+    const s = t[n - 1];
+    return new J(s.end.x, s.end.y, 0, 0);
+  }
+  appendSegment(t) {
+    const n = this.segments.length;
+    let e = n !== 0 ? this.segments[n - 1] : null, s;
+    const i = null;
+    if (Array.isArray(t))
+      for (let r = 0, o = t.length; r < o; r += 1) {
+        const l = t[r];
+        s = this.prepareSegment(l, e, i), this.segments.push(s), e = s;
+      }
+    else t != null && t.isSegment && (s = this.prepareSegment(t, e, i), this.segments.push(s));
+    return this;
+  }
+  insertSegment(t, n) {
+    const e = this.segments.length;
+    if (t < 0 && (t = e + t + 1), t > e || t < 0)
+      throw new Error("Index out of range.");
+    let s, i = null, r = null;
+    if (e !== 0 && (t >= 1 ? (i = this.segments[t - 1], r = i.nextSegment) : (i = null, r = this.segments[0])), !Array.isArray(n))
+      s = this.prepareSegment(n, i, r), this.segments.splice(t, 0, s);
+    else
+      for (let o = 0, l = n.length; o < l; o += 1) {
+        const g = n[o];
+        s = this.prepareSegment(g, i, r), this.segments.splice(t + o, 0, s), i = s;
+      }
+    return this;
+  }
+  removeSegment(t) {
+    const n = this.fixIndex(t), e = this.segments.splice(n, 1)[0], s = e.previousSegment, i = e.nextSegment;
+    return s && (s.nextSegment = i), i && (i.previousSegment = s), e.isSubpathStart && i && this.updateSubpathStartSegment(i), e;
+  }
+  replaceSegment(t, n) {
+    const e = this.fixIndex(t);
+    let s;
+    const i = this.segments[e];
+    let r = i.previousSegment;
+    const o = i.nextSegment;
+    let l = i.isSubpathStart;
+    if (!Array.isArray(n))
+      s = this.prepareSegment(n, r, o), this.segments.splice(e, 1, s), l && s.isSubpathStart && (l = !1);
+    else {
+      this.segments.splice(t, 1);
+      for (let g = 0, c = n.length; g < c; g += 1) {
+        const u = n[g];
+        s = this.prepareSegment(u, r, o), this.segments.splice(t + g, 0, s), r = s, l && s.isSubpathStart && (l = !1);
+      }
+    }
+    l && o && this.updateSubpathStartSegment(o);
+  }
+  getSegment(t) {
+    const n = this.fixIndex(t);
+    return this.segments[n];
+  }
+  fixIndex(t) {
+    const n = this.segments.length;
+    if (n === 0)
+      throw new Error("Path has no segments.");
+    let e = t;
+    for (; e < 0; )
+      e = n + e;
+    if (e >= n || e < 0)
+      throw new Error("Index out of range.");
+    return e;
+  }
+  segmentAt(t, n = {}) {
+    const e = this.segmentIndexAt(t, n);
+    return e ? this.getSegment(e) : null;
+  }
+  segmentAtLength(t, n = {}) {
+    const e = this.segmentIndexAtLength(t, n);
+    return e ? this.getSegment(e) : null;
+  }
+  segmentIndexAt(t, n = {}) {
+    if (this.segments.length === 0)
+      return null;
+    const e = d.clamp(t, 0, 1), s = this.getOptions(n), r = this.length(s) * e;
+    return this.segmentIndexAtLength(r, s);
+  }
+  segmentIndexAtLength(t, n = {}) {
+    const e = this.segments.length;
+    if (e === 0)
+      return null;
+    let s = !0;
+    t < 0 && (s = !1, t = -t);
+    const i = this.getPrecision(n), r = this.getSubdivisions(n);
+    let o = 0, l = null;
+    for (let g = 0; g < e; g += 1) {
+      const c = s ? g : e - 1 - g, u = this.segments[c], m = r[c], a = u.length({ precision: i, subdivisions: m });
+      if (u.isVisible) {
+        if (t <= o + a)
+          return c;
+        l = c;
+      }
+      o += a;
+    }
+    return l;
+  }
+  getSegmentSubdivisions(t = {}) {
+    const n = this.getPrecision(t), e = [];
+    for (let s = 0, i = this.segments.length; s < i; s += 1) {
+      const o = this.segments[s].getSubdivisions({ precision: n });
+      e.push(o);
+    }
+    return e;
+  }
+  updateSubpathStartSegment(t) {
+    let n = t.previousSegment, e = t;
+    for (; e && !e.isSubpathStart; )
+      n != null ? e.subpathStartSegment = n.subpathStartSegment : e.subpathStartSegment = null, n = e, e = e.nextSegment;
+  }
+  prepareSegment(t, n, e) {
+    t.previousSegment = n, t.nextSegment = e, n != null && (n.nextSegment = t), e != null && (e.previousSegment = t);
+    let s = t;
+    return t.isSubpathStart && (t.subpathStartSegment = t, s = e), s != null && this.updateSubpathStartSegment(s), t;
+  }
+  closestPoint(t, n = {}) {
+    const e = this.closestPointT(t, n);
+    return e ? this.pointAtT(e) : null;
+  }
+  closestPointLength(t, n = {}) {
+    const e = this.getOptions(n), s = this.closestPointT(t, e);
+    return s ? this.lengthAtT(s, e) : 0;
+  }
+  closestPointNormalizedLength(t, n = {}) {
+    const e = this.getOptions(n), s = this.closestPointLength(t, e);
+    if (s === 0)
+      return 0;
+    const i = this.length(e);
+    return i === 0 ? 0 : s / i;
+  }
+  closestPointT(t, n = {}) {
+    if (this.segments.length === 0)
+      return null;
+    const e = this.getPrecision(n), s = this.getSubdivisions(n);
+    let i, r = 1 / 0;
+    for (let o = 0, l = this.segments.length; o < l; o += 1) {
+      const g = this.segments[o], c = s[o];
+      if (g.isVisible) {
+        const u = g.closestPointT(t, {
+          precision: e,
+          subdivisions: c
+        }), m = g.pointAtT(u), a = d.squaredLength(m, t);
+        a < r && (i = { segmentIndex: o, value: u }, r = a);
+      }
+    }
+    return i || { segmentIndex: this.segments.length - 1, value: 1 };
+  }
+  closestPointTangent(t, n = {}) {
+    if (this.segments.length === 0)
+      return null;
+    const e = this.getPrecision(n), s = this.getSubdivisions(n);
+    let i, r = 1 / 0;
+    for (let o = 0, l = this.segments.length; o < l; o += 1) {
+      const g = this.segments[o], c = s[o];
+      if (g.isDifferentiable()) {
+        const u = g.closestPointT(t, {
+          precision: e,
+          subdivisions: c
+        }), m = g.pointAtT(u), a = d.squaredLength(m, t);
+        a < r && (i = g.tangentAtT(u), r = a);
+      }
+    }
+    return i || null;
+  }
+  containsPoint(t, n = {}) {
+    const e = this.toPolylines(n);
+    if (!e)
+      return !1;
+    let s = 0;
+    for (let i = 0, r = e.length; i < r; i += 1)
+      e[i].containsPoint(t) && (s += 1);
+    return s % 2 === 1;
+  }
+  pointAt(t, n = {}) {
+    if (this.segments.length === 0)
+      return null;
+    if (t <= 0)
+      return this.start.clone();
+    if (t >= 1)
+      return this.end.clone();
+    const e = this.getOptions(n), i = this.length(e) * t;
+    return this.pointAtLength(i, e);
+  }
+  pointAtLength(t, n = {}) {
+    if (this.segments.length === 0)
+      return null;
+    if (t === 0)
+      return this.start.clone();
+    let e = !0;
+    t < 0 && (e = !1, t = -t);
+    const s = this.getPrecision(n), i = this.getSubdivisions(n);
+    let r, o = 0;
+    for (let g = 0, c = this.segments.length; g < c; g += 1) {
+      const u = e ? g : c - 1 - g, m = this.segments[u], a = i[u], S = m.length({
+        precision: s,
+        subdivisions: a
+      });
+      if (m.isVisible) {
+        if (t <= o + S)
+          return m.pointAtLength((e ? 1 : -1) * (t - o), {
+            precision: s,
+            subdivisions: a
+          });
+        r = m;
+      }
+      o += S;
+    }
+    return r ? e ? r.end : r.start : this.segments[this.segments.length - 1].end.clone();
+  }
+  pointAtT(t) {
+    const n = this.segments, e = n.length;
+    if (e === 0)
+      return null;
+    const s = t.segmentIndex;
+    if (s < 0)
+      return n[0].pointAtT(0);
+    if (s >= e)
+      return n[e - 1].pointAtT(1);
+    const i = d.clamp(t.value, 0, 1);
+    return n[s].pointAtT(i);
+  }
+  divideAt(t, n = {}) {
+    if (this.segments.length === 0)
+      return null;
+    const e = d.clamp(t, 0, 1), s = this.getOptions(n), r = this.length(s) * e;
+    return this.divideAtLength(r, s);
+  }
+  divideAtLength(t, n = {}) {
+    if (this.segments.length === 0)
+      return null;
+    let e = !0;
+    t < 0 && (e = !1, t = -t);
+    const s = this.getPrecision(n), i = this.getSubdivisions(n);
+    let r = 0, o, l, g, c, u;
+    for (let p = 0, T = this.segments.length; p < T; p += 1) {
+      const v = e ? p : T - 1 - p, A = this.getSegment(v), I = i[v], w = { precision: s, subdivisions: I }, V = A.length(w);
+      if (A.isDifferentiable() && (g = A, c = v, t <= r + V)) {
+        l = v, o = A.divideAtLength((e ? 1 : -1) * (t - r), w);
+        break;
+      }
+      r += V;
+    }
+    if (!g)
+      return null;
+    o || (l = c, u = e ? 1 : 0, o = g.divideAtT(u));
+    const m = this.clone(), a = l;
+    m.replaceSegment(a, o);
+    const S = a;
+    let b = a + 1, x = a + 2;
+    o[0].isDifferentiable() || (m.removeSegment(S), b -= 1, x -= 1);
+    const N = m.getSegment(b).start;
+    m.insertSegment(b, h.createSegment("M", N)), x += 1, o[1].isDifferentiable() || (m.removeSegment(x - 1), x -= 1);
+    const Z = x - S - 1;
+    for (let p = x, T = m.segments.length; p < T; p += 1) {
+      const v = this.getSegment(p - Z), A = m.getSegment(p);
+      if (A.type === "Z" && !v.subpathStartSegment.end.equals(A.subpathStartSegment.end)) {
+        const I = h.createSegment("L", v.end);
+        m.replaceSegment(p, I);
+      }
+    }
+    const R = new h(m.segments.slice(0, b)), j = new h(m.segments.slice(b));
+    return [R, j];
+  }
+  intersectsWithLine(t, n = {}) {
+    const e = this.toPolylines(n);
+    if (e == null)
+      return null;
+    let s = null;
+    for (let i = 0, r = e.length; i < r; i += 1) {
+      const o = e[i], l = t.intersect(o);
+      l && (s == null && (s = []), Array.isArray(l) ? s.push(...l) : s.push(l));
+    }
+    return s;
+  }
+  isDifferentiable() {
+    for (let t = 0, n = this.segments.length; t < n; t += 1)
+      if (this.segments[t].isDifferentiable())
+        return !0;
+    return !1;
+  }
+  isValid() {
+    const t = this.segments;
+    return t.length === 0 || t[0].type === "M";
+  }
+  length(t = {}) {
+    if (this.segments.length === 0)
+      return 0;
+    const n = this.getSubdivisions(t);
+    let e = 0;
+    for (let s = 0, i = this.segments.length; s < i; s += 1) {
+      const r = this.segments[s], o = n[s];
+      e += r.length({ subdivisions: o });
+    }
+    return e;
+  }
+  lengthAtT(t, n = {}) {
+    const e = this.segments.length;
+    if (e === 0)
+      return 0;
+    let s = t.segmentIndex;
+    if (s < 0)
+      return 0;
+    let i = d.clamp(t.value, 0, 1);
+    s >= e && (s = e - 1, i = 1);
+    const r = this.getPrecision(n), o = this.getSubdivisions(n);
+    let l = 0;
+    for (let u = 0; u < s; u += 1) {
+      const m = this.segments[u], a = o[u];
+      l += m.length({ precision: r, subdivisions: a });
+    }
+    const g = this.segments[s], c = o[s];
+    return l += g.lengthAtT(i, { precision: r, subdivisions: c }), l;
+  }
+  tangentAt(t, n = {}) {
+    if (this.segments.length === 0)
+      return null;
+    const e = d.clamp(t, 0, 1), s = this.getOptions(n), r = this.length(s) * e;
+    return this.tangentAtLength(r, s);
+  }
+  tangentAtLength(t, n = {}) {
+    if (this.segments.length === 0)
+      return null;
+    let e = !0;
+    t < 0 && (e = !1, t = -t);
+    const s = this.getPrecision(n), i = this.getSubdivisions(n);
+    let r, o = 0;
+    for (let l = 0, g = this.segments.length; l < g; l += 1) {
+      const c = e ? l : g - 1 - l, u = this.segments[c], m = i[c], a = u.length({ precision: s, subdivisions: m });
+      if (u.isDifferentiable()) {
+        if (t <= o + a)
+          return u.tangentAtLength((e ? 1 : -1) * (t - o), {
+            precision: s,
+            subdivisions: m
+          });
+        r = u;
+      }
+      o += a;
+    }
+    if (r) {
+      const l = e ? 1 : 0;
+      return r.tangentAtT(l);
+    }
+    return null;
+  }
+  tangentAtT(t) {
+    const n = this.segments.length;
+    if (n === 0)
+      return null;
+    const e = t.segmentIndex;
+    if (e < 0)
+      return this.segments[0].tangentAtT(0);
+    if (e >= n)
+      return this.segments[n - 1].tangentAtT(1);
+    const s = d.clamp(t.value, 0, 1);
+    return this.segments[e].tangentAtT(s);
+  }
+  getPrecision(t = {}) {
+    return t.precision == null ? this.PRECISION : t.precision;
+  }
+  getSubdivisions(t = {}) {
+    if (t.segmentSubdivisions == null) {
+      const n = this.getPrecision(t);
+      return this.getSegmentSubdivisions({ precision: n });
+    }
+    return t.segmentSubdivisions;
+  }
+  getOptions(t = {}) {
+    const n = this.getPrecision(t), e = this.getSubdivisions(t);
+    return { precision: n, segmentSubdivisions: e };
+  }
+  toPoints(t = {}) {
+    const n = this.segments, e = n.length;
+    if (e === 0)
+      return null;
+    const s = this.getSubdivisions(t), i = [];
+    let r = [];
+    for (let o = 0; o < e; o += 1) {
+      const l = n[o];
+      if (l.isVisible) {
+        const g = s[o];
+        g.length > 0 ? g.forEach((c) => r.push(c.start)) : r.push(l.start);
+      } else r.length > 0 && (r.push(n[o - 1].end), i.push(r), r = []);
+    }
+    return r.length > 0 && (r.push(this.end), i.push(r)), i;
+  }
+  toPolylines(t = {}) {
+    const n = this.toPoints(t);
+    return n ? n.map((e) => new E(e)) : null;
+  }
+  scale(t, n, e) {
+    return this.segments.forEach((s) => s.scale(t, n, e)), this;
+  }
+  rotate(t, n) {
+    return this.segments.forEach((e) => e.rotate(t, n)), this;
+  }
+  translate(t, n) {
+    return typeof t == "number" ? this.segments.forEach((e) => e.translate(t, n)) : this.segments.forEach((e) => e.translate(t)), this;
+  }
+  clone() {
+    const t = new h();
+    return this.segments.forEach((n) => t.appendSegment(n.clone())), t;
+  }
+  equals(t) {
+    if (t == null)
+      return !1;
+    const n = this.segments, e = t.segments, s = n.length;
+    if (e.length !== s)
+      return !1;
+    for (let i = 0; i < s; i += 1) {
+      const r = n[i], o = e[i];
+      if (r.type !== o.type || !r.equals(o))
+        return !1;
+    }
+    return !0;
+  }
+  toJSON() {
+    return this.segments.map((t) => t.toJSON());
+  }
+  serialize() {
+    if (!this.isValid())
+      throw new Error("Invalid path segments.");
+    return this.segments.map((t) => t.serialize()).join(" ");
+  }
+  toString() {
+    return this.serialize();
+  }
+}
+(function(f) {
+  function t(n) {
+    return n != null && n instanceof f;
+  }
+  f.isPath = t;
+})(h || (h = {}));
+(function(f) {
+  function t(e) {
+    if (!e)
+      return new f();
+    const s = new f(), i = /(?:[a-zA-Z] *)(?:(?:-?\d+(?:\.\d+)?(?:e[-+]?\d+)? *,? *)|(?:-?\.\d+ *,? *))+|(?:[a-zA-Z] *)(?! |\d|-|\.)/g, r = f.normalize(e).match(i);
+    if (r != null)
+      for (let o = 0, l = r.length; o < l; o += 1) {
+        const g = r[o], c = /(?:[a-zA-Z])|(?:(?:-?\d+(?:\.\d+)?(?:e[-+]?\d+)?))|(?:(?:-?\.\d+))/g, u = g.match(c);
+        if (u != null) {
+          const m = u[0], a = u.slice(1).map((b) => +b), S = n.call(null, m, ...a);
+          s.appendSegment(S);
+        }
+      }
+    return s;
+  }
+  f.parse = t;
+  function n(e, ...s) {
+    if (e === "M")
+      return D.create.call(null, ...s);
+    if (e === "L")
+      return z.create.call(null, ...s);
+    if (e === "C")
+      return M.create.call(null, ...s);
+    if (e === "z" || e === "Z")
+      return q.create();
+    throw new Error(`Invalid path segment type "${e}"`);
+  }
+  f.createSegment = n;
+})(h || (h = {}));
+(function(f) {
+  f.normalize = k, f.isValid = B, f.drawArc = G, f.drawPoints = O, f.arcToCurves = P;
+})(h || (h = {}));
+export {
+  h as Path
+};

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

@@ -0,0 +1,44 @@
+import { Geometry as n } from "../geometry.js";
+class s extends n {
+  constructor() {
+    super(...arguments), this.isVisible = !0, this.isSegment = !0, this.isSubpathStart = !1;
+  }
+  get end() {
+    return this.endPoint;
+  }
+  get start() {
+    if (this.previousSegment == null)
+      throw new Error("Missing previous segment. (This segment cannot be the first segment of a path, or segment has not yet been added to a path.)");
+    return this.previousSegment.end;
+  }
+  closestPointT(t, i) {
+    if (this.closestPointNormalizedLength)
+      return this.closestPointNormalizedLength(t);
+    throw new Error("Neither `closestPointT` nor `closestPointNormalizedLength` method is implemented.");
+  }
+  // eslint-disable-next-line
+  lengthAtT(t, i) {
+    if (t <= 0)
+      return 0;
+    const e = this.length();
+    return t >= 1 ? e : e * t;
+  }
+  divideAtT(t) {
+    if (this.divideAt)
+      return this.divideAt(t);
+    throw new Error("Neither `divideAtT` nor `divideAt` method is implemented.");
+  }
+  pointAtT(t) {
+    if (this.pointAt)
+      return this.pointAt(t);
+    throw new Error("Neither `pointAtT` nor `pointAt` method is implemented.");
+  }
+  tangentAtT(t) {
+    if (this.tangentAt)
+      return this.tangentAt(t);
+    throw new Error("Neither `tangentAtT` nor `tangentAt` method is implemented.");
+  }
+}
+export {
+  s as Segment
+};

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

@@ -0,0 +1,80 @@
+import { Point as J } from "../point.js";
+const U = new RegExp("^[\\s\\dLMCZz,.]*$");
+function _(n) {
+  return typeof n != "string" ? !1 : U.test(n);
+}
+function $(n, c) {
+  return (n % c + c) % c;
+}
+function W(n, c, e, s, m) {
+  const u = [], M = n[n.length - 1], d = c != null && c > 0, r = c || 0;
+  if (s && d) {
+    n = n.slice();
+    const t = n[0], h = new J(M.x + (t.x - M.x) / 2, M.y + (t.y - M.y) / 2);
+    n.splice(0, 0, h);
+  }
+  let i = n[0], a = 1;
+  for (e ? u.push("M", i.x, i.y) : u.push("L", i.x, i.y); a < (s ? n.length : n.length - 1); ) {
+    let t = n[$(a, n.length)], h = i.x - t.x, o = i.y - t.y;
+    if (d && (h !== 0 || o !== 0) && (m == null || m.indexOf(a - 1) < 0)) {
+      let l = Math.sqrt(h * h + o * o);
+      const C = h * Math.min(r, l / 2) / l, j = o * Math.min(r, l / 2) / l, N = t.x + C, p = t.y + j;
+      u.push("L", N, p);
+      let x = n[$(a + 1, n.length)];
+      for (; a < n.length - 2 && Math.round(x.x - t.x) === 0 && Math.round(x.y - t.y) === 0; )
+        x = n[$(a + 2, n.length)], a += 1;
+      h = x.x - t.x, o = x.y - t.y, l = Math.max(1, Math.sqrt(h * h + o * o));
+      const q = h * Math.min(r, l / 2) / l, g = o * Math.min(r, l / 2) / l, y = t.x + q, E = t.y + g;
+      u.push("Q", t.x, t.y, y, E), t = new J(y, E);
+    } else
+      u.push("L", t.x, t.y);
+    i = t, a += 1;
+  }
+  return s ? u.push("Z") : u.push("L", M.x, M.y), u.map((t) => typeof t == "string" ? t : +t.toFixed(3)).join(" ");
+}
+function tt(n, c = {}) {
+  const e = [];
+  return n && n.length && n.forEach((s) => {
+    Array.isArray(s) ? e.push({ x: s[0], y: s[1] }) : e.push({ x: s.x, y: s.y });
+  }), W(e, c.round, c.initialMove == null || c.initialMove, c.close, c.exclude);
+}
+function X(n, c, e, s, m = 0, u = 0, M = 0, d, r) {
+  if (e === 0 || s === 0)
+    return [];
+  d -= n, r -= c, e = Math.abs(e), s = Math.abs(s);
+  const i = -d / 2, a = -r / 2, t = Math.cos(m * Math.PI / 180), h = Math.sin(m * Math.PI / 180), o = t * i + h * a, l = -1 * h * i + t * a, C = o * o, j = l * l, N = e * e, p = s * s, x = C / N + j / p;
+  let q;
+  if (x > 1)
+    e = Math.sqrt(x) * e, s = Math.sqrt(x) * s, q = 0;
+  else {
+    let f = 1;
+    u === M && (f = -1), q = f * Math.sqrt((N * p - N * j - p * C) / (N * j + p * C));
+  }
+  const g = q * e * l / s, y = -1 * q * s * o / e, E = t * g - h * y + d / 2, K = h * g + t * y + r / 2;
+  let P = Math.atan2((l - y) / s, (o - g) / e) - Math.atan2(0, 1), z = P >= 0 ? P : 2 * Math.PI + P;
+  P = Math.atan2((-l - y) / s, (-o - g) / e) - Math.atan2((l - y) / s, (o - g) / e);
+  let L = P >= 0 ? P : 2 * Math.PI + P;
+  M === 0 && L > 0 ? L -= 2 * Math.PI : M !== 0 && L < 0 && (L += 2 * Math.PI);
+  const O = L * 2 / Math.PI, k = Math.ceil(O < 0 ? -1 * O : O), S = L / k, Z = 8 / 3 * Math.sin(S / 4) * Math.sin(S / 4) / Math.sin(S / 2), Q = t * e, R = t * s, T = h * e, V = h * s;
+  let b = Math.cos(z), w = Math.sin(z), B = -Z * (Q * w + V * b), F = -Z * (T * w - R * b), v = 0, D = 0;
+  const I = [];
+  for (let f = 0; f < k; f += 1) {
+    z += S, b = Math.cos(z), w = Math.sin(z), v = Q * b - V * w + E, D = T * b + R * w + K;
+    const G = -Z * (Q * w + V * b), H = -Z * (T * w - R * b), A = f * 6;
+    I[A] = Number(B + n), I[A + 1] = Number(F + c), I[A + 2] = Number(v - G + n), I[A + 3] = Number(D - H + c), I[A + 4] = Number(v + n), I[A + 5] = Number(D + c), B = v + G, F = D + H;
+  }
+  return I.map((f) => +f.toFixed(2));
+}
+function nt(n, c, e, s, m = 0, u = 0, M = 0, d, r) {
+  const i = [], a = X(n, c, e, s, m, u, M, d, r);
+  if (a != null)
+    for (let t = 0, h = a.length; t < h; t += 6)
+      i.push("C", a[t], a[t + 1], a[t + 2], a[t + 3], a[t + 4], a[t + 5]);
+  return i.join(" ");
+}
+export {
+  X as arcToCurves,
+  nt as drawArc,
+  tt as drawPoints,
+  _ as isValid
+};