yahee-components 0.0.70 → 0.0.72

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/component/helper/BrushController.js

@@ -0,0 +1,466 @@
+import { __extends as ur } from "../../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.js";
+import { assert as T, each as p, bind as sr, merge as H, clone as l, map as F, curry as c, defaults as or } from "../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js";
+import fr from "../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/Eventful.js";
+import { transformDirection as hr, getTransform as vr } from "../../util/graphic.js";
+import { take as dr, release as pr } from "./interactionMutex.js";
+import gr from "../../data/DataDiffer.js";
+import V from "../../visual/tokens.js";
+import P from "../../../../../../zrender@6.0.0/node_modules/zrender/lib/graphic/Group.js";
+import _r from "../../../../../../zrender@6.0.0/node_modules/zrender/lib/graphic/shape/Polygon.js";
+import mr from "../../../../../../zrender@6.0.0/node_modules/zrender/lib/graphic/shape/Polyline.js";
+import X from "../../../../../../zrender@6.0.0/node_modules/zrender/lib/graphic/shape/Rect.js";
+var _ = !0, y = Math.min, b = Math.max, cr = Math.pow, lr = 1e4, br = 6, Cr = 6, Y = "globalPan", yr = {
+  w: [0, 0],
+  e: [0, 1],
+  n: [1, 0],
+  s: [1, 1]
+}, Er = {
+  w: "ew",
+  e: "ew",
+  n: "ns",
+  s: "ns",
+  ne: "nesw",
+  sw: "nesw",
+  nw: "nwse",
+  se: "nwse"
+}, W = {
+  brushStyle: {
+    lineWidth: 2,
+    stroke: V.color.backgroundTint,
+    fill: V.color.borderTint
+  },
+  transformable: !0,
+  brushMode: "single",
+  removeOnClick: !1
+}, wr = 0, Wr = (
+  /** @class */
+  function(r) {
+    ur(e, r);
+    function e(t) {
+      var n = r.call(this) || this;
+      return n._track = [], n._covers = [], n._handlers = {}, process.env.NODE_ENV !== "production" && T(t), n._zr = t, n.group = new P(), n._uid = "brushController_" + wr++, p(Sr, function(a, i) {
+        this._handlers[i] = sr(a, this);
+      }, n), n;
+    }
+    return e.prototype.enableBrush = function(t) {
+      return process.env.NODE_ENV !== "production" && T(this._mounted), this._brushType && this._doDisableBrush(), t.brushType && this._doEnableBrush(t), this;
+    }, e.prototype._doEnableBrush = function(t) {
+      var n = this._zr;
+      this._enableGlobalPan || dr(n, Y, this._uid), p(this._handlers, function(a, i) {
+        n.on(i, a);
+      }), this._brushType = t.brushType, this._brushOption = H(l(W), t, !0);
+    }, e.prototype._doDisableBrush = function() {
+      var t = this._zr;
+      pr(t, Y, this._uid), p(this._handlers, function(n, a) {
+        t.off(a, n);
+      }), this._brushType = this._brushOption = null;
+    }, e.prototype.setPanels = function(t) {
+      if (t && t.length) {
+        var n = this._panels = {};
+        p(t, function(a) {
+          n[a.panelId] = l(a);
+        });
+      } else
+        this._panels = null;
+      return this;
+    }, e.prototype.mount = function(t) {
+      t = t || {}, process.env.NODE_ENV !== "production" && (this._mounted = !0), this._enableGlobalPan = t.enableGlobalPan;
+      var n = this.group;
+      return this._zr.add(n), n.attr({
+        x: t.x || 0,
+        y: t.y || 0,
+        rotation: t.rotation || 0,
+        scaleX: t.scaleX || 1,
+        scaleY: t.scaleY || 1
+      }), this._transform = n.getLocalTransform(), this;
+    }, e.prototype.updateCovers = function(t) {
+      process.env.NODE_ENV !== "production" && T(this._mounted), t = F(t, function(f) {
+        return H(l(W), f, !0);
+      });
+      var n = "\0-brush-index-", a = this._covers, i = this._covers = [], u = this, s = this._creatingCover;
+      return new gr(a, t, v, o).add(d).update(d).remove(E).execute(), this;
+      function o(f, h) {
+        return (f.id != null ? f.id : n + h) + "-" + f.brushType;
+      }
+      function v(f, h) {
+        return o(f.__brushOption, h);
+      }
+      function d(f, h) {
+        var C = t[f];
+        if (h != null && a[h] === s)
+          i[f] = a[h];
+        else {
+          var w = i[f] = h != null ? (a[h].__brushOption = C, a[h]) : J(u, $(u, C));
+          k(u, w);
+        }
+      }
+      function E(f) {
+        a[f] !== s && u.group.remove(a[f]);
+      }
+    }, e.prototype.unmount = function() {
+      if (!(process.env.NODE_ENV !== "production" && !this._mounted))
+        return this.enableBrush(!1), O(this), this._zr.remove(this.group), process.env.NODE_ENV !== "production" && (this._mounted = !1), this;
+    }, e.prototype.dispose = function() {
+      this.unmount(), this.off();
+    }, e;
+  }(fr)
+);
+function $(r, e) {
+  var t = R[e.brushType].createCover(r, e);
+  return t.__brushOption = e, q(t, e), r.group.add(t), t;
+}
+function J(r, e) {
+  var t = z(e);
+  return t.endCreating && (t.endCreating(r, e), q(e, e.__brushOption)), e;
+}
+function Q(r, e) {
+  var t = e.__brushOption;
+  z(e).updateCoverShape(r, e, t.range, t);
+}
+function q(r, e) {
+  var t = e.z;
+  t == null && (t = lr), r.traverse(function(n) {
+    n.z = t, n.z2 = t;
+  });
+}
+function k(r, e) {
+  z(e).updateCommon(r, e), Q(r, e);
+}
+function z(r) {
+  return R[r.__brushOption.brushType];
+}
+function L(r, e, t) {
+  var n = r._panels;
+  if (!n)
+    return _;
+  var a, i = r._transform;
+  return p(n, function(u) {
+    u.isTargetByCursor(e, t, i) && (a = u);
+  }), a;
+}
+function x(r, e) {
+  var t = r._panels;
+  if (!t)
+    return _;
+  var n = e.__brushOption.panelId;
+  return n != null ? t[n] : _;
+}
+function O(r) {
+  var e = r._covers, t = e.length;
+  return p(e, function(n) {
+    r.group.remove(n);
+  }, r), e.length = 0, !!t;
+}
+function m(r, e) {
+  var t = F(r._covers, function(n) {
+    var a = n.__brushOption, i = l(a.range);
+    return {
+      brushType: a.brushType,
+      panelId: a.panelId,
+      range: i
+    };
+  });
+  r.trigger("brush", {
+    areas: t,
+    isEnd: !!e.isEnd,
+    removeOnClick: !!e.removeOnClick
+  });
+}
+function Tr(r) {
+  var e = r._track;
+  if (!e.length)
+    return !1;
+  var t = e[e.length - 1], n = e[0], a = t[0] - n[0], i = t[1] - n[1], u = cr(a * a + i * i, 0.5);
+  return u > br;
+}
+function rr(r) {
+  var e = r.length - 1;
+  return e < 0 && (e = 0), [r[0], r[e]];
+}
+function er(r, e, t, n) {
+  var a = new P();
+  return a.add(new X({
+    name: "main",
+    style: M(t),
+    silent: !0,
+    draggable: !0,
+    cursor: "move",
+    drift: c(Z, r, e, a, ["n", "s", "w", "e"]),
+    ondragend: c(m, e, {
+      isEnd: !0
+    })
+  })), p(n, function(i) {
+    a.add(new X({
+      name: i.join(""),
+      style: {
+        opacity: 0
+      },
+      draggable: !0,
+      silent: !0,
+      invisible: !0,
+      drift: c(Z, r, e, a, i),
+      ondragend: c(m, e, {
+        isEnd: !0
+      })
+    }));
+  }), a;
+}
+function tr(r, e, t, n) {
+  var a = n.brushStyle.lineWidth || 0, i = b(a, Cr), u = t[0][0], s = t[1][0], o = u - a / 2, v = s - a / 2, d = t[0][1], E = t[1][1], f = d - i + a / 2, h = E - i + a / 2, C = d - u, w = E - s, G = C + a, U = w + a;
+  g(r, e, "main", u, s, C, w), n.transformable && (g(r, e, "w", o, v, i, U), g(r, e, "e", f, v, i, U), g(r, e, "n", o, v, G, i), g(r, e, "s", o, h, G, i), g(r, e, "nw", o, v, i, i), g(r, e, "ne", f, v, i, i), g(r, e, "sw", o, h, i, i), g(r, e, "se", f, h, i, i));
+}
+function D(r, e) {
+  var t = e.__brushOption, n = t.transformable, a = e.childAt(0);
+  a.useStyle(M(t)), a.attr({
+    silent: !n,
+    cursor: n ? "move" : "default"
+  }), p([["w"], ["e"], ["n"], ["s"], ["s", "e"], ["s", "w"], ["n", "e"], ["n", "w"]], function(i) {
+    var u = e.childOfName(i.join("")), s = i.length === 1 ? B(r, i[0]) : Or(r, i);
+    u && u.attr({
+      silent: !n,
+      invisible: !n,
+      cursor: n ? Er[s] + "-resize" : null
+    });
+  });
+}
+function g(r, e, t, n, a, i, u) {
+  var s = e.childOfName(t);
+  s && s.setShape(Br(A(r, e, [[n, a], [n + i, a + u]])));
+}
+function M(r) {
+  return or({
+    strokeNoScale: !0
+  }, r.brushStyle);
+}
+function nr(r, e, t, n) {
+  var a = [y(r, t), y(e, n)], i = [b(r, t), b(e, n)];
+  return [
+    [a[0], i[0]],
+    [a[1], i[1]]
+    // y range
+  ];
+}
+function Rr(r) {
+  return vr(r.group);
+}
+function B(r, e) {
+  var t = {
+    w: "left",
+    e: "right",
+    n: "top",
+    s: "bottom"
+  }, n = {
+    left: "w",
+    right: "e",
+    top: "n",
+    bottom: "s"
+  }, a = hr(t[e], Rr(r));
+  return n[a];
+}
+function Or(r, e) {
+  var t = [B(r, e[0]), B(r, e[1])];
+  return (t[0] === "e" || t[0] === "w") && t.reverse(), t.join("");
+}
+function Z(r, e, t, n, a, i) {
+  var u = t.__brushOption, s = r.toRectRange(u.range), o = ar(e, a, i);
+  p(n, function(v) {
+    var d = yr[v];
+    s[d[0]][d[1]] += o[d[0]];
+  }), u.range = r.fromRectRange(nr(s[0][0], s[1][0], s[0][1], s[1][1])), k(e, t), m(e, {
+    isEnd: !1
+  });
+}
+function Dr(r, e, t, n) {
+  var a = e.__brushOption.range, i = ar(r, t, n);
+  p(a, function(u) {
+    u[0] += i[0], u[1] += i[1];
+  }), k(r, e), m(r, {
+    isEnd: !1
+  });
+}
+function ar(r, e, t) {
+  var n = r.group, a = n.transformCoordToLocal(e, t), i = n.transformCoordToLocal(0, 0);
+  return [a[0] - i[0], a[1] - i[1]];
+}
+function A(r, e, t) {
+  var n = x(r, e);
+  return n && n !== _ ? n.clipPath(t, r._transform) : l(t);
+}
+function Br(r) {
+  var e = y(r[0][0], r[1][0]), t = y(r[0][1], r[1][1]), n = b(r[0][0], r[1][0]), a = b(r[0][1], r[1][1]);
+  return {
+    x: e,
+    y: t,
+    width: n - e,
+    height: a - t
+  };
+}
+function Nr(r, e, t) {
+  if (
+    // Check active
+    !(!r._brushType || Pr(r, e.offsetX, e.offsetY))
+  ) {
+    var n = r._zr, a = r._covers, i = L(r, e, t);
+    if (!r._dragging)
+      for (var u = 0; u < a.length; u++) {
+        var s = a[u].__brushOption;
+        if (i && (i === _ || s.panelId === i.panelId) && R[s.brushType].contain(a[u], t[0], t[1]))
+          return;
+      }
+    i && n.setCursorStyle("crosshair");
+  }
+}
+function N(r) {
+  var e = r.event;
+  e.preventDefault && e.preventDefault();
+}
+function S(r, e, t) {
+  return r.childOfName("main").contain(e, t);
+}
+function ir(r, e, t, n) {
+  var a = r._creatingCover, i = r._creatingPanel, u = r._brushOption, s;
+  if (r._track.push(t.slice()), Tr(r) || a) {
+    if (i && !a) {
+      u.brushMode === "single" && O(r);
+      var o = l(u);
+      o.brushType = j(o.brushType, i), o.panelId = i === _ ? null : i.panelId, a = r._creatingCover = $(r, o), r._covers.push(a);
+    }
+    if (a) {
+      var v = R[j(r._brushType, i)], d = a.__brushOption;
+      d.range = v.getCreatingRange(A(r, a, r._track)), n && (J(r, a), v.updateCommon(r, a)), Q(r, a), s = {
+        isEnd: n
+      };
+    }
+  } else n && u.brushMode === "single" && u.removeOnClick && L(r, e, t) && O(r) && (s = {
+    isEnd: n,
+    removeOnClick: !0
+  });
+  return s;
+}
+function j(r, e) {
+  return r === "auto" ? (process.env.NODE_ENV !== "production" && T(e && e.defaultBrushType, 'MUST have defaultBrushType when brushType is "atuo"'), e.defaultBrushType) : r;
+}
+var Sr = {
+  mousedown: function(r) {
+    if (this._dragging)
+      K(this, r);
+    else if (!r.target || !r.target.draggable) {
+      N(r);
+      var e = this.group.transformCoordToLocal(r.offsetX, r.offsetY);
+      this._creatingCover = null;
+      var t = this._creatingPanel = L(this, r, e);
+      t && (this._dragging = !0, this._track = [e.slice()]);
+    }
+  },
+  mousemove: function(r) {
+    var e = r.offsetX, t = r.offsetY, n = this.group.transformCoordToLocal(e, t);
+    if (Nr(this, r, n), this._dragging) {
+      N(r);
+      var a = ir(this, r, n, !1);
+      a && m(this, a);
+    }
+  },
+  mouseup: function(r) {
+    K(this, r);
+  }
+};
+function K(r, e) {
+  if (r._dragging) {
+    N(e);
+    var t = e.offsetX, n = e.offsetY, a = r.group.transformCoordToLocal(t, n), i = ir(r, e, a, !0);
+    r._dragging = !1, r._track = [], r._creatingCover = null, i && m(r, i);
+  }
+}
+function Pr(r, e, t) {
+  var n = r._zr;
+  return e < 0 || e > n.getWidth() || t < 0 || t > n.getHeight();
+}
+var R = {
+  lineX: I(0),
+  lineY: I(1),
+  rect: {
+    createCover: function(r, e) {
+      function t(n) {
+        return n;
+      }
+      return er({
+        toRectRange: t,
+        fromRectRange: t
+      }, r, e, [["w"], ["e"], ["n"], ["s"], ["s", "e"], ["s", "w"], ["n", "e"], ["n", "w"]]);
+    },
+    getCreatingRange: function(r) {
+      var e = rr(r);
+      return nr(e[1][0], e[1][1], e[0][0], e[0][1]);
+    },
+    updateCoverShape: function(r, e, t, n) {
+      tr(r, e, t, n);
+    },
+    updateCommon: D,
+    contain: S
+  },
+  polygon: {
+    createCover: function(r, e) {
+      var t = new P();
+      return t.add(new mr({
+        name: "main",
+        style: M(e),
+        silent: !0
+      })), t;
+    },
+    getCreatingRange: function(r) {
+      return r;
+    },
+    endCreating: function(r, e) {
+      e.remove(e.childAt(0)), e.add(new _r({
+        name: "main",
+        draggable: !0,
+        drift: c(Dr, r, e),
+        ondragend: c(m, r, {
+          isEnd: !0
+        })
+      }));
+    },
+    updateCoverShape: function(r, e, t, n) {
+      e.childAt(0).setShape({
+        points: A(r, e, t)
+      });
+    },
+    updateCommon: D,
+    contain: S
+  }
+};
+function I(r) {
+  return {
+    createCover: function(e, t) {
+      return er({
+        toRectRange: function(n) {
+          var a = [n, [0, 100]];
+          return r && a.reverse(), a;
+        },
+        fromRectRange: function(n) {
+          return n[r];
+        }
+      }, e, t, [[["w"], ["e"]], [["n"], ["s"]]][r]);
+    },
+    getCreatingRange: function(e) {
+      var t = rr(e), n = y(t[0][r], t[1][r]), a = b(t[0][r], t[1][r]);
+      return [n, a];
+    },
+    updateCoverShape: function(e, t, n, a) {
+      var i, u = x(e, t);
+      if (u !== _ && u.getLinearBrushOtherExtent)
+        i = u.getLinearBrushOtherExtent(r);
+      else {
+        var s = e._zr;
+        i = [0, [s.getWidth(), s.getHeight()][1 - r]];
+      }
+      var o = [n, i];
+      r && o.reverse(), tr(e, t, o, a);
+    },
+    updateCommon: D,
+    contain: S
+  };
+}
+export {
+  Wr as default
+};

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/component/helper/BrushTargetManager.js

