web-core-tcm 0.0.59 → 0.0.62

package/dist/node_modules/zrender/lib/graphic/shape/Sector.js

@@ -0,0 +1,26 @@
+import { __extends as i } from "../../../../tslib/tslib.es6.js";
+import n from "../Path.js";
+import { buildPath as h } from "../helper/roundSector.js";
+var s = /* @__PURE__ */ (function() {
+  function e() {
+    this.cx = 0, this.cy = 0, this.r0 = 0, this.r = 0, this.startAngle = 0, this.endAngle = Math.PI * 2, this.clockwise = !0, this.cornerRadius = 0;
+  }
+  return e;
+})(), a = (function(e) {
+  i(t, e);
+  function t(r) {
+    return e.call(this, r) || this;
+  }
+  return t.prototype.getDefaultShape = function() {
+    return new s();
+  }, t.prototype.buildPath = function(r, o) {
+    h(r, o);
+  }, t.prototype.isZeroArea = function() {
+    return this.shape.startAngle === this.shape.endAngle || this.shape.r === this.shape.r0;
+  }, t;
+})(n);
+a.prototype.type = "sector";
+export {
+  s as SectorShape,
+  a as default
+};

package/dist/node_modules/zrender/lib/mixin/Draggable.js

@@ -0,0 +1,29 @@
+var n = /* @__PURE__ */ (function() {
+  function r(t, a) {
+    this.target = t, this.topTarget = a && a.topTarget;
+  }
+  return r;
+})(), o = (function() {
+  function r(t) {
+    this.handler = t, t.on("mousedown", this._dragStart, this), t.on("mousemove", this._drag, this), t.on("mouseup", this._dragEnd, this);
+  }
+  return r.prototype._dragStart = function(t) {
+    for (var a = t.target; a && !a.draggable; )
+      a = a.parent || a.__hostTarget;
+    a && (this._draggingTarget = a, a.dragging = !0, this._x = t.offsetX, this._y = t.offsetY, this.handler.dispatchToElement(new n(a, t), "dragstart", t.event));
+  }, r.prototype._drag = function(t) {
+    var a = this._draggingTarget;
+    if (a) {
+      var g = t.offsetX, s = t.offsetY, h = g - this._x, d = s - this._y;
+      this._x = g, this._y = s, a.drift(h, d, t), this.handler.dispatchToElement(new n(a, t), "drag", t.event);
+      var i = this.handler.findHover(g, s, a).target, e = this._dropTarget;
+      this._dropTarget = i, a !== i && (e && i !== e && this.handler.dispatchToElement(new n(e, t), "dragleave", t.event), i && i !== e && this.handler.dispatchToElement(new n(i, t), "dragenter", t.event));
+    }
+  }, r.prototype._dragEnd = function(t) {
+    var a = this._draggingTarget;
+    a && (a.dragging = !1), this.handler.dispatchToElement(new n(a, t), "dragend", t.event), this._dropTarget && this.handler.dispatchToElement(new n(this._dropTarget, t), "drop", t.event), this._draggingTarget = null, this._dropTarget = null;
+  }, r;
+})();
+export {
+  o as default
+};

package/dist/node_modules/zrender/lib/svg/Painter.js

