maz-ui 3.22.4 → 3.23.1

package/components/chunks/MazInputTags-aa95fae7.mjs

@@ -0,0 +1,446 @@
+import "../assets/MazInputTags.css";
+import { computed as u, defineComponent as O, defineAsyncComponent as w, ref as B, getCurrentInstance as ee, onMounted as te, useSlots as ae, openBlock as i, createElementBlock as v, normalizeClass as V, normalizeStyle as le, createElementVNode as $, renderSlot as T, createVNode as b, unref as m, createCommentVNode as y, withDirectives as re, mergeProps as D, toHandlers as ne, vModelDynamic as oe, createTextVNode as F, toDisplayString as L, createBlock as N, withModifiers as P, withCtx as x, TransitionGroup as ie, Fragment as se, renderList as ue, withKeys as q } from "vue";
+function de(e, n) {
+  let o;
+  return function(...l) {
+    clearTimeout(o), o = setTimeout(() => {
+      e.apply(this, l);
+    }, n);
+  };
+}
+const ce = ({
+  componentName: e,
+  instance: n,
+  providedId: o
+}) => u(() => o ?? `${e}-${n == null ? void 0 : n.uid}`), me = {
+  key: 0,
+  class: "m-input-wrapper-left"
+}, fe = { class: "m-input-wrapper-input" }, ve = ["id", "type", "name", "placeholder", "aria-label", "disabled", "readonly", "required"], ye = { key: 0 }, be = {
+  key: 1,
+  class: "m-input-wrapper-right"
+}, ge = /* @__PURE__ */ O({
+  inheritAttrs: !1,
+  __name: "MazInput",
+  props: {
+    style: { type: [String, Array, Object], default: void 0 },
+    class: { type: String, default: void 0 },
+    modelValue: {
+      type: [String, Number, Boolean],
+      default: void 0
+    },
+    placeholder: { type: String, default: void 0 },
+    color: {
+      type: String,
+      default: "primary"
+    },
+    label: { type: String, default: void 0 },
+    name: { type: String, default: "input" },
+    type: {
+      type: String,
+      default: "text",
+      validator: (e) => [
+        "text",
+        "date",
+        "number",
+        "tel",
+        "search",
+        "url",
+        "password",
+        "month",
+        "time",
+        "week",
+        "email"
+      ].includes(e)
+    },
+    required: { type: Boolean, default: !1 },
+    disabled: { type: Boolean, default: !1 },
+    readonly: { type: Boolean, default: !1 },
+    id: { type: String, default: void 0 },
+    error: { type: Boolean, default: !1 },
+    success: { type: Boolean, default: !1 },
+    warning: { type: Boolean, default: !1 },
+    hint: { type: String, default: void 0 },
+    inputClasses: { type: String, default: void 0 },
+    noBorder: { type: Boolean, default: !1 },
+    noRadius: { type: Boolean, default: !1 },
+    size: {
+      type: String,
+      default: "md",
+      validator: (e) => ["mini", "xs", "sm", "md", "lg", "xl"].includes(e)
+    },
+    debounce: { type: Boolean, default: !1 },
+    debounceDelay: { type: Number, default: 500 },
+    validButton: { type: Boolean, default: !1 },
+    validButtonLoading: { type: Boolean, default: !1 },
+    autoFocus: { type: Boolean, default: !1 },
+    borderActive: { type: Boolean, default: !1 },
+    leftIcon: { type: String, default: void 0 },
+    rightIcon: { type: String, default: void 0 }
+  },
+  emits: ["focus", "blur", "update:model-value", "click", "change", "update"],
+  setup(e, { emit: n }) {
+    const o = w(() => import("./MazBtn-555928ed.mjs")), l = w(() => import("./MazIcon-52a76873.mjs")), g = w(() => import("./eye-slash-fa42a017.mjs")), f = w(() => import("./eye-dc12ce09.mjs")), k = w(() => import("./check-c9b483c0.mjs")), t = e, p = n, h = B(!1), z = B(!1), s = B(), r = ee(), d = ce({
+      componentName: "MazInput",
+      instance: r,
+      providedId: t.id
+    });
+    te(() => {
+      var a;
+      t.autoFocus && ((a = s.value) == null || a.focus());
+    });
+    const S = u(() => t.class), C = u(() => t.type === "password"), J = u(() => h.value ? "text" : t.type), U = u(() => {
+      if (!t.noBorder) {
+        if (t.error)
+          return "maz-border-danger";
+        if (t.success)
+          return "maz-border-success";
+        if (t.warning)
+          return "maz-border-warning";
+        if (z.value || t.borderActive) {
+          if (t.color === "black")
+            return "maz-border-black";
+          if (t.color === "danger")
+            return "maz-border-danger";
+          if (t.color === "info")
+            return "maz-border-info";
+          if (t.color === "primary")
+            return "maz-border-primary";
+          if (t.color === "secondary")
+            return "maz-border-secondary";
+          if (t.color === "success")
+            return "maz-border-success";
+          if (t.color === "warning")
+            return "maz-border-warning";
+          if (t.color === "white")
+            return "maz-border-white";
+        }
+        return "--default-border";
+      }
+    }), M = ae(), K = u(() => {
+      const { required: a, placeholder: c } = t;
+      if (c)
+        return a ? `${c} *` : c;
+    }), R = u(() => t.modelValue !== void 0 && t.modelValue !== ""), A = u({
+      get: () => t.modelValue,
+      set: (a) => _(a)
+    }), j = u(() => (!!t.label || !!t.hint) && (z.value || !!R.value || !!t.placeholder || ["date", "month", "week"].includes(t.type))), G = u(() => !!t.label || !!t.hint), H = () => !!M["right-icon"] || C.value || !!M["valid-button"] || t.validButton || !!t.rightIcon, X = () => !!M["left-icon"] || !!t.leftIcon, Q = (a) => {
+      p("focus", a), z.value = !0;
+    }, W = (a) => {
+      p("blur", a), z.value = !1;
+    }, Y = (a) => p("change", a), Z = de((a) => {
+      p("update:model-value", a);
+    }, t.debounceDelay), _ = (a) => {
+      if (t.debounce)
+        return Z(a);
+      p("update:model-value", a);
+    };
+    return (a, c) => (i(), v(
+      "div",
+      {
+        class: V(["m-input", [
+          {
+            "--is-focused": z.value || e.borderActive,
+            "--should-up": j.value,
+            "--has-label": G.value,
+            "--is-disabled": e.disabled,
+            "--is-readonly": e.readonly,
+            "--has-z-2": e.error || e.warning || e.success,
+            "--has-state": e.error || e.warning || e.success
+          },
+          S.value,
+          `--${e.color}`,
+          `--${e.size}`
+        ]]),
+        style: le(e.style)
+      },
+      [
+        $(
+          "div",
+          {
+            class: V(["m-input-wrapper", [e.inputClasses, U.value, { "maz-rounded": !e.noRadius }]])
+          },
+          [
+            X() ? (i(), v("div", me, [
+              a.$slots["left-icon"] || e.leftIcon ? T(a.$slots, "left-icon", { key: 0 }, () => [
+                b(m(l), {
+                  name: e.leftIcon,
+                  class: "maz-text-xl maz-text-muted"
+                }, null, 8, ["name"])
+              ], !0) : y("v-if", !0)
+            ])) : y("v-if", !0),
+            $("div", fe, [
+              re($("input", D({
+                id: m(d),
+                ref_key: "input",
+                ref: s,
+                "onUpdate:modelValue": c[0] || (c[0] = (I) => A.value = I),
+                type: J.value,
+                name: e.name
+              }, a.$attrs, {
+                placeholder: K.value,
+                "aria-label": e.label || e.placeholder,
+                disabled: e.disabled,
+                readonly: e.readonly,
+                required: e.required,
+                class: "m-input-input"
+              }, ne({
+                blur: W,
+                focus: Q,
+                change: Y
+              }, !0), {
+                onClick: c[1] || (c[1] = (I) => a.$emit("click", I))
+              }), null, 16, ve), [
+                [oe, A.value]
+              ]),
+              e.label || e.hint ? (i(), v(
+                "span",
+                {
+                  key: 0,
+                  ref: "label",
+                  class: V(["m-input-label", [
+                    {
+                      "maz-text-danger-600": e.error,
+                      "maz-text-success-600": e.success,
+                      "maz-text-warning-600": e.warning
+                    }
+                  ]])
+                },
+                [
+                  F(
+                    L(e.hint || e.label) + " ",
+                    1
+                    /* TEXT */
+                  ),
+                  e.required ? (i(), v("sup", ye, "*")) : y("v-if", !0)
+                ],
+                2
+                /* CLASS */
+              )) : y("v-if", !0)
+            ]),
+            H() ? (i(), v("div", be, [
+              a.$slots["right-icon"] || e.rightIcon ? T(a.$slots, "right-icon", { key: 0 }, () => [
+                b(m(l), {
+                  name: e.rightIcon,
+                  class: "maz-text-xl maz-text-muted"
+                }, null, 8, ["name"])
+              ], !0) : y("v-if", !0),
+              C.value ? (i(), N(m(o), {
+                key: 1,
+                color: "transparent",
+                tabindex: "-1",
+                size: "mini",
+                onClick: c[2] || (c[2] = P((I) => h.value = !h.value, ["stop"]))
+              }, {
+                default: x(() => [
+                  h.value ? (i(), N(m(g), {
+                    key: 0,
+                    class: "maz-text-xl maz-text-muted"
+                  })) : (i(), N(m(f), {
+                    key: 1,
+                    class: "maz-text-xl maz-text-muted"
+                  }))
+                ]),
+                _: 1
+                /* STABLE */
+              })) : y("v-if", !0),
+              a.$slots["valid-button"] || e.validButton ? T(a.$slots, "valid-button", { key: 2 }, () => [
+                b(m(o), {
+                  color: "transparent",
+                  disabled: e.disabled,
+                  tabindex: "-1",
+                  loading: e.validButtonLoading,
+                  class: "m-input-valid-button",
+                  size: "mini",
+                  type: "submit"
+                }, {
+                  default: x(() => [
+                    b(m(k), { class: "maz-text-2xl maz-text-normal" })
+                  ]),
+                  _: 1
+                  /* STABLE */
+                }, 8, ["disabled", "loading"])
+              ], !0) : y("v-if", !0)
+            ])) : y("v-if", !0)
+          ],
+          2
+          /* CLASS */
+        )
+      ],
+      6
+      /* CLASS, STYLE */
+    ));
+  }
+});
+const E = (e, n) => {
+  const o = e.__vccOpts || e;
+  for (const [l, g] of n)
+    o[l] = g;
+  return o;
+}, pe = /* @__PURE__ */ E(ge, [["__scopeId", "data-v-32fa5093"]]), ze = {
+  xmlns: "http://www.w3.org/2000/svg",
+  width: "1em",
+  height: "1em",
+  fill: "none",
+  viewBox: "0 0 24 24"
+}, he = /* @__PURE__ */ $(
+  "path",
+  {
+    stroke: "currentColor",
+    "stroke-linecap": "round",
+    "stroke-linejoin": "round",
+    "stroke-width": "1.5",
+    d: "M6 18 18 6M6 6l12 12"
+  },
+  null,
+  -1
+  /* HOISTED */
+), we = [
+  he
+];
+function ke(e, n) {
+  return i(), v("svg", ze, [...we]);
+}
+const Be = { render: ke }, xe = /* @__PURE__ */ O({
+  __name: "MazInputTags",
+  props: {
+    // Input value, can be a `Array` of `String` or `null`
+    modelValue: {
+      type: Array,
+      default: void 0
+    },
+    // input placeholder
+    placeholder: { type: String, default: void 0 },
+    label: { type: String, default: void 0 },
+    // When is `true` the input is disable
+    disabled: { type: Boolean, default: !1 },
+    // When is `true` the input has the error style (red)
+    error: { type: Boolean, default: !1 },
+    success: { type: Boolean, default: !1 },
+    warning: { type: Boolean, default: !1 },
+    size: {
+      type: String,
+      default: "md",
+      validator: (e) => ["mini", "xs", "sm", "md", "lg", "xl"].includes(e)
+    },
+    color: {
+      type: String,
+      default: "primary"
+    }
+  },
+  emits: ["update:model-value"],
+  setup(e, { emit: n }) {
+    const o = w(() => import("./MazBtn-555928ed.mjs")), l = e, g = B(!1), f = B(), k = n, t = (s) => {
+      if (f.value) {
+        s.preventDefault();
+        const r = f.value.trim().split(",").map((d) => d.trim() === "," ? void 0 : d.trim()).filter(Boolean);
+        k("update:model-value", l.modelValue ? [...l.modelValue, ...r] : [...r]), f.value = void 0;
+      }
+    }, p = u(() => {
+      if (l.error)
+        return "maz-border-danger";
+      if (l.success)
+        return "maz-border-success";
+      if (l.warning)
+        return "maz-border-warning";
+      if (g.value) {
+        if (l.color === "primary")
+          return "maz-border-primary";
+        if (l.color === "secondary")
+          return "maz-border-secondary";
+        if (l.color === "info")
+          return "maz-border-info";
+        if (l.color === "danger")
+          return "maz-border-danger";
+        if (l.color === "success")
+          return "maz-border-success";
+        if (l.color === "warning")
+          return "maz-border-warning";
+        if (l.color === "black")
+          return "maz-border-black";
+        if (l.color === "white")
+          return "maz-border-white";
+      }
+      return "maz-border-gray-200";
+    }), h = () => {
+      if (!f.value || f.value === "") {
+        const s = JSON.parse(JSON.stringify(l.modelValue));
+        s.pop(), k("update:model-value", s);
+      }
+    }, z = (s) => {
+      const r = JSON.parse(JSON.stringify(l.modelValue));
+      r.splice(s, 1), k("update:model-value", r);
+    };
+    return (s, r) => (i(), v(
+      "div",
+      {
+        class: V(["m-input-tags", [p.value, `--${e.color}`]]),
+        onFocusCapture: r[1] || (r[1] = (d) => g.value = !0),
+        onBlurCapture: r[2] || (r[2] = (d) => g.value = !1)
+      },
+      [
+        b(ie, { name: "maz-tags" }, {
+          default: x(() => [
+            (i(!0), v(
+              se,
+              null,
+              ue(e.modelValue, (d, S) => (i(), v("div", {
+                key: `tag-${S}`
+              }, [
+                b(m(o), {
+                  class: "m-input-tags__tag",
+                  disabled: e.disabled,
+                  size: e.size,
+                  color: e.color,
+                  onClick: P((C) => z(S), ["stop"])
+                }, {
+                  default: x(() => [
+                    F(
+                      L(d),
+                      1
+                      /* TEXT */
+                    )
+                  ]),
+                  "right-icon": x(() => [
+                    b(m(Be), { class: "m-input-tags__tag__icon" })
+                  ]),
+                  _: 2
+                  /* DYNAMIC */
+                }, 1032, ["disabled", "size", "color", "onClick"])
+              ]))),
+              128
+              /* KEYED_FRAGMENT */
+            ))
+          ]),
+          _: 1
+          /* STABLE */
+        }),
+        b(pe, D({
+          key: "input-tags",
+          modelValue: f.value,
+          "onUpdate:modelValue": r[0] || (r[0] = (d) => f.value = d)
+        }, s.$attrs, {
+          placeholder: e.placeholder,
+          label: e.label,
+          "aria-label": e.label || e.placeholder,
+          error: e.error,
+          disabled: e.disabled,
+          color: e.color,
+          size: e.size,
+          "no-border": "",
+          class: "m-input-tags__input maz-flex-1",
+          onKeydown: [
+            q(t, ["enter"]),
+            q(h, ["delete"])
+          ]
+        }), null, 16, ["modelValue", "placeholder", "label", "aria-label", "error", "disabled", "color", "size", "onKeydown"])
+      ],
+      34
+      /* CLASS, HYDRATE_EVENTS */
+    ));
+  }
+});
+const Ve = /* @__PURE__ */ E(xe, [["__scopeId", "data-v-82c91368"]]);
+export {
+  Ve as M,
+  E as _
+};

