yahee-components 0.0.70 → 0.0.71

package/es/node_modules/.pnpm/zrender@6.0.0/node_modules/zrender/lib/canvas/Layer.js

@@ -0,0 +1,134 @@
+import { __extends as F } from "../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.js";
+import { isObject as D, disableUserSelect as L, each as U, isGradientObject as G, isImagePatternObject as W } from "../core/util.js";
+import { devicePixelRatio as X } from "../config.js";
+import Y from "../core/Eventful.js";
+import { getCanvasGradient as Z } from "./helper.js";
+import { createCanvasPattern as O } from "./graphic.js";
+import R from "../core/BoundingRect.js";
+import { REDRAW_BIT as S } from "../graphic/constants.js";
+import { platformApi as q } from "../core/platform.js";
+function E(I, h, a) {
+  var i = q.createCanvas(), r = h.getWidth(), e = h.getHeight(), t = i.style;
+  return t && (t.position = "absolute", t.left = "0", t.top = "0", t.width = r + "px", t.height = e + "px", i.setAttribute("data-zr-dom-id", I)), i.width = r * a, i.height = e * a, i;
+}
+var C = function(I) {
+  F(h, I);
+  function h(a, i, r) {
+    var e = I.call(this) || this;
+    e.motionBlur = !1, e.lastFrameAlpha = 0.7, e.dpr = 1, e.virtual = !1, e.config = {}, e.incremental = !1, e.zlevel = 0, e.maxRepaintRectCount = 5, e.__dirty = !0, e.__firstTimePaint = !0, e.__used = !1, e.__drawIndex = 0, e.__startIndex = 0, e.__endIndex = 0, e.__prevStartIndex = null, e.__prevEndIndex = null;
+    var t;
+    r = r || X, typeof a == "string" ? t = E(a, i, r) : D(a) && (t = a, a = t.id), e.id = a, e.dom = t;
+    var o = t.style;
+    return o && (L(t), t.onselectstart = function() {
+      return !1;
+    }, o.padding = "0", o.margin = "0", o.borderWidth = "0"), e.painter = i, e.dpr = r, e;
+  }
+  return h.prototype.getElementCount = function() {
+    return this.__endIndex - this.__startIndex;
+  }, h.prototype.afterBrush = function() {
+    this.__prevStartIndex = this.__startIndex, this.__prevEndIndex = this.__endIndex;
+  }, h.prototype.initContext = function() {
+    this.ctx = this.dom.getContext("2d"), this.ctx.dpr = this.dpr;
+  }, h.prototype.setUnpainted = function() {
+    this.__firstTimePaint = !0;
+  }, h.prototype.createBackBuffer = function() {
+    var a = this.dpr;
+    this.domBack = E("back-" + this.id, this.painter, a), this.ctxBack = this.domBack.getContext("2d"), a !== 1 && this.ctxBack.scale(a, a);
+  }, h.prototype.createRepaintRects = function(a, i, r, e) {
+    if (this.__firstTimePaint)
+      return this.__firstTimePaint = !1, null;
+    var t = [], o = this.maxRepaintRectCount, m = !1, _ = new R(0, 0, 0, 0);
+    function x(f) {
+      if (!(!f.isFinite() || f.isZero()))
+        if (t.length === 0) {
+          var v = new R(0, 0, 0, 0);
+          v.copy(f), t.push(v);
+        } else {
+          for (var g = !1, w = 1 / 0, P = 0, y = 0; y < t.length; ++y) {
+            var B = t[y];
+            if (B.intersect(f)) {
+              var k = new R(0, 0, 0, 0);
+              k.copy(B), k.union(f), t[y] = k, g = !0;
+              break;
+            } else if (m) {
+              _.copy(f), _.union(B);
+              var A = f.width * f.height, T = B.width * B.height, z = _.width * _.height, b = z - A - T;
+              b < w && (w = b, P = y);
+            }
+          }
+          if (m && (t[P].union(f), g = !0), !g) {
+            var v = new R(0, 0, 0, 0);
+            v.copy(f), t.push(v);
+          }
+          m || (m = t.length >= o);
+        }
+    }
+    for (var n = this.__startIndex; n < this.__endIndex; ++n) {
+      var s = a[n];
+      if (s) {
+        var l = s.shouldBePainted(r, e, !0, !0), u = s.__isRendered && (s.__dirty & S || !l) ? s.getPrevPaintRect() : null;
+        u && x(u);
+        var p = l && (s.__dirty & S || !s.__isRendered) ? s.getPaintRect() : null;
+        p && x(p);
+      }
+    }
+    for (var n = this.__prevStartIndex; n < this.__prevEndIndex; ++n) {
+      var s = i[n], l = s && s.shouldBePainted(r, e, !0, !0);
+      if (s && (!l || !s.__zr) && s.__isRendered) {
+        var u = s.getPrevPaintRect();
+        u && x(u);
+      }
+    }
+    var c;
+    do {
+      c = !1;
+      for (var n = 0; n < t.length; ) {
+        if (t[n].isZero()) {
+          t.splice(n, 1);
+          continue;
+        }
+        for (var d = n + 1; d < t.length; )
+          t[n].intersect(t[d]) ? (c = !0, t[n].union(t[d]), t.splice(d, 1)) : d++;
+        n++;
+      }
+    } while (c);
+    return this._paintRects = t, t;
+  }, h.prototype.debugGetPaintRects = function() {
+    return (this._paintRects || []).slice();
+  }, h.prototype.resize = function(a, i) {
+    var r = this.dpr, e = this.dom, t = e.style, o = this.domBack;
+    t && (t.width = a + "px", t.height = i + "px"), e.width = a * r, e.height = i * r, o && (o.width = a * r, o.height = i * r, r !== 1 && this.ctxBack.scale(r, r));
+  }, h.prototype.clear = function(a, i, r) {
+    var e = this.dom, t = this.ctx, o = e.width, m = e.height;
+    i = i || this.clearColor;
+    var _ = this.motionBlur && !a, x = this.lastFrameAlpha, n = this.dpr, s = this;
+    _ && (this.domBack || this.createBackBuffer(), this.ctxBack.globalCompositeOperation = "copy", this.ctxBack.drawImage(e, 0, 0, o / n, m / n));
+    var l = this.domBack;
+    function u(p, c, d, f) {
+      if (t.clearRect(p, c, d, f), i && i !== "transparent") {
+        var v = void 0;
+        if (G(i)) {
+          var g = i.global || i.__width === d && i.__height === f;
+          v = g && i.__canvasGradient || Z(t, i, {
+            x: 0,
+            y: 0,
+            width: d,
+            height: f
+          }), i.__canvasGradient = v, i.__width = d, i.__height = f;
+        } else W(i) && (i.scaleX = i.scaleX || n, i.scaleY = i.scaleY || n, v = O(t, i, {
+          dirty: function() {
+            s.setUnpainted(), s.painter.refresh();
+          }
+        }));
+        t.save(), t.fillStyle = v || i, t.fillRect(p, c, d, f), t.restore();
+      }
+      _ && (t.save(), t.globalAlpha = x, t.drawImage(l, p, c, d, f), t.restore());
+    }
+    !r || _ ? u(0, 0, o, m) : r.length && U(r, function(p) {
+      u(p.x * n, p.y * n, p.width * n, p.height * n);
+    });
+  }, h;
+}(Y);
+export {
+  C as default
+};