@@ -0,0 +1,151 @@
+import { brush as T, setClipPath as B, setGradient as D, setPattern as R } from "./graphic.js";
+import { createBrushScope as x, createVNode as l, getCssString as U, createSVGVNode as S, vNodeToString as A, createElement as z } from "./core.js";
+import { isPattern as L, encodeBase64 as C, isGradient as P, normalizeColor as H } from "./helper.js";
+import { map as M, keys as k, retrieve2 as g, extend as I, noop as O } from "../core/util.js";
+import E, { updateAttrs as F } from "./patch.js";
+import { getSize as b } from "../canvas/helper.js";
+var W = 0, Z = (function() {
+  function o(t, e, r) {
+    if (this.type = "svg", this.refreshHover = G(), this.configLayer = G(), this.storage = e, this._opts = r = I({}, r), this.root = t, this._id = "zr" + W++, this._oldVNode = S(r.width, r.height), t && !r.ssr) {
+      var s = this._viewport = document.createElement("div");
+      s.style.cssText = "position:relative;overflow:hidden";
+      var i = this._svgDom = this._oldVNode.elm = z("svg");
+      F(null, this._oldVNode), s.appendChild(i), t.appendChild(s);
+    }
+    this.resize(r.width, r.height);
+  }
+  return o.prototype.getType = function() {
+    return this.type;
+  }, o.prototype.getViewportRoot = function() {
+    return this._viewport;
+  }, o.prototype.getViewportRootOffset = function() {
+    var t = this.getViewportRoot();
+    if (t)
+      return {
+        offsetLeft: t.offsetLeft || 0,
+        offsetTop: t.offsetTop || 0
+      };
+  }, o.prototype.getSvgDom = function() {
+    return this._svgDom;
+  }, o.prototype.refresh = function() {
+    if (this.root) {
+      var t = this.renderToVNode({
+        willUpdate: !0
+      });
+      t.attrs.style = "position:absolute;left:0;top:0;user-select:none", E(this._oldVNode, t), this._oldVNode = t;
+    }
+  }, o.prototype.renderOneToVNode = function(t) {
+    return T(t, x(this._id));
+  }, o.prototype.renderToVNode = function(t) {
+    t = t || {};
+    var e = this.storage.getDisplayList(!0), r = this._width, s = this._height, i = x(this._id);
+    i.animation = t.animation, i.willUpdate = t.willUpdate, i.compress = t.compress, i.emphasis = t.emphasis, i.ssr = this._opts.ssr;
+    var a = [], n = this._bgVNode = j(r, s, this._backgroundColor, i);
+    n && a.push(n);
+    var h = t.compress ? null : this._mainVNode = l("g", "main", {}, []);
+    this._paintList(e, i, h ? h.children : a), h && a.push(h);
+    var v = M(k(i.defs), function(f) {
+      return i.defs[f];
+    });
+    if (v.length && a.push(l("defs", "defs", {}, v)), t.animation) {
+      var d = U(i.cssNodes, i.cssAnims, { newline: !0 });
+      if (d) {
+        var u = l("style", "stl", {}, [], d);
+        a.push(u);
+      }
+    }
+    return S(r, s, a, t.useViewBox);
+  }, o.prototype.renderToString = function(t) {
+    return t = t || {}, A(this.renderToVNode({
+      animation: g(t.cssAnimation, !0),
+      emphasis: g(t.cssEmphasis, !0),
+      willUpdate: !1,
+      compress: !0,
+      useViewBox: g(t.useViewBox, !0)
+    }), { newline: !0 });
+  }, o.prototype.setBackgroundColor = function(t) {
+    this._backgroundColor = t;
+  }, o.prototype.getSvgRoot = function() {
+    return this._mainVNode && this._mainVNode.elm;
+  }, o.prototype._paintList = function(t, e, r) {
+    for (var s = t.length, i = [], a = 0, n, h, v = 0, d = 0; d < s; d++) {
+      var u = t[d];
+      if (!u.invisible) {
+        var f = u.__clipPaths, _ = f && f.length || 0, V = h && h.length || 0, p = void 0;
+        for (p = Math.max(_ - 1, V - 1); p >= 0 && !(f && h && f[p] === h[p]); p--)
+          ;
+        for (var y = V - 1; y > p; y--)
+          a--, n = i[a - 1];
+        for (var c = p + 1; c < _; c++) {
+          var N = {};
+          B(f[c], N, e);
+          var m = l("g", "clip-g-" + v++, N, []);
+          (n ? n.children : r).push(m), i[a++] = m, n = m;
+        }
+        h = f;
+        var w = T(u, e);
+        w && (n ? n.children : r).push(w);
+      }
+    }
+  }, o.prototype.resize = function(t, e) {
+    var r = this._opts, s = this.root, i = this._viewport;
+    if (t != null && (r.width = t), e != null && (r.height = e), s && i && (i.style.display = "none", t = b(s, 0, r), e = b(s, 1, r), i.style.display = ""), this._width !== t || this._height !== e) {
+      if (this._width = t, this._height = e, i) {
+        var a = i.style;
+        a.width = t + "px", a.height = e + "px";
+      }
+      if (L(this._backgroundColor))
+        this.refresh();
+      else {
+        var n = this._svgDom;
+        n && (n.setAttribute("width", t), n.setAttribute("height", e));
+        var h = this._bgVNode && this._bgVNode.elm;
+        h && (h.setAttribute("width", t), h.setAttribute("height", e));
+      }
+    }
+  }, o.prototype.getWidth = function() {
+    return this._width;
+  }, o.prototype.getHeight = function() {
+    return this._height;
+  }, o.prototype.dispose = function() {
+    this.root && (this.root.innerHTML = ""), this._svgDom = this._viewport = this.storage = this._oldVNode = this._bgVNode = this._mainVNode = null;
+  }, o.prototype.clear = function() {
+    this._svgDom && (this._svgDom.innerHTML = null), this._oldVNode = null;
+  }, o.prototype.toDataURL = function(t) {
+    var e = this.renderToString(), r = "data:image/svg+xml;";
+    return t ? (e = C(e), e && r + "base64," + e) : r + "charset=UTF-8," + encodeURIComponent(e);
+  }, o;
+})();
+function G(o) {
+  return function() {
+  };
+}
+function j(o, t, e, r) {
+  var s;
+  if (e && e !== "none")
+    if (s = l("rect", "bg", {
+      width: o,
+      height: t,
+      x: "0",
+      y: "0"
+    }), P(e))
+      D({ fill: e }, s.attrs, "fill", r);
+    else if (L(e))
+      R({
+        style: {
+          fill: e
+        },
+        dirty: O,
+        getBoundingRect: function() {
+          return { width: o, height: t };
+        }
+      }, s.attrs, "fill", r);
+    else {
+      var i = H(e), a = i.color, n = i.opacity;
+      s.attrs.fill = a, n < 1 && (s.attrs["fill-opacity"] = n);
+    }
+  return s;
+}
+export {
+  Z as default
+};