package/components/chunks/MazLazyImg-0412ab38.mjs

@@ -0,0 +1,259 @@
+var u = Object.defineProperty;
+var f = (a, e, t) => e in a ? u(a, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : a[e] = t;
+var i = (a, e, t) => (f(a, typeof e != "symbol" ? e + "" : e, t), t);
+import "../assets/MazLazyImg.css";
+import { defineComponent as v, defineAsyncComponent as p, computed as A, withDirectives as I, openBlock as d, createElementBlock as c, normalizeClass as b, Fragment as y, renderList as C, createElementVNode as E, mergeProps as L, createVNode as O, unref as h, createCommentVNode as z, renderSlot as P } from "vue";
+const w = "data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7", B = {
+  baseClass: "m-lazy-img",
+  loadedClass: "m-lazy-loaded",
+  loadingClass: "m-lazy-loading",
+  errorClass: "m-lazy-error",
+  noPhotoClass: "m-lazy-no-photo",
+  noPhoto: !1,
+  observerOnce: !0,
+  loadOnce: !1,
+  noUseErrorPhoto: !1,
+  observerOptions: {
+    threshold: 0.1
+  }
+};
+class S {
+  constructor(e = {}) {
+    i(this, "observers", []);
+    i(this, "defaultOptions", B);
+    i(this, "options");
+    i(this, "onImgLoadedCallback");
+    i(this, "onImgErrorCallback");
+    i(this, "hasImgLoaded", !1);
+    this.options = this.buildOptions(e), this.onImgLoadedCallback = this.imageIsLoaded.bind(this), this.onImgErrorCallback = this.imageHasError.bind(this);
+  }
+  async loadErrorPhoto() {
+    const { default: e } = await import("./no-photography-4c6c77cf.mjs");
+    return e;
+  }
+  buildOptions(e) {
+    return {
+      ...this.defaultOptions,
+      ...e,
+      observerOptions: {
+        ...this.defaultOptions.observerOptions,
+        ...e.observerOptions
+      }
+    };
+  }
+  removeClass(e, t) {
+    e.classList.remove(t);
+  }
+  addClass(e, t) {
+    e.classList.add(t);
+  }
+  removeAllStateClasses(e) {
+    this.removeClass(e, this.options.loadedClass), this.removeClass(e, this.options.loadingClass), this.removeClass(e, this.options.errorClass), this.removeClass(e, this.options.noPhotoClass);
+  }
+  setBaseClass(e) {
+    this.addClass(e, this.options.baseClass);
+  }
+  imageIsLoading(e) {
+    var t, s;
+    this.addClass(e, this.options.loadingClass), (s = (t = this.options).onLoading) == null || s.call(t, e);
+  }
+  imageHasNoPhoto(e) {
+    this.removeClass(e, this.options.loadingClass), this.addClass(e, this.options.noPhotoClass), this.setDefaultPhoto(e);
+  }
+  imageIsLoaded(e) {
+    var t, s;
+    this.hasImgLoaded = !0, this.removeClass(e, this.options.loadingClass), this.addClass(e, this.options.loadedClass), (s = (t = this.options).onLoaded) == null || s.call(t, e);
+  }
+  imageHasError(e, t) {
+    var s, o;
+    console.warn("[maz-ui][MazLazyImg] Error while loading image", t), this.removeClass(e, this.options.loadingClass), this.addClass(e, this.options.errorClass), (o = (s = this.options).onError) == null || o.call(s, e), this.setDefaultPhoto(e);
+  }
+  getImageUrl(e, t) {
+    const s = this.getImgElement(e).getAttribute("data-lazy-src");
+    if (s)
+      return s;
+    t.value;
+    const o = typeof t.value == "object" ? t.value.src : t.value;
+    return o || console.warn("[maz-ui][MazLazyImg] src url is not defined"), o;
+  }
+  async setPictureSourceUrls(e) {
+    const t = e.querySelectorAll("source");
+    if (t.length > 0)
+      for await (const s of t) {
+        const o = s.getAttribute("data-lazy-srcset");
+        o ? s.srcset = o : console.warn(
+          '[maz-ui][MazLazyImg] the "[data-lazy-srcset]" attribute is not provided on "<source />"'
+        );
+      }
+    else
+      console.warn(
+        '[maz-ui][MazLazyImg] No "<source />" elements provided into the "<picture />" element'
+      ), this.imageHasError(e);
+  }
+  hasBgImgMode(e) {
+    return e.arg === "bg-image";
+  }
+  isPictureElement(e) {
+    return e instanceof HTMLPictureElement;
+  }
+  getImgElement(e) {
+    return this.isPictureElement(e) ? e.querySelector("img") : e;
+  }
+  async setDefaultPhoto(e) {
+    if (this.options.noUseErrorPhoto)
+      return;
+    const t = this.options.errorPhoto ?? await this.loadErrorPhoto(), s = e.querySelectorAll("source");
+    if (s.length > 0)
+      for await (const o of s)
+        o.srcset = t;
+    else
+      this.setImgSrc(e, t);
+  }
+  addEventListenerToImg(e) {
+    const t = this.getImgElement(e);
+    t.addEventListener("load", () => this.onImgLoadedCallback(e), {
+      once: !0
+    }), t.addEventListener("error", (s) => this.onImgErrorCallback(e, s), { once: !0 });
+  }
+  async loadImage(e, t) {
+    if (this.imageIsLoading(e), this.isPictureElement(e))
+      this.addEventListenerToImg(e), await this.setPictureSourceUrls(e);
+    else {
+      const s = this.getImageUrl(e, t);
+      if (!s)
+        return this.imageHasError(e);
+      this.hasBgImgMode(t) ? (e.style.backgroundImage = `url('${s}')`, this.imageIsLoaded(e)) : (this.addEventListenerToImg(e), this.setImgSrc(e, s));
+    }
+  }
+  setImgSrc(e, t) {
+    const s = this.getImgElement(e);
+    s.src = t;
+  }
+  handleIntersectionObserver(e, t, s, o) {
+    var l, r;
+    this.observers.push(o);
+    for (const n of s)
+      if (n.isIntersecting) {
+        if ((r = (l = this.options).onIntersecting) == null || r.call(l, n.target), this.options.observerOnce && o.unobserve(e), this.options.loadOnce && this.hasImgLoaded)
+          return;
+        this.loadImage(e, t);
+      }
+  }
+  createObserver(e, t) {
+    const s = (r, n) => {
+      this.handleIntersectionObserver(e, t, r, n);
+    }, o = this.options.observerOptions;
+    new IntersectionObserver(s, o).observe(e);
+  }
+  async imageHandler(e, t, s) {
+    if (s === "update")
+      for await (const o of this.observers)
+        o.unobserve(e);
+    window.IntersectionObserver ? this.createObserver(e, t) : this.loadImage(e, t);
+  }
+  async bindUpdateHandler(e, t, s) {
+    if (this.options.noPhoto)
+      return this.imageHasNoPhoto(e);
+    await this.imageHandler(e, t, s);
+  }
+  async add(e, t) {
+    if (this.hasBgImgMode(t) && this.isPictureElement(e))
+      throw new Error(`[MazLazyImg] You can't use the "bg-image" mode with "<picture />" element`);
+    setTimeout(() => this.setBaseClass(e), 0), e.getAttribute("src") || this.setImgSrc(e, w), await this.bindUpdateHandler(e, t, "bind");
+  }
+  async update(e, t) {
+    t.value !== t.oldValue && (this.hasImgLoaded = !1, this.removeAllStateClasses(e), await this.bindUpdateHandler(e, t, "update"));
+  }
+  remove(e, t) {
+    this.hasImgLoaded = !1, this.hasBgImgMode(t) && (e.style.backgroundImage = ""), this.removeAllStateClasses(e);
+    for (const s of this.observers)
+      s.unobserve(e);
+    this.observers = [];
+  }
+}
+let m;
+const H = {
+  created(a, e) {
+    const t = typeof e.value == "object" ? e.value : {};
+    m = new S(t), m.add(a, e);
+  },
+  updated(a, e) {
+    m.update(a, e);
+  },
+  unmounted(a, e) {
+    m.remove(a, e);
+  }
+}, M = ["data-lazy-srcset", "media"], k = ["alt"], U = {
+  key: 0,
+  class: "m-lazy-img-component-loader"
+}, T = /* @__PURE__ */ v({
+  __name: "MazLazyImg",
+  props: {
+    image: { type: [String, Object], default: void 0 },
+    alt: { type: String, default: void 0 },
+    noPhoto: { type: Boolean, default: !1 },
+    noLoader: { type: Boolean, default: !1 },
+    noObserverOnce: { type: Boolean, default: !1 },
+    loadOnce: { type: Boolean, default: !1 },
+    imageHeightFull: { type: Boolean, default: !1 },
+    observerOptions: { type: Object, default: null }
+  },
+  emits: ["intersecting", "loading", "loaded", "error"],
+  setup(a) {
+    const e = p(() => import("./MazSpinner-a13a50c9.mjs")), t = a, s = A(() => {
+      var o;
+      return typeof t.image == "string" ? [{ srcset: t.image }] : (o = t.image) == null ? void 0 : o.sources;
+    });
+    return (o, l) => I((d(), c(
+      "picture",
+      {
+        class: b(["m-lazy-img-component", { "-use-loader": !a.noLoader, "--height-full": a.imageHeightFull }])
+      },
+      [
+        (d(!0), c(
+          y,
+          null,
+          C(s.value, ({ srcset: r, media: n }, g) => (d(), c("source", {
+            key: g,
+            "data-lazy-srcset": r,
+            media: n
+          }, null, 8, M))),
+          128
+          /* KEYED_FRAGMENT */
+        )),
+        E("img", L(o.$attrs, {
+          src: "data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7",
+          loading: "lazy",
+          alt: a.alt
+        }), null, 16, k),
+        a.noLoader ? z("v-if", !0) : (d(), c("div", U, [
+          O(h(e), { size: "2em" })
+        ])),
+        P(o.$slots, "default", {}, void 0, !0)
+      ],
+      2
+      /* CLASS */
+    )), [
+      [h(H), {
+        noPhoto: a.noPhoto,
+        observerOnce: !a.noObserverOnce,
+        loadOnce: a.loadOnce,
+        onIntersecting: (r) => o.$emit("intersecting", r),
+        onLoading: (r) => o.$emit("loading", r),
+        onLoaded: (r) => o.$emit("loaded", r),
+        onError: (r) => o.$emit("error", r),
+        observerOptions: a.observerOptions
+      }]
+    ]);
+  }
+});
+const _ = (a, e) => {
+  const t = a.__vccOpts || a;
+  for (const [s, o] of e)
+    t[s] = o;
+  return t;
+}, j = /* @__PURE__ */ _(T, [["__scopeId", "data-v-3bfe9795"]]);
+export {
+  j as M,
+  _
+};