vue-mount-plugin 3.0.0 → 4.0.0-beta.0

package/dist/index.iife.js

@@ -0,0 +1,1103 @@
+var _VueDemiGlobal = typeof globalThis !== 'undefined' 
+  ? globalThis
+  : typeof global !== 'undefined'
+    ? global
+    : typeof self !== 'undefined'
+      ? self
+      : this
+var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
+  if (VueDemi.install) {
+    return VueDemi
+  }
+  if (!Vue) {
+    console.error('[vue-demi] no Vue instance found, please be sure to import `vue` before `vue-demi`.')
+    return VueDemi
+  }
+
+  // Vue 2.7
+  if (Vue.version.slice(0, 4) === '2.7.') {
+    for (var key in Vue) {
+      VueDemi[key] = Vue[key]
+    }
+    VueDemi.isVue2 = true
+    VueDemi.isVue3 = false
+    VueDemi.install = function () {}
+    VueDemi.Vue = Vue
+    VueDemi.Vue2 = Vue
+    VueDemi.version = Vue.version
+    VueDemi.warn = Vue.util.warn
+    VueDemi.hasInjectionContext = function() {
+      return !!VueDemi.getCurrentInstance()
+    }
+    function createApp(rootComponent, rootProps) {
+      var vm
+      var provide = {}
+      var app = {
+        config: Vue.config,
+        use: Vue.use.bind(Vue),
+        mixin: Vue.mixin.bind(Vue),
+        component: Vue.component.bind(Vue),
+        provide: function (key, value) {
+          provide[key] = value
+          return this
+        },
+        directive: function (name, dir) {
+          if (dir) {
+            Vue.directive(name, dir)
+            return app
+          } else {
+            return Vue.directive(name)
+          }
+        },
+        mount: function (el, hydrating) {
+          if (!vm) {
+            vm = new Vue(Object.assign({ propsData: rootProps }, rootComponent, { provide: Object.assign(provide, rootComponent.provide) }))
+            vm.$mount(el, hydrating)
+            return vm
+          } else {
+            return vm
+          }
+        },
+        unmount: function () {
+          if (vm) {
+            vm.$destroy()
+            vm = undefined
+          }
+        },
+      }
+      return app
+    }
+    VueDemi.createApp = createApp
+  }
+  // Vue 2.6.x
+  else if (Vue.version.slice(0, 2) === '2.') {
+    if (VueCompositionAPI) {
+      for (var key in VueCompositionAPI) {
+        VueDemi[key] = VueCompositionAPI[key]
+      }
+      VueDemi.isVue2 = true
+      VueDemi.isVue3 = false
+      VueDemi.install = function () {}
+      VueDemi.Vue = Vue
+      VueDemi.Vue2 = Vue
+      VueDemi.version = Vue.version
+      VueDemi.hasInjectionContext = function() {
+        return !!VueDemi.getCurrentInstance()
+      }
+    } else {
+      console.error('[vue-demi] no VueCompositionAPI instance found, please be sure to import `@vue/composition-api` before `vue-demi`.')
+    }
+  }
+  // Vue 3
+  else if (Vue.version.slice(0, 2) === '3.') {
+    for (var key in Vue) {
+      VueDemi[key] = Vue[key]
+    }
+    VueDemi.isVue2 = false
+    VueDemi.isVue3 = true
+    VueDemi.install = function () {}
+    VueDemi.Vue = Vue
+    VueDemi.Vue2 = undefined
+    VueDemi.version = Vue.version
+    VueDemi.set = function (target, key, val) {
+      if (Array.isArray(target)) {
+        target.length = Math.max(target.length, key)
+        target.splice(key, 1, val)
+        return val
+      }
+      target[key] = val
+      return val
+    }
+    VueDemi.del = function (target, key) {
+      if (Array.isArray(target)) {
+        target.splice(key, 1)
+        return
+      }
+      delete target[key]
+    }
+  } else {
+    console.error('[vue-demi] Vue version ' + Vue.version + ' is unsupported.')
+  }
+  return VueDemi
+})(
+  (_VueDemiGlobal.VueDemi = _VueDemiGlobal.VueDemi || (typeof VueDemi !== 'undefined' ? VueDemi : {})),
+  _VueDemiGlobal.Vue || (typeof Vue !== 'undefined' ? Vue : undefined),
+  _VueDemiGlobal.VueCompositionAPI || (typeof VueCompositionAPI !== 'undefined' ? VueCompositionAPI : undefined)
+);
+;
+/*!
+ * vue-mount-plugin v4.0.0
+ * A simple and easy to use vue instance extension plugin that supports vue2.0 and vue3.0
+ * (c) 2021-2026 saqqdy <https://github.com/saqqdy>  
+ * Released under the MIT License.
+ */
+(function (exports, vueDemi) {
+  'use strict';
+
+  function _arrayLikeToArray(r, a) {
+    (null == a || a > r.length) && (a = r.length);
+    for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
+    return n;
+  }
+  function _arrayWithHoles(r) {
+    if (Array.isArray(r)) return r;
+  }
+  function _arrayWithoutHoles(r) {
+    if (Array.isArray(r)) return _arrayLikeToArray(r);
+  }
+  function _assertThisInitialized(e) {
+    if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    return e;
+  }
+  function asyncGeneratorStep(n, t, e, r, o, a, c) {
+    try {
+      var i = n[a](c),
+        u = i.value;
+    } catch (n) {
+      return void e(n);
+    }
+    i.done ? t(u) : Promise.resolve(u).then(r, o);
+  }
+  function _asyncToGenerator(n) {
+    return function () {
+      var t = this,
+        e = arguments;
+      return new Promise(function (r, o) {
+        var a = n.apply(t, e);
+        function _next(n) {
+          asyncGeneratorStep(a, r, o, _next, _throw, "next", n);
+        }
+        function _throw(n) {
+          asyncGeneratorStep(a, r, o, _next, _throw, "throw", n);
+        }
+        _next(void 0);
+      });
+    };
+  }
+  function _callSuper(t, o, e) {
+    return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e));
+  }
+  function _classCallCheck(a, n) {
+    if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function");
+  }
+  function _defineProperties(e, r) {
+    for (var t = 0; t < r.length; t++) {
+      var o = r[t];
+      o.enumerable = o.enumerable || false, o.configurable = true, "value" in o && (o.writable = true), Object.defineProperty(e, _toPropertyKey(o.key), o);
+    }
+  }
+  function _createClass(e, r, t) {
+    return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", {
+      writable: false
+    }), e;
+  }
+  function _defineProperty(e, r, t) {
+    return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+      value: t,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    }) : e[r] = t, e;
+  }
+  function _getPrototypeOf(t) {
+    return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) {
+      return t.__proto__ || Object.getPrototypeOf(t);
+    }, _getPrototypeOf(t);
+  }
+  function _inherits(t, e) {
+    if ("function" != typeof e && null !== e) throw new TypeError("Super expression must either be null or a function");
+    t.prototype = Object.create(e && e.prototype, {
+      constructor: {
+        value: t,
+        writable: true,
+        configurable: true
+      }
+    }), Object.defineProperty(t, "prototype", {
+      writable: false
+    }), e && _setPrototypeOf(t, e);
+  }
+  function _isNativeReflectConstruct() {
+    try {
+      var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
+    } catch (t) {}
+    return (_isNativeReflectConstruct = function () {
+      return !!t;
+    })();
+  }
+  function _iterableToArray(r) {
+    if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r);
+  }
+  function _iterableToArrayLimit(r, l) {
+    var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+    if (null != t) {
+      var e,
+        n,
+        i,
+        u,
+        a = [],
+        f = true,
+        o = false;
+      try {
+        if (i = (t = t.call(r)).next, 0 === l) ; else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
+      } catch (r) {
+        o = true, n = r;
+      } finally {
+        try {
+          if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return;
+        } finally {
+          if (o) throw n;
+        }
+      }
+      return a;
+    }
+  }
+  function _nonIterableRest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+  function _nonIterableSpread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+  function ownKeys(e, r) {
+    var t = Object.keys(e);
+    if (Object.getOwnPropertySymbols) {
+      var o = Object.getOwnPropertySymbols(e);
+      r && (o = o.filter(function (r) {
+        return Object.getOwnPropertyDescriptor(e, r).enumerable;
+      })), t.push.apply(t, o);
+    }
+    return t;
+  }
+  function _objectSpread2(e) {
+    for (var r = 1; r < arguments.length; r++) {
+      var t = null != arguments[r] ? arguments[r] : {};
+      r % 2 ? ownKeys(Object(t), true).forEach(function (r) {
+        _defineProperty(e, r, t[r]);
+      }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) {
+        Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
+      });
+    }
+    return e;
+  }
+  function _possibleConstructorReturn(t, e) {
+    if (e && ("object" == typeof e || "function" == typeof e)) return e;
+    if (void 0 !== e) throw new TypeError("Derived constructors may only return object or undefined");
+    return _assertThisInitialized(t);
+  }
+  function _setPrototypeOf(t, e) {
+    return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) {
+      return t.__proto__ = e, t;
+    }, _setPrototypeOf(t, e);
+  }
+  function _slicedToArray(r, e) {
+    return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest();
+  }
+  function _toConsumableArray(r) {
+    return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread();
+  }
+  function _toPrimitive(t, r) {
+    if ("object" != typeof t || !t) return t;
+    var e = t[Symbol.toPrimitive];
+    if (void 0 !== e) {
+      var i = e.call(t, r);
+      if ("object" != typeof i) return i;
+      throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return ("string" === r ? String : Number)(t);
+  }
+  function _toPropertyKey(t) {
+    var i = _toPrimitive(t, "string");
+    return "symbol" == typeof i ? i : i + "";
+  }
+  function _unsupportedIterableToArray(r, a) {
+    if (r) {
+      if ("string" == typeof r) return _arrayLikeToArray(r, a);
+      var t = {}.toString.call(r).slice(8, -1);
+      return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
+    }
+  }
+
+  var singletonInstances = new Map();
+  var componentKeys = new WeakMap();
+  function getComponentKey(component) {
+    if (!componentKeys.has(component)) {
+      componentKeys.set(component, Symbol(component.name || 'anonymous'));
+    }
+    return componentKeys.get(component);
+  }
+  function getSingletonKey(component, singleton) {
+    if (singleton === false) return undefined;
+    if (typeof singleton === 'string') return singleton;
+    if (singleton === true) return getComponentKey(component);
+    return undefined;
+  }
+  function getSingleton(key) {
+    return singletonInstances.get(key);
+  }
+  function setSingleton(key, instance) {
+    var existing = singletonInstances.get(key);
+    if (existing && existing !== instance) {
+      existing.unmount();
+    }
+    singletonInstances.set(key, instance);
+  }
+  function removeSingleton(key) {
+    singletonInstances.delete(key);
+  }
+  function clearSingletons() {
+    singletonInstances.forEach(function (instance) {
+      return instance.unmount();
+    });
+    singletonInstances.clear();
+  }
+  function hasSingleton(key) {
+    return singletonInstances.has(key);
+  }
+  function getSingletonKeys() {
+    return Array.from(singletonInstances.keys());
+  }
+
+  var globalConfig = {
+    installed: false
+  };
+  function setGlobalConfig(config) {
+    Object.assign(globalConfig, config);
+  }
+  function getGlobalConfig() {
+    return _objectSpread2({}, globalConfig);
+  }
+  function resetGlobalConfig() {
+    Object.keys(globalConfig).forEach(function (key) {
+      delete globalConfig[key];
+    });
+    globalConfig.installed = false;
+  }
+  function mergeWithGlobalConfig(options) {
+    return _objectSpread2(_objectSpread2({}, globalConfig), options);
+  }
+
+  function isBrowser() {
+    return typeof document !== 'undefined';
+  }
+  function isNodeEnv() {
+    var _process$versions;
+    return typeof process !== 'undefined' && !!((_process$versions = process.versions) !== null && _process$versions !== void 0 && _process$versions.node);
+  }
+  function resolveTarget(target) {
+    if (!target) return null;
+    if (typeof target === 'string') {
+      if (!isBrowser()) return null;
+      return document.querySelector(target);
+    }
+    return target;
+  }
+  function createElement() {
+    var tagName = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'div';
+    var attributes = arguments.length > 1 ? arguments[1] : undefined;
+    if (!isBrowser()) {
+      throw new TypeError('This plugin works in browser');
+    }
+    var el = document.createElement(tagName);
+    if (attributes) {
+      Object.entries(attributes).forEach(function (_ref) {
+        var _ref2 = _slicedToArray(_ref, 2),
+          key = _ref2[0],
+          value = _ref2[1];
+        el.setAttribute(key, value);
+      });
+    }
+    return el;
+  }
+  function appendTo(element, target) {
+    if (!isBrowser()) return;
+    var resolvedTarget = resolveTarget(target);
+    if (resolvedTarget) {
+      resolvedTarget.appendChild(element);
+    } else {
+      document.body.appendChild(element);
+    }
+  }
+  function removeElement(element) {
+    if (element.parentNode) {
+      element.parentNode.removeChild(element);
+    }
+  }
+  function isInDOM(element) {
+    return document.body.contains(element);
+  }
+  function setZIndex(element, zIndex) {
+    if (zIndex !== undefined) {
+      element.style.zIndex = String(zIndex);
+    }
+  }
+  function addClass(element, className) {
+    if (className) {
+      var _element$classList;
+      (_element$classList = element.classList).add.apply(_element$classList, _toConsumableArray(className.split(/\s+/).filter(Boolean)));
+    }
+  }
+  function removeClass(element, className) {
+    if (className) {
+      var _element$classList2;
+      (_element$classList2 = element.classList).remove.apply(_element$classList2, _toConsumableArray(className.split(/\s+/).filter(Boolean)));
+    }
+  }
+
+  var EventEmitter = /*#__PURE__*/function () {
+    function EventEmitter() {
+      _classCallCheck(this, EventEmitter);
+      _defineProperty(this, "events", new Map());
+    }
+    return _createClass(EventEmitter, [{
+      key: "on",
+      value: function on(event, handler) {
+        if (!this.events.has(event)) {
+          this.events.set(event, new Set());
+        }
+        this.events.get(event).add(handler);
+        return this;
+      }
+    }, {
+      key: "off",
+      value: function off(event, handler) {
+        if (handler) {
+          var _this$events$get;
+          (_this$events$get = this.events.get(event)) === null || _this$events$get === void 0 || _this$events$get.delete(handler);
+        } else {
+          this.events.delete(event);
+        }
+        return this;
+      }
+    }, {
+      key: "emit",
+      value: function emit(event) {
+        var _this$events$get2;
+        for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+          args[_key - 1] = arguments[_key];
+        }
+        (_this$events$get2 = this.events.get(event)) === null || _this$events$get2 === void 0 || _this$events$get2.forEach(function (handler) {
+          try {
+            handler.apply(void 0, args);
+          } catch (error) {
+            console.error("Error in event handler for \"".concat(event, "\":"), error);
+          }
+        });
+        return this;
+      }
+    }, {
+      key: "has",
+      value: function has(event) {
+        return this.events.has(event) && this.events.get(event).size > 0;
+      }
+    }, {
+      key: "clear",
+      value: function clear() {
+        this.events.clear();
+      }
+    }, {
+      key: "eventNames",
+      value: function eventNames() {
+        return Array.from(this.events.keys());
+      }
+    }]);
+  }();
+  var instanceCounter = 0;
+  function createInstanceId() {
+    return "mount-".concat(++instanceCounter, "-").concat(Date.now().toString(36));
+  }
+  function capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+  }
+  function eventToPropName(event) {
+    return "on".concat(capitalize(event));
+  }
+
+  var instances = new Set();
+  var MountBase = /*#__PURE__*/function () {
+    function MountBase(component) {
+      var _this = this;
+      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      _classCallCheck(this, MountBase);
+      _defineProperty(this, "mounted", false);
+      _defineProperty(this, "el", null);
+      _defineProperty(this, "_eventEmitter", new EventEmitter());
+      _defineProperty(this, "_autoCreatedTarget", false);
+      _defineProperty(this, "_hidden", false);
+      _defineProperty(this, "_destroyed", false);
+      _defineProperty(this, "destroy", this.unmount);
+      _defineProperty(this, "remove", this.unmount);
+      this.id = createInstanceId();
+      this._component = component;
+      this.options = mergeWithGlobalConfig(options);
+      this._promise = new Promise(function (resolve, reject) {
+        _this._resolve = resolve;
+        _this._reject = reject;
+      });
+      this._singletonKey = getSingletonKey(component, options.singleton);
+      if (this._singletonKey) {
+        setSingleton(this._singletonKey, this);
+      }
+      instances.add(this);
+    }
+    return _createClass(MountBase, [{
+      key: "show",
+      value: function show() {
+        var _this$options$onBefor, _this$options, _this$options$onMount, _this$options2;
+        if (this.mounted && !this._hidden) return this;
+        (_this$options$onBefor = (_this$options = this.options).onBeforeMount) === null || _this$options$onBefor === void 0 || _this$options$onBefor.call(_this$options, this);
+        this._ensureElement();
+        this._mountVM();
+        if (this.options.zIndex && this.el) {
+          setZIndex(this.el, this.options.zIndex);
+        }
+        this.mounted = true;
+        this._hidden = false;
+        (_this$options$onMount = (_this$options2 = this.options).onMounted) === null || _this$options$onMount === void 0 || _this$options$onMount.call(_this$options2, this);
+        this.emit('show', this);
+        return this;
+      }
+    }, {
+      key: "hide",
+      value: function hide() {
+        if (!this.mounted || this._hidden) return this;
+        this.emit('beforeHide', this);
+        if (this.el && isInDOM(this.el)) {
+          removeElement(this.el);
+        }
+        this._hidden = true;
+        this.emit('hide', this);
+        return this;
+      }
+    }, {
+      key: "unmount",
+      value: function unmount() {
+        var _this$options$onUnmou, _this$options4;
+        if (this._destroyed) return;
+        this._destroyed = true;
+        if (this.mounted || this._hidden) {
+          var _this$options$onBefor2, _this$options3;
+          (_this$options$onBefor2 = (_this$options3 = this.options).onBeforeUnmount) === null || _this$options$onBefor2 === void 0 || _this$options$onBefor2.call(_this$options3, this);
+        }
+        this._eventEmitter.emit('beforeUnmount', this);
+        this._unmountVM();
+        if (this._autoCreatedTarget && this.el) {
+          removeElement(this.el);
+        }
+        this.mounted = false;
+        this._hidden = false;
+        this.el = null;
+        this.vm = null;
+        instances.delete(this);
+        if (this._singletonKey) {
+          removeSingleton(this._singletonKey);
+        }
+        (_this$options$onUnmou = (_this$options4 = this.options).onUnmounted) === null || _this$options$onUnmou === void 0 || _this$options$onUnmou.call(_this$options4, this);
+        this._eventEmitter.clear();
+      }
+    }, {
+      key: "setProps",
+      value: function setProps(props) {
+        this.options = _objectSpread2(_objectSpread2({}, this.options), {}, {
+          props: _objectSpread2(_objectSpread2({}, this.options.props), props)
+        });
+        if (this.mounted) {
+          this._updateVM();
+        }
+        return this;
+      }
+    }, {
+      key: "on",
+      value: function on(event, handler) {
+        this._eventEmitter.on(event, handler);
+        return this;
+      }
+    }, {
+      key: "off",
+      value: function off(event, handler) {
+        this._eventEmitter.off(event, handler);
+        return this;
+      }
+    }, {
+      key: "emit",
+      value: function emit(event) {
+        var _this$_eventEmitter;
+        if (this._destroyed) return this;
+        for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+          args[_key - 1] = arguments[_key];
+        }
+        (_this$_eventEmitter = this._eventEmitter).emit.apply(_this$_eventEmitter, [event].concat(args));
+        return this;
+      }
+    }, {
+      key: "then",
+      value: function then(resolve) {
+        return this._promise.then(resolve);
+      }
+    }, {
+      key: "catch",
+      value: function _catch(reject) {
+        return this._promise.catch(reject);
+      }
+    }, {
+      key: "finally",
+      value: function _finally(onFinally) {
+        return this._promise.finally(onFinally);
+      }
+    }, {
+      key: "setTarget",
+      value: function setTarget(target) {
+        this.options.target = target;
+        return this;
+      }
+    }, {
+      key: "setHooks",
+      value: function setHooks(hooks) {
+        this.options = _objectSpread2(_objectSpread2({}, this.options), hooks);
+        return this;
+      }
+    }, {
+      key: "setSlots",
+      value: function setSlots(slots) {
+        this.options = _objectSpread2(_objectSpread2({}, this.options), {}, {
+          slots: _objectSpread2(_objectSpread2({}, this.options.slots), slots)
+        });
+        return this;
+      }
+    }, {
+      key: "_ensureElement",
+      value: function _ensureElement() {
+        if (this.el) return;
+        var target = resolveTarget(this.options.target);
+        if (target instanceof Element) {
+          this.el = target;
+          this._autoCreatedTarget = false;
+        } else {
+          this.el = createElement(this.options.tagName || 'div', {
+            'data-mount-id': this.id
+          });
+          this._autoCreatedTarget = true;
+        }
+      }
+    }, {
+      key: "_appendElementToDOM",
+      value: function _appendElementToDOM() {
+        if (!this.el) return;
+        if (this._autoCreatedTarget) {
+          appendTo(this.el, null);
+        }
+      }
+    }, {
+      key: "_resolvePromise",
+      value: function _resolvePromise(value) {
+        this._resolve(value);
+      }
+    }, {
+      key: "_rejectPromise",
+      value: function _rejectPromise(error) {
+        this._reject(error);
+      }
+    }, {
+      key: "_mergeListenersToProps",
+      value: function _mergeListenersToProps(listeners) {
+        var result = {};
+        Object.entries(listeners).forEach(function (_ref) {
+          var _ref2 = _slicedToArray(_ref, 2),
+            event = _ref2[0],
+            handler = _ref2[1];
+          result["on".concat(capitalize(event))] = handler;
+        });
+        return result;
+      }
+    }], [{
+      key: "instances",
+      get: function get() {
+        return Array.from(instances);
+      }
+    }, {
+      key: "unmountAll",
+      value: function unmountAll() {
+        instances.forEach(function (instance) {
+          return instance.unmount();
+        });
+      }
+    }, {
+      key: "getById",
+      value: function getById(id) {
+        return Array.from(instances).find(function (instance) {
+          return instance.id === id;
+        });
+      }
+    }]);
+  }();
+  function getInstances() {
+    return Array.from(instances);
+  }
+  function unmountAll() {
+    MountBase.unmountAll();
+  }
+  function getInstanceById(id) {
+    return MountBase.getById(id);
+  }
+
+  function inheritVue2Context(parent, options) {
+    var context = options.context || {};
+    if (parent && (parent._isVue || parent.$options)) {
+      return _objectSpread2({
+        router: parent.$router || context.router,
+        store: parent.$store || context.store,
+        i18n: parent.$i18n || context.i18n,
+        route: parent.$route
+      }, context);
+    }
+    return context;
+  }
+  function inheritVue3Context(app, _options) {
+    if (app !== null && app !== void 0 && app._context) {
+      return {
+        appContext: app._context,
+        provides: app._context.provides
+      };
+    }
+    return {};
+  }
+  function getCurrentComponentContext(componentInstance) {
+    var _componentInstance$$;
+    if (!componentInstance) return {};
+    var context = {};
+    if (componentInstance.$router) context.router = componentInstance.$router;
+    if (componentInstance.$store) context.store = componentInstance.$store;
+    if (componentInstance.$i18n) context.i18n = componentInstance.$i18n;
+    if ((_componentInstance$$ = componentInstance.$) !== null && _componentInstance$$ !== void 0 && _componentInstance$$.appContext) {
+      context.appContext = componentInstance.$.appContext;
+    }
+    return context;
+  }
+
+  var MountVue2 = /*#__PURE__*/function (_MountBase) {
+    function MountVue2(component) {
+      var _this;
+      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      _classCallCheck(this, MountVue2);
+      _this = _callSuper(this, MountVue2, [component, options]);
+      _defineProperty(_this, "vm", null);
+      _defineProperty(_this, "_vue2Instance", null);
+      if (!vueDemi.isVue2) {
+        throw new Error('MountVue2 can only be used with Vue 2');
+      }
+      _this._createVM();
+      return _this;
+    }
+    _inherits(MountVue2, _MountBase);
+    return _createClass(MountVue2, [{
+      key: "_createVM",
+      value: function _createVM() {
+        var VueConstructor = vueDemi.Vue2;
+        var _this$options = this.options,
+          props = _this$options.props,
+          parent = _this$options.parent,
+          listeners = _this$options.listeners,
+          on = _this$options.on;
+        var mergedListeners = _objectSpread2(_objectSpread2({}, listeners), on);
+        var context = inheritVue2Context(parent, this.options);
+        var componentOptions = this._component;
+        if (this._component.options) {
+          componentOptions = this._component.options;
+        }
+        var ComponentConstructor = VueConstructor.extend(componentOptions);
+        var instance = new ComponentConstructor({
+          propsData: props || {},
+          parent: parent,
+          router: context.router,
+          store: context.store,
+          i18n: context.i18n
+        });
+        Object.entries(mergedListeners).forEach(function (_ref) {
+          var _ref2 = _slicedToArray(_ref, 2),
+            event = _ref2[0],
+            handler = _ref2[1];
+          if (Array.isArray(handler)) {
+            handler.forEach(function (h) {
+              return instance.$on(event, h);
+            });
+          } else {
+            instance.$on(event, handler);
+          }
+        });
+        instance._mountId = this.id;
+        this._vue2Instance = instance;
+      }
+    }, {
+      key: "_mountVM",
+      value: function _mountVM() {
+        if (!this._vue2Instance) return;
+        this._ensureElement();
+        this._appendElementToDOM();
+        this._vue2Instance.$mount(this.el);
+        if (this._vue2Instance.$el) {
+          this.el = this._vue2Instance.$el;
+        }
+        this.vm = this._vue2Instance;
+        this.mounted = true;
+      }
+    }, {
+      key: "_unmountVM",
+      value: function _unmountVM() {
+        if (this._vue2Instance) {
+          this._vue2Instance.$destroy();
+          this._vue2Instance = null;
+        }
+        this.vm = null;
+        this.mounted = false;
+      }
+    }, {
+      key: "_updateVM",
+      value: function _updateVM() {
+        if (this._vue2Instance && this.options.props) {
+          Object.assign(this._vue2Instance.$props, this.options.props);
+        }
+      }
+    }]);
+  }(MountBase);
+
+  var cachedRender;
+  function getRender() {
+    return _getRender.apply(this, arguments);
+  }
+  function _getRender() {
+    _getRender = _asyncToGenerator(function* () {
+      if (cachedRender) return cachedRender;
+      var vue = yield import('vue');
+      cachedRender = vue.render;
+      return cachedRender;
+    });
+    return _getRender.apply(this, arguments);
+  }
+  var MountVue3 = /*#__PURE__*/function (_MountBase) {
+    function MountVue3(component) {
+      var _this;
+      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      _classCallCheck(this, MountVue3);
+      _this = _callSuper(this, MountVue3, [component, options]);
+      _defineProperty(_this, "vm", null);
+      _defineProperty(_this, "_vNode", null);
+      if (vueDemi.isVue2) {
+        throw new Error('MountVue3 can only be used with Vue 3');
+      }
+      _this._createVM();
+      return _this;
+    }
+    _inherits(MountVue3, _MountBase);
+    return _createClass(MountVue3, [{
+      key: "_createVM",
+      value: function _createVM() {
+        var _this$options = this.options,
+          props = _this$options.props,
+          children = _this$options.children,
+          app = _this$options.app,
+          listeners = _this$options.listeners,
+          on = _this$options.on,
+          slots = _this$options.slots;
+        var mergedListeners = _objectSpread2(_objectSpread2({}, listeners), on);
+        var mergedProps = _objectSpread2(_objectSpread2({}, props), this._mergeListenersToProps(mergedListeners));
+        var mergedChildren = slots ? _objectSpread2(_objectSpread2({}, slots), children ? {
+          default: children
+        } : {}) : children;
+        var vNode = vueDemi.h(this._component, mergedProps, mergedChildren);
+        if (app !== null && app !== void 0 && app._context) {
+          vNode.appContext = app._context;
+        }
+        this._vNode = vNode;
+      }
+    }, {
+      key: "_mountVM",
+      value: function _mountVM() {
+        var _this2 = this;
+        if (!this._vNode) {
+          this._createVM();
+        }
+        this._ensureElement();
+        this._appendElementToDOM();
+        getRender().then(function (render) {
+          if (render && _this2._vNode && _this2.el) {
+            var _this2$_vNode$compone, _this2$_vNode$compone2;
+            render(_this2._vNode, _this2.el);
+            _this2.vm = (_this2$_vNode$compone = (_this2$_vNode$compone2 = _this2._vNode.component) === null || _this2$_vNode$compone2 === void 0 ? void 0 : _this2$_vNode$compone2.proxy) !== null && _this2$_vNode$compone !== void 0 ? _this2$_vNode$compone : null;
+          }
+        });
+        this.mounted = true;
+      }
+    }, {
+      key: "_unmountVM",
+      value: function _unmountVM() {
+        var _this3 = this;
+        if (this._vNode) {
+          getRender().then(function (render) {
+            if (render && _this3.el) {
+              render(null, _this3.el);
+            }
+          });
+          this._vNode = null;
+        }
+        this.vm = null;
+        this.mounted = false;
+      }
+    }, {
+      key: "_updateVM",
+      value: function _updateVM() {
+        var _this4 = this;
+        this._createVM();
+        if (this.mounted && this.el && this._vNode) {
+          getRender().then(function (render) {
+            if (render) {
+              var _this4$_vNode$compone, _this4$_vNode$compone2;
+              render(_this4._vNode, _this4.el);
+              _this4.vm = (_this4$_vNode$compone = (_this4$_vNode$compone2 = _this4._vNode.component) === null || _this4$_vNode$compone2 === void 0 ? void 0 : _this4$_vNode$compone2.proxy) !== null && _this4$_vNode$compone !== void 0 ? _this4$_vNode$compone : null;
+            }
+          });
+        }
+      }
+    }]);
+  }(MountBase);
+
+  function useMount() {
+    var instances = vueDemi.ref([]);
+    var mount = function mount(component, options) {
+      var instance = createMount(component, options);
+      instances.value.push(instance);
+      return instance;
+    };
+    var unmount = function unmount(instance) {
+      instance.unmount();
+      instances.value = instances.value.filter(function (i) {
+        return i !== instance;
+      });
+    };
+    var unmountAll = function unmountAll() {
+      instances.value.forEach(function (instance) {
+        return instance.unmount();
+      });
+      instances.value = [];
+    };
+    var getById = function getById(id) {
+      return instances.value.find(function (instance) {
+        return instance.id === id;
+      });
+    };
+    var hasInstances = function hasInstances() {
+      return instances.value.length > 0;
+    };
+    var count = function count() {
+      return instances.value.length;
+    };
+    if (!vueDemi.isVue2) {
+      vueDemi.onUnmounted(unmountAll);
+    }
+    return {
+      instances: instances,
+      mount: mount,
+      unmount: unmount,
+      unmountAll: unmountAll,
+      getById: getById,
+      hasInstances: hasInstances,
+      count: count
+    };
+  }
+  function useSingleton() {
+    var getOrCreate = function getOrCreate(key, component, options) {
+      var existingInstances = useMount().instances.value;
+      var existing = existingInstances.find(function (i) {
+        return i.id === key || i.options.singleton === key;
+      });
+      if (existing) {
+        return existing;
+      }
+      var instance = createMount(component, _objectSpread2(_objectSpread2({}, options), {}, {
+        singleton: key
+      }));
+      return instance;
+    };
+    return {
+      getOrCreate: getOrCreate
+    };
+  }
+
+  function createMount(component) {
+    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    if (vueDemi.isVue2) {
+      return new MountVue2(component, options);
+    }
+    return new MountVue3(component, options);
+  }
+  function mount(component) {
+    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    var instance = createMount(component, options);
+    return instance.show();
+  }
+  var MountPlugin = {
+    install: function install(app) {
+      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      setGlobalConfig(_objectSpread2(_objectSpread2({}, options), {}, {
+        installed: true
+      }));
+      var name = options.name || '$mount';
+      if (vueDemi.isVue2) {
+        app.prototype[name] = mount;
+      } else {
+        app.config.globalProperties[name] = mount;
+      }
+    }
+  };
+  function isMounted(id) {
+    var _instance$mounted;
+    var instance = getInstanceById(id);
+    return (_instance$mounted = instance === null || instance === void 0 ? void 0 : instance.mounted) !== null && _instance$mounted !== void 0 ? _instance$mounted : false;
+  }
+  function getActiveInstanceIds() {
+    return getInstances().map(function (instance) {
+      return instance.id;
+    });
+  }
+
+  exports.EventEmitter = EventEmitter;
+  exports.MountBase = MountBase;
+  exports.MountPlugin = MountPlugin;
+  exports.MountVue2 = MountVue2;
+  exports.MountVue3 = MountVue3;
+  exports.addClass = addClass;
+  exports.appendTo = appendTo;
+  exports.capitalize = capitalize;
+  exports.clearSingletons = clearSingletons;
+  exports.createElement = createElement;
+  exports.createInstanceId = createInstanceId;
+  exports.createMount = createMount;
+  exports.eventToPropName = eventToPropName;
+  exports.getActiveInstanceIds = getActiveInstanceIds;
+  exports.getCurrentComponentContext = getCurrentComponentContext;
+  exports.getGlobalConfig = getGlobalConfig;
+  exports.getInstanceById = getInstanceById;
+  exports.getInstances = getInstances;
+  exports.getSingleton = getSingleton;
+  exports.getSingletonKey = getSingletonKey;
+  exports.getSingletonKeys = getSingletonKeys;
+  exports.globalConfig = globalConfig;
+  exports.hasSingleton = hasSingleton;
+  exports.inheritVue2Context = inheritVue2Context;
+  exports.inheritVue3Context = inheritVue3Context;
+  exports.isBrowser = isBrowser;
+  exports.isInDOM = isInDOM;
+  exports.isMounted = isMounted;
+  exports.isNodeEnv = isNodeEnv;
+  exports.mergeWithGlobalConfig = mergeWithGlobalConfig;
+  exports.mount = mount;
+  exports.removeClass = removeClass;
+  exports.removeElement = removeElement;
+  exports.removeSingleton = removeSingleton;
+  exports.resetGlobalConfig = resetGlobalConfig;
+  exports.resolveTarget = resolveTarget;
+  exports.setGlobalConfig = setGlobalConfig;
+  exports.setSingleton = setSingleton;
+  exports.setZIndex = setZIndex;
+  exports.unmountAll = unmountAll;
+  exports.useMount = useMount;
+  exports.useSingleton = useSingleton;
+
+})(this.VueMount = this.VueMount || {}, VueDemi);