package/dist/node_modules/zrender/lib/svg/SVGPathRebuilder.js

@@ -0,0 +1,52 @@
+import { isAroundZero as C } from "./helper.js";
+var l = Math.sin, M = Math.cos, S = Math.PI, d = Math.PI * 2, g = 180 / S, j = (function() {
+  function r() {
+  }
+  return r.prototype.reset = function(t) {
+    this._start = !0, this._d = [], this._str = "", this._p = Math.pow(10, t || 4);
+  }, r.prototype.moveTo = function(t, a) {
+    this._add("M", t, a);
+  }, r.prototype.lineTo = function(t, a) {
+    this._add("L", t, a);
+  }, r.prototype.bezierCurveTo = function(t, a, i, o, n, e) {
+    this._add("C", t, a, i, o, n, e);
+  }, r.prototype.quadraticCurveTo = function(t, a, i, o) {
+    this._add("Q", t, a, i, o);
+  }, r.prototype.arc = function(t, a, i, o, n, e) {
+    this.ellipse(t, a, i, i, 0, o, n, e);
+  }, r.prototype.ellipse = function(t, a, i, o, n, e, _, P) {
+    var h = _ - e, s = !P, u = Math.abs(h), p = C(u - d) || (s ? h >= d : -h >= d), v = h > 0 ? h % d : h % d + d, f = !1;
+    p ? f = !0 : C(u) ? f = !1 : f = v >= S == !!s;
+    var m = t + i * M(e), y = a + o * l(e);
+    this._start && this._add("M", m, y);
+    var c = Math.round(n * g);
+    if (p) {
+      var T = 1 / this._p, b = (s ? 1 : -1) * (d - T);
+      this._add("A", i, o, c, 1, +s, t + i * M(e + b), a + o * l(e + b)), T > 0.01 && this._add("A", i, o, c, 0, +s, m, y);
+    } else {
+      var I = t + i * M(_), Z = a + o * l(_);
+      this._add("A", i, o, c, +f, +s, I, Z);
+    }
+  }, r.prototype.rect = function(t, a, i, o) {
+    this._add("M", t, a), this._add("l", i, 0), this._add("l", 0, o), this._add("l", -i, 0), this._add("Z");
+  }, r.prototype.closePath = function() {
+    this._d.length > 0 && this._add("Z");
+  }, r.prototype._add = function(t, a, i, o, n, e, _, P, h) {
+    for (var s = [], u = this._p, p = 1; p < arguments.length; p++) {
+      var v = arguments[p];
+      if (isNaN(v)) {
+        this._invalid = !0;
+        return;
+      }
+      s.push(Math.round(v * u) / u);
+    }
+    this._d.push(t + s.join(" ")), this._start = t === "Z";
+  }, r.prototype.generateStr = function() {
+    this._str = this._invalid ? "" : this._d.join(""), this._d = [];
+  }, r.prototype.getStr = function() {
+    return this._str;
+  }, r;
+})();
+export {
+  j as default
+};

package/dist/node_modules/zrender/lib/svg/core.js

