/**
 *
 */
"use strict";

function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }

function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

if (window.Vue) (function () {
  var DolphyInstance = {};
  var DolphyInitCallbacks = [];

  function DolphyApp(options) {
    if (!(this instanceof DolphyApp ? this.constructor : void 0)) {
      throw 'DolphyApp must be instantiated as an object.';
    }

    var app = Vue.createApp(options);

    var _iterator = _createForOfIteratorHelper(DolphyInitCallbacks),
        _step;

    try {
      for (_iterator.s(); !(_step = _iterator.n()).done;) {
        var callback = _step.value;
        if (typeof callback !== 'function') return;
        callback.call(app, app);
      }
    } catch (err) {
      _iterator.e(err);
    } finally {
      _iterator.f();
    }

    return app;
  }

  Object.defineProperty(DolphyApp, 'add', {
    writable: false,
    value: function value(name, data) {
      Object.defineProperty(DolphyInstance, name, {
        enumerable: true,
        writable: false,
        value: data
      });
    }
  });
  Object.defineProperty(DolphyApp, 'onInit', {
    writable: false,
    value: function value(callback) {
      if (typeof callback !== 'function') return;
      DolphyInitCallbacks.push(callback);
    }
  });
  Object.defineProperty(DolphyApp, '$dolphy', {
    writable: false,
    value: DolphyInstance
  });
  DolphyApp.onInit(function (app) {
    Object.defineProperty(app, '$dolphy', {
      get: function get() {
        return DolphyInstance;
      }
    });
    app.provide('$dolphy', DolphyInstance);
    app.mixin({
      inject: ['$dolphy']
    });
  }); // BEGIN: DolphyApp Features

  function DolphyAppFeatures(app, type) {
    if (!type) type = 'default';
    Object.defineProperty(this, '$app', {
      writable: false,
      value: app
    });
    Object.defineProperty(this, '$type', {
      writable: false,
      value: type
    });
  }

  DolphyAppFeatures["protected"] = ['$app', '$type'];

  DolphyAppFeatures.validate = function (name) {
    if (!/[\w\d]+/.test(name)) return false;
    if (/(^[^a-zA-Z]+|[^a-zA-Z]+$)/.test(name)) return false;
    return true;
  };

  Object.defineProperty(DolphyApp, 'addFeature', {
    writable: false,
    value: function value(name, callback) {
      if (!DolphyAppFeatures.validate(name)) {
        throw "Feature name \"".concat(name, "\" does not appear to be valid!");
      }

      if (DolphyAppFeatures["protected"].indexOf(name) >= 0) {
        throw "\"".concat(name, "\" is a protected variable");
      }

      if (name in DolphyAppFeatures.prototype) {
        throw "The feature \"".concat(name, "\" already exists!");
      }

      Object.defineProperty(DolphyAppFeatures.prototype, name, {
        writable: false,
        enumerable: true,
        value: callback
      });
    }
  });
  Object.defineProperty(DolphyApp, 'features', {
    writable: false,
    value: function value(app, type) {
      return new DolphyAppFeatures(app, type);
    }
  }); // END: DolphyApp Features

  window.DolphyApp = DolphyApp;
})();
if (window.DolphyApp) (function () {
  var Axios = axios.create();
  var _window = window,
      _window$Dolphy = _window.Dolphy,
      Dolphy = _window$Dolphy === void 0 ? null : _window$Dolphy;
  var ApiAddon = {};
  Object.defineProperty(ApiAddon, 'endpoint', {
    get: function get() {
      if (!Dolphy) return null;
      return Dolphy.ajax;
    }
  });
  Object.defineProperty(ApiAddon, 'of', {
    writable: false,
    value: function value(type) {
      var endpoint = this.endpoint;
      var params = new URLSearchParams();
      if (type) params.set('type', type);
      return {
        url: function url(action, query) {
          params.set('action', action);

          if (query && _typeof(query) === 'object') {
            for (var key in query) {
              if (['action', 'type'].indexOf(key) >= 0) continue;
              params.set(key, query[key]);
            }
          }

          return "".concat(endpoint, "?").concat(params.toString());
        }
      };
    }
  });
  Object.defineProperty(ApiAddon, 'url', {
    get: function get() {
      return this.of('default').url;
    }
  });
  Object.defineProperty(ApiAddon, 'account', {
    get: function get() {
      return this.of('account');
    }
  });
  Object.defineProperty(ApiAddon, 'admin', {
    get: function get() {
      return this.of('admin');
    }
  }); // BEGIN: Request Methods ---------------

  Object.defineProperty(ApiAddon, 'get', {
    value: function value() {
      return Axios.get.apply(Axios, arguments);
    },
    writable: false
  });
  Object.defineProperty(ApiAddon, 'post', {
    value: function value() {
      return Axios.post.apply(Axios, arguments);
    },
    writable: false
  });
  Object.defineProperty(ApiAddon, 'patch', {
    value: function value() {
      return Axios.patch.apply(Axios, arguments);
    },
    writable: false
  });
  Object.defineProperty(ApiAddon, 'put', {
    value: function value() {
      return Axios.put.apply(Axios, arguments);
    },
    writable: false
  });
  Object.defineProperty(ApiAddon, 'delete', {
    value: function value() {
      return Axios["delete"].apply(Axios, arguments);
    },
    writable: false
  }); // END: Request Methods ---------------

  DolphyApp.add('$api', ApiAddon);
  DolphyApp.add('api', ApiAddon);
})();
if (window.DolphyApp) (function () {
  DolphyApp.addFeature('component', function (name, path, options) {
    var $app = this.$app,
        $type = this.$type;
    var _$app$$dolphy = $app.$dolphy,
        $preloader = _$app$$dolphy.$preloader,
        $api = _$app$$dolphy.$api;
    $app.component(name, Vue.defineAsyncComponent(function () {
      return new Promise(function (resolve, reject) {
        var url = $api.of($type).url('page', {
          path: path
        });
        $preloader.start();
        $api.get(url).then(function (resp) {
          resolve(_objectSpread(_objectSpread({}, options), {}, {
            template: resp.data
          }));
        })["catch"](function (error) {
          if ('response' in error) {
            resolve(_objectSpread(_objectSpread({}, options), {}, {
              template: error.response.data
            }));
          } else {
            swal('', error.message, 'error');
          }
        })["finally"](function () {
          $preloader.stop();
        });
      });
    }));
  }); // BEGIN: Component Methods

  var DolphyAppComponents = new Map();
  Object.defineProperty(DolphyApp, 'component', {
    writable: false,
    value: function value(name, path, options) {
      if (DolphyAppComponents.has(name)) {
        throw "Component, ".concat(name, ", already exists!");
      }

      DolphyAppComponents.set(name, {
        path: path,
        options: options
      });
    }
  });
  Object.defineProperty(DolphyApp, 'accountComponent', {
    writable: false,
    value: function value(name, path, options) {
      if (DolphyAppComponents.has(name)) {
        throw "Component, ".concat(name, ", already exists!");
      }

      DolphyAppComponents.set(name, {
        path: path,
        options: options,
        type: 'account'
      });
    }
  });
  DolphyApp.onInit(function (app) {
    var $features = DolphyApp.features(app);
    var $accountFeatures = DolphyApp.features(app, 'account');
    DolphyAppComponents.forEach(function (value, name) {
      var path = value.path,
          options = value.options,
          _value$type = value.type,
          type = _value$type === void 0 ? 'default' : _value$type;

      switch (type) {
        case 'account':
          {
            $accountFeatures.component(name, path, options);
          }
          break;

        default:
          {
            $features.component(name, path, options);
          }
      }
    });
  }); // END: Component Methods
})();
if (window.DolphyApp) (function () {
  var _Vue = Vue,
      reactive = _Vue.reactive,
      ref = _Vue.ref,
      watch = _Vue.watch,
      computed = _Vue.computed;
  var DolphyDialogList = reactive([]);
  var DolphyDialogResolvers = new Map();

  function DolphyDialog(options) {
    var $options = reactive({
      component: {
        template: '<div class="dol-text-center">No content</div>'
      }
    });
    Object.assign($options, options);
    Object.defineProperty(this, 'options', {
      writable: false,
      value: $options
    });
    return reactive(this);
  }

  Object.defineProperty(DolphyDialog.prototype, 'open', {
    writable: false,
    value: function value() {
      var _this = this;

      if (DolphyDialogResolvers.has(this)) {
        return Promise.reject('Dialog already opened!');
      }

      return new Promise(function (resolve) {
        DolphyDialogResolvers.set(_this, resolve);
        DolphyDialog.add(_this);
      });
    }
  });
  Object.defineProperty(DolphyDialog.prototype, 'close', {
    writable: false,
    value: function value(data) {
      if (!DolphyDialogResolvers.has(this)) return;
      var resolve = DolphyDialogResolvers.get(this);
      DolphyDialog.remove(this);
      DolphyDialogResolvers["delete"](this);
      resolve(data);
    }
  });
  Object.defineProperty(DolphyDialog, 'add', {
    writable: false,
    value: function value(data) {
      DolphyDialogList.push(data);
      DolphyDialog.update();
    }
  });
  Object.defineProperty(DolphyDialog, 'remove', {
    writable: false,
    value: function value(data) {
      var index = DolphyDialogList.indexOf(data);
      DolphyDialogList.splice(index, 1);
      DolphyDialog.update();
    }
  });
  Object.defineProperty(DolphyDialog, 'update', {
    writable: false,
    value: function value() {
      var className = 'dolphy-dialog-noscroll';

      if (DolphyDialogList.length) {
        document.body.classList.add(className);
      } else {
        document.body.classList.remove(className);
      }
    }
  }); // BEGIN: Dialog Addon

  var DolphyDialogAddon = {};
  Object.defineProperty(DolphyDialogAddon, 'create', {
    writable: false,
    value: function value(options) {
      return new DolphyDialog(options);
    }
  });
  Object.defineProperty(DolphyDialogAddon, 'alert', {
    writable: false,
    value: function value(title, message, type) {
      var $dialog = this.create({
        backdropClose: false,
        component: {
          data: function data() {
            return {
              title: title,
              message: message
            };
          },
          inject: ['$dialogInstance'],
          setup: function setup(props) {
            var color = computed(function () {
              return type ? "dol-text-color-".concat(type) : '';
            });
            return {
              color: color
            };
          },
          template: "\n          <dolphy-dialog-window :close-btn=\"false\">\n            <dolphy-dialog-title v-if=\"title\">\n              {{ title }}\n            </dolphy-dialog-title>\n\n            <dolphy-dialog-body :class=\"color\">\n              {{ message }}\n            </dolphy-dialog-body>\n\n            <dolphy-dialog-footer>\n              <dolphy-dialog-button type=\"primary\" @click=\"close()\">\n                <span>Okay</span>\n              </dolphy-dialog-button>\n            </dolphy-dialog-footer>\n          </dolphy-dialog-window>\n          ",
          methods: {
            close: function close() {
              var $dialogInstance = this.$dialogInstance;
              $dialogInstance.close(true);
            }
          }
        }
      });
      return $dialog.open();
    }
  });
  Object.defineProperty(DolphyDialogAddon, 'confirm', {
    writable: false,
    value: function value(title, message, type) {
      var $dialog = this.create({
        backdropClose: false,
        component: {
          data: function data() {
            return {
              title: title,
              message: message
            };
          },
          inject: ['$dialogInstance'],
          setup: function setup(props) {
            var color = computed(function () {
              return type ? "dol-text-color-".concat(type) : '';
            });
            return {
              color: color
            };
          },
          template: "\n          <dolphy-dialog-window :close-btn=\"false\">\n            <dolphy-dialog-title v-if=\"title\">\n              {{ title }}\n            </dolphy-dialog-title>\n\n            <dolphy-dialog-body :class=\"color\">\n              {{ message }}\n            </dolphy-dialog-body>\n\n            <dolphy-dialog-footer>\n              <dolphy-dialog-button @click=\"cancel()\">\n                <span>Cancel</span>\n              </dolphy-dialog-button>\n\n              <dolphy-dialog-button type=\"primary\" @click=\"okay()\">\n                <span>Okay</span>\n              </dolphy-dialog-button>\n            </dolphy-dialog-footer>\n          </dolphy-dialog-window>\n          ",
          methods: {
            okay: function okay() {
              var $dialogInstance = this.$dialogInstance;
              $dialogInstance.close(true);
            },
            cancel: function cancel() {
              var $dialogInstance = this.$dialogInstance;
              $dialogInstance.close(false);
            }
          }
        }
      });
      return $dialog.open();
    }
  });
  Object.defineProperty(DolphyDialogAddon, 'error', {
    writable: false,
    value: function value(title, message) {
      return this.alert(title, message, 'error');
    }
  });
  DolphyApp.onInit(function (app) {
    // Dialog Placeholder
    app.component('dolphy-dialog-placeholder', {
      template: "\n      <teleport to=\"body\">\n      <div class=\"dolphy-dialog-placeholder\">\n        <transition-group name=\"dialog\" :duration=\"500\">\n          <dolphy-dialog v-for=\"dialog in dialogList\" :dialog=\"dialog\"></dolphy-dialog>\n        </transition-group>\n      </div>\n      </teleport>\n      ",
      computed: {
        dialogList: function dialogList() {
          return DolphyDialogList;
        }
      }
    }); // Dialog Component

    app.component('dolphy-dialog', {
      props: {
        dialog: Object
      },
      template: "\n      <div class=\"dolphy-dialog\" :key=\"dialog\" @click=\"onBackdropClick($event)\">\n        <div class=\"dolphy-dialog__content\">\n          <component\n            :is=\"dialog.options.component\"\n            class=\"dolphy-dialog__component\"\n            @click=\"stopPropagation($event)\"\n          ></component>\n        </div>\n      </div>\n      ",
      provide: function provide() {
        var dialog = this.dialog;
        var options = dialog.options;
        var $dialogInstance = dialog;
        var $dialogData = _typeof(options.data) === 'object' ? options.data : {};
        return {
          $dialogInstance: $dialogInstance,
          $dialogData: $dialogData
        };
      },
      methods: {
        stopPropagation: function stopPropagation(e) {
          e.preventDefault();
          e.stopPropagation();
        },
        onBackdropClick: function onBackdropClick(e) {
          e.preventDefault();
          var dialog = this.dialog;

          if (dialog.options.backdropClose !== false) {
            dialog.close('backdrop');
          }
        },
        close: function close(e) {
          e.preventDefault();
          var dialog = this.dialog;
          dialog.close('closeButton');
        }
      }
    });
    app.component('dolphy-dialog-window', {
      props: {
        closeBtn: {
          type: Boolean,
          "default": function _default() {
            return true;
          }
        }
      },
      inject: ['$dialogInstance'],
      template: "\n      <div class=\"dolphy-dialog__window\">\n        <div class=\"dolphy-dialog__window--close-button\" @click=\"close()\" v-if=\"closeBtn\">\n          <span class=\"dashicons dashicons-no-alt\"></span>\n        </div>\n\n        <div class=\"dolphy-dialog__window--content\">\n          <slot></slot>\n        </div>\n      </div>\n      ",
      methods: {
        close: function close() {
          var $dialogInstance = this.$dialogInstance;

          if ($dialogInstance) {
            $dialogInstance.close(false);
          }
        }
      }
    });
    app.component('dolphy-dialog-title', {
      template: "\n      <h1 class=\"dolphy-dialog__title\">\n        <slot></slot>\n      </h1>\n      "
    });
    app.component('dolphy-dialog-body', {
      template: "\n      <div class=\"dolphy-dialog__body\">\n        <slot></slot>\n      </div>\n      "
    });
    app.component('dolphy-dialog-footer', {
      template: "\n      <div class=\"dolphy-dialog__footer\">\n        <slot></slot>\n      </div>\n      "
    });
    app.component('dolphy-dialog-button', {
      props: {
        type: {
          type: String,
          "default": function _default() {
            return 'default';
          }
        }
      },
      template: "\n      <button class=\"dolphy-dialog__button\" :class=\"typeClass\">\n        <slot></slot>\n      </button>\n      ",
      computed: {
        typeClass: function typeClass() {
          var type = this.type;
          return "--".concat(type);
        }
      }
    });
  });
  DolphyApp.add('$dialog', DolphyDialogAddon); // END: Dialog Addon
})();
if (window.DolphyApp) (function () {
  var DolphyHooks = {};
  var DolphyHooksHash = {};

  function addHook(type, name, callback, priority) {
    if (typeof name !== 'string') throw 'Name of hook must be a string!';
    if (typeof callback !== 'function') throw 'Callback must be a function';

    if (typeof priority !== 'number') {
      priority = 10;
    }

    if (!(type in DolphyHooksHash)) {
      DolphyHooksHash[type] = {};
    }

    if (!(name in DolphyHooksHash[type])) {
      DolphyHooksHash[type][name] = new Map();
    }

    if (!DolphyHooksHash[type][name].has(priority)) {
      DolphyHooksHash[type][name].set(priority, []);
    }

    var info = DolphyHooksHash[type][name].get(priority);
    info.push(callback);
  }

  function getHooks(type, name) {
    if (!(type in DolphyHooksHash)) return null;
    if (!(name in DolphyHooksHash[type])) return null;
    return DolphyHooksHash[type][name];
  }

  function runHooks(type, name, handler) {
    var _this2 = this;

    if (typeof handler !== 'function') {
      throw 'Handler must be a function';
    }

    var hooks = getHooks(type, name);
    if (!hooks) return;
    hooks.forEach(function (callbackList, priority) {
      var _iterator2 = _createForOfIteratorHelper(callbackList),
          _step2;

      try {
        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
          var callback = _step2.value;
          handler.call(_this2, name, callback, priority);
        }
      } catch (err) {
        _iterator2.e(err);
      } finally {
        _iterator2.f();
      }
    });
  }

  Object.defineProperty(DolphyHooks, 'addFilter', {
    writable: false,
    value: function value(name, callback, priority) {
      addHook.call(this, 'filters', name, callback, priority);
    }
  });
  Object.defineProperty(DolphyHooks, 'addAction', {
    writable: false,
    value: function value(name, callback, priority) {
      addHook.call(this, 'actions', name, callback, priority);
    }
  });
  Object.defineProperty(DolphyHooks, 'applyFilters', {
    writable: false,
    value: function value(name, _value) {
      var _this3 = this;

      for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
        args[_key - 2] = arguments[_key];
      }

      runHooks.call(this, 'filters', name, function (name, callback) {
        _value = callback.call.apply(callback, [_this3, _value].concat(args));
      });
      return _value;
    }
  });
  Object.defineProperty(DolphyHooks, 'doAction', {
    writable: false,
    value: function value(name) {
      var _this4 = this;

      for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
        args[_key2 - 1] = arguments[_key2];
      }

      var $promise = Promise.resolve();
      runHooks.call(this, 'actions', name, function (name, callback) {
        $promise = $promise.then(function () {
          return callback.apply(_this4, args);
        });
      });
      return $promise;
    }
  });
  DolphyApp.add('$hooks', DolphyHooks);
})();
if (window.DolphyApp) (function () {
  var $element = document.createElement('div');
  $element.innerHTML = '<div class="animation"></div>';
  $element.classList.add('dolphy-loading');
  document.body.appendChild($element);
  var $content = document.createElement('div');
  $content.classList.add('text');
  var count = 0,
      isPreloading = Vue.ref(false);
  var PreloaderAddon = {};
  Object.defineProperty(PreloaderAddon, 'loading', {
    get: function get() {
      return isPreloading.value;
    }
  });
  Object.defineProperty(PreloaderAddon, 'start', {
    writable: false,
    value: function value(message) {
      if (message && typeof message === 'string') {
        $content.innerText = message;
        $element.appendChild($content);
      }

      $element.classList.add('show');
      isPreloading.value = true;
      count++;
    }
  });
  Object.defineProperty(PreloaderAddon, 'stop', {
    writable: false,
    value: function value() {
      count = Math.max(0, --count);

      if (count === 0) {
        isPreloading.value = false;
        $element.classList.remove('show');
        $content.remove();
      }
    }
  });
  DolphyApp.add('$preloader', PreloaderAddon);
  DolphyApp.add('preloader', PreloaderAddon);
  DolphyApp.onInit(function (app) {
    // Add Mixin
    app.mixin({
      computed: {
        loading: function loading() {
          return isPreloading.value;
        }
      }
    });
  });
})();
if (window.DolphyApp) (function () {
  var _DolphyApp = DolphyApp,
      $dolphy = _DolphyApp.$dolphy;
  var DolphyMessage = {};
  Object.defineProperty(DolphyMessage, 'parseError', {
    writable: false,
    value: function value(error) {
      // console.log([error]);
      if (typeof error === 'string') return error;

      if (_typeof(error) === 'object') {
        if ('response' in error) {
          if ('data' in error.response) return error.response.data;
        }

        if ('message' in error) return error.message;
      }

      return 'An unknown error occured. Please try again later';
    }
  });
  Object.defineProperty(DolphyMessage, 'handle', {
    writable: false,
    value: function value(error) {
      var $dialog = $dolphy.$dialog;
      $dialog.error('Error', this.parseError(error));
    }
  });
  DolphyApp.add('$message', DolphyMessage);
})();
if (window.DolphyApp) (function () {
  var DolphyServiceWorker = {};
  DolphyApp.add('$sw', DolphyServiceWorker);
})();
if (window.DolphyApp) (function () {
  var AccessServicePlugin = {
    install: function install(app) {
      var $dolphy = app.$dolphy;
      var AccessService = {
        login: function login(data) {
          var $api = $dolphy.$api;
          var url = $api.url('login');
          return $api.post(url, data);
        },
        postLogin: function postLogin(dplc) {
          var $api = $dolphy.$api;
          var url = $api.url('post_login');
          return $api.post(url, {
            dplc: dplc
          });
        },
        forgotPassword: function forgotPassword(data) {
          var $api = $dolphy.$api;
          var url = $api.url('forgot_password');
          return $api.post(url, data);
        },
        resetPassword: function resetPassword(data) {
          var $api = $dolphy.$api;
          var url = $api.url('reset_password');
          return $api.post(url, data);
        },
        signup: function signup(data) {
          var $api = $dolphy.$api;
          var url = $api.url('signup');
          return $api.post(url, data);
        }
      };
      app.provide('AccessService', AccessService);
    }
  };
  DolphyApp.onInit(function (app) {
    app.use(AccessServicePlugin);
  });
})();
if (window.DolphyApp) (function () {
  var TwoFAServicePlugin = {
    install: function install(app) {
      var $dolphy = app.$dolphy;
      var TwoFAService = {
        getInfo: function getInfo() {
          var $api = $dolphy.$api;
          var url = $api.account.url('security_2fa');
          return $api.get(url);
        },
        enable: function enable(data) {
          var $api = $dolphy.$api;
          var url = $api.account.url('security_2fa');
          return $api.post(url, data);
        },
        disable: function disable() {
          var $api = $dolphy.$api;
          var url = $api.account.url('security_2fa');
          return $api["delete"](url);
        }
      };
      app.provide('TwoFAService', TwoFAService);
    }
  };
  DolphyApp.onInit(function (app) {
    app.use(TwoFAServicePlugin);
  });
})();
if (window.DolphyApp) (function () {
  var UserServicePlugin = {
    install: function install(app) {
      var dolphy = app.dolphy;
      var UserService = {
        me: function me() {
          var api = dolphy.api;
          var url = api.account.url('me');
          return api.get(url);
        }
      };
      app.provide('UserService', UserService);
    }
  };
  DolphyApp.onInit(function (app) {
    app.use(UserServicePlugin);
  });
})();
if (window.DolphyApp) (function () {
  DolphyApp.onInit(function (app) {
    app.component('dolphy-flex', {
      props: {
        device: {
          type: String,
          "default": function _default() {
            return '';
          }
        }
      },
      template: "\n      <div :class=\"className\">\n        <slot></slot>\n      </div>\n      ",
      computed: {
        className: function className() {
          var device = this.device;
          return "dol-".concat(device ? device + '-' : '', "flex");
        }
      }
    });
  });
})();