maz-ui 3.50.1 → 4.0.0-alpha.2

package/dist/helpers/freezeValue.js

@@ -0,0 +1,8 @@
+import { toValue as t } from "vue";
+function o(r) {
+  const e = t(r);
+  return Array.isArray(e) ? Object.freeze([...e]) : typeof e == "object" && e !== null ? Object.freeze({ ...e }) : e;
+}
+export {
+  o as freezeValue
+};

package/dist/helpers/idleTimeout.js

@@ -0,0 +1,114 @@
+var l = Object.defineProperty;
+var r = (s, t, e) => t in s ? l(s, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : s[t] = e;
+var i = (s, t, e) => r(s, typeof t != "symbol" ? t + "" : t, e);
+import { isClient as o } from "./isClient.js";
+class m {
+  constructor(t, e) {
+    i(this, "defaultOptions", {
+      element: void 0,
+      timeout: 60 * 1e3 * 5,
+      // 5 minutes
+      once: !1,
+      immediate: !0
+    });
+    i(this, "options");
+    i(this, "timeoutHandler");
+    i(this, "isIdle", !1);
+    i(this, "isDestroy", !1);
+    i(this, "startTime", 0);
+    i(this, "remainingTime", 0);
+    i(this, "lastClientX", -1);
+    i(this, "lastClientY", -1);
+    i(this, "eventNames", [
+      "DOMMouseScroll",
+      "mousedown",
+      "mousemove",
+      "mousewheel",
+      "MSPointerDown",
+      "MSPointerMove",
+      "keydown",
+      "touchmove",
+      "touchstart",
+      "wheel",
+      "click"
+    ]);
+    i(this, "handleEvent", (t) => {
+      try {
+        if (this.remainingTime > 0)
+          return;
+        if (t.type === "mousemove") {
+          const { clientX: e, clientY: n } = t;
+          if (e === void 0 && n === void 0 || e === this.lastClientX && n === this.lastClientY)
+            return;
+          this.lastClientX = e, this.lastClientY = n;
+        }
+        this.resetTimeout(), this.callback({ isIdle: this.isIdle, eventType: t.type, instance: this });
+      } catch (e) {
+        throw new Error(`[IdleTimeout](handleEvent) ${e}`);
+      }
+    });
+    this.callback = t, this.options = {
+      ...this.defaultOptions,
+      ...e
+    }, o() && this.start();
+  }
+  get element() {
+    return this.options.element ?? document.body;
+  }
+  start() {
+    if (!o()) {
+      console.warn("[IdleTimeout](start) you should run this method on client side");
+      return;
+    }
+    for (const t of this.eventNames)
+      this.element.addEventListener(t, this.handleEvent);
+    this.resetTimeout(), this.options.immediate && this.callback({ isIdle: !1, instance: this });
+  }
+  pause() {
+    const t = this.startTime + this.options.timeout - Date.now();
+    t <= 0 || (this.remainingTime = t, this.timeoutHandler && (clearTimeout(this.timeoutHandler), this.timeoutHandler = void 0));
+  }
+  resume() {
+    this.remainingTime <= 0 || (this.resetTimeout(), this.callback({ isIdle: this.isIdle, instance: this }), this.remainingTime = 0);
+  }
+  reset() {
+    this.isDestroy = !1, this.isIdle = !1, this.remainingTime = 0, this.resetTimeout(), this.callback({ isIdle: this.isIdle, instance: this });
+  }
+  destroy() {
+    if (!o()) {
+      console.warn("[IdleTimeout](destroy) you should run this method on client side");
+      return;
+    }
+    this.isDestroy = !0;
+    for (const t of this.eventNames)
+      this.element.removeEventListener(t, this.handleEvent);
+    this.timeoutHandler && clearTimeout(this.timeoutHandler);
+  }
+  resetTimeout() {
+    this.isIdle = !1, 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 = !0, this.callback({ isIdle: this.isIdle, instance: this }), this.options.once && this.destroy();
+  }
+  get destroyed() {
+    return this.isDestroy;
+  }
+  get timeout() {
+    return this.options.timeout;
+  }
+  set timeout(t) {
+    this.options.timeout = t;
+  }
+  get idle() {
+    return this.isIdle;
+  }
+  set idle(t) {
+    t ? this.handleTimeout() : this.reset(), this.callback({ isIdle: this.isIdle, instance: this });
+  }
+}
+export {
+  m as IdleTimeout
+};

package/dist/helpers/injectStrict.js

@@ -0,0 +1,10 @@
+import { inject as e } from "vue";
+function n(t, o) {
+  const r = e(t, o);
+  if (!r)
+    throw new TypeError(`[maz-ui](injectStrict) Could not resolve ${t.toString()}`);
+  return r;
+}
+export {
+  n as injectStrict
+};

package/dist/helpers/isClient.js

@@ -0,0 +1,6 @@
+function e() {
+  return typeof document < "u";
+}
+export {
+  e as isClient
+};

package/dist/helpers/isEqual.js

@@ -0,0 +1,26 @@
+function i(e) {
+  return e == null || typeof e == "string" || typeof e == "number" || typeof e == "boolean" || typeof e == "symbol" || typeof e == "bigint";
+}
+function o(e, r) {
+  if (e.length !== r.length)
+    return !1;
+  for (const [t, n] of e.entries())
+    if (!s(n, r[t]))
+      return !1;
+  return !0;
+}
+function y(e, r) {
+  const t = Object.keys(e), n = Object.keys(r);
+  if (t.length !== n.length)
+    return !1;
+  for (const f of t)
+    if (!n.includes(f) || !s(e[f], r[f]))
+      return !1;
+  return !0;
+}
+function s(e, r) {
+  return i(e) || i(r) ? e === r : e instanceof Date && r instanceof Date ? e.getTime() === r.getTime() : typeof e != typeof r || Array.isArray(e) !== Array.isArray(r) ? !1 : Array.isArray(e) && Array.isArray(r) ? o(e, r) : typeof e == "object" && typeof r == "object" ? y(e, r) : !1;
+}
+export {
+  s as isEqual
+};

package/dist/helpers/isStandaloneMode.js

@@ -0,0 +1,10 @@
+import { isClient as t } from "./isClient.js";
+function e() {
+  if (!t())
+    return !1;
+  const n = navigator, a = window.matchMedia("(display-mode: standalone)").matches;
+  return n.standalone || a;
+}
+export {
+  e as isStandaloneMode
+};

package/dist/helpers/mountComponent.js

@@ -0,0 +1,16 @@
+import { createVNode as m, render as c } from "vue";
+function y(l, e) {
+  let r = e == null ? void 0 : e.element;
+  function f() {
+    r && c(null, r);
+  }
+  const u = { ...e == null ? void 0 : e.props, ...e != null && e.addDestroyInProps ? { destroy: f } : {} }, d = m(
+    l,
+    u,
+    e == null ? void 0 : e.children
+  );
+  return e != null && e.app ? (d.appContext = e.app._context, r ? c(d, r) : typeof document < "u" && (r = document.createElement("div"), c(d, r))) : (r = r ?? document.body, c(d, r)), { vNode: d, destroy: f, el: r };
+}
+export {
+  y as mount
+};

package/dist/helpers/normalizeString.js

@@ -0,0 +1,69 @@
+const l = {
+  removeAccents: !0,
+  caseSensitive: !1,
+  replaceSpaces: !0,
+  removeSpecialCharacters: !1,
+  trim: !0,
+  normalizeSpaces: !0,
+  removeNumbers: !1,
+  customNormalizationForms: ["NFC", "NFKD"]
+};
+function s(o, i) {
+  const r = { ...l, ...i }, t = {
+    À: "A",
+    Á: "A",
+    Â: "A",
+    Ã: "A",
+    Ä: "A",
+    Å: "A",
+    à: "a",
+    á: "a",
+    â: "a",
+    ã: "a",
+    ä: "a",
+    å: "a",
+    È: "E",
+    É: "E",
+    Ê: "E",
+    Ë: "E",
+    è: "e",
+    é: "e",
+    ê: "e",
+    ë: "e",
+    Î: "I",
+    Ï: "I",
+    í: "I",
+    î: "i",
+    ï: "i",
+    Ô: "O",
+    Õ: "O",
+    Ö: "O",
+    Ø: "O",
+    ô: "o",
+    õ: "o",
+    ö: "o",
+    ø: "o",
+    Ù: "U",
+    Ú: "U",
+    Û: "U",
+    Ü: "U",
+    ù: "u",
+    ú: "u",
+    û: "u",
+    ü: "u",
+    Ç: "C",
+    ç: "c",
+    ÿ: "y",
+    Ñ: "N",
+    ñ: "n",
+    ó: "o"
+  };
+  let e = o.toString();
+  if (r.trim && (e = e.trim()), r.normalizeSpaces && (e = e.replaceAll(/\s+/g, " ")), r.replaceSpaces && (e = e.replaceAll(" ", "-")), r.removeNumbers && (e = e.replaceAll(/\d/g, "")), r.removeAccents && (e = e.replaceAll(/[ÀÁÂÃÄÅÇÈÉÊËÎÏÑÔÕÖØÙÚÛÜàáâãäåçèéêëíîïñóôõöøùúûüÿ]/g, (a) => t[a] || a), e = e.replaceAll(/[\u0300-\u036F]/g, "")), r.caseSensitive === !1 && (e = e.toLowerCase()), r.removeSpecialCharacters && (e = e.replaceAll(/[^\dA-Z-]/gi, "")), r.trim && (e = e.trim()), r.customNormalizationForms)
+    for (const a of r.customNormalizationForms)
+      e = e.normalize(a);
+  return e;
+}
+export {
+  s as normalizeString
+};

package/dist/helpers/scriptLoader.js

@@ -0,0 +1,47 @@
+var d = Object.defineProperty;
+var c = (o, e, r) => e in o ? d(o, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : o[e] = r;
+var n = (o, e, r) => c(o, typeof e != "symbol" ? e + "" : e, r);
+class h {
+  constructor({ src: e, identifier: r, once: s = !0, async: t = !0, defer: i = !0 }) {
+    n(this, "src");
+    n(this, "script");
+    n(this, "once");
+    n(this, "async");
+    n(this, "defer");
+    n(this, "identifier");
+    if (typeof window > "u")
+      throw new TypeError("[ScriptLoader]: Is supported only on browser side");
+    if (!e)
+      throw new Error('[ScriptLoader]: You should provide the attribut "src"');
+    if (!r)
+      throw new Error('[ScriptLoader]: You should provide the attribut "identifier"');
+    this.src = e, this.identifier = r, this.once = s, this.async = t, this.defer = i;
+  }
+  removeTag(e) {
+    var r;
+    typeof e == "string" ? (r = document.head.querySelector(`[data-identifier="${e}"]`)) == null || r.remove() : e.remove();
+  }
+  load() {
+    const e = window, r = document.head.querySelectorAll(`[data-identifier="${this.identifier}"]`);
+    if (this.once && e[this.identifier] && r.length > 0)
+      return this.script = e[this.identifier], Promise.resolve(this.script);
+    if (!this.once && r.length > 0)
+      for (const s of r)
+        this.removeTag(s);
+    return this.injectScript();
+  }
+  injectScript() {
+    const e = window;
+    return new Promise((r, s) => {
+      try {
+        const t = document.createElement("script");
+        t.src = this.src, t.async = this.async, t.defer = this.defer, t.dataset.identifier = this.identifier, t.addEventListener("error", (i) => s(new Error(`[ScriptLoader](injectScript) ${i.message}`))), t.addEventListener("load", (i) => (this.script = i, e[this.identifier] = i, r(i))), document.head.append(t);
+      } catch (t) {
+        throw new Error(`[ScriptLoader](init) ${t}`);
+      }
+    });
+  }
+}
+export {
+  h as ScriptLoader
+};

package/dist/helpers/sleep.js

@@ -0,0 +1,6 @@
+function n(e) {
+  return new Promise((t) => setTimeout(t, e));
+}
+export {
+  n as sleep
+};

package/dist/helpers/swipeHandler.js

@@ -0,0 +1,85 @@
+var f = Object.defineProperty;
+var d = (i, t, s) => t in i ? f(i, t, { enumerable: !0, configurable: !0, writable: !0, value: s }) : i[t] = s;
+var e = (i, t, s) => d(i, typeof t != "symbol" ? t + "" : t, s);
+const c = {
+  preventDefaultOnTouchMove: !1,
+  preventDefaultOnMouseWheel: !1,
+  threshold: 50,
+  immediate: !1,
+  triggerOnEnd: !1
+};
+class p {
+  constructor(t) {
+    e(this, "element");
+    e(this, "xStart");
+    e(this, "yStart");
+    e(this, "xEnd");
+    e(this, "yEnd");
+    e(this, "xDiff");
+    e(this, "yDiff");
+    e(this, "onToucheStartCallback");
+    e(this, "onToucheMoveCallback");
+    e(this, "onToucheEndCallback");
+    e(this, "onMouseWheelCallback");
+    e(this, "start");
+    e(this, "stop");
+    e(this, "options");
+    this.inputOption = t, this.options = { ...c, ...t }, this.onToucheStartCallback = this.toucheStartHandler.bind(this), this.onToucheMoveCallback = this.handleTouchMove.bind(this), this.onToucheEndCallback = this.handleTouchEnd.bind(this), this.onMouseWheelCallback = this.handleMouseWheel.bind(this), this.start = this.startListening.bind(this), this.stop = this.stopListening.bind(this), this.options.element && this.setElement(this.options.element), this.options.immediate && this.start();
+  }
+  startListening() {
+    this.setElement(this.options.element), this.element.addEventListener("touchstart", this.onToucheStartCallback, { passive: !0 }), this.element.addEventListener("touchmove", this.onToucheMoveCallback, { passive: !0 }), this.options.triggerOnEnd && this.element.addEventListener("touchend", this.onToucheEndCallback, { passive: !0 }), this.options.preventDefaultOnMouseWheel && this.element.addEventListener("mousewheel", this.onMouseWheelCallback, { passive: !1 });
+  }
+  stopListening() {
+    this.element.removeEventListener("touchstart", this.onToucheStartCallback), this.element.removeEventListener("touchmove", this.onToucheMoveCallback), this.element.removeEventListener("touchend", this.onToucheEndCallback), this.options.preventDefaultOnMouseWheel && this.element.removeEventListener("mousewheel", this.onMouseWheelCallback);
+  }
+  setElement(t) {
+    if (!t) {
+      console.error(
+        "[maz-ui][SwipeHandler](setElement) Element should be provided. Its can be a string selector or an HTMLElement"
+      );
+      return;
+    }
+    if (typeof t == "string") {
+      const s = document.querySelector(t);
+      if (!(s instanceof HTMLElement)) {
+        console.error("[maz-ui][SwipeHandler](setElement) String selector for element is not found");
+        return;
+      }
+      this.element = s;
+    } else
+      this.element = t;
+  }
+  handleMouseWheel(t) {
+    t.preventDefault();
+  }
+  toucheStartHandler(t) {
+    this.xStart = t.touches[0].clientX, this.yStart = t.touches[0].clientY, this.emitValuesChanged();
+  }
+  emitValuesChanged() {
+    var t, s;
+    (s = (t = this.options).onValuesChanged) == null || s.call(t, {
+      xStart: this.xStart,
+      yStart: this.yStart,
+      xEnd: this.xEnd,
+      yEnd: this.yEnd,
+      xDiff: this.xDiff,
+      yDiff: this.yDiff
+    });
+  }
+  handleTouchMove(t) {
+    this.options.preventDefaultOnTouchMove && t.cancelable && t.preventDefault(), this.xEnd = t.touches[0].clientX, this.yEnd = t.touches[0].clientY, !(!this.xStart || !this.yStart) && (this.xDiff = this.xStart - this.xEnd, this.yDiff = this.yStart - this.yEnd, this.emitValuesChanged(), this.options.triggerOnEnd || this.runCallbacks(t));
+  }
+  handleTouchEnd(t) {
+    this.runCallbacks(t), this.emitValuesChanged();
+  }
+  runCallbacks(t) {
+    var s, n, h, o, a, l, r, u;
+    typeof this.xDiff != "number" || typeof this.yDiff != "number" || Math.abs(this.xDiff) < this.options.threshold && Math.abs(this.yDiff) < this.options.threshold || (Math.abs(this.xDiff) > Math.abs(this.yDiff) ? this.xDiff > 0 ? (n = (s = this.options).onLeft) == null || n.call(s, t) : (o = (h = this.options).onRight) == null || o.call(h, t) : this.yDiff > 0 ? (l = (a = this.options).onUp) == null || l.call(a, t) : (u = (r = this.options).onDown) == null || u.call(r, t), this.resetValues());
+  }
+  resetValues() {
+    this.xStart = void 0, this.yStart = void 0, this.xEnd = void 0, this.yEnd = void 0, this.xDiff = void 0, this.yDiff = void 0, this.emitValuesChanged();
+  }
+}
+export {
+  p as Swipe
+};

package/dist/helpers/throttle.js

@@ -0,0 +1,11 @@
+function i(e, a) {
+  let l = !1, n, t;
+  return function(...o) {
+    l ? (clearTimeout(n), n = setTimeout(() => {
+      Date.now() - t >= a && (e.apply(this, o), t = Date.now());
+    }, Math.max(a - (Date.now() - t), 0))) : (e.apply(this, o), t = Date.now(), l = !0);
+  };
+}
+export {
+  i as throttle
+};

package/dist/helpers/throttleId.js

@@ -0,0 +1,19 @@
+function c(s, o, t) {
+  const l = {};
+  return async (...m) => {
+    const a = Date.now();
+    return l[s] || (l[s] = { promise: null, lastCall: 0, lastArgs: [] }), a - l[s].lastCall >= t ? (l[s].lastCall = a, o(...m)) : (l[s].lastArgs = m, l[s].promise || (l[s].promise = new Promise((u) => {
+      setTimeout(
+        async () => {
+          l[s].lastCall = Date.now();
+          const p = await o(...l[s].lastArgs);
+          l[s].promise = null, u(p);
+        },
+        t - (a - l[s].lastCall)
+      );
+    })), l[s].promise);
+  };
+}
+export {
+  c as throttleId
+};

package/dist/helpers/truthyFilter.js

@@ -0,0 +1,6 @@
+function r(t) {
+  return !!t;
+}
+export {
+  r as truthyFilter
+};

package/dist/helpers/userVisibility.js

@@ -0,0 +1,53 @@
+var o = Object.defineProperty;
+var l = (e, i, s) => i in e ? o(e, i, { enumerable: !0, configurable: !0, writable: !0, value: s }) : e[i] = s;
+var t = (e, i, s) => l(e, typeof i != "symbol" ? i + "" : i, s);
+import { isClient as n } from "./isClient.js";
+class h {
+  constructor(i, s) {
+    t(this, "eventHandlerFunction");
+    t(this, "event", "visibilitychange");
+    t(this, "timeoutHandler");
+    t(this, "options");
+    t(this, "defaultOptions", {
+      timeout: 5e3,
+      once: !1,
+      immediate: !0
+    });
+    t(this, "isVisible", !1);
+    this.callback = i, this.options = {
+      ...this.defaultOptions,
+      ...s
+    }, this.eventHandlerFunction = this.eventHandler.bind(this), n() && this.start();
+  }
+  start() {
+    if (!n()) {
+      console.warn("[UserVisibility](start) you should run this method on client side");
+      return;
+    }
+    this.options.immediate && this.emitCallback(), this.addEventListener();
+  }
+  emitCallback() {
+    this.isVisible = document.visibilityState === "visible", this.callback({ isVisible: this.isVisible }), this.options.once && this.destroy();
+  }
+  eventHandler() {
+    document.visibilityState === "visible" && !this.isVisible ? (this.clearTimeout(), this.emitCallback()) : document.visibilityState === "hidden" && this.initTimeout();
+  }
+  clearTimeout() {
+    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(), this.timeoutHandler && clearTimeout(this.timeoutHandler);
+  }
+}
+export {
+  h as UserVisibility
+};

package/dist/maz-ui.js

@@ -0,0 +1,162 @@
+import { useAos as H } from "./composables/useAos.js";
+import { useBreakpoints as V } from "./composables/useBreakpoints.js";
+import { useDialog as R } from "./composables/useDialog.js";
+import { useFormField as M } from "./composables/useFormField.js";
+import { useFormValidator as Z } from "./composables/useFormValidator.js";
+import { useIdleTimeout as j } from "./composables/useIdleTimeout.js";
+import { useInstanceUniqId as E } from "./composables/useInstanceUniqId.js";
+import { iso6391Codes as G, languageCodes as J, useLanguageDisplayNames as K } from "./composables/useLanguageDisplayNames.js";
+import { useReadingTime as Q } from "./composables/useReadingTime.js";
+import { useStringMatching as Y } from "./composables/useStringMatching.js";
+import { useSwipe as oo } from "./composables/useSwipe.js";
+import { useThemeHandler as eo } from "./composables/useThemeHandler.js";
+import { useTimer as lo } from "./composables/useTimer.js";
+import { useToast as io } from "./composables/useToast.js";
+import { useUserVisibility as ao } from "./composables/useUserVisibilty.js";
+import { useWait as no } from "./composables/useWait.js";
+import { useWindowSize as uo } from "./composables/useWindowSize.js";
+import { vClickOutsideInstall as e } from "./directives/vClickOutside.js";
+import { vClickOutside as go } from "./directives/vClickOutside.js";
+import { vClosableInstall as t } from "./directives/vClosable.js";
+import { vClosable as Io } from "./directives/vClosable.js";
+import { vFullscreenImgInstall as l } from "./directives/vFullscreenImg.js";
+import { vLazyImgInstall as s } from "./directives/vLazyImg.js";
+import { vTooltipInstall as i } from "./directives/vTooltip.js";
+import { vTooltip as Co } from "./directives/vTooltip.js";
+import { vZoomImgInstall as m } from "./directives/vZoomImg.js";
+import { vZoomImg as To } from "./directives/vZoomImg.js";
+import { camelCase as a } from "./filters/camelCase.js";
+import { capitalize as p } from "./filters/capitalize.js";
+import { currency as n } from "./filters/currency.js";
+import { date as f } from "./filters/date.js";
+import { number as u } from "./filters/number.js";
+import { pascalCase as x } from "./filters/pascalCase.js";
+import { checkAvailability as yo } from "./helpers/checkAvailability.js";
+import { countryCodeToUnicodeFlag as Uo } from "./helpers/countryCodeToUnicodeFlag.js";
+import { countryFlagUrlFromFlagCdn as ho } from "./helpers/countryFlagFromFlagCdn.js";
+import { debounce as Do } from "./helpers/debounce.js";
+import { debounceCallback as Ao } from "./helpers/debounceCallback.js";
+import { debounceId as Lo } from "./helpers/debounceId.js";
+import { freezeValue as wo } from "./helpers/freezeValue.js";
+import { IdleTimeout as Wo } from "./helpers/idleTimeout.js";
+import { injectStrict as Oo } from "./helpers/injectStrict.js";
+import { isClient as qo } from "./helpers/isClient.js";
+import { isEqual as Bo } from "./helpers/isEqual.js";
+import { isStandaloneMode as No } from "./helpers/isStandaloneMode.js";
+import { mount as Jo } from "./helpers/mountComponent.js";
+import { normalizeString as Po } from "./helpers/normalizeString.js";
+import { ScriptLoader as Xo } from "./helpers/scriptLoader.js";
+import { sleep as _o } from "./helpers/sleep.js";
+import { Swipe as rr } from "./helpers/swipeHandler.js";
+import { throttle as tr } from "./helpers/throttle.js";
+import { throttleId as sr } from "./helpers/throttleId.js";
+import { truthyFilter as mr } from "./helpers/truthyFilter.js";
+import { UserVisibility as pr } from "./helpers/userVisibility.js";
+import { AosHandler as fr, getInstance as ur, plugin as xr } from "./plugins/aos.js";
+import { DialogHandler as cr, installDialog as dr } from "./plugins/dialog.js";
+import { ToasterHandler as vr, installToaster as Cr } from "./plugins/toaster.js";
+import { WaitHandler as Tr, plugin as br, instance as yr } from "./plugins/wait.js";
+import { UnpluginDirectivesResolver as Ur } from "./resolvers/UnpluginDirectivesResolver.js";
+import { UnpluginModulesResolver as hr } from "./resolvers/UnpluginModulesResolver.js";
+import { UnpluginVueComponentsResolver as Dr } from "./resolvers/UnpluginVueComponentsResolver.js";
+import { d as Ar } from "./chunks/fullscreen-img.directive.CaOkiCBy.js";
+import { d as Lr } from "./chunks/lazy-img.directive.Cjz2aiGf.js";
+const g = [
+  t,
+  m,
+  s,
+  e,
+  l,
+  i
+], k = {
+  install(o) {
+    for (const r of g)
+      r.install(o, {});
+  }
+}, c = {
+  capitalize: p,
+  camelCase: a,
+  currency: n,
+  date: f,
+  number: u,
+  pascalCase: x
+}, D = {
+  install(o) {
+    o.provide("filters", c);
+  }
+};
+export {
+  fr as AosHandler,
+  cr as DialogHandler,
+  Wo as IdleTimeout,
+  Xo as ScriptLoader,
+  rr as Swipe,
+  vr as ToasterHandler,
+  Ur as UnpluginDirectivesResolver,
+  hr as UnpluginModulesResolver,
+  Dr as UnpluginVueComponentsResolver,
+  pr as UserVisibility,
+  Tr as WaitHandler,
+  a as camelCase,
+  p as capitalize,
+  yo as checkAvailability,
+  Uo as countryCodeToUnicodeFlag,
+  ho as countryFlagUrlFromFlagCdn,
+  n as currency,
+  f as date,
+  Do as debounce,
+  Ao as debounceCallback,
+  Lo as debounceId,
+  wo as freezeValue,
+  ur as getAosInstance,
+  Oo as injectStrict,
+  xr as installAos,
+  dr as installDialog,
+  k as installDirectives,
+  D as installFilters,
+  Cr as installToaster,
+  br as installWait,
+  qo as isClient,
+  Bo as isEqual,
+  No as isStandaloneMode,
+  G as iso6391Codes,
+  J as languageCodes,
+  Jo as mount,
+  Po as normalizeString,
+  u as number,
+  x as pascalCase,
+  _o as sleep,
+  tr as throttle,
+  sr as throttleId,
+  mr as truthyFilter,
+  H as useAos,
+  V as useBreakpoints,
+  R as useDialog,
+  M as useFormField,
+  Z as useFormValidator,
+  j as useIdleTimeout,
+  E as useInstanceUniqId,
+  K as useLanguageDisplayNames,
+  Q as useReadingTime,
+  Y as useStringMatching,
+  oo as useSwipe,
+  eo as useThemeHandler,
+  lo as useTimer,
+  io as useToast,
+  ao as useUserVisibility,
+  no as useWait,
+  uo as useWindowSize,
+  go as vClickOutside,
+  e as vClickOutsideInstall,
+  Io as vClosable,
+  t as vClosableInstall,
+  Ar as vFullscreenImg,
+  l as vFullscreenImgInstall,
+  Lr as vLazyImg,
+  s as vLazyImgInstall,
+  Co as vTooltip,
+  i as vTooltipInstall,
+  To as vZoomImg,
+  m as vZoomImgInstall,
+  yr as waitInstance
+};