@@ -0,0 +1,98 @@
+import { map as a, keys as s } from "../core/util.js";
+import { encodeHTML as d } from "../core/dom.js";
+var h = "http://www.w3.org/2000/svg", g = "http://www.w3.org/1999/xlink", C = "http://www.w3.org/2000/xmlns/", j = "http://www.w3.org/XML/1998/namespace", I = "ecmeta_";
+function k(r) {
+  return document.createElementNS(h, r);
+}
+function x(r, e, i, n, t) {
+  return {
+    tag: r,
+    attrs: i || {},
+    children: n,
+    text: t,
+    key: e
+  };
+}
+function S(r, e) {
+  var i = [];
+  if (e)
+    for (var n in e) {
+      var t = e[n], u = n;
+      t !== !1 && (t !== !0 && t != null && (u += '="' + t + '"'), i.push(u));
+    }
+  return "<" + r + " " + i.join(" ") + ">";
+}
+function p(r) {
+  return "</" + r + ">";
+}
+function M(r, e) {
+  e = e || {};
+  var i = e.newline ? `
+` : "";
+  function n(t) {
+    var u = t.children, f = t.tag, v = t.attrs, c = t.text;
+    return S(f, v) + (f !== "style" ? d(c) : c || "") + (u ? "" + i + a(u, function(o) {
+      return n(o);
+    }).join(i) + i : "") + p(f);
+  }
+  return n(r);
+}
+function T(r, e, i) {
+  i = i || {};
+  var n = i.newline ? `
+` : "", t = " {" + n, u = n + "}", f = a(s(r), function(c) {
+    return c + t + a(s(r[c]), function(o) {
+      return o + ":" + r[c][o] + ";";
+    }).join(n) + u;
+  }).join(n), v = a(s(e), function(c) {
+    return "@keyframes " + c + t + a(s(e[c]), function(o) {
+      return o + t + a(s(e[c][o]), function(w) {
+        var l = e[c][o][w];
+        return w === "d" && (l = 'path("' + l + '")'), w + ":" + l + ";";
+      }).join(n) + u;
+    }).join(n) + u;
+  }).join(n);
+  return !f && !v ? "" : ["<![CDATA[", f, v, "]]>"].join(n);
+}
+function m(r) {
+  return {
+    zrId: r,
+    shadowCache: {},
+    patternCache: {},
+    gradientCache: {},
+    clipPathCache: {},
+    defs: {},
+    cssNodes: {},
+    cssAnims: {},
+    cssStyleCache: {},
+    cssAnimIdx: 0,
+    shadowIdx: 0,
+    gradientIdx: 0,
+    patternIdx: 0,
+    clipPathIdx: 0
+  };
+}
+function L(r, e, i, n) {
+  return x("svg", "root", {
+    width: r,
+    height: e,
+    xmlns: h,
+    "xmlns:xlink": g,
+    version: "1.1",
+    baseProfile: "full",
+    viewBox: n ? "0 0 " + r + " " + e : !1
+  }, i);
+}
+export {
+  I as META_DATA_PREFIX,
+  h as SVGNS,
+  g as XLINKNS,
+  C as XMLNS,
+  j as XML_NAMESPACE,
+  m as createBrushScope,
+  k as createElement,
+  L as createSVGVNode,
+  x as createVNode,
+  T as getCssString,
+  M as vNodeToString
+};

package/dist/node_modules/zrender/lib/svg/cssAnimation.js

