text: module.exports =
  /******/ (function(modules) { // webpackBootstrap
  /******/ 	// The module cache
  /******/ 	var installedModules = {};
  /******/
  /******/ 	// The require function
  /******/ 	function __webpack_require__(moduleId) {
  /******/
  /******/ 		// Check if module is in cache
  /******/ 		if(installedModules[moduleId]) {
  /******/ 			return installedModules[moduleId].exports;
  /******/ 		}
  /******/ 		// Create a new module (and put it into the cache)
  /******/ 		var module = installedModules[moduleId] = {
  /******/ 			i: moduleId,
  /******/ 			l: false,
  /******/ 			exports: {}
  /******/ 		};
  /******/
  /******/ 		// Execute the module function
  /******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
  /******/
  /******/ 		// Flag the module as loaded
  /******/ 		module.l = true;
  /******/
  /******/ 		// Return the exports of the module
  /******/ 		return module.exports;
  /******/ 	}
  /******/
  /******/
  /******/ 	// expose the modules object (__webpack_modules__)
  /******/ 	__webpack_require__.m = modules;
  /******/
  /******/ 	// expose the module cache
  /******/ 	__webpack_require__.c = installedModules;
  /******/
  /******/ 	// define getter function for harmony exports
  /******/ 	__webpack_require__.d = function(exports, name, getter) {
  /******/ 		if(!__webpack_require__.o(exports, name)) {
  /******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
  /******/ 		}
  /******/ 	};
  /******/
  /******/ 	// define __esModule on exports
  /******/ 	__webpack_require__.r = function(exports) {
  /******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
  /******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
  /******/ 		}
  /******/ 		Object.defineProperty(exports, '__esModule', { value: true });
  /******/ 	};
  /******/
  /******/ 	// create a fake namespace object
  /******/ 	// mode & 1: value is a module id, require it
  /******/ 	// mode & 2: merge all properties of value into the ns
  /******/ 	// mode & 4: return value when already ns object
  /******/ 	// mode & 8|1: behave like require
  /******/ 	__webpack_require__.t = function(value, mode) {
  /******/ 		if(mode & 1) value = __webpack_require__(value);
  /******/ 		if(mode & 8) return value;
  /******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
  /******/ 		var ns = Object.create(null);
  /******/ 		__webpack_require__.r(ns);
  /******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
  /******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
  /******/ 		return ns;
  /******/ 	};
  /******/
  /******/ 	// getDefaultExport function for compatibility with non-harmony modules
  /******/ 	__webpack_require__.n = function(module) {
  /******/ 		var getter = module && module.__esModule ?
  /******/ 			function getDefault() { return module['default']; } :
  /******/ 			function getModuleExports() { return module; };
  /******/ 		__webpack_require__.d(getter, 'a', getter);
  /******/ 		return getter;
  /******/ 	};
  /******/
  /******/ 	// Object.prototype.hasOwnProperty.call
  /******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
  /******/
  /******/ 	// __webpack_public_path__
  /******/ 	__webpack_require__.p = "/dist/";
  /******/
  /******/
  /******/ 	// Load entry module and return exports
  /******/ 	return __webpack_require__(__webpack_require__.s = 69);
  /******/ })
  /************************************************************************/
  /******/ ({
  
  /***/ 0:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return normalizeComponent; });
  /* globals __VUE_SSR_CONTEXT__ */
  
  // IMPORTANT: Do NOT use ES2015 features in this file (except for modules).
  // This module is a runtime utility for cleaner component module output and will
  // be included in the final webpack user bundle.
  
  function normalizeComponent (
    scriptExports,
    render,
    staticRenderFns,
    functionalTemplate,
    injectStyles,
    scopeId,
    moduleIdentifier, /* server only */
    shadowMode /* vue-cli only */
  ) {
    // Vue.extend constructor export interop
    var options = typeof scriptExports === 'function'
      ? scriptExports.options
      : scriptExports
  
    // render functions
    if (render) {
      options.render = render
      options.staticRenderFns = staticRenderFns
      options._compiled = true
    }
  
    // functional template
    if (functionalTemplate) {
      options.functional = true
    }
  
    // scopedId
    if (scopeId) {
      options._scopeId = 'data-v-' + scopeId
    }
  
    var hook
    if (moduleIdentifier) { // server build
      hook = function (context) {
        // 2.3 injection
        context =
          context || // cached call
          (this.$vnode && this.$vnode.ssrContext) || // stateful
          (this.parent && this.parent.$vnode && this.parent.$vnode.ssrContext) // functional
        // 2.2 with runInNewContext: true
        if (!context && typeof __VUE_SSR_CONTEXT__ !== 'undefined') {
          context = __VUE_SSR_CONTEXT__
        }
        // inject component styles
        if (injectStyles) {
          injectStyles.call(this, context)
        }
        // register component module identifier for async chunk inferrence
        if (context && context._registeredComponents) {
          context._registeredComponents.add(moduleIdentifier)
        }
      }
      // used by ssr in case component is cached and beforeCreate
      // never gets called
      options._ssrRegister = hook
    } else if (injectStyles) {
      hook = shadowMode
        ? function () {
          injectStyles.call(
            this,
            (options.functional ? this.parent : this).$root.$options.shadowRoot
          )
        }
        : injectStyles
    }
  
    if (hook) {
      if (options.functional) {
        // for template-only hot-reload because in that case the render fn doesn't
        // go through the normalizer
        options._injectStyles = hook
        // register for functional component in vue file
        var originalRender = options.render
        options.render = function renderWithStyleInjection (h, context) {
          hook.call(context)
          return originalRender(h, context)
        }
      } else {
        // inject component registration as beforeCreate hook
        var existing = options.beforeCreate
        options.beforeCreate = existing
          ? [].concat(existing, hook)
          : [hook]
      }
    }
  
    return {
      exports: scriptExports,
      options: options
    }
  }
  
  
  /***/ }),
  
  /***/ 15:
  /***/ (function(module, exports) {
  
  module.exports = require("element-ui/lib/utils/popup");
  
  /***/ }),
  
  /***/ 2:
  /***/ (function(module, exports) {
  
  module.exports = require("element-ui/lib/utils/dom");
  
  /***/ }),
  
  /***/ 41:
  /***/ (function(module, exports) {
  
  module.exports = require("element-ui/lib/utils/after-leave");
  
  /***/ }),
  
  /***/ 69:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  // ESM COMPAT FLAG
  __webpack_require__.r(__webpack_exports__);
  
  // EXTERNAL MODULE: external "vue"
  var external_vue_ = __webpack_require__(7);
  var external_vue_default = /*#__PURE__*/__webpack_require__.n(external_vue_);
  
  // CONCATENATED MODULE: ./node_modules/vue-loader/lib/loaders/templateLoader.js??vue-loader-options!./node_modules/vue-loader/lib??vue-loader-options!./packages/loading/src/loading.vue?vue&type=template&id=eee0a7ac&
  var render = function () {
    var _vm = this
    var _h = _vm.$createElement
    var _c = _vm._self._c || _h
    return _c(
      "transition",
      {
        attrs: { name: "el-loading-fade" },
        on: { "after-leave": _vm.handleAfterLeave },
      },
      [
        _c(
          "div",
          {
            directives: [
              {
                name: "show",
                rawName: "v-show",
                value: _vm.visible,
                expression: "visible",
              },
            ],
            staticClass: "el-loading-mask",
            class: [_vm.customClass, { "is-fullscreen": _vm.fullscreen }],
            style: { backgroundColor: _vm.background || "" },
          },
          [
            _c("div", { staticClass: "el-loading-spinner" }, [
              !_vm.spinner
                ? _c(
                    "svg",
                    {
                      staticClass: "circular",
                      attrs: { viewBox: "25 25 50 50" },
                    },
                    [
                      _c("circle", {
                        staticClass: "path",
                        attrs: { cx: "50", cy: "50", r: "20", fill: "none" },
                      }),
                    ]
                  )
                : _c("i", { class: _vm.spinner }),
              _vm.text
                ? _c("p", { staticClass: "el-loading-text" }, [
                    _vm._v(_vm._s(_vm.text)),
                  ])
                : _vm._e(),
            ]),
          ]
        ),
      ]
    )
  }
  var staticRenderFns = []
  render._withStripped = true
  
  
  // CONCATENATED MODULE: ./packages/loading/src/loading.vue?vue&type=template&id=eee0a7ac&
  
  // CONCATENATED MODULE: ./node_modules/babel-loader/lib!./node_modules/vue-loader/lib??vue-loader-options!./packages/loading/src/loading.vue?vue&type=script&lang=js&
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  
  /* harmony default export */ var loadingvue_type_script_lang_js_ = ({
    data: function data() {
      return {
        text: null,
        spinner: null,
        background: null,
        fullscreen: true,
        visible: false,
        customClass: ''
      };
    },
  
  
    methods: {
      handleAfterLeave: function handleAfterLeave() {
        this.$emit('after-leave');
      },
      setText: function setText(text) {
        this.text = text;
      }
    }
  });
  // CONCATENATED MODULE: ./packages/loading/src/loading.vue?vue&type=script&lang=js&
   /* harmony default export */ var src_loadingvue_type_script_lang_js_ = (loadingvue_type_script_lang_js_); 
  // EXTERNAL MODULE: ./node_modules/vue-loader/lib/runtime/componentNormalizer.js
  var componentNormalizer = __webpack_require__(0);
  
  // CONCATENATED MODULE: ./packages/loading/src/loading.vue
  
  
  
  
  
  /* normalize component */
  
  var component = Object(componentNormalizer["a" /* default */])(
    src_loadingvue_type_script_lang_js_,
    render,
    staticRenderFns,
    false,
    null,
    null,
    null
    
  )
  
  /* hot reload */
  if (false) { var api; }
  component.options.__file = "packages/loading/src/loading.vue"
  /* harmony default export */ var loading = (component.exports);
  // EXTERNAL MODULE: external "element-ui/lib/utils/dom"
  var dom_ = __webpack_require__(2);
  
  // EXTERNAL MODULE: external "element-ui/lib/utils/popup"
  var popup_ = __webpack_require__(15);
  
  // EXTERNAL MODULE: external "element-ui/lib/utils/after-leave"
  var after_leave_ = __webpack_require__(41);
  var after_leave_default = /*#__PURE__*/__webpack_require__.n(after_leave_);
  
  // CONCATENATED MODULE: ./packages/loading/src/directive.js
  
  
  
  
  
  var Mask = external_vue_default.a.extend(loading);
  
  var loadingDirective = {};
  loadingDirective.install = function (Vue) {
    if (Vue.prototype.$isServer) return;
    var toggleLoading = function toggleLoading(el, binding) {
      if (binding.value) {
        Vue.nextTick(function () {
          if (binding.modifiers.fullscreen) {
            el.originalPosition = Object(dom_["getStyle"])(document.body, 'position');
            el.originalOverflow = Object(dom_["getStyle"])(document.body, 'overflow');
            el.maskStyle.zIndex = popup_["PopupManager"].nextZIndex();
  
            Object(dom_["addClass"])(el.mask, 'is-fullscreen');
            insertDom(document.body, el, binding);
          } else {
            Object(dom_["removeClass"])(el.mask, 'is-fullscreen');
  
            if (binding.modifiers.body) {
              el.originalPosition = Object(dom_["getStyle"])(document.body, 'position');['top', 'left'].forEach(function (property) {
                var scroll = property === 'top' ? 'scrollTop' : 'scrollLeft';
                el.maskStyle[property] = el.getBoundingClientRect()[property] + document.body[scroll] + document.documentElement[scroll] - parseInt(Object(dom_["getStyle"])(document.body, 'margin-' + property), 10) + 'px';
              });['height', 'width'].forEach(function (property) {
                el.maskStyle[property] = el.getBoundingClientRect()[property] + 'px';
              });
  
              insertDom(document.body, el, binding);
            } else {
              el.originalPosition = Object(dom_["getStyle"])(el, 'position');
              insertDom(el, el, binding);
            }
          }
        });
      } else {
        after_leave_default()(el.instance, function (_) {
          if (!el.instance.hiding) return;
          el.domVisible = false;
          var target = binding.modifiers.fullscreen || binding.modifiers.body ? document.body : el;
          Object(dom_["removeClass"])(target, 'el-loading-parent--relative');
          Object(dom_["removeClass"])(target, 'el-loading-parent--hidden');
          el.instance.hiding = false;
        }, 300, true);
        el.instance.visible = false;
        el.instance.hiding = true;
      }
    };
    var insertDom = function insertDom(parent, el, binding) {
      if (!el.domVisible && Object(dom_["getStyle"])(el, 'display') !== 'none' && Object(dom_["getStyle"])(el, 'visibility') !== 'hidden') {
        Object.keys(el.maskStyle).forEach(function (property) {
          el.mask.style[property] = el.maskStyle[property];
        });
  
        if (el.originalPosition !== 'absolute' && el.originalPosition !== 'fixed') {
          Object(dom_["addClass"])(parent, 'el-loading-parent--relative');
        }
        if (binding.modifiers.fullscreen && binding.modifiers.lock) {
          Object(dom_["addClass"])(parent, 'el-loading-parent--hidden');
        }
        el.domVisible = true;
  
        parent.appendChild(el.mask);
        Vue.nextTick(function () {
          if (el.instance.hiding) {
            el.instance.$emit('after-leave');
          } else {
            el.instance.visible = true;
          }
        });
        el.domInserted = true;
      } else if (el.domVisible && el.instance.hiding === true) {
        el.instance.visible = true;
        el.instance.hiding = false;
      }
    };
  
    Vue.directive('loading', {
      bind: function bind(el, binding, vnode) {
        var textExr = el.getAttribute('element-loading-text');
        var spinnerExr = el.getAttribute('element-loading-spinner');
        var backgroundExr = el.getAttribute('element-loading-background');
        var customClassExr = el.getAttribute('element-loading-custom-class');
        var vm = vnode.context;
        var mask = new Mask({
          el: document.createElement('div'),
          data: {
            text: vm && vm[textExr] || textExr,
            spinner: vm && vm[spinnerExr] || spinnerExr,
            background: vm && vm[backgroundExr] || backgroundExr,
            customClass: vm && vm[customClassExr] || customClassExr,
            fullscreen: !!binding.modifiers.fullscreen
          }
        });
        el.instance = mask;
        el.mask = mask.$el;
        el.maskStyle = {};
  
        binding.value && toggleLoading(el, binding);
      },
  
      update: function update(el, binding) {
        el.instance.setText(el.getAttribute('element-loading-text'));
        if (binding.oldValue !== binding.value) {
          toggleLoading(el, binding);
        }
      },
  
      unbind: function unbind(el, binding) {
        if (el.domInserted) {
          el.mask && el.mask.parentNode && el.mask.parentNode.removeChild(el.mask);
          toggleLoading(el, { value: false, modifiers: binding.modifiers });
        }
        el.instance && el.instance.$destroy();
      }
    });
  };
  
  /* harmony default export */ var directive = (loadingDirective);
  // EXTERNAL MODULE: external "element-ui/lib/utils/merge"
  var merge_ = __webpack_require__(9);
  var merge_default = /*#__PURE__*/__webpack_require__.n(merge_);
  
  // CONCATENATED MODULE: ./packages/loading/src/index.js
  
  
  
  
  
  
  
  var LoadingConstructor = external_vue_default.a.extend(loading);
  
  var defaults = {
    text: null,
    fullscreen: true,
    body: false,
    lock: false,
    customClass: ''
  };
  
  var fullscreenLoading = void 0;
  
  LoadingConstructor.prototype.originalPosition = '';
  LoadingConstructor.prototype.originalOverflow = '';
  
  LoadingConstructor.prototype.close = function () {
    var _this = this;
  
    if (this.fullscreen) {
      fullscreenLoading = undefined;
    }
    after_leave_default()(this, function (_) {
      var target = _this.fullscreen || _this.body ? document.body : _this.target;
      Object(dom_["removeClass"])(target, 'el-loading-parent--relative');
      Object(dom_["removeClass"])(target, 'el-loading-parent--hidden');
      if (_this.$el && _this.$el.parentNode) {
        _this.$el.parentNode.removeChild(_this.$el);
      }
      _this.$destroy();
    }, 300);
    this.visible = false;
  };
  
  var src_addStyle = function addStyle(options, parent, instance) {
    var maskStyle = {};
    if (options.fullscreen) {
      instance.originalPosition = Object(dom_["getStyle"])(document.body, 'position');
      instance.originalOverflow = Object(dom_["getStyle"])(document.body, 'overflow');
      maskStyle.zIndex = popup_["PopupManager"].nextZIndex();
    } else if (options.body) {
      instance.originalPosition = Object(dom_["getStyle"])(document.body, 'position');['top', 'left'].forEach(function (property) {
        var scroll = property === 'top' ? 'scrollTop' : 'scrollLeft';
        maskStyle[property] = options.target.getBoundingClientRect()[property] + document.body[scroll] + document.documentElement[scroll] + 'px';
      });['height', 'width'].forEach(function (property) {
        maskStyle[property] = options.target.getBoundingClientRect()[property] + 'px';
      });
    } else {
      instance.originalPosition = Object(dom_["getStyle"])(parent, 'position');
    }
    Object.keys(maskStyle).forEach(function (property) {
      instance.$el.style[property] = maskStyle[property];
    });
  };
  
  var src_Loading = function Loading() {
    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
  
    if (external_vue_default.a.prototype.$isServer) return;
    options = merge_default()({}, defaults, options);
    if (typeof options.target === 'string') {
      options.target = document.querySelector(options.target);
    }
    options.target = options.target || document.body;
    if (options.target !== document.body) {
      options.fullscreen = false;
    } else {
      options.body = true;
    }
    if (options.fullscreen && fullscreenLoading) {
      return fullscreenLoading;
    }
  
    var parent = options.body ? document.body : options.target;
    var instance = new LoadingConstructor({
      el: document.createElement('div'),
      data: options
    });
  
    src_addStyle(options, parent, instance);
    if (instance.originalPosition !== 'absolute' && instance.originalPosition !== 'fixed') {
      Object(dom_["addClass"])(parent, 'el-loading-parent--relative');
    }
    if (options.fullscreen && options.lock) {
      Object(dom_["addClass"])(parent, 'el-loading-parent--hidden');
    }
    parent.appendChild(instance.$el);
    external_vue_default.a.nextTick(function () {
      instance.visible = true;
    });
    if (options.fullscreen) {
      fullscreenLoading = instance;
    }
    return instance;
  };
  
  /* harmony default export */ var src = (src_Loading);
  // CONCATENATED MODULE: ./packages/loading/index.js
  
  
  
  /* harmony default export */ var packages_loading = __webpack_exports__["default"] = ({
    install: function install(Vue) {
      Vue.use(directive);
      Vue.prototype.$loading = src;
    },
  
    directive: directive,
    service: src
  });
  
  /***/ }),
  
  /***/ 7:
  /***/ (function(module, exports) {
  
  module.exports = require("vue");
  
  /***/ }),
  
  /***/ 9:
  /***/ (function(module, exports) {
  
  module.exports = require("element-ui/lib/utils/merge");
  
  /***/ })
  
  /******/ });