@@ -0,0 +1,196 @@
+import { each as d, indexOf as f, createHashMap as _, curry as l, assert as x, map as v } from "../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js";
+import { getTransform as b } from "../../util/graphic.js";
+import { makeLinearBrushOtherExtent as P, makeRectIsTargetByCursor as D, makeRectPanelClipPath as R } from "./brushHelper.js";
+import { parseFinder as B } from "../../util/model.js";
+var E = ["grid", "xAxis", "yAxis", "geo", "graph", "polar", "radiusAxis", "angleAxis", "bmap"], O = (
+  /** @class */
+  function() {
+    function i(e, r, t) {
+      var n = this;
+      this._targetInfoList = [];
+      var s = M(r, e);
+      d(L, function(o, a) {
+        (!t || !t.include || f(t.include, a) >= 0) && o(s, n._targetInfoList);
+      });
+    }
+    return i.prototype.setOutputRanges = function(e, r) {
+      return this.matchOutputRanges(e, r, function(t, n, s) {
+        if ((t.coordRanges || (t.coordRanges = [])).push(n), !t.coordRange) {
+          t.coordRange = n;
+          var o = y[t.brushType](0, s, n);
+          t.__rangeOffset = {
+            offset: A[t.brushType](o.values, t.range, [1, 1]),
+            xyMinMax: o.xyMinMax
+          };
+        }
+      }), e;
+    }, i.prototype.matchOutputRanges = function(e, r, t) {
+      d(e, function(n) {
+        var s = this.findTargetInfo(n, r);
+        s && s !== !0 && d(s.coordSyses, function(o) {
+          var a = y[n.brushType](1, o, n.range, !0);
+          t(n, a.values, o, r);
+        });
+      }, this);
+    }, i.prototype.setInputRanges = function(e, r) {
+      d(e, function(t) {
+        var n = this.findTargetInfo(t, r);
+        if (process.env.NODE_ENV !== "production" && (x(!n || n === !0 || t.coordRange, "coordRange must be specified when coord index specified."), x(!n || n !== !0 || t.range, "range must be specified in global brush.")), t.range = t.range || [], n && n !== !0) {
+          t.panelId = n.panelId;
+          var s = y[t.brushType](0, n.coordSys, t.coordRange), o = t.__rangeOffset;
+          t.range = o ? A[t.brushType](s.values, o.offset, k(s.xyMinMax, o.xyMinMax)) : s.values;
+        }
+      }, this);
+    }, i.prototype.makePanelOpts = function(e, r) {
+      return v(this._targetInfoList, function(t) {
+        var n = t.getPanelRect();
+        return {
+          panelId: t.panelId,
+          defaultBrushType: r ? r(t) : null,
+          clipPath: R(n),
+          isTargetByCursor: D(n, e, t.coordSysModel),
+          getLinearBrushOtherExtent: P(n)
+        };
+      });
+    }, i.prototype.controlSeries = function(e, r, t) {
+      var n = this.findTargetInfo(e, t);
+      return n === !0 || n && f(n.coordSyses, r.coordinateSystem) >= 0;
+    }, i.prototype.findTargetInfo = function(e, r) {
+      for (var t = this._targetInfoList, n = M(r, e), s = 0; s < t.length; s++) {
+        var o = t[s], a = e.panelId;
+        if (a) {
+          if (o.panelId === a)
+            return o;
+        } else
+          for (var u = 0; u < m.length; u++)
+            if (m[u](n, o))
+              return o;
+      }
+      return !0;
+    }, i;
+  }()
+);
+function h(i) {
+  return i[0] > i[1] && i.reverse(), i;
+}
+function M(i, e) {
+  return B(i, e, {
+    includeMainTypes: E
+  });
+}
+var L = {
+  grid: function(i, e) {
+    var r = i.xAxisModels, t = i.yAxisModels, n = i.gridModels, s = _(), o = {}, a = {};
+    !r && !t && !n || (d(r, function(u) {
+      var c = u.axis.grid.model;
+      s.set(c.id, c), o[c.id] = !0;
+    }), d(t, function(u) {
+      var c = u.axis.grid.model;
+      s.set(c.id, c), a[c.id] = !0;
+    }), d(n, function(u) {
+      s.set(u.id, u), o[u.id] = !0, a[u.id] = !0;
+    }), s.each(function(u) {
+      var c = u.coordinateSystem, p = [];
+      d(c.getCartesians(), function(g, F) {
+        (f(r, g.getAxis("x").model) >= 0 || f(t, g.getAxis("y").model) >= 0) && p.push(g);
+      }), e.push({
+        panelId: "grid--" + u.id,
+        gridModel: u,
+        coordSysModel: u,
+        // Use the first one as the representitive coordSys.
+        coordSys: p[0],
+        coordSyses: p,
+        getPanelRect: T.grid,
+        xAxisDeclared: o[u.id],
+        yAxisDeclared: a[u.id]
+      });
+    }));
+  },
+  geo: function(i, e) {
+    d(i.geoModels, function(r) {
+      var t = r.coordinateSystem;
+      e.push({
+        panelId: "geo--" + r.id,
+        geoModel: r,
+        coordSysModel: r,
+        coordSys: t,
+        coordSyses: [t],
+        getPanelRect: T.geo
+      });
+    });
+  }
+}, m = [
+  // grid
+  function(i, e) {
+    var r = i.xAxisModel, t = i.yAxisModel, n = i.gridModel;
+    return !n && r && (n = r.axis.grid.model), !n && t && (n = t.axis.grid.model), n && n === e.gridModel;
+  },
+  // geo
+  function(i, e) {
+    var r = i.geoModel;
+    return r && r === e.geoModel;
+  }
+], T = {
+  grid: function() {
+    return this.coordSys.master.getRect().clone();
+  },
+  geo: function() {
+    var i = this.coordSys, e = i.getBoundingRect().clone();
+    return e.applyTransform(b(i)), e;
+  }
+}, y = {
+  lineX: l(I, 0),
+  lineY: l(I, 1),
+  rect: function(i, e, r, t) {
+    var n = i ? e.pointToData([r[0][0], r[1][0]], t) : e.dataToPoint([r[0][0], r[1][0]], t), s = i ? e.pointToData([r[0][1], r[1][1]], t) : e.dataToPoint([r[0][1], r[1][1]], t), o = [h([n[0], s[0]]), h([n[1], s[1]])];
+    return {
+      values: o,
+      xyMinMax: o
+    };
+  },
+  polygon: function(i, e, r, t) {
+    var n = [[1 / 0, -1 / 0], [1 / 0, -1 / 0]], s = v(r, function(o) {
+      var a = i ? e.pointToData(o, t) : e.dataToPoint(o, t);
+      return n[0][0] = Math.min(n[0][0], a[0]), n[1][0] = Math.min(n[1][0], a[1]), n[0][1] = Math.max(n[0][1], a[0]), n[1][1] = Math.max(n[1][1], a[1]), a;
+    });
+    return {
+      values: s,
+      xyMinMax: n
+    };
+  }
+};
+function I(i, e, r, t) {
+  process.env.NODE_ENV !== "production" && x(r.type === "cartesian2d", "lineX/lineY brush is available only in cartesian2d.");
+  var n = r.getAxis(["x", "y"][i]), s = h(v([0, 1], function(a) {
+    return e ? n.coordToData(n.toLocalCoord(t[a]), !0) : n.toGlobalCoord(n.dataToCoord(t[a]));
+  })), o = [];
+  return o[i] = s, o[1 - i] = [NaN, NaN], {
+    values: s,
+    xyMinMax: o
+  };
+}
+var A = {
+  lineX: l(N, 0),
+  lineY: l(N, 1),
+  rect: function(i, e, r) {
+    return [[i[0][0] - r[0] * e[0][0], i[0][1] - r[0] * e[0][1]], [i[1][0] - r[1] * e[1][0], i[1][1] - r[1] * e[1][1]]];
+  },
+  polygon: function(i, e, r) {
+    return v(i, function(t, n) {
+      return [t[0] - r[0] * e[n][0], t[1] - r[1] * e[n][1]];
+    });
+  }
+};
+function N(i, e, r, t) {
+  return [e[0] - t[i] * r[0], e[1] - t[i] * r[1]];
+}
+function k(i, e) {
+  var r = S(i), t = S(e), n = [r[0] / t[0], r[1] / t[1]];
+  return isNaN(n[0]) && (n[0] = 1), isNaN(n[1]) && (n[1] = 1), n;
+}
+function S(i) {
+  return i ? [i[0][1] - i[0][0], i[1][1] - i[1][0]] : [NaN, NaN];
+}
+export {
+  O as default
+};