@@ -0,0 +1,182 @@
+import { copyTransform as mr } from "../core/Transformable.js";
+import { createBrushScope as lr } from "./core.js";
+import cr from "./SVGPathRebuilder.js";
+import hr from "../core/PathProxy.js";
+import { getSRTTransformString as dr, getPathPrecision as gr } from "./helper.js";
+import { each as pr, keys as V, isString as tr, extend as X, filter as Ir, isNumber as Or } from "../core/util.js";
+import Sr from "../graphic/CompoundPath.js";
+import { createCubicEasingFunc as Ar } from "../animation/cubicEasing.js";
+import { getClassId as br } from "./cssClassId.js";
+var ar = {
+  cubicIn: "0.32,0,0.67,0",
+  cubicOut: "0.33,1,0.68,1",
+  cubicInOut: "0.65,0,0.35,1",
+  quadraticIn: "0.11,0,0.5,0",
+  quadraticOut: "0.5,1,0.89,1",
+  quadraticInOut: "0.45,0,0.55,1",
+  quarticIn: "0.5,0,0.75,0",
+  quarticOut: "0.25,1,0.5,1",
+  quarticInOut: "0.76,0,0.24,1",
+  quinticIn: "0.64,0,0.78,0",
+  quinticOut: "0.22,1,0.36,1",
+  quinticInOut: "0.83,0,0.17,1",
+  sinusoidalIn: "0.12,0,0.39,0",
+  sinusoidalOut: "0.61,1,0.88,1",
+  sinusoidalInOut: "0.37,0,0.63,1",
+  exponentialIn: "0.7,0,0.84,0",
+  exponentialOut: "0.16,1,0.3,1",
+  exponentialInOut: "0.87,0,0.13,1",
+  circularIn: "0.55,0,1,0.45",
+  circularOut: "0,0.55,0.45,1",
+  circularInOut: "0.85,0,0.15,1"
+}, g = "transform-origin";
+function Tr(r, t, n) {
+  var u = X({}, r.shape);
+  X(u, t), r.buildPath(n, u);
+  var e = new cr();
+  return e.reset(gr(r)), n.rebuildPath(e, 1), e.generateStr(), e.getStr();
+}
+function xr(r, t) {
+  var n = t.originX, u = t.originY;
+  (n || u) && (r[g] = n + "px " + u + "px");
+}
+var Pr = {
+  fill: "fill",
+  opacity: "opacity",
+  lineWidth: "stroke-width",
+  lineDashOffset: "stroke-dashoffset"
+};
+function er(r, t) {
+  var n = t.zrId + "-ani-" + t.cssAnimIdx++;
+  return t.cssAnims[n] = r, n;
+}
+function qr(r, t, n) {
+  var u = r.shape.paths, e = {}, l, v;
+  if (pr(u, function(h) {
+    var s = lr(n.zrId);
+    s.animation = !0, Cr(h, {}, s, !0);
+    var f = s.cssAnims, m = s.cssNodes, S = V(f), A = S.length;
+    if (A) {
+      v = S[A - 1];
+      var d = f[v];
+      for (var p in d) {
+        var B = d[p];
+        e[p] = e[p] || { d: "" }, e[p].d += B.d || "";
+      }
+      for (var P in m) {
+        var b = m[P].animation;
+        b.indexOf(v) >= 0 && (l = b);
+      }
+    }
+  }), !!l) {
+    t.d = !1;
+    var c = er(e, n);
+    return l.replace(v, c);
+  }
+}
+function nr(r) {
+  return tr(r) ? ar[r] ? "cubic-bezier(" + ar[r] + ")" : Ar(r) ? r : "" : "";
+}
+function Cr(r, t, n, u) {
+  var e = r.animators, l = e.length, v = [];
+  if (r instanceof Sr) {
+    var c = qr(r, t, n);
+    if (c)
+      v.push(c);
+    else if (!l)
+      return;
+  } else if (!l)
+    return;
+  for (var h = {}, s = 0; s < l; s++) {
+    var f = e[s], m = [f.getMaxTime() / 1e3 + "s"], S = nr(f.getClip().easing), A = f.getDelay();
+    S ? m.push(S) : m.push("linear"), A && m.push(A / 1e3 + "s"), f.getLoop() && m.push("infinite");
+    var d = m.join(" ");
+    h[d] = h[d] || [d, []], h[d][1].push(f);
+  }
+  function p(b) {
+    var D = b[1], W = D.length, q = {}, C = {}, i = {}, T = "animation-timing-function";
+    function F(w, z, Z) {
+      for (var E = w.getTracks(), fr = w.getMaxTime(), K = 0; K < E.length; K++) {
+        var L = E[K];
+        if (L.needsAnimate()) {
+          var $ = L.keyframes, Y = L.propName;
+          if (Z && (Y = Z(Y)), Y)
+            for (var R = 0; R < $.length; R++) {
+              var _ = $[R], j = Math.round(_.time / fr * 100) + "%", rr = nr(_.easing), ir = _.rawValue;
+              (tr(ir) || Or(ir)) && (z[j] = z[j] || {}, z[j][Y] = _.rawValue, rr && (z[j][T] = rr));
+            }
+        }
+      }
+    }
+    for (var o = 0; o < W; o++) {
+      var I = D[o], N = I.targetName;
+      N ? N === "shape" && F(I, C) : !u && F(I, q);
+    }
+    for (var a in q) {
+      var y = {};
+      mr(y, r), X(y, q[a]);
+      var k = dr(y), x = q[a][T];
+      i[a] = k ? {
+        transform: k
+      } : {}, xr(i[a], y), x && (i[a][T] = x);
+    }
+    var O, H = !0;
+    for (var a in C) {
+      i[a] = i[a] || {};
+      var J = !O, x = C[a][T];
+      J && (O = new hr());
+      var or = O.len();
+      O.reset(), i[a].d = Tr(r, C[a], O);
+      var ur = O.len();
+      if (!J && or !== ur) {
+        H = !1;
+        break;
+      }
+      x && (i[a][T] = x);
+    }
+    if (!H)
+      for (var a in i)
+        delete i[a].d;
+    if (!u)
+      for (var o = 0; o < W; o++) {
+        var I = D[o], N = I.targetName;
+        N === "style" && F(I, i, function(E) {
+          return Pr[E];
+        });
+      }
+    for (var M = V(i), Q = !0, G, o = 1; o < M.length; o++) {
+      var U = M[o - 1], vr = M[o];
+      if (i[U][g] !== i[vr][g]) {
+        Q = !1;
+        break;
+      }
+      G = i[U][g];
+    }
+    if (Q && G) {
+      for (var a in i)
+        i[a][g] && delete i[a][g];
+      t[g] = G;
+    }
+    if (Ir(M, function(w) {
+      return V(i[w]).length > 0;
+    }).length) {
+      var sr = er(i, n);
+      return sr + " " + b[0] + " both";
+    }
+  }
+  for (var B in h) {
+    var c = p(h[B]);
+    c && v.push(c);
+  }
+  if (v.length) {
+    var P = n.zrId + "-cls-" + br();
+    n.cssNodes["." + P] = {
+      animation: v.join(",")
+    }, t.class = P;
+  }
+}
+export {
+  Pr as ANIMATE_STYLE_MAP,
+  ar as EASING_MAP,
+  Cr as createCSSAnimation
+};