package/es/node_modules/.pnpm/zrender@6.0.0/node_modules/zrender/lib/canvas/Painter.js

@@ -0,0 +1,308 @@
+import { devicePixelRatio as F } from "../config.js";
+import { each as k, merge as C, logError as P, indexOf as U, extend as z, disableUserSelect as j } from "../core/util.js";
+import D from "./Layer.js";
+import q from "../animation/requestAnimationFrame.js";
+import Y from "../core/env.js";
+import { brush as I, brushSingle as G } from "./graphic.js";
+import { REDRAW_BIT as J } from "../graphic/constants.js";
+import { getSize as R } from "./helper.js";
+var O = 1e5, y = 314159, b = 0.01, K = 1e-3;
+function Q(a) {
+  return a ? a.__builtin__ ? !0 : !(typeof a.resize != "function" || typeof a.refresh != "function") : !1;
+}
+function X(a, t) {
+  var i = document.createElement("div");
+  return i.style.cssText = [
+    "position:relative",
+    "width:" + a + "px",
+    "height:" + t + "px",
+    "padding:0",
+    "margin:0",
+    "border-width:0"
+  ].join(";") + ";", i;
+}
+var ot = function() {
+  function a(t, i, e, r) {
+    this.type = "canvas", this._zlevelList = [], this._prevDisplayList = [], this._layers = {}, this._layerConfig = {}, this._needsManuallyCompositing = !1, this.type = "canvas";
+    var s = !t.nodeName || t.nodeName.toUpperCase() === "CANVAS";
+    this._opts = e = z({}, e || {}), this.dpr = e.devicePixelRatio || F, this._singleCanvas = s, this.root = t;
+    var n = t.style;
+    n && (j(t), t.innerHTML = ""), this.storage = i;
+    var f = this._zlevelList;
+    this._prevDisplayList = [];
+    var o = this._layers;
+    if (s) {
+      var h = t, _ = h.width, p = h.height;
+      e.width != null && (_ = e.width), e.height != null && (p = e.height), this.dpr = e.devicePixelRatio || 1, h.width = _ * this.dpr, h.height = p * this.dpr, this._width = _, this._height = p;
+      var u = new D(h, this, this.dpr);
+      u.__builtin__ = !0, u.initContext(), o[y] = u, u.zlevel = y, f.push(y), this._domRoot = t;
+    } else {
+      this._width = R(t, 0, e), this._height = R(t, 1, e);
+      var d = this._domRoot = X(this._width, this._height);
+      t.appendChild(d);
+    }
+  }
+  return a.prototype.getType = function() {
+    return "canvas";
+  }, a.prototype.isSingleCanvas = function() {
+    return this._singleCanvas;
+  }, a.prototype.getViewportRoot = function() {
+    return this._domRoot;
+  }, a.prototype.getViewportRootOffset = function() {
+    var t = this.getViewportRoot();
+    if (t)
+      return {
+        offsetLeft: t.offsetLeft || 0,
+        offsetTop: t.offsetTop || 0
+      };
+  }, a.prototype.refresh = function(t) {
+    var i = this.storage.getDisplayList(!0), e = this._prevDisplayList, r = this._zlevelList;
+    this._redrawId = Math.random(), this._paintList(i, e, t, this._redrawId);
+    for (var s = 0; s < r.length; s++) {
+      var n = r[s], f = this._layers[n];
+      if (!f.__builtin__ && f.refresh) {
+        var o = s === 0 ? this._backgroundColor : null;
+        f.refresh(o);
+      }
+    }
+    return this._opts.useDirtyRect && (this._prevDisplayList = i.slice()), this;
+  }, a.prototype.refreshHover = function() {
+    this._paintHoverList(this.storage.getDisplayList(!1));
+  }, a.prototype._paintHoverList = function(t) {
+    var i = t.length, e = this._hoverlayer;
+    if (e && e.clear(), !!i) {
+      for (var r = {
+        inHover: !0,
+        viewWidth: this._width,
+        viewHeight: this._height
+      }, s, n = 0; n < i; n++) {
+        var f = t[n];
+        f.__inHover && (e || (e = this._hoverlayer = this.getLayer(O)), s || (s = e.ctx, s.save()), I(s, f, r, n === i - 1));
+      }
+      s && s.restore();
+    }
+  }, a.prototype.getHoverLayer = function() {
+    return this.getLayer(O);
+  }, a.prototype.paintOne = function(t, i) {
+    G(t, i);
+  }, a.prototype._paintList = function(t, i, e, r) {
+    if (this._redrawId === r) {
+      e = e || !1, this._updateLayerStatus(t);
+      var s = this._doPaintList(t, i, e), n = s.finished, f = s.needsRefreshHover;
+      if (this._needsManuallyCompositing && this._compositeManually(), f && this._paintHoverList(t), n)
+        this.eachLayer(function(d) {
+          d.afterBrush && d.afterBrush();
+        });
+      else {
+        var o = this;
+        q(function() {
+          o._paintList(t, i, e, r);
+        });
+      }
+    }
+  }, a.prototype._compositeManually = function() {
+    var t = this.getLayer(y).ctx, i = this._domRoot.width, e = this._domRoot.height;
+    t.clearRect(0, 0, i, e), this.eachBuiltinLayer(function(r) {
+      r.virtual && t.drawImage(r.dom, 0, 0, i, e);
+    });
+  }, a.prototype._doPaintList = function(t, i, e) {
+    for (var r = this, s = [], n = this._opts.useDirtyRect, f = 0; f < this._zlevelList.length; f++) {
+      var o = this._zlevelList[f], d = this._layers[o];
+      d.__builtin__ && d !== this._hoverlayer && (d.__dirty || e) && s.push(d);
+    }
+    for (var h = !0, _ = !1, p = function(g) {
+      var v = s[g], l = v.ctx, L = n && v.createRepaintRects(t, i, u._width, u._height), m = e ? v.__startIndex : v.__drawIndex, M = !e && v.incremental && Date.now, W = M && Date.now(), N = v.zlevel === u._zlevelList[0] ? u._backgroundColor : null;
+      if (v.__startIndex === v.__endIndex)
+        v.clear(!1, N, L);
+      else if (m === v.__startIndex) {
+        var T = t[m];
+        (!T.incremental || !T.notClear || e) && v.clear(!1, N, L);
+      }
+      m === -1 && (console.error("For some unknown reason. drawIndex is -1"), m = v.__startIndex);
+      var c, B = function(Z) {
+        var S = {
+          inHover: !1,
+          allClipped: !1,
+          prevEl: null,
+          viewWidth: r._width,
+          viewHeight: r._height
+        };
+        for (c = m; c < v.__endIndex; c++) {
+          var V = t[c];
+          if (V.__inHover && (_ = !0), r._doPaintEl(V, v, n, Z, S, c === v.__endIndex - 1), M) {
+            var A = Date.now() - W;
+            if (A > 15)
+              break;
+          }
+        }
+        S.prevElClipPaths && l.restore();
+      };
+      if (L)
+        if (L.length === 0)
+          c = v.__endIndex;
+        else
+          for (var w = u.dpr, H = 0; H < L.length; ++H) {
+            var x = L[H];
+            l.save(), l.beginPath(), l.rect(x.x * w, x.y * w, x.width * w, x.height * w), l.clip(), B(x), l.restore();
+          }
+      else
+        l.save(), B(), l.restore();
+      v.__drawIndex = c, v.__drawIndex < v.__endIndex && (h = !1);
+    }, u = this, E = 0; E < s.length; E++)
+      p(E);
+    return Y.wxa && k(this._layers, function(g) {
+      g && g.ctx && g.ctx.draw && g.ctx.draw();
+    }), {
+      finished: h,
+      needsRefreshHover: _
+    };
+  }, a.prototype._doPaintEl = function(t, i, e, r, s, n) {
+    var f = i.ctx;
+    if (e) {
+      var o = t.getPaintRect();
+      (!r || o && o.intersect(r)) && (I(f, t, s, n), t.setPrevPaintRect(o));
+    } else
+      I(f, t, s, n);
+  }, a.prototype.getLayer = function(t, i) {
+    this._singleCanvas && !this._needsManuallyCompositing && (t = y);
+    var e = this._layers[t];
+    return e || (e = new D("zr_" + t, this, this.dpr), e.zlevel = t, e.__builtin__ = !0, this._layerConfig[t] ? C(e, this._layerConfig[t], !0) : this._layerConfig[t - b] && C(e, this._layerConfig[t - b], !0), i && (e.virtual = i), this.insertLayer(t, e), e.initContext()), e;
+  }, a.prototype.insertLayer = function(t, i) {
+    var e = this._layers, r = this._zlevelList, s = r.length, n = this._domRoot, f = null, o = -1;
+    if (e[t]) {
+      process.env.NODE_ENV !== "production" && P("ZLevel " + t + " has been used already");
+      return;
+    }
+    if (!Q(i)) {
+      process.env.NODE_ENV !== "production" && P("Layer of zlevel " + t + " is not valid");
+      return;
+    }
+    if (s > 0 && t > r[0]) {
+      for (o = 0; o < s - 1 && !(r[o] < t && r[o + 1] > t); o++)
+        ;
+      f = e[r[o]];
+    }
+    if (r.splice(o + 1, 0, t), e[t] = i, !i.virtual)
+      if (f) {
+        var d = f.dom;
+        d.nextSibling ? n.insertBefore(i.dom, d.nextSibling) : n.appendChild(i.dom);
+      } else
+        n.firstChild ? n.insertBefore(i.dom, n.firstChild) : n.appendChild(i.dom);
+    i.painter || (i.painter = this);
+  }, a.prototype.eachLayer = function(t, i) {
+    for (var e = this._zlevelList, r = 0; r < e.length; r++) {
+      var s = e[r];
+      t.call(i, this._layers[s], s);
+    }
+  }, a.prototype.eachBuiltinLayer = function(t, i) {
+    for (var e = this._zlevelList, r = 0; r < e.length; r++) {
+      var s = e[r], n = this._layers[s];
+      n.__builtin__ && t.call(i, n, s);
+    }
+  }, a.prototype.eachOtherLayer = function(t, i) {
+    for (var e = this._zlevelList, r = 0; r < e.length; r++) {
+      var s = e[r], n = this._layers[s];
+      n.__builtin__ || t.call(i, n, s);
+    }
+  }, a.prototype.getLayers = function() {
+    return this._layers;
+  }, a.prototype._updateLayerStatus = function(t) {
+    this.eachBuiltinLayer(function(_, p) {
+      _.__dirty = _.__used = !1;
+    });
+    function i(_) {
+      s && (s.__endIndex !== _ && (s.__dirty = !0), s.__endIndex = _);
+    }
+    if (this._singleCanvas)
+      for (var e = 1; e < t.length; e++) {
+        var r = t[e];
+        if (r.zlevel !== t[e - 1].zlevel || r.incremental) {
+          this._needsManuallyCompositing = !0;
+          break;
+        }
+      }
+    var s = null, n = 0, f, o;
+    for (o = 0; o < t.length; o++) {
+      var r = t[o], d = r.zlevel, h = void 0;
+      f !== d && (f = d, n = 0), r.incremental ? (h = this.getLayer(d + K, this._needsManuallyCompositing), h.incremental = !0, n = 1) : h = this.getLayer(d + (n > 0 ? b : 0), this._needsManuallyCompositing), h.__builtin__ || P("ZLevel " + d + " has been used by unkown layer " + h.id), h !== s && (h.__used = !0, h.__startIndex !== o && (h.__dirty = !0), h.__startIndex = o, h.incremental ? h.__drawIndex = -1 : h.__drawIndex = o, i(o), s = h), r.__dirty & J && !r.__inHover && (h.__dirty = !0, h.incremental && h.__drawIndex < 0 && (h.__drawIndex = o));
+    }
+    i(o), this.eachBuiltinLayer(function(_, p) {
+      !_.__used && _.getElementCount() > 0 && (_.__dirty = !0, _.__startIndex = _.__endIndex = _.__drawIndex = 0), _.__dirty && _.__drawIndex < 0 && (_.__drawIndex = _.__startIndex);
+    });
+  }, a.prototype.clear = function() {
+    return this.eachBuiltinLayer(this._clearLayer), this;
+  }, a.prototype._clearLayer = function(t) {
+    t.clear();
+  }, a.prototype.setBackgroundColor = function(t) {
+    this._backgroundColor = t, k(this._layers, function(i) {
+      i.setUnpainted();
+    });
+  }, a.prototype.configLayer = function(t, i) {
+    if (i) {
+      var e = this._layerConfig;
+      e[t] ? C(e[t], i, !0) : e[t] = i;
+      for (var r = 0; r < this._zlevelList.length; r++) {
+        var s = this._zlevelList[r];
+        if (s === t || s === t + b) {
+          var n = this._layers[s];
+          C(n, e[t], !0);
+        }
+      }
+    }
+  }, a.prototype.delLayer = function(t) {
+    var i = this._layers, e = this._zlevelList, r = i[t];
+    r && (r.dom.parentNode.removeChild(r.dom), delete i[t], e.splice(U(e, t), 1));
+  }, a.prototype.resize = function(t, i) {
+    if (this._domRoot.style) {
+      var e = this._domRoot;
+      e.style.display = "none";
+      var r = this._opts, s = this.root;
+      if (t != null && (r.width = t), i != null && (r.height = i), t = R(s, 0, r), i = R(s, 1, r), e.style.display = "", this._width !== t || i !== this._height) {
+        e.style.width = t + "px", e.style.height = i + "px";
+        for (var n in this._layers)
+          this._layers.hasOwnProperty(n) && this._layers[n].resize(t, i);
+        this.refresh(!0);
+      }
+      this._width = t, this._height = i;
+    } else {
+      if (t == null || i == null)
+        return;
+      this._width = t, this._height = i, this.getLayer(y).resize(t, i);
+    }
+    return this;
+  }, a.prototype.clearLayer = function(t) {
+    var i = this._layers[t];
+    i && i.clear();
+  }, a.prototype.dispose = function() {
+    this.root.innerHTML = "", this.root = this.storage = this._domRoot = this._layers = null;
+  }, a.prototype.getRenderedCanvas = function(t) {
+    if (t = t || {}, this._singleCanvas && !this._compositeManually)
+      return this._layers[y].dom;
+    var i = new D("image", this, t.pixelRatio || this.dpr);
+    i.initContext(), i.clear(!1, t.backgroundColor || this._backgroundColor);
+    var e = i.ctx;
+    if (t.pixelRatio <= this.dpr) {
+      this.refresh();
+      var r = i.dom.width, s = i.dom.height;
+      this.eachLayer(function(_) {
+        _.__builtin__ ? e.drawImage(_.dom, 0, 0, r, s) : _.renderToCanvas && (e.save(), _.renderToCanvas(e), e.restore());
+      });
+    } else
+      for (var n = {
+        inHover: !1,
+        viewWidth: this._width,
+        viewHeight: this._height
+      }, f = this.storage.getDisplayList(!0), o = 0, d = f.length; o < d; o++) {
+        var h = f[o];
+        I(e, h, n, o === d - 1);
+      }
+    return i.dom;
+  }, a.prototype.getWidth = function() {
+    return this._width;
+  }, a.prototype.getHeight = function() {
+    return this._height;
+  }, a;
+}();
+export {
+  ot as default
+};

