@yxy_27/yxyeasy 0.0.1

package/dist/index.es.js

@@ -0,0 +1,1391 @@
+import { getCurrentInstance, onMounted, nextTick, getCurrentScope, onScopeDispose, ref, watch, unref, defineComponent, useAttrs, shallowRef, onUnmounted, openBlock, createElementBlock, createElementVNode } from "vue";
+import * as echarts from "echarts";
+var collectionUtils = { exports: {} };
+var utils$3 = collectionUtils.exports = {};
+utils$3.forEach = function(collection, callback) {
+  for (var i = 0; i < collection.length; i++) {
+    var result = callback(collection[i]);
+    if (result) {
+      return result;
+    }
+  }
+};
+var elementUtils = function(options) {
+  var getState2 = options.stateHandler.getState;
+  function isDetectable(element) {
+    var state = getState2(element);
+    return state && !!state.isDetectable;
+  }
+  function markAsDetectable(element) {
+    getState2(element).isDetectable = true;
+  }
+  function isBusy(element) {
+    return !!getState2(element).busy;
+  }
+  function markBusy(element, busy) {
+    getState2(element).busy = !!busy;
+  }
+  return {
+    isDetectable,
+    markAsDetectable,
+    isBusy,
+    markBusy
+  };
+};
+var listenerHandler = function(idHandler2) {
+  var eventListeners = {};
+  function getListeners(element) {
+    var id = idHandler2.get(element);
+    if (id === void 0) {
+      return [];
+    }
+    return eventListeners[id] || [];
+  }
+  function addListener(element, listener) {
+    var id = idHandler2.get(element);
+    if (!eventListeners[id]) {
+      eventListeners[id] = [];
+    }
+    eventListeners[id].push(listener);
+  }
+  function removeListener(element, listener) {
+    var listeners = getListeners(element);
+    for (var i = 0, len = listeners.length; i < len; ++i) {
+      if (listeners[i] === listener) {
+        listeners.splice(i, 1);
+        break;
+      }
+    }
+  }
+  function removeAllListeners(element) {
+    var listeners = getListeners(element);
+    if (!listeners) {
+      return;
+    }
+    listeners.length = 0;
+  }
+  return {
+    get: getListeners,
+    add: addListener,
+    removeListener,
+    removeAllListeners
+  };
+};
+var idGenerator = function() {
+  var idCount = 1;
+  function generate() {
+    return idCount++;
+  }
+  return {
+    generate
+  };
+};
+var idHandler = function(options) {
+  var idGenerator2 = options.idGenerator;
+  var getState2 = options.stateHandler.getState;
+  function getId(element) {
+    var state = getState2(element);
+    if (state && state.id !== void 0) {
+      return state.id;
+    }
+    return null;
+  }
+  function setId(element) {
+    var state = getState2(element);
+    if (!state) {
+      throw new Error("setId required the element to have a resize detection state.");
+    }
+    var id = idGenerator2.generate();
+    state.id = id;
+    return id;
+  }
+  return {
+    get: getId,
+    set: setId
+  };
+};
+var reporter = function(quiet) {
+  function noop2() {
+  }
+  var reporter2 = {
+    log: noop2,
+    warn: noop2,
+    error: noop2
+  };
+  if (!quiet && window.console) {
+    var attachFunction = function(reporter3, name) {
+      reporter3[name] = function reporterProxy() {
+        var f = console[name];
+        if (f.apply) {
+          f.apply(console, arguments);
+        } else {
+          for (var i = 0; i < arguments.length; i++) {
+            f(arguments[i]);
+          }
+        }
+      };
+    };
+    attachFunction(reporter2, "log");
+    attachFunction(reporter2, "warn");
+    attachFunction(reporter2, "error");
+  }
+  return reporter2;
+};
+var browserDetector$2 = { exports: {} };
+var detector = browserDetector$2.exports = {};
+detector.isIE = function(version) {
+  function isAnyIeVersion() {
+    var agent = navigator.userAgent.toLowerCase();
+    return agent.indexOf("msie") !== -1 || agent.indexOf("trident") !== -1 || agent.indexOf(" edge/") !== -1;
+  }
+  if (!isAnyIeVersion()) {
+    return false;
+  }
+  if (!version) {
+    return true;
+  }
+  var ieVersion = function() {
+    var undef, v = 3, div = document.createElement("div"), all = div.getElementsByTagName("i");
+    do {
+      div.innerHTML = "<!--[if gt IE " + ++v + "]><i></i><![endif]-->";
+    } while (all[0]);
+    return v > 4 ? v : undef;
+  }();
+  return version === ieVersion;
+};
+detector.isLegacyOpera = function() {
+  return !!window.opera;
+};
+var utils$2 = { exports: {} };
+var utils$1 = utils$2.exports = {};
+utils$1.getOption = getOption$1;
+function getOption$1(options, name, defaultValue) {
+  var value = options[name];
+  if ((value === void 0 || value === null) && defaultValue !== void 0) {
+    return defaultValue;
+  }
+  return value;
+}
+var utils = utils$2.exports;
+var batchProcessor = function batchProcessorMaker(options) {
+  options = options || {};
+  var reporter2 = options.reporter;
+  var asyncProcess = utils.getOption(options, "async", true);
+  var autoProcess = utils.getOption(options, "auto", true);
+  if (autoProcess && !asyncProcess) {
+    reporter2 && reporter2.warn("Invalid options combination. auto=true and async=false is invalid. Setting async=true.");
+    asyncProcess = true;
+  }
+  var batch = Batch();
+  var asyncFrameHandler;
+  var isProcessing = false;
+  function addFunction(level, fn) {
+    if (!isProcessing && autoProcess && asyncProcess && batch.size() === 0) {
+      processBatchAsync();
+    }
+    batch.add(level, fn);
+  }
+  function processBatch() {
+    isProcessing = true;
+    while (batch.size()) {
+      var processingBatch = batch;
+      batch = Batch();
+      processingBatch.process();
+    }
+    isProcessing = false;
+  }
+  function forceProcessBatch(localAsyncProcess) {
+    if (isProcessing) {
+      return;
+    }
+    if (localAsyncProcess === void 0) {
+      localAsyncProcess = asyncProcess;
+    }
+    if (asyncFrameHandler) {
+      cancelFrame(asyncFrameHandler);
+      asyncFrameHandler = null;
+    }
+    if (localAsyncProcess) {
+      processBatchAsync();
+    } else {
+      processBatch();
+    }
+  }
+  function processBatchAsync() {
+    asyncFrameHandler = requestFrame(processBatch);
+  }
+  function cancelFrame(listener) {
+    var cancel = clearTimeout;
+    return cancel(listener);
+  }
+  function requestFrame(callback) {
+    var raf = function(fn) {
+      return setTimeout(fn, 0);
+    };
+    return raf(callback);
+  }
+  return {
+    add: addFunction,
+    force: forceProcessBatch
+  };
+};
+function Batch() {
+  var batch = {};
+  var size = 0;
+  var topLevel = 0;
+  var bottomLevel = 0;
+  function add(level, fn) {
+    if (!fn) {
+      fn = level;
+      level = 0;
+    }
+    if (level > topLevel) {
+      topLevel = level;
+    } else if (level < bottomLevel) {
+      bottomLevel = level;
+    }
+    if (!batch[level]) {
+      batch[level] = [];
+    }
+    batch[level].push(fn);
+    size++;
+  }
+  function process() {
+    for (var level = bottomLevel; level <= topLevel; level++) {
+      var fns = batch[level];
+      for (var i = 0; i < fns.length; i++) {
+        var fn = fns[i];
+        fn();
+      }
+    }
+  }
+  function getSize() {
+    return size;
+  }
+  return {
+    add,
+    process,
+    size: getSize
+  };
+}
+var prop = "_erd";
+function initState(element) {
+  element[prop] = {};
+  return getState(element);
+}
+function getState(element) {
+  return element[prop];
+}
+function cleanState(element) {
+  delete element[prop];
+}
+var stateHandler$1 = {
+  initState,
+  getState,
+  cleanState
+};
+var browserDetector$1 = browserDetector$2.exports;
+var object = function(options) {
+  options = options || {};
+  var reporter2 = options.reporter;
+  var batchProcessor2 = options.batchProcessor;
+  var getState2 = options.stateHandler.getState;
+  if (!reporter2) {
+    throw new Error("Missing required dependency: reporter.");
+  }
+  function addListener(element, listener) {
+    function listenerProxy() {
+      listener(element);
+    }
+    if (browserDetector$1.isIE(8)) {
+      getState2(element).object = {
+        proxy: listenerProxy
+      };
+      element.attachEvent("onresize", listenerProxy);
+    } else {
+      var object2 = getObject(element);
+      if (!object2) {
+        throw new Error("Element is not detectable by this strategy.");
+      }
+      object2.contentDocument.defaultView.addEventListener("resize", listenerProxy);
+    }
+  }
+  function buildCssTextString(rules) {
+    var seperator = options.important ? " !important; " : "; ";
+    return (rules.join(seperator) + seperator).trim();
+  }
+  function makeDetectable(options2, element, callback) {
+    if (!callback) {
+      callback = element;
+      element = options2;
+      options2 = null;
+    }
+    options2 = options2 || {};
+    options2.debug;
+    function injectObject(element2, callback2) {
+      var OBJECT_STYLE = buildCssTextString(["display: block", "position: absolute", "top: 0", "left: 0", "width: 100%", "height: 100%", "border: none", "padding: 0", "margin: 0", "opacity: 0", "z-index: -1000", "pointer-events: none"]);
+      var positionCheckPerformed = false;
+      var style = window.getComputedStyle(element2);
+      var width = element2.offsetWidth;
+      var height = element2.offsetHeight;
+      getState2(element2).startSize = {
+        width,
+        height
+      };
+      function mutateDom() {
+        function alterPositionStyles() {
+          if (style.position === "static") {
+            element2.style.setProperty("position", "relative", options2.important ? "important" : "");
+            var removeRelativeStyles = function(reporter3, element3, style2, property) {
+              function getNumericalValue(value2) {
+                return value2.replace(/[^-\d\.]/g, "");
+              }
+              var value = style2[property];
+              if (value !== "auto" && getNumericalValue(value) !== "0") {
+                reporter3.warn("An element that is positioned static has style." + property + "=" + value + " which is ignored due to the static positioning. The element will need to be positioned relative, so the style." + property + " will be set to 0. Element: ", element3);
+                element3.style.setProperty(property, "0", options2.important ? "important" : "");
+              }
+            };
+            removeRelativeStyles(reporter2, element2, style, "top");
+            removeRelativeStyles(reporter2, element2, style, "right");
+            removeRelativeStyles(reporter2, element2, style, "bottom");
+            removeRelativeStyles(reporter2, element2, style, "left");
+          }
+        }
+        function onObjectLoad() {
+          if (!positionCheckPerformed) {
+            alterPositionStyles();
+          }
+          function getDocument(element3, callback3) {
+            if (!element3.contentDocument) {
+              var state = getState2(element3);
+              if (state.checkForObjectDocumentTimeoutId) {
+                window.clearTimeout(state.checkForObjectDocumentTimeoutId);
+              }
+              state.checkForObjectDocumentTimeoutId = setTimeout(function checkForObjectDocument() {
+                state.checkForObjectDocumentTimeoutId = 0;
+                getDocument(element3, callback3);
+              }, 100);
+              return;
+            }
+            callback3(element3.contentDocument);
+          }
+          var objectElement = this;
+          getDocument(objectElement, function onObjectDocumentReady(objectDocument) {
+            callback2(element2);
+          });
+        }
+        if (style.position !== "") {
+          alterPositionStyles();
+          positionCheckPerformed = true;
+        }
+        var object2 = document.createElement("object");
+        object2.style.cssText = OBJECT_STYLE;
+        object2.tabIndex = -1;
+        object2.type = "text/html";
+        object2.setAttribute("aria-hidden", "true");
+        object2.onload = onObjectLoad;
+        if (!browserDetector$1.isIE()) {
+          object2.data = "about:blank";
+        }
+        if (!getState2(element2)) {
+          return;
+        }
+        element2.appendChild(object2);
+        getState2(element2).object = object2;
+        if (browserDetector$1.isIE()) {
+          object2.data = "about:blank";
+        }
+      }
+      if (batchProcessor2) {
+        batchProcessor2.add(mutateDom);
+      } else {
+        mutateDom();
+      }
+    }
+    if (browserDetector$1.isIE(8)) {
+      callback(element);
+    } else {
+      injectObject(element, callback);
+    }
+  }
+  function getObject(element) {
+    return getState2(element).object;
+  }
+  function uninstall(element) {
+    if (!getState2(element)) {
+      return;
+    }
+    var object2 = getObject(element);
+    if (!object2) {
+      return;
+    }
+    if (browserDetector$1.isIE(8)) {
+      element.detachEvent("onresize", object2.proxy);
+    } else {
+      element.removeChild(object2);
+    }
+    if (getState2(element).checkForObjectDocumentTimeoutId) {
+      window.clearTimeout(getState2(element).checkForObjectDocumentTimeoutId);
+    }
+    delete getState2(element).object;
+  }
+  return {
+    makeDetectable,
+    addListener,
+    uninstall
+  };
+};
+var forEach$1 = collectionUtils.exports.forEach;
+var scroll = function(options) {
+  options = options || {};
+  var reporter2 = options.reporter;
+  var batchProcessor2 = options.batchProcessor;
+  var getState2 = options.stateHandler.getState;
+  options.stateHandler.hasState;
+  var idHandler2 = options.idHandler;
+  if (!batchProcessor2) {
+    throw new Error("Missing required dependency: batchProcessor");
+  }
+  if (!reporter2) {
+    throw new Error("Missing required dependency: reporter.");
+  }
+  var scrollbarSizes = getScrollbarSizes();
+  var styleId = "erd_scroll_detection_scrollbar_style";
+  var detectionContainerClass = "erd_scroll_detection_container";
+  function initDocument(targetDocument) {
+    injectScrollStyle(targetDocument, styleId, detectionContainerClass);
+  }
+  initDocument(window.document);
+  function buildCssTextString(rules) {
+    var seperator = options.important ? " !important; " : "; ";
+    return (rules.join(seperator) + seperator).trim();
+  }
+  function getScrollbarSizes() {
+    var width = 500;
+    var height = 500;
+    var child = document.createElement("div");
+    child.style.cssText = buildCssTextString(["position: absolute", "width: " + width * 2 + "px", "height: " + height * 2 + "px", "visibility: hidden", "margin: 0", "padding: 0"]);
+    var container = document.createElement("div");
+    container.style.cssText = buildCssTextString(["position: absolute", "width: " + width + "px", "height: " + height + "px", "overflow: scroll", "visibility: none", "top: " + -width * 3 + "px", "left: " + -height * 3 + "px", "visibility: hidden", "margin: 0", "padding: 0"]);
+    container.appendChild(child);
+    document.body.insertBefore(container, document.body.firstChild);
+    var widthSize = width - container.clientWidth;
+    var heightSize = height - container.clientHeight;
+    document.body.removeChild(container);
+    return {
+      width: widthSize,
+      height: heightSize
+    };
+  }
+  function injectScrollStyle(targetDocument, styleId2, containerClass) {
+    function injectStyle(style2, method) {
+      method = method || function(element) {
+        targetDocument.head.appendChild(element);
+      };
+      var styleElement = targetDocument.createElement("style");
+      styleElement.innerHTML = style2;
+      styleElement.id = styleId2;
+      method(styleElement);
+      return styleElement;
+    }
+    if (!targetDocument.getElementById(styleId2)) {
+      var containerAnimationClass = containerClass + "_animation";
+      var containerAnimationActiveClass = containerClass + "_animation_active";
+      var style = "/* Created by the element-resize-detector library. */\n";
+      style += "." + containerClass + " > div::-webkit-scrollbar { " + buildCssTextString(["display: none"]) + " }\n\n";
+      style += "." + containerAnimationActiveClass + " { " + buildCssTextString(["-webkit-animation-duration: 0.1s", "animation-duration: 0.1s", "-webkit-animation-name: " + containerAnimationClass, "animation-name: " + containerAnimationClass]) + " }\n";
+      style += "@-webkit-keyframes " + containerAnimationClass + " { 0% { opacity: 1; } 50% { opacity: 0; } 100% { opacity: 1; } }\n";
+      style += "@keyframes " + containerAnimationClass + " { 0% { opacity: 1; } 50% { opacity: 0; } 100% { opacity: 1; } }";
+      injectStyle(style);
+    }
+  }
+  function addAnimationClass(element) {
+    element.className += " " + detectionContainerClass + "_animation_active";
+  }
+  function addEvent(el, name, cb) {
+    if (el.addEventListener) {
+      el.addEventListener(name, cb);
+    } else if (el.attachEvent) {
+      el.attachEvent("on" + name, cb);
+    } else {
+      return reporter2.error("[scroll] Don't know how to add event listeners.");
+    }
+  }
+  function removeEvent(el, name, cb) {
+    if (el.removeEventListener) {
+      el.removeEventListener(name, cb);
+    } else if (el.detachEvent) {
+      el.detachEvent("on" + name, cb);
+    } else {
+      return reporter2.error("[scroll] Don't know how to remove event listeners.");
+    }
+  }
+  function getExpandElement(element) {
+    return getState2(element).container.childNodes[0].childNodes[0].childNodes[0];
+  }
+  function getShrinkElement(element) {
+    return getState2(element).container.childNodes[0].childNodes[0].childNodes[1];
+  }
+  function addListener(element, listener) {
+    var listeners = getState2(element).listeners;
+    if (!listeners.push) {
+      throw new Error("Cannot add listener to an element that is not detectable.");
+    }
+    getState2(element).listeners.push(listener);
+  }
+  function makeDetectable(options2, element, callback) {
+    if (!callback) {
+      callback = element;
+      element = options2;
+      options2 = null;
+    }
+    options2 = options2 || {};
+    function debug() {
+      if (options2.debug) {
+        var args = Array.prototype.slice.call(arguments);
+        args.unshift(idHandler2.get(element), "Scroll: ");
+        if (reporter2.log.apply) {
+          reporter2.log.apply(null, args);
+        } else {
+          for (var i = 0; i < args.length; i++) {
+            reporter2.log(args[i]);
+          }
+        }
+      }
+    }
+    function isDetached(element2) {
+      function isInDocument(element3) {
+        var isInShadowRoot = element3.getRootNode && element3.getRootNode().contains(element3);
+        return element3 === element3.ownerDocument.body || element3.ownerDocument.body.contains(element3) || isInShadowRoot;
+      }
+      if (!isInDocument(element2)) {
+        return true;
+      }
+      if (window.getComputedStyle(element2) === null) {
+        return true;
+      }
+      return false;
+    }
+    function isUnrendered(element2) {
+      var container = getState2(element2).container.childNodes[0];
+      var style = window.getComputedStyle(container);
+      return !style.width || style.width.indexOf("px") === -1;
+    }
+    function getStyle() {
+      var elementStyle = window.getComputedStyle(element);
+      var style = {};
+      style.position = elementStyle.position;
+      style.width = element.offsetWidth;
+      style.height = element.offsetHeight;
+      style.top = elementStyle.top;
+      style.right = elementStyle.right;
+      style.bottom = elementStyle.bottom;
+      style.left = elementStyle.left;
+      style.widthCSS = elementStyle.width;
+      style.heightCSS = elementStyle.height;
+      return style;
+    }
+    function storeStartSize() {
+      var style = getStyle();
+      getState2(element).startSize = {
+        width: style.width,
+        height: style.height
+      };
+      debug("Element start size", getState2(element).startSize);
+    }
+    function initListeners() {
+      getState2(element).listeners = [];
+    }
+    function storeStyle() {
+      debug("storeStyle invoked.");
+      if (!getState2(element)) {
+        debug("Aborting because element has been uninstalled");
+        return;
+      }
+      var style = getStyle();
+      getState2(element).style = style;
+    }
+    function storeCurrentSize(element2, width, height) {
+      getState2(element2).lastWidth = width;
+      getState2(element2).lastHeight = height;
+    }
+    function getExpandChildElement(element2) {
+      return getExpandElement(element2).childNodes[0];
+    }
+    function getWidthOffset() {
+      return 2 * scrollbarSizes.width + 1;
+    }
+    function getHeightOffset() {
+      return 2 * scrollbarSizes.height + 1;
+    }
+    function getExpandWidth(width) {
+      return width + 10 + getWidthOffset();
+    }
+    function getExpandHeight(height) {
+      return height + 10 + getHeightOffset();
+    }
+    function getShrinkWidth(width) {
+      return width * 2 + getWidthOffset();
+    }
+    function getShrinkHeight(height) {
+      return height * 2 + getHeightOffset();
+    }
+    function positionScrollbars(element2, width, height) {
+      var expand = getExpandElement(element2);
+      var shrink = getShrinkElement(element2);
+      var expandWidth = getExpandWidth(width);
+      var expandHeight = getExpandHeight(height);
+      var shrinkWidth = getShrinkWidth(width);
+      var shrinkHeight = getShrinkHeight(height);
+      expand.scrollLeft = expandWidth;
+      expand.scrollTop = expandHeight;
+      shrink.scrollLeft = shrinkWidth;
+      shrink.scrollTop = shrinkHeight;
+    }
+    function injectContainerElement() {
+      var container = getState2(element).container;
+      if (!container) {
+        container = document.createElement("div");
+        container.className = detectionContainerClass;
+        container.style.cssText = buildCssTextString(["visibility: hidden", "display: inline", "width: 0px", "height: 0px", "z-index: -1", "overflow: hidden", "margin: 0", "padding: 0"]);
+        getState2(element).container = container;
+        addAnimationClass(container);
+        element.appendChild(container);
+        var onAnimationStart = function() {
+          getState2(element).onRendered && getState2(element).onRendered();
+        };
+        addEvent(container, "animationstart", onAnimationStart);
+        getState2(element).onAnimationStart = onAnimationStart;
+      }
+      return container;
+    }
+    function injectScrollElements() {
+      function alterPositionStyles() {
+        var style = getState2(element).style;
+        if (style.position === "static") {
+          element.style.setProperty("position", "relative", options2.important ? "important" : "");
+          var removeRelativeStyles = function(reporter3, element2, style2, property) {
+            function getNumericalValue(value2) {
+              return value2.replace(/[^-\d\.]/g, "");
+            }
+            var value = style2[property];
+            if (value !== "auto" && getNumericalValue(value) !== "0") {
+              reporter3.warn("An element that is positioned static has style." + property + "=" + value + " which is ignored due to the static positioning. The element will need to be positioned relative, so the style." + property + " will be set to 0. Element: ", element2);
+              element2.style[property] = 0;
+            }
+          };
+          removeRelativeStyles(reporter2, element, style, "top");
+          removeRelativeStyles(reporter2, element, style, "right");
+          removeRelativeStyles(reporter2, element, style, "bottom");
+          removeRelativeStyles(reporter2, element, style, "left");
+        }
+      }
+      function getLeftTopBottomRightCssText(left, top, bottom, right) {
+        left = !left ? "0" : left + "px";
+        top = !top ? "0" : top + "px";
+        bottom = !bottom ? "0" : bottom + "px";
+        right = !right ? "0" : right + "px";
+        return ["left: " + left, "top: " + top, "right: " + right, "bottom: " + bottom];
+      }
+      debug("Injecting elements");
+      if (!getState2(element)) {
+        debug("Aborting because element has been uninstalled");
+        return;
+      }
+      alterPositionStyles();
+      var rootContainer = getState2(element).container;
+      if (!rootContainer) {
+        rootContainer = injectContainerElement();
+      }
+      var scrollbarWidth = scrollbarSizes.width;
+      var scrollbarHeight = scrollbarSizes.height;
+      var containerContainerStyle = buildCssTextString(["position: absolute", "flex: none", "overflow: hidden", "z-index: -1", "visibility: hidden", "width: 100%", "height: 100%", "left: 0px", "top: 0px"]);
+      var containerStyle = buildCssTextString(["position: absolute", "flex: none", "overflow: hidden", "z-index: -1", "visibility: hidden"].concat(getLeftTopBottomRightCssText(-(1 + scrollbarWidth), -(1 + scrollbarHeight), -scrollbarHeight, -scrollbarWidth)));
+      var expandStyle = buildCssTextString(["position: absolute", "flex: none", "overflow: scroll", "z-index: -1", "visibility: hidden", "width: 100%", "height: 100%"]);
+      var shrinkStyle = buildCssTextString(["position: absolute", "flex: none", "overflow: scroll", "z-index: -1", "visibility: hidden", "width: 100%", "height: 100%"]);
+      var expandChildStyle = buildCssTextString(["position: absolute", "left: 0", "top: 0"]);
+      var shrinkChildStyle = buildCssTextString(["position: absolute", "width: 200%", "height: 200%"]);
+      var containerContainer = document.createElement("div");
+      var container = document.createElement("div");
+      var expand = document.createElement("div");
+      var expandChild = document.createElement("div");
+      var shrink = document.createElement("div");
+      var shrinkChild = document.createElement("div");
+      containerContainer.dir = "ltr";
+      containerContainer.style.cssText = containerContainerStyle;
+      containerContainer.className = detectionContainerClass;
+      container.className = detectionContainerClass;
+      container.style.cssText = containerStyle;
+      expand.style.cssText = expandStyle;
+      expandChild.style.cssText = expandChildStyle;
+      shrink.style.cssText = shrinkStyle;
+      shrinkChild.style.cssText = shrinkChildStyle;
+      expand.appendChild(expandChild);
+      shrink.appendChild(shrinkChild);
+      container.appendChild(expand);
+      container.appendChild(shrink);
+      containerContainer.appendChild(container);
+      rootContainer.appendChild(containerContainer);
+      function onExpandScroll() {
+        var state = getState2(element);
+        if (state && state.onExpand) {
+          state.onExpand();
+        } else {
+          debug("Aborting expand scroll handler: element has been uninstalled");
+        }
+      }
+      function onShrinkScroll() {
+        var state = getState2(element);
+        if (state && state.onShrink) {
+          state.onShrink();
+        } else {
+          debug("Aborting shrink scroll handler: element has been uninstalled");
+        }
+      }
+      addEvent(expand, "scroll", onExpandScroll);
+      addEvent(shrink, "scroll", onShrinkScroll);
+      getState2(element).onExpandScroll = onExpandScroll;
+      getState2(element).onShrinkScroll = onShrinkScroll;
+    }
+    function registerListenersAndPositionElements() {
+      function updateChildSizes(element2, width, height) {
+        var expandChild = getExpandChildElement(element2);
+        var expandWidth = getExpandWidth(width);
+        var expandHeight = getExpandHeight(height);
+        expandChild.style.setProperty("width", expandWidth + "px", options2.important ? "important" : "");
+        expandChild.style.setProperty("height", expandHeight + "px", options2.important ? "important" : "");
+      }
+      function updateDetectorElements(done) {
+        var width = element.offsetWidth;
+        var height = element.offsetHeight;
+        var sizeChanged = width !== getState2(element).lastWidth || height !== getState2(element).lastHeight;
+        debug("Storing current size", width, height);
+        storeCurrentSize(element, width, height);
+        batchProcessor2.add(0, function performUpdateChildSizes() {
+          if (!sizeChanged) {
+            return;
+          }
+          if (!getState2(element)) {
+            debug("Aborting because element has been uninstalled");
+            return;
+          }
+          if (!areElementsInjected()) {
+            debug("Aborting because element container has not been initialized");
+            return;
+          }
+          if (options2.debug) {
+            var w = element.offsetWidth;
+            var h = element.offsetHeight;
+            if (w !== width || h !== height) {
+              reporter2.warn(idHandler2.get(element), "Scroll: Size changed before updating detector elements.");
+            }
+          }
+          updateChildSizes(element, width, height);
+        });
+        batchProcessor2.add(1, function updateScrollbars() {
+          if (!getState2(element)) {
+            debug("Aborting because element has been uninstalled");
+            return;
+          }
+          if (!areElementsInjected()) {
+            debug("Aborting because element container has not been initialized");
+            return;
+          }
+          positionScrollbars(element, width, height);
+        });
+        if (sizeChanged && done) {
+          batchProcessor2.add(2, function() {
+            if (!getState2(element)) {
+              debug("Aborting because element has been uninstalled");
+              return;
+            }
+            if (!areElementsInjected()) {
+              debug("Aborting because element container has not been initialized");
+              return;
+            }
+            done();
+          });
+        }
+      }
+      function areElementsInjected() {
+        return !!getState2(element).container;
+      }
+      function notifyListenersIfNeeded() {
+        function isFirstNotify() {
+          return getState2(element).lastNotifiedWidth === void 0;
+        }
+        debug("notifyListenersIfNeeded invoked");
+        var state = getState2(element);
+        if (isFirstNotify() && state.lastWidth === state.startSize.width && state.lastHeight === state.startSize.height) {
+          return debug("Not notifying: Size is the same as the start size, and there has been no notification yet.");
+        }
+        if (state.lastWidth === state.lastNotifiedWidth && state.lastHeight === state.lastNotifiedHeight) {
+          return debug("Not notifying: Size already notified");
+        }
+        debug("Current size not notified, notifying...");
+        state.lastNotifiedWidth = state.lastWidth;
+        state.lastNotifiedHeight = state.lastHeight;
+        forEach$1(getState2(element).listeners, function(listener) {
+          listener(element);
+        });
+      }
+      function handleRender() {
+        debug("startanimation triggered.");
+        if (isUnrendered(element)) {
+          debug("Ignoring since element is still unrendered...");
+          return;
+        }
+        debug("Element rendered.");
+        var expand = getExpandElement(element);
+        var shrink = getShrinkElement(element);
+        if (expand.scrollLeft === 0 || expand.scrollTop === 0 || shrink.scrollLeft === 0 || shrink.scrollTop === 0) {
+          debug("Scrollbars out of sync. Updating detector elements...");
+          updateDetectorElements(notifyListenersIfNeeded);
+        }
+      }
+      function handleScroll() {
+        debug("Scroll detected.");
+        if (isUnrendered(element)) {
+          debug("Scroll event fired while unrendered. Ignoring...");
+          return;
+        }
+        updateDetectorElements(notifyListenersIfNeeded);
+      }
+      debug("registerListenersAndPositionElements invoked.");
+      if (!getState2(element)) {
+        debug("Aborting because element has been uninstalled");
+        return;
+      }
+      getState2(element).onRendered = handleRender;
+      getState2(element).onExpand = handleScroll;
+      getState2(element).onShrink = handleScroll;
+      var style = getState2(element).style;
+      updateChildSizes(element, style.width, style.height);
+    }
+    function finalizeDomMutation() {
+      debug("finalizeDomMutation invoked.");
+      if (!getState2(element)) {
+        debug("Aborting because element has been uninstalled");
+        return;
+      }
+      var style = getState2(element).style;
+      storeCurrentSize(element, style.width, style.height);
+      positionScrollbars(element, style.width, style.height);
+    }
+    function ready() {
+      callback(element);
+    }
+    function install2() {
+      debug("Installing...");
+      initListeners();
+      storeStartSize();
+      batchProcessor2.add(0, storeStyle);
+      batchProcessor2.add(1, injectScrollElements);
+      batchProcessor2.add(2, registerListenersAndPositionElements);
+      batchProcessor2.add(3, finalizeDomMutation);
+      batchProcessor2.add(4, ready);
+    }
+    debug("Making detectable...");
+    if (isDetached(element)) {
+      debug("Element is detached");
+      injectContainerElement();
+      debug("Waiting until element is attached...");
+      getState2(element).onRendered = function() {
+        debug("Element is now attached");
+        install2();
+      };
+    } else {
+      install2();
+    }
+  }
+  function uninstall(element) {
+    var state = getState2(element);
+    if (!state) {
+      return;
+    }
+    state.onExpandScroll && removeEvent(getExpandElement(element), "scroll", state.onExpandScroll);
+    state.onShrinkScroll && removeEvent(getShrinkElement(element), "scroll", state.onShrinkScroll);
+    state.onAnimationStart && removeEvent(state.container, "animationstart", state.onAnimationStart);
+    state.container && element.removeChild(state.container);
+  }
+  return {
+    makeDetectable,
+    addListener,
+    uninstall,
+    initDocument
+  };
+};
+var forEach = collectionUtils.exports.forEach;
+var elementUtilsMaker = elementUtils;
+var listenerHandlerMaker = listenerHandler;
+var idGeneratorMaker = idGenerator;
+var idHandlerMaker = idHandler;
+var reporterMaker = reporter;
+var browserDetector = browserDetector$2.exports;
+var batchProcessorMaker2 = batchProcessor;
+var stateHandler = stateHandler$1;
+var objectStrategyMaker = object;
+var scrollStrategyMaker = scroll;
+function isCollection(obj) {
+  return Array.isArray(obj) || obj.length !== void 0;
+}
+function toArray(collection) {
+  if (!Array.isArray(collection)) {
+    var array = [];
+    forEach(collection, function(obj) {
+      array.push(obj);
+    });
+    return array;
+  } else {
+    return collection;
+  }
+}
+function isElement(obj) {
+  return obj && obj.nodeType === 1;
+}
+var elementResizeDetector = function(options) {
+  options = options || {};
+  var idHandler2;
+  if (options.idHandler) {
+    idHandler2 = {
+      get: function(element) {
+        return options.idHandler.get(element, true);
+      },
+      set: options.idHandler.set
+    };
+  } else {
+    var idGenerator2 = idGeneratorMaker();
+    var defaultIdHandler = idHandlerMaker({
+      idGenerator: idGenerator2,
+      stateHandler
+    });
+    idHandler2 = defaultIdHandler;
+  }
+  var reporter2 = options.reporter;
+  if (!reporter2) {
+    var quiet = reporter2 === false;
+    reporter2 = reporterMaker(quiet);
+  }
+  var batchProcessor2 = getOption(options, "batchProcessor", batchProcessorMaker2({ reporter: reporter2 }));
+  var globalOptions = {};
+  globalOptions.callOnAdd = !!getOption(options, "callOnAdd", true);
+  globalOptions.debug = !!getOption(options, "debug", false);
+  var eventListenerHandler = listenerHandlerMaker(idHandler2);
+  var elementUtils2 = elementUtilsMaker({
+    stateHandler
+  });
+  var detectionStrategy;
+  var desiredStrategy = getOption(options, "strategy", "object");
+  var importantCssRules = getOption(options, "important", false);
+  var strategyOptions = {
+    reporter: reporter2,
+    batchProcessor: batchProcessor2,
+    stateHandler,
+    idHandler: idHandler2,
+    important: importantCssRules
+  };
+  if (desiredStrategy === "scroll") {
+    if (browserDetector.isLegacyOpera()) {
+      reporter2.warn("Scroll strategy is not supported on legacy Opera. Changing to object strategy.");
+      desiredStrategy = "object";
+    } else if (browserDetector.isIE(9)) {
+      reporter2.warn("Scroll strategy is not supported on IE9. Changing to object strategy.");
+      desiredStrategy = "object";
+    }
+  }
+  if (desiredStrategy === "scroll") {
+    detectionStrategy = scrollStrategyMaker(strategyOptions);
+  } else if (desiredStrategy === "object") {
+    detectionStrategy = objectStrategyMaker(strategyOptions);
+  } else {
+    throw new Error("Invalid strategy name: " + desiredStrategy);
+  }
+  var onReadyCallbacks = {};
+  function listenTo(options2, elements, listener) {
+    function onResizeCallback(element) {
+      var listeners = eventListenerHandler.get(element);
+      forEach(listeners, function callListenerProxy(listener2) {
+        listener2(element);
+      });
+    }
+    function addListener(callOnAdd2, element, listener2) {
+      eventListenerHandler.add(element, listener2);
+      if (callOnAdd2) {
+        listener2(element);
+      }
+    }
+    if (!listener) {
+      listener = elements;
+      elements = options2;
+      options2 = {};
+    }
+    if (!elements) {
+      throw new Error("At least one element required.");
+    }
+    if (!listener) {
+      throw new Error("Listener required.");
+    }
+    if (isElement(elements)) {
+      elements = [elements];
+    } else if (isCollection(elements)) {
+      elements = toArray(elements);
+    } else {
+      return reporter2.error("Invalid arguments. Must be a DOM element or a collection of DOM elements.");
+    }
+    var elementsReady = 0;
+    var callOnAdd = getOption(options2, "callOnAdd", globalOptions.callOnAdd);
+    var onReadyCallback = getOption(options2, "onReady", function noop2() {
+    });
+    var debug = getOption(options2, "debug", globalOptions.debug);
+    forEach(elements, function attachListenerToElement(element) {
+      if (!stateHandler.getState(element)) {
+        stateHandler.initState(element);
+        idHandler2.set(element);
+      }
+      var id = idHandler2.get(element);
+      debug && reporter2.log("Attaching listener to element", id, element);
+      if (!elementUtils2.isDetectable(element)) {
+        debug && reporter2.log(id, "Not detectable.");
+        if (elementUtils2.isBusy(element)) {
+          debug && reporter2.log(id, "System busy making it detectable");
+          addListener(callOnAdd, element, listener);
+          onReadyCallbacks[id] = onReadyCallbacks[id] || [];
+          onReadyCallbacks[id].push(function onReady() {
+            elementsReady++;
+            if (elementsReady === elements.length) {
+              onReadyCallback();
+            }
+          });
+          return;
+        }
+        debug && reporter2.log(id, "Making detectable...");
+        elementUtils2.markBusy(element, true);
+        return detectionStrategy.makeDetectable({ debug, important: importantCssRules }, element, function onElementDetectable(element2) {
+          debug && reporter2.log(id, "onElementDetectable");
+          if (stateHandler.getState(element2)) {
+            elementUtils2.markAsDetectable(element2);
+            elementUtils2.markBusy(element2, false);
+            detectionStrategy.addListener(element2, onResizeCallback);
+            addListener(callOnAdd, element2, listener);
+            var state = stateHandler.getState(element2);
+            if (state && state.startSize) {
+              var width = element2.offsetWidth;
+              var height = element2.offsetHeight;
+              if (state.startSize.width !== width || state.startSize.height !== height) {
+                onResizeCallback(element2);
+              }
+            }
+            if (onReadyCallbacks[id]) {
+              forEach(onReadyCallbacks[id], function(callback) {
+                callback();
+              });
+            }
+          } else {
+            debug && reporter2.log(id, "Element uninstalled before being detectable.");
+          }
+          delete onReadyCallbacks[id];
+          elementsReady++;
+          if (elementsReady === elements.length) {
+            onReadyCallback();
+          }
+        });
+      }
+      debug && reporter2.log(id, "Already detecable, adding listener.");
+      addListener(callOnAdd, element, listener);
+      elementsReady++;
+    });
+    if (elementsReady === elements.length) {
+      onReadyCallback();
+    }
+  }
+  function uninstall(elements) {
+    if (!elements) {
+      return reporter2.error("At least one element is required.");
+    }
+    if (isElement(elements)) {
+      elements = [elements];
+    } else if (isCollection(elements)) {
+      elements = toArray(elements);
+    } else {
+      return reporter2.error("Invalid arguments. Must be a DOM element or a collection of DOM elements.");
+    }
+    forEach(elements, function(element) {
+      eventListenerHandler.removeAllListeners(element);
+      detectionStrategy.uninstall(element);
+      stateHandler.cleanState(element);
+    });
+  }
+  function initDocument(targetDocument) {
+    detectionStrategy.initDocument && detectionStrategy.initDocument(targetDocument);
+  }
+  return {
+    listenTo,
+    removeListener: eventListenerHandler.removeListener,
+    removeAllListeners: eventListenerHandler.removeAllListeners,
+    uninstall,
+    initDocument
+  };
+};
+function getOption(options, name, defaultValue) {
+  var value = options[name];
+  if ((value === void 0 || value === null) && defaultValue !== void 0) {
+    return defaultValue;
+  }
+  return value;
+}
+var _a;
+const isClient = typeof window !== "undefined";
+const isString = (val) => typeof val === "string";
+const noop = () => {
+};
+isClient && ((_a = window == null ? void 0 : window.navigator) == null ? void 0 : _a.userAgent) && /iP(ad|hone|od)/.test(window.navigator.userAgent);
+function tryOnScopeDispose(fn) {
+  if (getCurrentScope()) {
+    onScopeDispose(fn);
+    return true;
+  }
+  return false;
+}
+function tryOnMounted(fn, sync = true) {
+  if (getCurrentInstance())
+    onMounted(fn);
+  else if (sync)
+    fn();
+  else
+    nextTick(fn);
+}
+function unrefElement(elRef) {
+  var _a2;
+  const plain = unref(elRef);
+  return (_a2 = plain == null ? void 0 : plain.$el) != null ? _a2 : plain;
+}
+const defaultWindow = isClient ? window : void 0;
+isClient ? window.document : void 0;
+isClient ? window.navigator : void 0;
+isClient ? window.location : void 0;
+function useEventListener(...args) {
+  let target;
+  let event;
+  let listener;
+  let options;
+  if (isString(args[0])) {
+    [event, listener, options] = args;
+    target = defaultWindow;
+  } else {
+    [target, event, listener, options] = args;
+  }
+  if (!target)
+    return noop;
+  let cleanup = noop;
+  const stopWatch = watch(() => unrefElement(target), (el) => {
+    cleanup();
+    if (!el)
+      return;
+    el.addEventListener(event, listener, options);
+    cleanup = () => {
+      el.removeEventListener(event, listener, options);
+      cleanup = noop;
+    };
+  }, { immediate: true, flush: "post" });
+  const stop = () => {
+    stopWatch();
+    cleanup();
+  };
+  tryOnScopeDispose(stop);
+  return stop;
+}
+const _global = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
+const globalKey = "__vueuse_ssr_handlers__";
+_global[globalKey] = _global[globalKey] || {};
+_global[globalKey];
+var SwipeDirection;
+(function(SwipeDirection2) {
+  SwipeDirection2["UP"] = "UP";
+  SwipeDirection2["RIGHT"] = "RIGHT";
+  SwipeDirection2["DOWN"] = "DOWN";
+  SwipeDirection2["LEFT"] = "LEFT";
+  SwipeDirection2["NONE"] = "NONE";
+})(SwipeDirection || (SwipeDirection = {}));
+function useWindowSize(options = {}) {
+  const {
+    window: window2 = defaultWindow,
+    initialWidth = Infinity,
+    initialHeight = Infinity,
+    listenOrientation = true
+  } = options;
+  const width = ref(initialWidth);
+  const height = ref(initialHeight);
+  const update = () => {
+    if (window2) {
+      width.value = window2.innerWidth;
+      height.value = window2.innerHeight;
+    }
+  };
+  update();
+  tryOnMounted(update);
+  useEventListener("resize", update, { passive: true });
+  if (listenOrientation)
+    useEventListener("orientationchange", update, { passive: true });
+  return { width, height };
+}
+var index_vue_vue_type_style_index_0_scoped_true_lang = "";
+var _export_sfc = (sfc, props) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props) {
+    target[key] = val;
+  }
+  return target;
+};
+const _hoisted_1 = { class: "ChartContent" };
+const _sfc_main = defineComponent({
+  __name: "index",
+  setup(__props, { expose: __expose }) {
+    const attrs = useAttrs();
+    const chartRef = shallowRef(null);
+    const myChart = shallowRef();
+    const { width, height } = useWindowSize();
+    watch([width, height], (n) => {
+      onResize();
+    });
+    const handleChart = () => {
+      var _a2, _b, _c, _d, _e;
+      myChart.value ? (_a2 = myChart.value) == null ? void 0 : _a2.dispose() : null;
+      myChart.value = echarts.init(
+        chartRef.value,
+        null,
+        attrs == null ? void 0 : attrs.initInfo
+      );
+      (_b = attrs == null ? void 0 : attrs.getSeriesData) == null ? void 0 : _b.call(attrs, attrs == null ? void 0 : attrs.data, myChart.value);
+      myChart.value && attrs.option ? (_c = myChart.value) == null ? void 0 : _c.setOption(attrs.option) : null;
+      onResize();
+      (_d = myChart.value) == null ? void 0 : _d.on("legendselectchanged", (params) => {
+        var _a3;
+        if (attrs == null ? void 0 : attrs.chartEventLegendselectchanged) {
+          const options = attrs == null ? void 0 : attrs.chartEventLegendselectchanged(params);
+          myChart.value && (attrs.option || options) ? (_a3 = myChart.value) == null ? void 0 : _a3.setOption(options || attrs.option) : null;
+        }
+      });
+      (_e = myChart.value) == null ? void 0 : _e.on("click", (params) => {
+        var _a3;
+        if (attrs == null ? void 0 : attrs.chartEventClick) {
+          const options = attrs == null ? void 0 : attrs.chartEventClick(params);
+          myChart.value && (attrs.option || options) ? (_a3 = myChart.value) == null ? void 0 : _a3.setOption(options || attrs.option) : null;
+        }
+      });
+    };
+    const onResize = () => {
+      let elementResize2 = elementResizeDetector({
+        strategy: "scroll",
+        callOnAdd: true
+      });
+      nextTick(() => {
+        chartRef.value ? elementResize2.listenTo(chartRef.value, function(element) {
+          chartRef.value ? echarts == null ? void 0 : echarts.init(chartRef.value).resize() : null;
+        }) : null;
+      });
+    };
+    watch(
+      () => attrs.data,
+      (n) => {
+        if (n || (n == null ? void 0 : n.length)) {
+          if (chartRef.value) {
+            handleChart();
+          }
+        }
+      },
+      {
+        immediate: true,
+        deep: true
+      }
+    );
+    __expose({
+      myChart,
+      onResize
+    });
+    const hasData = () => {
+      var _a2, _b;
+      if ((attrs == null ? void 0 : attrs.data) != null && (attrs == null ? void 0 : attrs.data) != void 0) {
+        if (Array.isArray(attrs == null ? void 0 : attrs.data)) {
+          return (_a2 = attrs == null ? void 0 : attrs.data) == null ? void 0 : _a2.length;
+        } else if (Object.prototype.toString.call(attrs == null ? void 0 : attrs.data) === "[object Object]") {
+          return (_b = Object.keys(attrs == null ? void 0 : attrs.data)) == null ? void 0 : _b.length;
+        }
+      } else {
+        return false;
+      }
+    };
+    onMounted(() => {
+      if (hasData() && chartRef.value) {
+        handleChart();
+      }
+    });
+    onUnmounted(() => {
+      var _a2;
+      myChart.value ? (_a2 = myChart.value) == null ? void 0 : _a2.dispose() : null;
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1, [
+        createElementVNode("div", {
+          class: "chart",
+          ref_key: "chartRef",
+          ref: chartRef
+        }, null, 512)
+      ]);
+    };
+  }
+});
+var YCharts = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-9ee3fe2c"]]);
+YCharts.install = (app) => {
+  app.component("YCharts", YCharts);
+};
+const components = [YCharts];
+const install = (app) => {
+  components.forEach((component) => {
+    if (component.install) {
+      app.use(component);
+    } else if (component.name) {
+      app.component(component.name, component);
+    }
+  });
+};
+var index$2 = { install, version: "0.0.1" };
+var components$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  YCharts,
+  "default": index$2
+}, Symbol.toStringTag, { value: "Module" }));
+var index$1 = "";
+function debounce(fn, delay) {
+  let timer = null;
+  return function(...args) {
+    if (timer)
+      clearTimeout(timer);
+    timer = setTimeout(() => {
+      fn.apply(this, args);
+    }, delay);
+  };
+}
+function throttle(fn, delay) {
+  let last = 0;
+  return function(...args) {
+    const now = Date.now();
+    if (now - last >= delay) {
+      fn.apply(this, args);
+      last = now;
+    }
+  };
+}
+var index = {
+  install: (app) => {
+    Object.values(components$1).forEach((component) => {
+      if (component.install) {
+        app.use(component);
+      } else if (component.name) {
+        app.component(component.name, component);
+      }
+    });
+  }
+};
+export { YCharts, debounce, index as default, throttle };
+//# sourceMappingURL=index.es.js.map