package/dist/node_modules/zrender/lib/svg/cssClassId.js

@@ -0,0 +1,7 @@
+var s = 0;
+function r() {
+  return s++;
+}
+export {
+  r as getClassId
+};

package/dist/node_modules/zrender/lib/svg/cssEmphasis.js

@@ -0,0 +1,33 @@
+import { liftColor as C } from "../tool/color.js";
+import { getClassId as k } from "./cssClassId.js";
+function N(s, o, e) {
+  if (!s.ignore)
+    if (s.isSilent()) {
+      var a = {
+        "pointer-events": "none"
+      };
+      v(a, o, e);
+    } else {
+      var r = s.states.emphasis && s.states.emphasis.style ? s.states.emphasis.style : {}, t = r.fill;
+      if (!t) {
+        var i = s.style && s.style.fill, n = s.states.select && s.states.select.style && s.states.select.style.fill, c = s.currentStates.indexOf("select") >= 0 && n || i;
+        c && (t = C(c));
+      }
+      var f = r.lineWidth;
+      if (f) {
+        var y = !r.strokeNoScale && s.transform ? s.transform[0] : 1;
+        f = f / y;
+      }
+      var a = {
+        cursor: "pointer"
+      };
+      t && (a.fill = t), r.stroke && (a.stroke = r.stroke), f && (a["stroke-width"] = f), v(a, o, e);
+    }
+}
+function v(s, o, e, a) {
+  var r = JSON.stringify(s), t = e.cssStyleCache[r];
+  t || (t = e.zrId + "-cls-" + k(), e.cssStyleCache[r] = t, e.cssNodes["." + t + ":hover"] = s), o.class = o.class ? o.class + " " + t : t;
+}
+export {
+  N as createCSSEmphasis
+};

package/dist/node_modules/zrender/lib/svg/domapi.js

@@ -0,0 +1,30 @@
+function o(e) {
+  return document.createTextNode(e);
+}
+function i(e, n, t) {
+  e.insertBefore(n, t);
+}
+function r(e, n) {
+  e.removeChild(n);
+}
+function d(e, n) {
+  e.appendChild(n);
+}
+function u(e) {
+  return e.parentNode;
+}
+function c(e) {
+  return e.nextSibling;
+}
+function f(e, n) {
+  e.textContent = n;
+}
+export {
+  d as appendChild,
+  o as createTextNode,
+  i as insertBefore,
+  c as nextSibling,
+  u as parentNode,
+  r as removeChild,
+  f as setTextContent
+};