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

package/dist/index.mjs

@@ -1,120 +1,926 @@
-import { isVue2, Vue2, createVNode, render } from 'vue-demi';
+import { Vue2, isVue2, h, ref, onUnmounted } from 'vue-demi';
 
-function _classCallCheck(instance, Constructor) {
-  if (!(instance instanceof Constructor)) {
-    throw new TypeError("Cannot call a class as a function");
+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 _defineProperties(target, props) {
-  for (var i = 0; i < props.length; i++) {
-    var descriptor = props[i];
-    descriptor.enumerable = descriptor.enumerable || false;
-    descriptor.configurable = true;
-    if ("value" in descriptor) descriptor.writable = true;
-    Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);
+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(Constructor, protoProps, staticProps) {
-  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
-  if (staticProps) _defineProperties(Constructor, staticProps);
-  Object.defineProperty(Constructor, "prototype", {
+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];
   });
-  return Constructor;
-}
-function _defineProperty(obj, key, value) {
-  key = _toPropertyKey(key);
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value: value,
-      enumerable: true,
-      configurable: true,
-      writable: true
+  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 {
-    obj[key] = value;
+    document.body.appendChild(element);
   }
-  return obj;
 }
-function _toPrimitive(input, hint) {
-  if (typeof input !== "object" || input === null) return input;
-  var prim = input[Symbol.toPrimitive];
-  if (prim !== undefined) {
-    var res = prim.call(input, hint || "default");
-    if (typeof res !== "object") return res;
-    throw new TypeError("@@toPrimitive must return a primitive value.");
+function removeElement(element) {
+  if (element.parentNode) {
+    element.parentNode.removeChild(element);
   }
-  return (hint === "string" ? String : Number)(input);
 }
-function _toPropertyKey(arg) {
-  var key = _toPrimitive(arg, "string");
-  return typeof key === "symbol" ? key : String(key);
+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 Mount = /*#__PURE__*/function () {
-  function Mount(component) {
-    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-    _classCallCheck(this, Mount);
-    _defineProperty(this, "vNode", null);
-    _defineProperty(this, "options", {});
-    _defineProperty(this, "seed", 1);
-    if (typeof document === 'undefined') throw new Error('This plugin works in browser');
-    this.options = options;
-    this.target = (typeof options.target === 'string' ? document.querySelector(options.target) : options.target) || document.createElement(options.tagName || 'div');
-    this.vNode = this.createVM(component, options);
-  }
-  _createClass(Mount, [{
-    key: "createVM",
-    value: function createVM(component) {
-      var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
-        props = _ref.props,
-        children = _ref.children,
-        patchFlag = _ref.patchFlag,
-        dynamicProps = _ref.dynamicProps,
-        isBlockNode = _ref.isBlockNode,
-        app = _ref.app,
-        context = _ref.context,
-        parent = _ref.parent;
-      var vNode;
-      if (isVue2) {
-        var VueConstructor = Vue2.extend(Object.assign({}, context || {}, component));
-        vNode = new VueConstructor({
-          parent: parent,
-          propsData: props
-        });
-        vNode.id = 'mount-plugin-' + this.seed++;
-        return vNode;
-      } else {
-        vNode = createVNode(component, props, children, patchFlag, dynamicProps, isBlockNode);
-        if (app !== null && app !== void 0 && app._context) vNode.appContext = app._context;
-        return vNode;
+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: "mount",
-    value: function mount() {
-      !this.options.target && document.body.appendChild(this.target);
-      if (isVue2) {
-        this.vNode && this.vNode.$mount(this.target);
+    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 {
-        render(this.vNode, this.target);
+        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() {
-      if (isVue2) {
-        this.vNode.$destroy();
-        document.body.removeChild(this.vNode.$el);
+      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 {
-        render(null, this.target);
-        document.body.removeChild(this.target);
+        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);
       }
-      this.vNode = null;
-      this.target = 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;
+      });
     }
   }]);
-  return Mount;
 }();
+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 (!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 = 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 (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 = 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 = 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 (!isVue2) {
+    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 (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 (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;
+  });
+}
 
-export { Mount as default };
+export { EventEmitter, MountBase, MountPlugin, MountVue2, MountVue3, addClass, appendTo, capitalize, clearSingletons, createElement, createInstanceId, createMount, eventToPropName, getActiveInstanceIds, getCurrentComponentContext, getGlobalConfig, getInstanceById, getInstances, getSingleton, getSingletonKey, getSingletonKeys, globalConfig, hasSingleton, inheritVue2Context, inheritVue3Context, isBrowser, isInDOM, isMounted, isNodeEnv, mergeWithGlobalConfig, mount, removeClass, removeElement, removeSingleton, resetGlobalConfig, resolveTarget, setGlobalConfig, setSingleton, setZIndex, unmountAll, useMount, useSingleton };