maz-ui 3.5.0 → 3.6.2

package/modules/maz-ui.mjs

@@ -0,0 +1,1892 @@
+(function(){"use strict";try{if(typeof document!="undefined"){var a=document.createElement("style");a.appendChild(document.createTextNode(".m-toast-container{-webkit-box-sizing:border-box;box-sizing:border-box;position:fixed;display:-webkit-box;display:-ms-flexbox;display:flex;-webkit-box-orient:vertical;-webkit-box-direction:normal;-ms-flex-direction:column;flex-direction:column}.m-toast-container>:not([hidden])~:not([hidden]){--tw-space-y-reverse: 0;margin-top:calc(.5rem * calc(1 - var(--tw-space-y-reverse)));margin-bottom:calc(.5rem * var(--tw-space-y-reverse))}.m-toast-container{padding:1rem;z-index:1051}.m-toast-container.--top{top:0px;display:-webkit-box;display:-ms-flexbox;display:flex}.m-toast-container.--center{width:100%}@media (min-width: 768px){.m-toast-container.--center{position:fixed;left:50%;width:auto;-webkit-transform:translate(-50%,0);transform:translate(-50%)}}.m-toast-container.--bottom{bottom:0px;display:-webkit-box;display:-ms-flexbox;display:flex;-webkit-box-orient:vertical;-webkit-box-direction:reverse;-ms-flex-direction:column-reverse;flex-direction:column-reverse}.m-toast-container.--bottom>:not([hidden])~:not([hidden]){margin-bottom:calc(.5rem * calc(1 - var(--tw-space-y-reverse)));margin-top:calc(.5rem * var(--tw-space-y-reverse))}.m-toast-container.--right{right:0px;width:100%}@media (min-width: 768px){.m-toast-container.--right{width:auto}}.m-toast-container.--left{left:0px;width:100%}@media (min-width: 768px){.m-toast-container.--left{width:auto}}.m-toast[data-v-ba28d9a5],.m-toast *[data-v-ba28d9a5]{-webkit-box-sizing:border-box;box-sizing:border-box}.m-toast[data-v-ba28d9a5]{position:relative;display:-webkit-box;display:-ms-flexbox;display:flex;width:100%;cursor:pointer;-webkit-box-align:center;-ms-flex-align:center;align-items:center;-ms-flex-item-align:center;align-self:center;border-radius:var(--maz-border-radius);padding-left:.5rem;padding-right:.5rem;color:var(--maz-color-white);-webkit-transition-property:color,background-color,border-color,text-decoration-color,fill,stroke,opacity,-webkit-box-shadow,-webkit-transform,-webkit-filter,-webkit-backdrop-filter;transition-property:color,background-color,border-color,text-decoration-color,fill,stroke,opacity,-webkit-box-shadow,-webkit-transform,-webkit-filter,-webkit-backdrop-filter;transition-property:color,background-color,border-color,text-decoration-color,fill,stroke,opacity,box-shadow,transform,filter,backdrop-filter;transition-property:color,background-color,border-color,text-decoration-color,fill,stroke,opacity,box-shadow,transform,filter,backdrop-filter,-webkit-box-shadow,-webkit-transform,-webkit-filter,-webkit-backdrop-filter;-webkit-transition-duration:.3s;transition-duration:.3s;-webkit-transition-timing-function:cubic-bezier(.4,0,.2,1);transition-timing-function:cubic-bezier(.4,0,.2,1)}@media (min-width: 768px){.m-toast.--left[data-v-ba28d9a5],.m-toast.--right[data-v-ba28d9a5]{width:20rem}.m-toast.--center[data-v-ba28d9a5]{width:20rem;-webkit-box-pack:center;-ms-flex-pack:center;justify-content:center}}.m-toast__message-wrapper[data-v-ba28d9a5]{-webkit-box-flex:1;-ms-flex:1 1 0%;flex:1 1 0%;padding-top:.75rem;padding-bottom:.75rem}.m-toast__message[data-v-ba28d9a5]{margin:0;font-weight:500}.m-toast .--close[data-v-ba28d9a5]{margin-left:.25rem;display:-webkit-box;display:-ms-flexbox;display:flex;height:1.75rem;width:1.75rem;border-radius:var(--maz-border-radius);background-color:transparent;padding:0;-webkit-box-align:center;-ms-flex-align:center;align-items:center;-webkit-box-pack:center;-ms-flex-pack:center;justify-content:center}.m-toast .--close[data-v-ba28d9a5]:hover{background-color:#11182733}.m-toast .--close .--icon[data-v-ba28d9a5]{height:1.25rem;width:1.25rem;cursor:pointer}.m-toast.--info[data-v-ba28d9a5]{background-color:var(--maz-color-info);color:var(--maz-color-info-contrast)}.m-toast.--info[data-v-ba28d9a5]:hover{background-color:var(--maz-color-info-600)}.m-toast.--info .--close[data-v-ba28d9a5]{color:var(--maz-color-info-contrast)}.m-toast.--success[data-v-ba28d9a5]{background-color:var(--maz-color-success);color:var(--maz-color-success-contrast)}.m-toast.--success[data-v-ba28d9a5]:hover{background-color:var(--maz-color-success-600)}.m-toast.--success .--close[data-v-ba28d9a5]{color:var(--maz-color-success-contrast)}.m-toast.--warning[data-v-ba28d9a5]{background-color:var(--maz-color-warning);color:var(--maz-color-warning-contrast)}.m-toast.--warning[data-v-ba28d9a5]:hover{background-color:var(--maz-color-warning-600)}.m-toast.--warning .--close[data-v-ba28d9a5]{color:var(--maz-color-warning-contrast)}.m-toast.--danger[data-v-ba28d9a5]{background-color:var(--maz-color-danger);color:var(--maz-color-danger-contrast)}.m-toast.--danger[data-v-ba28d9a5]:hover{background-color:var(--maz-color-danger-600)}.m-toast.--danger .--close[data-v-ba28d9a5]{color:var(--maz-color-danger-contrast)}.m-slide-top-enter-active[data-v-ba28d9a5],.m-slide-top-leave-active[data-v-ba28d9a5]{opacity:1;-webkit-transition:all .3s;transition:all .3s;-webkit-transform:translateY(0);transform:translateY(0)}.m-slide-top-enter-from[data-v-ba28d9a5],.m-slide-top-leave-to[data-v-ba28d9a5]{opacity:0;-webkit-transform:translateY(-100%);transform:translateY(-100%)}.m-slide-bottom-enter-active[data-v-ba28d9a5],.m-slide-bottom-leave-active[data-v-ba28d9a5]{opacity:1;-webkit-transition:all .3s;transition:all .3s;-webkit-transform:translateY(0);transform:translateY(0)}.m-slide-bottom-enter-from[data-v-ba28d9a5],.m-slide-bottom-leave-to[data-v-ba28d9a5]{opacity:0;-webkit-transform:translateY(100%);transform:translateY(100%)}.m-slide-right-enter-active[data-v-ba28d9a5],.m-slide-right-leave-active[data-v-ba28d9a5]{opacity:1;-webkit-transition:all .3s;transition:all .3s;-webkit-transform:translateX(0);transform:translate(0)}.m-slide-right-enter-from[data-v-ba28d9a5],.m-slide-right-leave-to[data-v-ba28d9a5]{opacity:0;-webkit-transform:translateX(100%);transform:translate(100%)}.m-slide-left-enter-active[data-v-ba28d9a5],.m-slide-left-leave-active[data-v-ba28d9a5]{opacity:1;-webkit-transition:all .3s;transition:all .3s;-webkit-transform:translateX(0);transform:translate(0)}.m-slide-left-enter-from[data-v-ba28d9a5],.m-slide-left-leave-to[data-v-ba28d9a5]{opacity:0;-webkit-transform:translateX(-100%);transform:translate(-100%)}")),document.head.appendChild(a)}}catch(t){console.error("vite-plugin-css-injected-by-js",t)}})();
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+import { inject, createVNode, render, nextTick, defineComponent, ref, computed, onMounted as onMounted$1, watchEffect, openBlock, createElementBlock, mergeProps, createCommentVNode, createBlock, Transition, unref, withCtx, withDirectives, createElementVNode, normalizeClass, toDisplayString, vShow } from "vue";
+function injectStrict(key, fallback) {
+  const resolved = inject(key, fallback);
+  if (!resolved) {
+    throw new Error(`[maz-ui](injectStrict) Could not resolve ${key}`);
+  }
+  return resolved;
+}
+function debounce(fn, wait = 0, callFirst = false) {
+  let timeout;
+  let debouncedFn;
+  const clear = function() {
+    if (timeout) {
+      clearTimeout(timeout);
+      debouncedFn = void 0;
+      timeout = void 0;
+    }
+  };
+  const flush = function() {
+    const call = debouncedFn;
+    clear();
+    if (call) {
+      call();
+    }
+  };
+  const debounceWrapper = function(...args) {
+    if (!wait) {
+      return fn.apply(this, args);
+    }
+    const context = this;
+    const callNow = callFirst && !timeout;
+    clear();
+    debouncedFn = function() {
+      fn.apply(context, args);
+    };
+    timeout = setTimeout(function() {
+      timeout = void 0;
+      if (!callNow) {
+        const call = debouncedFn;
+        debouncedFn = void 0;
+        if (call !== void 0)
+          return call();
+      }
+    }, wait);
+    if (callNow) {
+      return debouncedFn();
+    }
+  };
+  debounceWrapper.cancel = clear;
+  debounceWrapper.flush = flush;
+  return debounceWrapper;
+}
+function truthyFilter(value) {
+  return !!value;
+}
+function mount(component, {
+  props,
+  children,
+  element,
+  app
+} = {}) {
+  let el = element;
+  const vNode = createVNode(component, props, children);
+  if (app && app._context)
+    vNode.appContext = app._context;
+  if (el)
+    render(vNode, el);
+  else if (typeof document !== "undefined") {
+    render(vNode, el = document.createElement("div"));
+  }
+  const destroy = () => {
+    if (el)
+      render(null, el);
+  };
+  return { vNode, destroy, el };
+}
+function isClient() {
+  return typeof document !== "undefined";
+}
+class IdleTimeout {
+  constructor(callback, options) {
+    __publicField(this, "defaultOptions", {
+      element: void 0,
+      timeout: 60 * 1e3 * 5,
+      once: false,
+      immediate: true,
+      ssr: false
+    });
+    __publicField(this, "options");
+    __publicField(this, "timeoutHandler");
+    __publicField(this, "isIdle", false);
+    __publicField(this, "isDestroy", false);
+    __publicField(this, "startTime", 0);
+    __publicField(this, "remainingTime", 0);
+    __publicField(this, "lastClientX", -1);
+    __publicField(this, "lastClientY", -1);
+    __publicField(this, "eventNames", [
+      "DOMMouseScroll",
+      "mousedown",
+      "mousemove",
+      "mousewheel",
+      "MSPointerDown",
+      "MSPointerMove",
+      "keydown",
+      "touchmove",
+      "touchstart",
+      "wheel",
+      "click"
+    ]);
+    __publicField(this, "handleEvent", (event) => {
+      try {
+        if (this.remainingTime > 0) {
+          return;
+        }
+        if (event.type === "mousemove") {
+          const { clientX, clientY } = event;
+          if (clientX === void 0 && clientY === void 0 || clientX === this.lastClientX && clientY === this.lastClientY) {
+            return;
+          }
+          this.lastClientX = clientX;
+          this.lastClientY = clientY;
+        }
+        this.resetTimeout();
+        this.callback({ isIdle: this.isIdle, eventType: event.type });
+      } catch (error) {
+        throw new Error(`[IdleTimeout](handleEvent) ${error}`);
+      }
+    });
+    this.callback = callback;
+    this.options = {
+      ...this.defaultOptions,
+      ...options
+    };
+    if (!this.options.ssr && isClient()) {
+      this.start();
+    } else if (!this.options.ssr && !isClient()) {
+      console.warn(
+        `[IdleTimeout](constructor) executed on server side - set immediate option to "false"`
+      );
+    }
+  }
+  get element() {
+    return this.options.element ?? document.body;
+  }
+  start() {
+    if (!isClient()) {
+      console.warn(
+        `[IdleTimeout](start) you should run this method on client side`
+      );
+      return;
+    }
+    for (const eventName of this.eventNames) {
+      this.element.addEventListener(eventName, this.handleEvent);
+    }
+    this.resetTimeout();
+    if (this.options.immediate) {
+      this.callback({ isIdle: false });
+    }
+  }
+  pause() {
+    const remainingTime = this.startTime + this.options.timeout - Date.now();
+    if (remainingTime <= 0) {
+      return;
+    }
+    this.remainingTime = remainingTime;
+    if (this.timeoutHandler) {
+      clearTimeout(this.timeoutHandler);
+      this.timeoutHandler = void 0;
+    }
+  }
+  resume() {
+    if (this.remainingTime <= 0) {
+      return;
+    }
+    this.resetTimeout();
+    this.callback({ isIdle: this.isIdle });
+    this.remainingTime = 0;
+  }
+  reset() {
+    this.isDestroy = false;
+    this.isIdle = false;
+    this.remainingTime = 0;
+    this.resetTimeout();
+    this.callback({ isIdle: this.isIdle });
+  }
+  destroy() {
+    if (!isClient()) {
+      console.warn(
+        `[IdleTimeout](destroy) you should run this method on client side`
+      );
+      return;
+    }
+    this.isDestroy = true;
+    for (const eventName of this.eventNames) {
+      this.element.removeEventListener(eventName, this.handleEvent);
+    }
+    if (this.timeoutHandler) {
+      clearTimeout(this.timeoutHandler);
+    }
+  }
+  resetTimeout() {
+    this.isIdle = false;
+    if (this.timeoutHandler) {
+      clearTimeout(this.timeoutHandler);
+      this.timeoutHandler = void 0;
+    }
+    this.timeoutHandler = setTimeout(
+      this.handleTimeout.bind(this),
+      this.remainingTime || this.options.timeout
+    );
+    this.startTime = Date.now();
+  }
+  handleTimeout() {
+    this.isIdle = true;
+    this.callback({ isIdle: this.isIdle });
+    if (this.options.once) {
+      this.destroy();
+    }
+  }
+  get destroyed() {
+    return this.isDestroy;
+  }
+  get timeout() {
+    return this.options.timeout;
+  }
+  set timeout(value) {
+    this.options.timeout = value;
+  }
+  get idle() {
+    return this.isIdle;
+  }
+  set idle(value) {
+    if (value) {
+      this.handleTimeout();
+    } else {
+      this.reset();
+    }
+    this.callback({ isIdle: this.isIdle });
+  }
+}
+class UserVisibility {
+  constructor(callback, options) {
+    __publicField(this, "eventHandlerFunction");
+    __publicField(this, "event", "visibilitychange");
+    __publicField(this, "timeoutHandler");
+    __publicField(this, "options");
+    __publicField(this, "defaultOptions", {
+      timeout: 5e3,
+      once: false,
+      immediate: true,
+      ssr: false
+    });
+    __publicField(this, "isVisible", false);
+    this.callback = callback;
+    this.options = {
+      ...this.defaultOptions,
+      ...options
+    };
+    this.eventHandlerFunction = this.eventHandler.bind(this);
+    if (!this.options.ssr && isClient()) {
+      this.start();
+    } else if (!this.options.ssr && !isClient()) {
+      console.warn(
+        `[UserVisibility](constructor) executed on server side - set "ssr" option to "false"`
+      );
+    }
+  }
+  start() {
+    if (!isClient()) {
+      console.warn(
+        `[UserVisibility](start) you should run this method on client side`
+      );
+      return;
+    }
+    if (this.options.immediate) {
+      this.emitCallback();
+    }
+    this.addEventListener();
+  }
+  emitCallback() {
+    this.isVisible = document.visibilityState === "visible";
+    this.callback({ isVisible: this.isVisible });
+    if (this.options.once) {
+      this.destroy();
+    }
+  }
+  eventHandler() {
+    if (document.visibilityState === "visible" && !this.isVisible) {
+      this.clearTimeout();
+      this.emitCallback();
+    } else if (document.visibilityState === "hidden") {
+      this.initTimeout();
+    }
+  }
+  clearTimeout() {
+    if (this.timeoutHandler) {
+      clearTimeout(this.timeoutHandler);
+      this.timeoutHandler = void 0;
+    }
+  }
+  initTimeout() {
+    this.clearTimeout();
+    this.timeoutHandler = setTimeout(
+      this.emitCallback.bind(this),
+      this.options.timeout
+    );
+  }
+  addEventListener() {
+    document.addEventListener(this.event, this.eventHandlerFunction);
+  }
+  removeEventListener() {
+    document.removeEventListener(this.event, this.eventHandlerFunction);
+  }
+  destroy() {
+    this.removeEventListener();
+    if (this.timeoutHandler) {
+      clearTimeout(this.timeoutHandler);
+    }
+  }
+}
+const sleep$1 = (duration) => {
+  return new Promise((resolve) => {
+    setTimeout(resolve, duration);
+  });
+};
+const UNIQUE_ID = "__vue_click_away__";
+const getEventType$1 = () => {
+  return document.ontouchstart === null ? "touchstart" : "click";
+};
+const onMounted = async (el, binding) => {
+  onUnmounted(el);
+  const vm = binding.instance;
+  const callback = binding.value;
+  const isCallbackFunction = typeof callback === "function";
+  if (!isCallbackFunction) {
+    throw new Error("[maz-ui](vClickOutside) the callback should be a function");
+  }
+  await nextTick();
+  el[UNIQUE_ID] = (event) => {
+    if ((!el || !el.contains(event.target)) && callback && isCallbackFunction) {
+      return callback.call(vm, event);
+    }
+  };
+  const eventType = getEventType$1();
+  document.addEventListener(eventType, el[UNIQUE_ID], false);
+};
+const onUnmounted = (el) => {
+  const eventType = getEventType$1();
+  document.removeEventListener(eventType, el[UNIQUE_ID], false);
+  delete el[UNIQUE_ID];
+};
+const onUpdated = (el, binding) => {
+  if (binding.value === binding.oldValue) {
+    return;
+  }
+  onMounted(el, binding);
+};
+const directive$1 = {
+  mounted: onMounted,
+  updated: onUpdated,
+  unmounted: onUnmounted
+};
+const plugin$6 = {
+  install: (app) => {
+    app.directive("click-outside", directive$1);
+  }
+};
+const handleOutsideClick = (event, element, binding, vnode) => {
+  event.stopPropagation();
+  const { handler: handler2, exclude } = binding.value;
+  let clickedOnExcludedElement = false;
+  if (exclude && exclude.length > 0) {
+    for (const referenceName of exclude) {
+      if (!clickedOnExcludedElement) {
+        const excludedElement = vnode.context.$refs[referenceName];
+        clickedOnExcludedElement = excludedElement.contains(event.target);
+      }
+    }
+  }
+  if (!element.contains(event.target) && !clickedOnExcludedElement) {
+    vnode.context[handler2]();
+  }
+};
+const getEventType = () => {
+  return document.ontouchstart === null ? "touchstart" : "click";
+};
+const unbind = (element, binding, vnode) => {
+  const eventType = getEventType();
+  document.removeEventListener(
+    eventType,
+    (event) => handleOutsideClick(event, element, binding, vnode)
+  );
+};
+const bind = (element, binding, vnode) => {
+  const eventType = getEventType();
+  document.addEventListener(
+    eventType,
+    (event) => handleOutsideClick(event, element, binding, vnode)
+  );
+};
+const directive = {
+  mounted: bind,
+  unmounted: unbind
+};
+const plugin$5 = {
+  install: (app) => {
+    app.directive("closable", directive);
+  }
+};
+const style = `
+.maz-zoom-img {
+  position: fixed;
+  top: 0;
+  bottom: 0;
+  left: 0;
+  right: 0;
+  padding: 2.5rem;
+  z-index: 1050;
+  background-color: hsla(238, 15%, 40%, 0.7);
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  flex-direction: column;
+}
+
+.maz-zoom-img,
+.maz-zoom-img * {
+  box-sizing: border-box;
+}
+
+.maz-zoom-img .maz-zoom-img__wrapper {
+  position: relative;
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  min-width: 0;
+  min-height: 0;
+  max-width: 100%;
+  max-height: 100%;
+  transition: all 300ms ease-in-out;
+  opacity: 0;
+  transform: scale(0.5);
+}
+
+.maz-zoom-img.maz-animate .maz-zoom-img__wrapper {
+  opacity: 1;
+  transform: scale(1);
+}
+
+.maz-zoom-img.maz-animate .maz-zoom-img__loader {
+  position: absolute;
+  top: 0;
+  bottom: 0;
+  left: 0;
+  right: 0;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  background-color: hsla(238, 15%, 40%, 0.7);
+  border-radius: 1rem;
+  z-index: 2;
+  min-width: 60px;
+  min-height: 60px;
+}
+.maz-zoom-img.maz-animate .maz-zoom-img__loader[hidden] {
+  display: none;
+}
+
+@-webkit-keyframes spin {
+  0% { transform: rotate(0deg); }
+  100% { transform: rotate(360deg); }
+}
+
+@keyframes spin {
+  0% { transform: rotate(0deg); }
+  100% { transform: rotate(360deg); }
+}
+
+.maz-zoom-img.maz-animate .maz-zoom-img__loader__svg {
+  animation: spin .6s linear infinite;
+}
+
+.maz-zoom-img img {
+  max-width: 100%;
+  max-height: 100%;
+  min-width: 0;
+  border-radius: 1rem;
+}
+
+.maz-zoom-img .maz-zoom-btn {
+  margin: 0 auto;
+  border: none;
+  background-color: hsla(0, 0%, 7%, 0.5);
+  box-shadow: 0 0 0.5rem 0 hsla(0, 0%, 0%, 0.2);
+  height: 2.2rem;
+  min-height: 2.2rem;
+  width: 2.2rem;
+  min-width: 2.2rem;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  border-radius: 2.2rem;
+  cursor: pointer;
+  flex: 0 0 auto;
+  outline: none;
+}
+
+.maz-zoom-img .maz-zoom-btn svg {
+  fill: white;
+}
+
+.maz-zoom-img .maz-zoom-btn.maz-zoom-btn--close {
+  position: absolute;
+  top: 0.5rem;
+  right: 0.5rem;
+  z-index: 1;
+}
+
+.maz-zoom-img .maz-zoom-btn.maz-zoom-btn--previous {
+  position: absolute;
+  left: 0.5rem;
+  z-index: 1;
+}
+
+.maz-zoom-img .maz-zoom-btn.maz-zoom-btn--next {
+  position: absolute;
+  right: 0.5rem;
+  z-index: 1;
+}
+
+.maz-zoom-img .maz-zoom-btn:hover {
+  background-color: hsl(0, 0%, 0%);
+}`;
+const svgs = {
+  close: '<svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24"><path d="M0 0h24v24H0z" fill="none"/><path d="M19 6.41L17.59 5 12 10.59 6.41 5 5 6.41 10.59 12 5 17.59 6.41 19 12 13.41 17.59 19 19 17.59 13.41 12z"/></svg>',
+  next: '<svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24"><path d="M0 0h24v24H0z" fill="none"/><path d="M10 6L8.59 7.41 13.17 12l-4.58 4.59L10 18l6-6z"/></svg>',
+  previous: '<svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24"><path d="M0 0h24v24H0z" fill="none"/><path d="M15.41 7.41L14 6l-6 6 6 6 1.41-1.41L10.83 12z"/></svg>',
+  spinner: '<svg width="40px" height="40px" version="1.1" xmlns="http://www.w3.org/2000/svg" fill="currentColor" x="0px" y="0px" viewBox="0 0 50 50" xml:space="preserve" class="maz-zoom-img__loader__svg" data-v-6d1cb50c=""><path d="M43.935,25.145c0-10.318-8.364-18.683-18.683-18.683c-10.318,0-18.683,8.365-18.683,18.683h4.068c0-8.071,6.543-14.615,14.615-14.615c8.072,0,14.615,6.543,14.615,14.615H43.935z"></path></svg>'
+};
+class VueZoomImg {
+  constructor(binding) {
+    __publicField(this, "options");
+    __publicField(this, "loader");
+    __publicField(this, "wrapper");
+    __publicField(this, "img");
+    __publicField(this, "keydownHandler");
+    __publicField(this, "onImgLoadedCallback");
+    __publicField(this, "buttonsAdded");
+    __publicField(this, "defaultOptions", {
+      scale: true,
+      blur: true,
+      disabled: false
+    });
+    __publicField(this, "mouseEnterListener");
+    __publicField(this, "mouseLeaveListener");
+    __publicField(this, "renderPreviewListener");
+    if (!binding.value) {
+      throw new Error(
+        '[MazUI](zoom-img) Image path must be defined. Ex: `v-zoom-img="<PATH_TO_IMAGE>"`'
+      );
+    }
+    if (typeof binding.value === "object" && !binding.value.src) {
+      throw new Error("[maz-ui](zoom-img) src of image must be provided");
+    }
+    this.buttonsAdded = false;
+    this.options = this.buildOptions(binding);
+    this.keydownHandler = this.keydownLister.bind(this);
+    this.loader = this.getLoader();
+    this.wrapper = document.createElement("div");
+    this.wrapper.classList.add("maz-zoom-img__wrapper");
+    this.wrapper.prepend(this.loader);
+    this.img = document.createElement("img");
+    this.onImgLoadedCallback = this.onImgLoaded.bind(this);
+    this.imgEventHandler(true);
+  }
+  buildOptions(binding) {
+    return {
+      ...this.defaultOptions,
+      ...typeof binding.value === "object" ? binding.value : { src: binding.value }
+    };
+  }
+  get allInstances() {
+    return [
+      ...document.querySelectorAll(".maz-zoom-img-instance")
+    ];
+  }
+  create(el) {
+    if (this.options.disabled)
+      return;
+    el.style.cursor = "pointer";
+    setTimeout(() => el.classList.add("maz-zoom-img-instance"));
+    el.setAttribute("data-src", this.options.src);
+    if (this.options.alt)
+      el.setAttribute("data-alt", this.options.alt);
+    el.style.transition = "all 300ms ease-in-out";
+    this.mouseEnterListener = () => this.mouseEnter(el);
+    this.mouseLeaveListener = () => this.mouseLeave(el);
+    this.renderPreviewListener = () => this.renderPreview(el, this.options);
+    el.addEventListener("mouseenter", this.mouseEnterListener);
+    el.addEventListener("mouseleave", this.mouseLeaveListener);
+    el.addEventListener("click", this.renderPreviewListener);
+  }
+  update(binding) {
+    this.options = this.buildOptions(binding);
+  }
+  remove(el) {
+    this.imgEventHandler(false);
+    el.removeEventListener("mouseenter", this.mouseEnterListener);
+    el.removeEventListener("mouseleave", this.mouseLeaveListener);
+    el.removeEventListener("click", this.renderPreviewListener);
+    el.classList.remove("maz-zoom-img-instance");
+    el.removeAttribute("data-src");
+    el.removeAttribute("data-alt");
+    el.style.cursor = "";
+  }
+  renderPreview(el, options) {
+    el.classList.add("maz-is-open");
+    this.addStyle(style);
+    const container = document.createElement("div");
+    container.classList.add("maz-zoom-img");
+    container.setAttribute("id", "MazImgPreviewFullsize");
+    container.addEventListener("click", (e) => {
+      if (container.isEqualNode(e.target)) {
+        this.closePreview();
+      }
+    });
+    if (typeof options === "object") {
+      this.img.setAttribute("src", options.src);
+      if (options.alt)
+        this.img.setAttribute("alt", options.alt);
+      this.img.id = "MazImgElement";
+    }
+    this.wrapper.append(this.img);
+    container.append(this.wrapper);
+    document.body.append(container);
+    this.keyboardEventHandler(true);
+    setTimeout(() => {
+      if (container)
+        container.classList.add("maz-animate");
+    }, 100);
+  }
+  onImgLoaded() {
+    this.wrapper.style.width = `${this.img.width}px`;
+    this.wrapper.style.minWidth = `200px`;
+    this.loader.hidden = true;
+    const closeButton = this.getButton();
+    const buttons = [];
+    const hasMultipleInstance = this.allInstances.length > 1;
+    if (!this.buttonsAdded) {
+      this.buttonsAdded = true;
+      if (hasMultipleInstance) {
+        const previousButton = this.getButton("previous");
+        const nextButton = this.getButton("next");
+        buttons.push(previousButton, nextButton);
+      }
+      this.wrapper.append(closeButton);
+      if (hasMultipleInstance) {
+        this.wrapper.prepend(buttons[0]);
+        this.wrapper.append(buttons[1]);
+      }
+    }
+  }
+  getLoader() {
+    const loader = document.createElement("div");
+    loader.classList.add("maz-zoom-img__loader");
+    loader.innerHTML = svgs.spinner;
+    return loader;
+  }
+  mouseLeave(el) {
+    if (this.options.scale)
+      el.style.transform = "";
+    if (this.options.blur)
+      el.style.filter = "";
+    el.style.zIndex = "";
+  }
+  mouseEnter(el) {
+    el.style.zIndex = "1";
+    if (this.options.scale)
+      el.style.transform = "scale(1.1)";
+    if (this.options.blur)
+      el.style.filter = "blur(2px)";
+  }
+  keydownLister(e) {
+    e.preventDefault();
+    if (e.key === "Escape" || e.key === " ") {
+      this.closePreview();
+    }
+    if (e.key === "ArrowLeft" || e.key === "ArrowRight") {
+      this.nextPreviousImage(e.key === "ArrowRight");
+    }
+  }
+  getButton(iconName = "close") {
+    const button = document.createElement("button");
+    button.innerHTML = svgs[iconName];
+    button.addEventListener("click", () => {
+      iconName === "close" ? this.closePreview() : this.allInstances ? this.nextPreviousImage(iconName === "next") : null;
+    });
+    button.classList.add("maz-zoom-btn");
+    button.classList.add(`maz-zoom-btn--${iconName}`);
+    return button;
+  }
+  closePreview() {
+    const container = document.querySelector(
+      "#MazImgPreviewFullsize"
+    );
+    const style2 = document.querySelector("#MazPreviewStyle");
+    const instance2 = document.querySelector(
+      ".maz-zoom-img-instance.maz-is-open"
+    );
+    if (instance2)
+      instance2.classList.remove("maz-is-open");
+    if (container)
+      container.classList.remove("maz-animate");
+    this.keyboardEventHandler(false);
+    setTimeout(() => {
+      if (container)
+        container.remove();
+      if (style2)
+        style2.remove();
+    }, 300);
+  }
+  getNewInstanceIndex(newInstanceIndex) {
+    return newInstanceIndex < 0 ? this.allInstances.length - 1 : newInstanceIndex >= this.allInstances.length ? 0 : newInstanceIndex;
+  }
+  nextPreviousImage(isNext) {
+    const selectNextInstance = isNext;
+    const currentInstance = document.querySelector(
+      ".maz-zoom-img-instance.maz-is-open"
+    );
+    if (currentInstance) {
+      const currentInstanceIndex = this.allInstances.indexOf(currentInstance);
+      const newInstanceIndex = selectNextInstance ? currentInstanceIndex + 1 : currentInstanceIndex - 1;
+      const nextInstance = this.allInstances[this.getNewInstanceIndex(newInstanceIndex)];
+      if (nextInstance) {
+        this.useNextInstance(currentInstance, nextInstance);
+      }
+    }
+  }
+  useNextInstance(currentInstance, nextInstance) {
+    currentInstance.classList.remove("maz-is-open");
+    nextInstance.classList.add("maz-is-open");
+    const src = nextInstance.getAttribute("data-src");
+    const alt = nextInstance.getAttribute("data-alt");
+    this.wrapper.style.width = "";
+    this.loader.hidden = false;
+    if (src)
+      this.img.setAttribute("src", src);
+    if (alt)
+      this.img.setAttribute("alt", alt);
+  }
+  addStyle(styleString) {
+    const style2 = document.createElement("style");
+    style2.id = "MazPreviewStyle";
+    style2.textContent = styleString;
+    document.head.append(style2);
+  }
+  keyboardEventHandler(add) {
+    if (add)
+      return document.addEventListener("keydown", this.keydownHandler);
+    document.removeEventListener("keydown", this.keydownHandler);
+  }
+  imgEventHandler(add) {
+    if (add)
+      return this.img.addEventListener("load", this.onImgLoadedCallback);
+    this.img.removeEventListener("load", this.onImgLoadedCallback);
+  }
+}
+let instance$4;
+const vZoomImg = {
+  created(el, binding) {
+    instance$4 = new VueZoomImg(binding);
+    instance$4.create(el);
+  },
+  updated(_el, binding) {
+    instance$4.update(binding);
+  },
+  unmounted(el) {
+    instance$4.remove(el);
+  }
+};
+const plugin$4 = {
+  install(app) {
+    app.directive("zoom-img", vZoomImg);
+  }
+};
+const EMPTY_PHOTO = "data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7";
+const DEFAULT_OPTIONS$5 = {
+  baseClass: "m-lazy-img",
+  loadedClass: "m-lazy-loaded",
+  loadingClass: "m-lazy-loading",
+  errorClass: "m-lazy-error",
+  noPhotoClass: "m-lazy-no-photo",
+  noPhoto: false,
+  observerOnce: true,
+  loadOnce: false,
+  noUseErrorPhoto: false,
+  observerOptions: {
+    threshold: 0.1
+  }
+};
+class LazyImg {
+  constructor(opts = {}) {
+    __publicField(this, "observers", []);
+    __publicField(this, "defaultOptions", DEFAULT_OPTIONS$5);
+    __publicField(this, "options");
+    __publicField(this, "onImgLoadedCallback");
+    __publicField(this, "onImgErrorCallback");
+    __publicField(this, "hasImgLoaded", false);
+    this.options = this.buildOptions(opts);
+    this.onImgLoadedCallback = this.imageIsLoaded.bind(this);
+    this.onImgErrorCallback = this.imageHasError.bind(this);
+  }
+  async loadErrorPhoto() {
+    const { default: photo } = await import("./no_photo-410a8f01.mjs");
+    return photo;
+  }
+  buildOptions(opts) {
+    return {
+      ...this.defaultOptions,
+      ...opts,
+      observerOptions: {
+        ...this.defaultOptions.observerOptions,
+        ...opts.observerOptions
+      }
+    };
+  }
+  removeClass(el, className) {
+    el.classList.remove(className);
+  }
+  addClass(el, className) {
+    el.classList.add(className);
+  }
+  removeAllStateClasses(el) {
+    this.removeClass(el, this.options.loadedClass);
+    this.removeClass(el, this.options.loadingClass);
+    this.removeClass(el, this.options.errorClass);
+    this.removeClass(el, this.options.noPhotoClass);
+  }
+  setBaseClass(el) {
+    this.addClass(el, this.options.baseClass);
+  }
+  imageIsLoading(el) {
+    var _a, _b;
+    this.addClass(el, this.options.loadingClass);
+    (_b = (_a = this.options).onLoading) == null ? void 0 : _b.call(_a, el);
+  }
+  imageHasNoPhoto(el) {
+    this.removeClass(el, this.options.loadingClass);
+    this.addClass(el, this.options.noPhotoClass);
+    this.setDefaultPhoto(el);
+  }
+  imageIsLoaded(el) {
+    var _a, _b;
+    this.hasImgLoaded = true;
+    this.removeClass(el, this.options.loadingClass);
+    this.addClass(el, this.options.loadedClass);
+    (_b = (_a = this.options).onLoaded) == null ? void 0 : _b.call(_a, el);
+  }
+  imageHasError(el, event) {
+    var _a, _b;
+    console.warn(`[maz-ui][MazLazyImg] Error while loading image`, event);
+    this.removeClass(el, this.options.loadingClass);
+    this.addClass(el, this.options.errorClass);
+    (_b = (_a = this.options).onError) == null ? void 0 : _b.call(_a, el);
+    this.setDefaultPhoto(el);
+  }
+  getImageUrl(el, binding) {
+    const dataSrc = this.getImgElement(el).getAttribute("data-src");
+    if (dataSrc)
+      return dataSrc;
+    const bindingSrc = typeof binding.value === "object" ? binding.value.src : binding.value;
+    if (!bindingSrc)
+      console.warn(`[maz-ui][MazLazyImg] src url is not defined`);
+    return bindingSrc;
+  }
+  async setPictureSourceUrls(el) {
+    const sourceElements = el.querySelectorAll("source");
+    if (sourceElements.length > 0) {
+      for await (const source of sourceElements) {
+        const srcSet = source.getAttribute("data-srcset");
+        if (srcSet) {
+          source.srcset = srcSet;
+        } else {
+          console.warn(
+            '[maz-ui][MazLazyImg] the "[data-srcset]" attribute is not provided on "<source />"'
+          );
+        }
+      }
+    } else {
+      console.warn(
+        '[maz-ui][MazLazyImg] No "<source />" elements provided into the "<picture />" element'
+      );
+      this.imageHasError(el);
+    }
+  }
+  hasBgImgMode(binding) {
+    return binding.arg === "bg-image";
+  }
+  isPictureElement(el) {
+    return el instanceof HTMLPictureElement;
+  }
+  getImgElement(el) {
+    const isPictureElement = this.isPictureElement(el);
+    return isPictureElement ? el.querySelector("img") : el;
+  }
+  async setDefaultPhoto(el) {
+    if (this.options.noUseErrorPhoto)
+      return;
+    const errorPhoto = this.options.errorPhoto ?? await this.loadErrorPhoto();
+    const sourceElements = el.querySelectorAll("source");
+    if (sourceElements.length > 0) {
+      for await (const source of sourceElements) {
+        source.srcset = errorPhoto;
+      }
+    } else {
+      this.setImgSrc(el, errorPhoto);
+    }
+  }
+  addEventListenerToImg(el) {
+    const imgElement = this.getImgElement(el);
+    imgElement.addEventListener("load", () => this.onImgLoadedCallback(el), {
+      once: true
+    });
+    imgElement.addEventListener(
+      "error",
+      (err) => this.onImgErrorCallback(el, err),
+      { once: true }
+    );
+  }
+  async loadImage(el, binding) {
+    this.imageIsLoading(el);
+    if (this.isPictureElement(el)) {
+      this.addEventListenerToImg(el);
+      await this.setPictureSourceUrls(el);
+    } else {
+      const imageUrl = this.getImageUrl(el, binding);
+      if (!imageUrl)
+        return this.imageHasError(el);
+      if (this.hasBgImgMode(binding)) {
+        el.style.backgroundImage = `url('${imageUrl}')`;
+        this.imageIsLoaded(el);
+      } else {
+        this.addEventListenerToImg(el);
+        this.setImgSrc(el, imageUrl);
+      }
+    }
+  }
+  setImgSrc(el, src) {
+    const imgElement = this.getImgElement(el);
+    imgElement.src = src;
+  }
+  handleIntersectionObserver(el, binding, entries, observer) {
+    var _a, _b;
+    this.observers.push(observer);
+    for (const entry of entries) {
+      if (entry.isIntersecting) {
+        (_b = (_a = this.options).onIntersecting) == null ? void 0 : _b.call(_a, entry.target);
+        if (this.options.observerOnce) {
+          observer.unobserve(el);
+        }
+        if (this.options.loadOnce && this.hasImgLoaded)
+          return;
+        this.loadImage(el, binding);
+      }
+    }
+  }
+  createObserver(el, binding) {
+    const observerCallback = (entries, intersectionObserver) => {
+      this.handleIntersectionObserver(
+        el,
+        binding,
+        entries,
+        intersectionObserver
+      );
+    };
+    const observerOptions = this.options.observerOptions;
+    const observer = new IntersectionObserver(observerCallback, observerOptions);
+    observer.observe(el);
+  }
+  async imageHandler(el, binding, type) {
+    if (type === "update") {
+      for await (const observer of this.observers)
+        observer.unobserve(el);
+    }
+    if (window.IntersectionObserver) {
+      this.createObserver(el, binding);
+    } else {
+      this.loadImage(el, binding);
+    }
+  }
+  async bindUpdateHandler(el, binding, type) {
+    if (this.options.noPhoto)
+      return this.imageHasNoPhoto(el);
+    await this.imageHandler(el, binding, type);
+  }
+  async add(el, binding) {
+    if (this.hasBgImgMode(binding) && this.isPictureElement(el)) {
+      throw new Error(
+        `[MazLazyImg] You can't use the "bg-image" mode with "<picture />" element`
+      );
+    }
+    setTimeout(() => this.setBaseClass(el), 0);
+    if (!el.getAttribute("src"))
+      this.setImgSrc(el, EMPTY_PHOTO);
+    await this.bindUpdateHandler(el, binding, "bind");
+  }
+  async update(el, binding) {
+    if (binding.value !== binding.oldValue) {
+      this.hasImgLoaded = false;
+      this.removeAllStateClasses(el);
+      await this.bindUpdateHandler(el, binding, "update");
+    }
+  }
+  remove(el, binding) {
+    this.hasImgLoaded = false;
+    if (this.hasBgImgMode(binding))
+      el.style.backgroundImage = "";
+    this.removeAllStateClasses(el);
+    for (const observer of this.observers)
+      observer.unobserve(el);
+    this.observers = [];
+  }
+}
+let instance$3;
+const vLazyImg = {
+  created(el, binding) {
+    const options = typeof binding.value === "object" ? binding.value : {};
+    instance$3 = new LazyImg(options);
+    instance$3.add(el, binding);
+  },
+  updated(el, binding) {
+    instance$3.update(el, binding);
+  },
+  unmounted(el, binding) {
+    instance$3.remove(el, binding);
+  }
+};
+const DIRECTIVE_NAME = "lazy-img";
+const plugin$3 = {
+  install(app, opts = {}) {
+    const options = {
+      ...DEFAULT_OPTIONS$5,
+      ...opts,
+      observerOptions: {
+        ...DEFAULT_OPTIONS$5.observerOptions,
+        ...opts.observerOptions
+      }
+    };
+    const instance2 = new LazyImg(options);
+    app.directive(DIRECTIVE_NAME, {
+      created: instance2.add.bind(instance2),
+      updated: instance2.update.bind(instance2),
+      unmounted: instance2.remove.bind(instance2)
+    });
+  }
+};
+const directives = [
+  {
+    name: "click-outside",
+    directive: directive$1
+  },
+  {
+    name: "closable",
+    directive
+  },
+  {
+    name: "zoom-img",
+    directive: vZoomImg
+  },
+  {
+    name: "lazy-img",
+    directive: vLazyImg
+  }
+];
+const installDirectives = {
+  install(app) {
+    for (const { name, directive: directive2 } of directives) {
+      app.directive(name, directive2);
+    }
+  }
+};
+const capitalize = (value) => {
+  if (!value)
+    return "";
+  value = value.toString();
+  return value.charAt(0).toUpperCase() + value.slice(1);
+};
+const DEFAULT_OPTIONS$4 = {
+  style: "currency",
+  minimumFractionDigits: 2,
+  round: false
+};
+const getFormattedCurrency = (number2, locale, options) => {
+  let numberToFormat = Number(number2);
+  if (options.round) {
+    numberToFormat = Math.floor(numberToFormat);
+    options.minimumFractionDigits = 0;
+  }
+  return new Intl.NumberFormat(locale, options).format(numberToFormat);
+};
+const validRequiredAttributes = (number2, locale, options) => {
+  if (number2 === void 0)
+    throw new TypeError(
+      "[maz-ui](FilterCurrency) The `number` attribute is required."
+    );
+  if (locale === void 0)
+    throw new TypeError(
+      "[maz-ui](FilterCurrency) The `locale` attribute is required."
+    );
+  if (typeof locale !== "string")
+    throw new TypeError(
+      "[maz-ui](FilterCurrency) The `locale` attribute must be a string."
+    );
+  if (options.currency === void 0)
+    throw new TypeError(
+      "[maz-ui](FilterCurrency) The `options.currency` attribute is required."
+    );
+};
+const currency = (number2, locale, options) => {
+  const options_ = {
+    ...DEFAULT_OPTIONS$4,
+    ...options
+  };
+  validRequiredAttributes(number2, locale, options_);
+  try {
+    return getFormattedCurrency(number2, locale, options_);
+  } catch (error) {
+    throw new Error(`[maz-ui](FilterCurrency) ${error}`);
+  }
+};
+const DEFAULT_OPTIONS$3 = {
+  month: "short",
+  day: "numeric",
+  year: "numeric"
+};
+const date = (date2, locale, options) => {
+  if (locale === void 0) {
+    throw new TypeError(
+      "[maz-ui](FilterDate) The `locale` attribute is required."
+    );
+  }
+  if (typeof locale !== "string") {
+    throw new TypeError(
+      "[maz-ui](FilterDate) The `locale` attribute must be a string."
+    );
+  }
+  const opts = options ?? DEFAULT_OPTIONS$3;
+  try {
+    const usedDate = date2 instanceof Date ? date2 : new Date(date2);
+    return new Intl.DateTimeFormat(locale, opts).format(usedDate);
+  } catch (error) {
+    throw new Error(`[maz-ui](FilterDate) ${error}`);
+  }
+};
+const DEFAULT_OPTIONS$2 = {
+  minimumFractionDigits: 2
+};
+const number = (number2, locale, options) => {
+  options = {
+    ...DEFAULT_OPTIONS$2,
+    ...options
+  };
+  if (number2 === void 0)
+    throw new TypeError(
+      "[maz-ui](FilterNumber) The `number` attribute is required."
+    );
+  if (locale === void 0)
+    throw new TypeError(
+      "[maz-ui](FilterNumber) The `locale` attribute is required."
+    );
+  if (typeof locale !== "string")
+    throw new TypeError(
+      "[maz-ui](FilterNumber) The `locale` attribute must be a string."
+    );
+  try {
+    return new Intl.NumberFormat(locale, options).format(Number(number2));
+  } catch (error) {
+    throw new Error(`[maz-ui](FilterNumber) ${error}`);
+  }
+};
+const filters = {
+  capitalize,
+  currency,
+  date,
+  number
+};
+const installFilters = {
+  install(app) {
+    app.provide("filters", filters);
+  }
+};
+class ToasterTimer {
+  constructor(callback, delay) {
+    __publicField(this, "callback");
+    __publicField(this, "delay");
+    __publicField(this, "timer");
+    __publicField(this, "startedAt");
+    this.startedAt = Date.now();
+    this.callback = callback;
+    this.delay = delay;
+    this.start();
+  }
+  pause() {
+    this.stop();
+    this.delay -= Date.now() - this.startedAt;
+  }
+  resume() {
+    this.startedAt = Date.now();
+    this.start();
+  }
+  start() {
+    this.timer = setTimeout(this.callback, this.delay);
+  }
+  stop() {
+    clearTimeout(this.timer);
+  }
+}
+const _hoisted_1$1 = ["innerHTML"];
+const _sfc_main$1 = /* @__PURE__ */ defineComponent({
+  __name: "MazIcon",
+  props: {
+    src: { type: String, default: void 0 },
+    path: { type: String, default: void 0 },
+    name: { type: String, default: void 0 },
+    size: { type: String, default: "1.5rem" },
+    title: { type: String, default: void 0 },
+    transformSource: {
+      type: Function,
+      default: (svg) => svg
+    }
+  },
+  emits: ["loaded", "unloaded", "error"],
+  setup(__props, { emit: emits }) {
+    const props = __props;
+    const cache = {};
+    const svgElSource = ref();
+    const svgElem = ref();
+    const getMazIconPath = () => {
+      try {
+        return injectStrict("mazIconPath");
+      } catch {
+        return void 0;
+      }
+    };
+    const iconPath = computed(() => props.path ?? getMazIconPath());
+    const fullSrc = computed(() => {
+      if (props.src) {
+        return props.src;
+      } else if (iconPath.value) {
+        return `${iconPath.value}/${props.name}.svg`;
+      } else {
+        return `/${props.name}.svg`;
+      }
+    });
+    onMounted$1(() => {
+      if (!props.name && !props.src) {
+        console.error(
+          '[maz-ui](MazIcon) you should provide "name" or "src" as prop'
+        );
+      }
+    });
+    const setTitle = (svg, title) => {
+      const titleTags = svg.querySelectorAll("title");
+      if (titleTags.length > 0) {
+        titleTags[0].textContent = title;
+      } else {
+        const titleEl = document.createElementNS(
+          "http://www.w3.org/2000/svg",
+          "title"
+        );
+        titleEl.textContent = title;
+        svg.append(titleEl);
+      }
+    };
+    const filterAttrs = (attrs) => {
+      return Object.keys(attrs).reduce((result, key) => {
+        if (attrs[key] !== false && attrs[key] !== null && attrs[key] !== void 0) {
+          result[key] = attrs[key];
+        }
+        return result;
+      }, {});
+    };
+    const getSvgAttrs = (svgEl) => {
+      const svgAttrs = {};
+      const attrs = svgEl.attributes;
+      if (!attrs) {
+        return svgAttrs;
+      }
+      for (let i = attrs.length - 1; i >= 0; i--) {
+        svgAttrs[attrs[i].name] = attrs[i].value;
+      }
+      return svgAttrs;
+    };
+    const getSvgContent = (svgEl) => {
+      let svgElNode = svgEl.cloneNode(true);
+      svgElNode = props.transformSource(svgEl);
+      if (props.title) {
+        setTitle(svgElNode, props.title);
+      }
+      return svgEl.innerHTML;
+    };
+    const getSource = async (src) => {
+      if (!cache[src]) {
+        cache[src] = download(src);
+      }
+      try {
+        svgElSource.value = await cache[src];
+        await nextTick();
+        emits("loaded", svgElem.value);
+      } catch (error) {
+        if (svgElSource.value) {
+          svgElSource.value = void 0;
+          emits("unloaded");
+        }
+        delete cache[src];
+        emits("error", error);
+      }
+    };
+    const download = (url) => {
+      return new Promise((resolve, reject) => {
+        const request = new XMLHttpRequest();
+        request.open("GET", url, true);
+        request.addEventListener("load", () => {
+          if (request.status >= 200 && request.status < 400) {
+            try {
+              const parser = new DOMParser();
+              const result = parser.parseFromString(
+                request.responseText,
+                "text/xml"
+              );
+              let svgEl = result.querySelectorAll("svg")[0];
+              if (svgEl) {
+                svgEl = props.transformSource(svgEl);
+                resolve(svgEl);
+              } else {
+                reject(new Error('Loaded file is not valid SVG"'));
+              }
+            } catch (error) {
+              reject(error);
+            }
+          } else {
+            reject(new Error("Error loading SVG"));
+          }
+        });
+        request.addEventListener("error", () => reject());
+        request.send();
+      });
+    };
+    watchEffect(() => getSource(fullSrc.value));
+    return (_ctx, _cache) => {
+      return svgElSource.value ? (openBlock(), createElementBlock("svg", mergeProps({
+        key: 0,
+        ref_key: "svgElem",
+        ref: svgElem,
+        width: "1em",
+        height: "1em"
+      }, {
+        ...getSvgAttrs(svgElSource.value),
+        ...filterAttrs(_ctx.$attrs)
+      }, {
+        style: `font-size: ${__props.size}`,
+        innerHTML: getSvgContent(svgElSource.value)
+      }), null, 16, _hoisted_1$1)) : createCommentVNode("", true);
+    };
+  }
+});
+const XIcon = "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIGZpbGw9Im5vbmUiIHZpZXdCb3g9IjAgMCAyNCAyNCIgc3Ryb2tlPSJjdXJyZW50Q29sb3IiIGFyaWEtaGlkZGVuPSJ0cnVlIj4KICA8cGF0aCBzdHJva2UtbGluZWNhcD0icm91bmQiIHN0cm9rZS1saW5lam9pbj0icm91bmQiIHN0cm9rZS13aWR0aD0iMiIgZD0iTTYgMThMMTggNk02IDZsMTIgMTIiLz4KPC9zdmc+Cg==";
+const _hoisted_1 = { class: "m-toast__message-wrapper" };
+const _hoisted_2 = { class: "m-toast__message" };
+const _hoisted_3 = {
+  key: 0,
+  class: "--close"
+};
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "MazToast",
+  props: {
+    position: {
+      type: String,
+      default: "bottom-right"
+    },
+    maxToasts: { type: [Number, Boolean], default: false },
+    timeout: { type: Number, default: 1e4 },
+    queue: { type: Boolean, default: false },
+    noPauseOnHover: { type: Boolean, default: false },
+    type: {
+      type: String,
+      default: "info",
+      validator: (value) => {
+        return ["info", "success", "warning", "danger"].includes(value);
+      }
+    },
+    message: { type: String, required: true },
+    persistent: { type: Boolean, default: false }
+  },
+  emits: ["close", "click"],
+  setup(__props, { emit: emits }) {
+    const props = __props;
+    const Toaster = ref();
+    const positionY = computed(
+      () => props.position.includes("top") ? "top" : "bottom"
+    );
+    const positionX = computed(() => {
+      if (props.position.includes("left"))
+        return "left";
+      if (props.position.includes("right"))
+        return "right";
+      return "center";
+    });
+    const transitionName = computed(() => {
+      if (positionX.value !== "center") {
+        return positionX.value === "right" ? "m-slide-right" : "m-slide-left";
+      }
+      return positionY.value === "top" ? "m-slide-top" : "m-slide-bottom";
+    });
+    const isActive = ref(false);
+    const timer = ref();
+    const queueTimer = ref();
+    const containerClassName = `m-toast-container --${positionY.value} --${positionX.value}`;
+    const selectorContainerClass = `.${containerClassName.replaceAll(" ", ".")}`;
+    const createParents = () => {
+      const container = document.querySelector(selectorContainerClass);
+      if (container)
+        return;
+      if (!container) {
+        const body = document.body;
+        const toCreate = document.createElement("div");
+        toCreate.className = containerClassName;
+        body.append(toCreate);
+      }
+    };
+    const shouldQueue = () => {
+      const container = document.querySelector(selectorContainerClass);
+      if (!props.queue && props.maxToasts === false) {
+        return false;
+      }
+      if (props.maxToasts !== false && container) {
+        return props.maxToasts <= container.childElementCount;
+      }
+      return container && container.childElementCount > 0;
+    };
+    const showNotice = () => {
+      if (shouldQueue()) {
+        queueTimer.value = setTimeout(showNotice, 250);
+        return;
+      }
+      const container = document.querySelector(selectorContainerClass);
+      if (Toaster.value && container) {
+        container.prepend(Toaster.value);
+      }
+      isActive.value = true;
+      timer.value = props.timeout ? new ToasterTimer(close, props.timeout) : void 0;
+    };
+    function click(event) {
+      emits("click", event);
+      if (!props.persistent) {
+        close();
+      }
+    }
+    const toggleTimer = (newVal) => {
+      if (timer.value && !props.noPauseOnHover) {
+        newVal ? timer.value.pause() : timer.value.resume();
+      }
+    };
+    const stopTimer = () => {
+      timer.value && timer.value.stop();
+      if (queueTimer.value) {
+        clearTimeout(queueTimer.value);
+      }
+    };
+    const close = () => {
+      stopTimer();
+      isActive.value = false;
+      setTimeout(() => {
+        var _a;
+        emits("close");
+        (_a = Toaster.value) == null ? void 0 : _a.remove();
+        const container = document.querySelector(selectorContainerClass);
+        if (container && !(container == null ? void 0 : container.hasChildNodes())) {
+          container.remove();
+        }
+      }, 300);
+    };
+    onMounted$1(() => {
+      createParents();
+      showNotice();
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(Transition, { name: unref(transitionName) }, {
+        default: withCtx(() => [
+          withDirectives(createElementVNode("div", {
+            ref_key: "Toaster",
+            ref: Toaster,
+            class: normalizeClass(["m-toast", [`--${__props.type}`, `--${unref(positionY)}`, `--${unref(positionX)}`]]),
+            role: "alert",
+            onMouseover: _cache[0] || (_cache[0] = ($event) => toggleTimer(true)),
+            onMouseleave: _cache[1] || (_cache[1] = ($event) => toggleTimer(false)),
+            onClick: _cache[2] || (_cache[2] = ($event) => click($event))
+          }, [
+            createElementVNode("div", _hoisted_1, [
+              createElementVNode("p", _hoisted_2, toDisplayString(__props.message), 1)
+            ]),
+            !__props.persistent ? (openBlock(), createElementBlock("button", _hoisted_3, [
+              createVNode(_sfc_main$1, {
+                src: unref(XIcon),
+                class: "--icon"
+              }, null, 8, ["src"])
+            ])) : createCommentVNode("", true)
+          ], 34), [
+            [vShow, isActive.value]
+          ])
+        ]),
+        _: 1
+      }, 8, ["name"]);
+    };
+  }
+});
+const MazToast_vue_vue_type_style_index_0_lang = "";
+const MazToast_vue_vue_type_style_index_1_scoped_ba28d9a5_lang = "";
+const _export_sfc = (sfc, props) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props) {
+    target[key] = val;
+  }
+  return target;
+};
+const MazToast = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-ba28d9a5"]]);
+class ToasterHandler {
+  constructor(app, globalOptions) {
+    this.app = app;
+    this.globalOptions = globalOptions;
+  }
+  show(message, options) {
+    const localOptions = { message, ...options };
+    const propsData = {
+      ...localOptions,
+      ...this.globalOptions,
+      ...options
+    };
+    mount(MazToast, {
+      props: propsData,
+      app: this.app
+    });
+  }
+  getLocalOptions(type, options) {
+    return {
+      type,
+      ...options
+    };
+  }
+  success(message, options) {
+    return this.show(message, this.getLocalOptions("success", options));
+  }
+  error(message, options) {
+    return this.show(message, this.getLocalOptions("danger", options));
+  }
+  info(message, options) {
+    return this.show(message, this.getLocalOptions("info", options));
+  }
+  warning(message, options) {
+    return this.show(message, this.getLocalOptions("warning", options));
+  }
+}
+const defaultOptions = {
+  position: "bottom-right",
+  timeout: 1e4,
+  persistent: true
+};
+let instance$2;
+const plugin$2 = {
+  install(app, options) {
+    instance$2 = new ToasterHandler(app, {
+      ...defaultOptions,
+      ...options
+    });
+    app.provide("toast", instance$2);
+  }
+};
+const DEFAULT_LOADER = "";
+const uniq = (array) => {
+  return array.filter((el, index, arr) => index === arr.indexOf(el));
+};
+const contains = (array) => (predicate = DEFAULT_LOADER) => {
+  return typeof predicate === "function" ? array.findIndex((...args) => predicate(...args)) > -1 : array.includes(predicate);
+};
+const hasItems = (array) => array.length > 0;
+const push = (array) => (item = DEFAULT_LOADER) => uniq([...array, item]);
+const pop = (array) => (item = DEFAULT_LOADER) => array.filter((_item) => _item !== item);
+class WaitHandler {
+  constructor() {
+    __publicField(this, "_loaders", ref([]));
+  }
+  get loaders() {
+    return computed(() => this._loaders.value);
+  }
+  stop(loaderId = DEFAULT_LOADER) {
+    this._loaders.value = pop(this._loaders.value)(loaderId);
+  }
+  start(loaderId = DEFAULT_LOADER) {
+    this._loaders.value = push(this._loaders.value)(loaderId);
+    return () => this.stop(loaderId);
+  }
+  get anyLoading() {
+    return computed(() => hasItems(this._loaders.value));
+  }
+  isLoading(loaderId = DEFAULT_LOADER) {
+    const isLoading = computed(() => contains(this._loaders.value)(loaderId));
+    return isLoading.value;
+  }
+}
+const instance$1 = new WaitHandler();
+const plugin$1 = {
+  install: (app) => {
+    app.provide("wait", instance$1);
+  }
+};
+const sleep = (ms) => {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+};
+const DEFAULT_OPTIONS$1 = {
+  delay: 100,
+  observer: {
+    root: void 0,
+    rootMargin: "0px",
+    threshold: 0.2
+  },
+  animation: {
+    once: true,
+    duration: 300
+  }
+};
+class AosHandler {
+  constructor(options) {
+    __publicField(this, "options");
+    this.options = {
+      delay: (options == null ? void 0 : options.delay) ?? DEFAULT_OPTIONS$1.delay,
+      observer: {
+        ...DEFAULT_OPTIONS$1.observer,
+        ...options == null ? void 0 : options.observer
+      },
+      animation: {
+        ...DEFAULT_OPTIONS$1.animation,
+        ...options == null ? void 0 : options.animation
+      }
+    };
+  }
+  runAnimations() {
+    if (isClient()) {
+      return this.handleObserver();
+    } else {
+      console.warn("[MazAos](runAnimations) should be executed on client side");
+    }
+  }
+  async handleObserver() {
+    await sleep(this.options.delay);
+    const observer = new IntersectionObserver(this.handleIntersect.bind(this), {
+      ...this.options.observer
+    });
+    for (const element of document.querySelectorAll("[data-maz-aos]")) {
+      const anchorAttr = element.getAttribute("data-maz-aos-anchor");
+      if (anchorAttr) {
+        const anchorElement = document.querySelector(anchorAttr);
+        if (anchorElement) {
+          anchorElement.setAttribute("data-maz-aos-children", "true");
+          observer.observe(anchorElement);
+        } else {
+          console.warn(
+            `[maz-ui](aos) no element found with selector "${anchorAttr}"`
+          );
+        }
+      } else {
+        observer.observe(element);
+      }
+    }
+  }
+  handleIntersect(entries, observer) {
+    for (const entry of entries) {
+      const target = entry.target;
+      const hasChildren = target.getAttribute("data-maz-aos-children") === "true";
+      const animateElements = entry.target.getAttribute(
+        "data-maz-aos"
+      ) ? [entry.target] : [];
+      if (hasChildren) {
+        const children = [
+          ...document.querySelectorAll("[data-maz-aos-anchor]")
+        ].map(
+          (child) => child.getAttribute("data-maz-aos-anchor") === `#${entry.target.id}` ? child : void 0
+        );
+        for (const child of children) {
+          if (child) {
+            animateElements.push(child);
+          }
+        }
+      }
+      for (const element of animateElements) {
+        const once = element.getAttribute("data-maz-aos-once");
+        const useOnce = typeof once === "string" ? once === "true" : this.options.animation.once;
+        if (entry.intersectionRatio > this.options.observer.threshold) {
+          const duration = element.getAttribute("data-maz-aos-duration");
+          if (!duration) {
+            element.style.transitionDuration = `${this.options.animation.duration}ms`;
+            setTimeout(() => {
+              element.style.transitionDuration = "0";
+            }, 1e3);
+          }
+          element.classList.add("maz-aos-animate");
+          if (useOnce) {
+            observer.unobserve(element);
+          }
+        } else {
+          element.classList.remove("maz-aos-animate");
+        }
+      }
+    }
+  }
+}
+let instance;
+const plugin = {
+  install: (app, options) => {
+    instance = new AosHandler(options);
+    app.provide("aos", instance);
+    if (!isClient()) {
+      return;
+    }
+    if (options == null ? void 0 : options.router) {
+      options.router.afterEach(async () => {
+        instance.runAnimations();
+      });
+    } else {
+      instance.runAnimations();
+    }
+  }
+};
+const DEFAULT_OPTIONS = {
+  darkClass: "dark",
+  storageThemeKey: "theme",
+  storageThemeValueDark: "dark",
+  storageThemeValueLight: "light"
+};
+const theme = ref();
+const autoSetTheme = ({
+  storageThemeKey,
+  storageThemeValueDark,
+  darkClass,
+  storageThemeValueLight
+}) => {
+  if (localStorage[storageThemeKey] === storageThemeValueDark || !(storageThemeKey in localStorage) && window.matchMedia("(prefers-color-scheme: dark)").matches) {
+    document.documentElement.classList.add(darkClass);
+    localStorage[storageThemeKey] = storageThemeValueDark;
+    theme.value = storageThemeValueDark;
+  } else {
+    document.documentElement.classList.remove(darkClass);
+    localStorage[storageThemeKey] = storageThemeValueLight;
+    theme.value = storageThemeValueLight;
+  }
+};
+const toggleTheme = ({
+  storageThemeKey,
+  storageThemeValueDark,
+  darkClass,
+  storageThemeValueLight
+}) => {
+  if (localStorage[storageThemeKey] === storageThemeValueDark) {
+    document.documentElement.classList.remove(darkClass);
+    localStorage[storageThemeKey] = storageThemeValueLight;
+    theme.value = storageThemeValueLight;
+  } else {
+    document.documentElement.classList.add(darkClass);
+    localStorage[storageThemeKey] = storageThemeValueDark;
+    theme.value = storageThemeValueDark;
+  }
+};
+const useThemeHandler = (opts = DEFAULT_OPTIONS) => {
+  const options = {
+    ...DEFAULT_OPTIONS,
+    ...opts
+  };
+  const hasDarkTheme = computed(
+    () => theme.value === options.storageThemeValueDark
+  );
+  const hasLightTheme = computed(
+    () => theme.value === options.storageThemeValueLight
+  );
+  return {
+    autoSetTheme: () => autoSetTheme(options),
+    toggleTheme: () => toggleTheme(options),
+    hasDarkTheme,
+    hasLightTheme,
+    theme
+  };
+};
+const useInstanceUniqId = ({
+  componentName,
+  instance: instance2,
+  providedId
+}) => {
+  const instanceId = computed(
+    () => providedId ?? `${componentName}-${instance2 == null ? void 0 : instance2.uid}`
+  );
+  return {
+    instanceId
+  };
+};
+const useAos = () => {
+  const aos = injectStrict("aos");
+  return {
+    aos
+  };
+};
+const useWait = () => {
+  const wait = injectStrict("wait");
+  return {
+    wait
+  };
+};
+const useToast = () => {
+  const toast = injectStrict("toast");
+  return {
+    toast
+  };
+};
+const handler$1 = ref();
+const useIdleTimeout = ({
+  callback,
+  options
+}) => {
+  const instance2 = new IdleTimeout(callback, options);
+  handler$1.value = instance2;
+  const idle = handler$1;
+  return {
+    idle
+  };
+};
+const handler = ref();
+const useUserVisibility = ({
+  callback,
+  options
+}) => {
+  const instance2 = new UserVisibility(callback, options);
+  handler.value = instance2;
+  const visibility = handler;
+  return {
+    visibility
+  };
+};
+export {
+  AosHandler,
+  IdleTimeout,
+  ToasterHandler,
+  UserVisibility,
+  WaitHandler,
+  instance as aosInstance,
+  capitalize,
+  currency,
+  date,
+  debounce,
+  injectStrict,
+  plugin as installAos,
+  installDirectives,
+  installFilters,
+  plugin$2 as installToaster,
+  plugin$1 as installWait,
+  isClient,
+  mount,
+  number,
+  sleep$1 as sleep,
+  theme,
+  instance$2 as toastInstance,
+  truthyFilter,
+  useAos,
+  useIdleTimeout,
+  useInstanceUniqId,
+  useThemeHandler,
+  useToast,
+  useUserVisibility,
+  useWait,
+  directive$1 as vClickOutside,
+  plugin$6 as vClickOutsideInstall,
+  directive as vClosable,
+  plugin$5 as vClosableInstall,
+  vLazyImg,
+  plugin$3 as vLazyImgInstall,
+  vZoomImg,
+  plugin$4 as vZoomImgInstall,
+  instance$1 as waitInstance
+};