package/es/node_modules/.pnpm/zrender@6.0.0/node_modules/zrender/lib/canvas/dashStyle.js

@@ -0,0 +1,18 @@
+import { map as o, isNumber as u, isArray as i } from "../core/util.js";
+function h(r, t) {
+  return !r || r === "solid" || !(t > 0) ? null : r === "dashed" ? [4 * t, 2 * t] : r === "dotted" ? [t] : u(r) ? [r] : i(r) ? r : null;
+}
+function e(r) {
+  var t = r.style, s = t.lineDash && t.lineWidth > 0 && h(t.lineDash, t.lineWidth), f = t.lineDashOffset;
+  if (s) {
+    var a = t.strokeNoScale && r.getLineScale ? r.getLineScale() : 1;
+    a && a !== 1 && (s = o(s, function(n) {
+      return n / a;
+    }), f /= a);
+  }
+  return [s, f];
+}
+export {
+  e as getLineDash,
+  h as normalizeLineDash
+};

package/es/node_modules/.pnpm/zrender@6.0.0/node_modules/zrender/lib/canvas/graphic.js

@@ -0,0 +1,197 @@
+import { DEFAULT_COMMON_STYLE as p } from "../graphic/Displayable.js";
+import $ from "../core/PathProxy.js";
+import { createOrUpdateImage as V, isImageReady as j } from "../graphic/helper/image.js";
+import { isClipPathChanged as x, getCanvasGradient as W } from "./helper.js";
+import I from "../graphic/Path.js";
+import c from "../graphic/Image.js";
+import rr from "../graphic/TSpan.js";
+import { RADIAN_TO_DEGREE as ar } from "../core/util.js";
+import { getLineDash as q } from "./dashStyle.js";
+import { REDRAW_BIT as ir, SHAPE_CHANGED_BIT as er } from "../graphic/constants.js";
+import { DEFAULT_FONT as fr } from "../core/platform.js";
+var nr = new $(!0);
+function D(a) {
+  var r = a.stroke;
+  return !(r == null || r === "none" || !(a.lineWidth > 0));
+}
+function L(a) {
+  return typeof a == "string" && a !== "none";
+}
+function P(a) {
+  var r = a.fill;
+  return r != null && r !== "none";
+}
+function M(a, r) {
+  if (r.fillOpacity != null && r.fillOpacity !== 1) {
+    var i = a.globalAlpha;
+    a.globalAlpha = r.fillOpacity * r.opacity, a.fill(), a.globalAlpha = i;
+  } else
+    a.fill();
+}
+function Y(a, r) {
+  if (r.strokeOpacity != null && r.strokeOpacity !== 1) {
+    var i = a.globalAlpha;
+    a.globalAlpha = r.strokeOpacity * r.opacity, a.stroke(), a.globalAlpha = i;
+  } else
+    a.stroke();
+}
+function U(a, r, i) {
+  var f = V(r.image, r.__image, i);
+  if (j(f)) {
+    var n = a.createPattern(f, r.repeat || "repeat");
+    if (typeof DOMMatrix == "function" && n && n.setTransform) {
+      var e = new DOMMatrix();
+      e.translateSelf(r.x || 0, r.y || 0), e.rotateSelf(0, 0, (r.rotation || 0) * ar), e.scaleSelf(r.scaleX || 1, r.scaleY || 1), n.setTransform(e);
+    }
+    return n;
+  }
+}
+function tr(a, r, i, f) {
+  var n, e = D(i), o = P(i), h = i.strokePercent, t = h < 1, l = !r.path;
+  (!r.silent || t) && l && r.createPathProxy();
+  var v = r.path || nr, u = r.__dirty;
+  if (!f) {
+    var d = i.fill, _ = i.stroke, C = o && !!d.colorStops, w = e && !!_.colorStops, O = o && !!d.image, A = e && !!_.image, S = void 0, k = void 0, b = void 0, m = void 0, B = void 0;
+    (C || w) && (B = r.getBoundingRect()), C && (S = u ? W(a, d, B) : r.__canvasFillGradient, r.__canvasFillGradient = S), w && (k = u ? W(a, _, B) : r.__canvasStrokeGradient, r.__canvasStrokeGradient = k), O && (b = u || !r.__canvasFillPattern ? U(a, d, r) : r.__canvasFillPattern, r.__canvasFillPattern = b), A && (m = u || !r.__canvasStrokePattern ? U(a, _, r) : r.__canvasStrokePattern, r.__canvasStrokePattern = m), C ? a.fillStyle = S : O && (b ? a.fillStyle = b : o = !1), w ? a.strokeStyle = k : A && (m ? a.strokeStyle = m : e = !1);
+  }
+  var H = r.getGlobalScale();
+  v.setScale(H[0], H[1], r.segmentIgnoreThreshold);
+  var T, R;
+  a.setLineDash && i.lineDash && (n = q(r), T = n[0], R = n[1]);
+  var F = !0;
+  (l || u & er) && (v.setDPR(a.dpr), t ? v.setContext(null) : (v.setContext(a), F = !1), v.reset(), r.buildPath(v, r.shape, f), v.toStatic(), r.pathUpdated()), F && v.rebuildPath(a, t ? h : 1), T && (a.setLineDash(T), a.lineDashOffset = R), f || (i.strokeFirst ? (e && Y(a, i), o && M(a, i)) : (o && M(a, i), e && Y(a, i))), T && a.setLineDash([]);
+}
+function or(a, r, i) {
+  var f = r.__image = V(i.image, r.__image, r, r.onload);
+  if (!(!f || !j(f))) {
+    var n = i.x || 0, e = i.y || 0, o = r.getWidth(), h = r.getHeight(), t = f.width / f.height;
+    if (o == null && h != null ? o = h * t : h == null && o != null ? h = o / t : o == null && h == null && (o = f.width, h = f.height), i.sWidth && i.sHeight) {
+      var l = i.sx || 0, v = i.sy || 0;
+      a.drawImage(f, l, v, i.sWidth, i.sHeight, n, e, o, h);
+    } else if (i.sx && i.sy) {
+      var l = i.sx, v = i.sy, u = o - l, d = h - v;
+      a.drawImage(f, l, v, u, d, n, e, o, h);
+    } else
+      a.drawImage(f, n, e, o, h);
+  }
+}
+function hr(a, r, i) {
+  var f, n = i.text;
+  if (n != null && (n += ""), n) {
+    a.font = i.font || fr, a.textAlign = i.textAlign, a.textBaseline = i.textBaseline;
+    var e = void 0, o = void 0;
+    a.setLineDash && i.lineDash && (f = q(r), e = f[0], o = f[1]), e && (a.setLineDash(e), a.lineDashOffset = o), i.strokeFirst ? (D(i) && a.strokeText(n, i.x, i.y), P(i) && a.fillText(n, i.x, i.y)) : (P(i) && a.fillText(n, i.x, i.y), D(i) && a.strokeText(n, i.x, i.y)), e && a.setLineDash([]);
+  }
+}
+var N = ["shadowBlur", "shadowOffsetX", "shadowOffsetY"], y = [
+  ["lineCap", "butt"],
+  ["lineJoin", "miter"],
+  ["miterLimit", 10]
+];
+function z(a, r, i, f, n) {
+  var e = !1;
+  if (!f && (i = i || {}, r === i))
+    return !1;
+  if (f || r.opacity !== i.opacity) {
+    s(a, n), e = !0;
+    var o = Math.max(Math.min(r.opacity, 1), 0);
+    a.globalAlpha = isNaN(o) ? p.opacity : o;
+  }
+  (f || r.blend !== i.blend) && (e || (s(a, n), e = !0), a.globalCompositeOperation = r.blend || p.blend);
+  for (var h = 0; h < N.length; h++) {
+    var t = N[h];
+    (f || r[t] !== i[t]) && (e || (s(a, n), e = !0), a[t] = a.dpr * (r[t] || 0));
+  }
+  return (f || r.shadowColor !== i.shadowColor) && (e || (s(a, n), e = !0), a.shadowColor = r.shadowColor || p.shadowColor), e;
+}
+function X(a, r, i, f, n) {
+  var e = g(r, n.inHover), o = f ? null : i && g(i, n.inHover) || {};
+  if (e === o)
+    return !1;
+  var h = z(a, e, o, f, n);
+  if ((f || e.fill !== o.fill) && (h || (s(a, n), h = !0), L(e.fill) && (a.fillStyle = e.fill)), (f || e.stroke !== o.stroke) && (h || (s(a, n), h = !0), L(e.stroke) && (a.strokeStyle = e.stroke)), (f || e.opacity !== o.opacity) && (h || (s(a, n), h = !0), a.globalAlpha = e.opacity == null ? 1 : e.opacity), r.hasStroke()) {
+    var t = e.lineWidth, l = t / (e.strokeNoScale && r.getLineScale ? r.getLineScale() : 1);
+    a.lineWidth !== l && (h || (s(a, n), h = !0), a.lineWidth = l);
+  }
+  for (var v = 0; v < y.length; v++) {
+    var u = y[v], d = u[0];
+    (f || e[d] !== o[d]) && (h || (s(a, n), h = !0), a[d] = e[d] || u[1]);
+  }
+  return h;
+}
+function vr(a, r, i, f, n) {
+  return z(a, g(r, n.inHover), i && g(i, n.inHover), f, n);
+}
+function Q(a, r) {
+  var i = r.transform, f = a.dpr || 1;
+  i ? a.setTransform(f * i[0], f * i[1], f * i[2], f * i[3], f * i[4], f * i[5]) : a.setTransform(f, 0, 0, f, 0, 0);
+}
+function lr(a, r, i) {
+  for (var f = !1, n = 0; n < a.length; n++) {
+    var e = a[n];
+    f = f || e.isZeroArea(), Q(r, e), r.beginPath(), e.buildPath(r, e.shape), r.clip();
+  }
+  i.allClipped = f;
+}
+function ur(a, r) {
+  return a && r ? a[0] !== r[0] || a[1] !== r[1] || a[2] !== r[2] || a[3] !== r[3] || a[4] !== r[4] || a[5] !== r[5] : !(!a && !r);
+}
+var Z = 1, G = 2, J = 3, K = 4;
+function sr(a) {
+  var r = P(a), i = D(a);
+  return !(a.lineDash || !(+r ^ +i) || r && typeof a.fill != "string" || i && typeof a.stroke != "string" || a.strokePercent < 1 || a.strokeOpacity < 1 || a.fillOpacity < 1);
+}
+function s(a, r) {
+  r.batchFill && a.fill(), r.batchStroke && a.stroke(), r.batchFill = "", r.batchStroke = "";
+}
+function g(a, r) {
+  return r && a.__hoverStyle || a.style;
+}
+function Br(a, r) {
+  E(a, r, { inHover: !1, viewWidth: 0, viewHeight: 0 }, !0);
+}
+function E(a, r, i, f) {
+  var n = r.transform;
+  if (!r.shouldBePainted(i.viewWidth, i.viewHeight, !1, !1)) {
+    r.__dirty &= ~ir, r.__isRendered = !1;
+    return;
+  }
+  var e = r.__clipPaths, o = i.prevElClipPaths, h = !1, t = !1;
+  if ((!o || x(e, o)) && (o && o.length && (s(a, i), a.restore(), t = h = !0, i.prevElClipPaths = null, i.allClipped = !1, i.prevEl = null), e && e.length && (s(a, i), a.save(), lr(e, a, i), h = !0), i.prevElClipPaths = e), i.allClipped) {
+    r.__isRendered = !1;
+    return;
+  }
+  r.beforeBrush && r.beforeBrush(), r.innerBeforeBrush();
+  var l = i.prevEl;
+  l || (t = h = !0);
+  var v = r instanceof I && r.autoBatch && sr(r.style);
+  h || ur(n, l.transform) ? (s(a, i), Q(a, r)) : v || s(a, i);
+  var u = g(r, i.inHover);
+  r instanceof I ? (i.lastDrawType !== Z && (t = !0, i.lastDrawType = Z), X(a, r, l, t, i), (!v || !i.batchFill && !i.batchStroke) && a.beginPath(), tr(a, r, u, v), v && (i.batchFill = u.fill || "", i.batchStroke = u.stroke || "")) : r instanceof rr ? (i.lastDrawType !== J && (t = !0, i.lastDrawType = J), X(a, r, l, t, i), hr(a, r, u)) : r instanceof c ? (i.lastDrawType !== G && (t = !0, i.lastDrawType = G), vr(a, r, l, t, i), or(a, r, u)) : r.getTemporalDisplayables && (i.lastDrawType !== K && (t = !0, i.lastDrawType = K), dr(a, r, i)), v && f && s(a, i), r.innerAfterBrush(), r.afterBrush && r.afterBrush(), i.prevEl = r, r.__dirty = 0, r.__isRendered = !0;
+}
+function dr(a, r, i) {
+  var f = r.getDisplayables(), n = r.getTemporalDisplayables();
+  a.save();
+  var e = {
+    prevElClipPaths: null,
+    prevEl: null,
+    allClipped: !1,
+    viewWidth: i.viewWidth,
+    viewHeight: i.viewHeight,
+    inHover: i.inHover
+  }, o, h;
+  for (o = r.getCursor(), h = f.length; o < h; o++) {
+    var t = f[o];
+    t.beforeBrush && t.beforeBrush(), t.innerBeforeBrush(), E(a, t, e, o === h - 1), t.innerAfterBrush(), t.afterBrush && t.afterBrush(), e.prevEl = t;
+  }
+  for (var l = 0, v = n.length; l < v; l++) {
+    var t = n[l];
+    t.beforeBrush && t.beforeBrush(), t.innerBeforeBrush(), E(a, t, e, l === v - 1), t.innerAfterBrush(), t.afterBrush && t.afterBrush(), e.prevEl = t;
+  }
+  r.clearTemporalDisplayables(), r.notClear = !0, a.restore();
+}
+export {
+  E as brush,
+  Br as brushSingle,
+  U as createCanvasPattern
+};