@ironsource/shared-ui 2.0.0-rc.6 → 2.0.0-rc.7

package/components/radioButton/v4/index.d.ts

@@ -0,0 +1,334 @@
+import { default as RadioButton } from './RadioButtonV4.vue';
+import { default as RadioGroup } from './RadioGroupV4.vue';
+declare const RadioButtonTypes: () => (({
+    new (...args: any[]): {
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{
+            name: string;
+            label: string;
+            testId: string;
+            modelValue: string;
+        }> & Omit<Readonly<import("vue").ExtractPropTypes<{
+            value: {
+                type: import("vue").PropType<unknown>;
+                required: true;
+            };
+            name: {
+                type: import("vue").PropType<string>;
+                default: string;
+            };
+            label: {
+                type: import("vue").PropType<string>;
+                required: true;
+                default: string;
+            };
+            testId: {
+                type: import("vue").PropType<string>;
+                default: string;
+            };
+            modelValue: {
+                type: import("vue").PropType<string>;
+                default: any;
+            };
+        }>> & {
+            onChange?: (...args: any[]) => any;
+            "onUpdate:modelValue"?: (...args: any[]) => any;
+        } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "name" | "label" | "testId" | "modelValue">;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import("vue").Slot;
+        }>;
+        $root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>;
+        $parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>;
+        $emit: ((event: "update:modelValue", ...args: any[]) => void) & ((event: "change", ...args: any[]) => void);
+        $el: any;
+        $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+            value: {
+                type: import("vue").PropType<unknown>;
+                required: true;
+            };
+            name: {
+                type: import("vue").PropType<string>;
+                default: string;
+            };
+            label: {
+                type: import("vue").PropType<string>;
+                required: true;
+                default: string;
+            };
+            testId: {
+                type: import("vue").PropType<string>;
+                default: string;
+            };
+            modelValue: {
+                type: import("vue").PropType<string>;
+                default: any;
+            };
+        }>> & {
+            onChange?: (...args: any[]) => any;
+            "onUpdate:modelValue"?: (...args: any[]) => any;
+        }, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            "update:modelValue": (...args: any[]) => void;
+            change: (...args: any[]) => void;
+        }, string, {
+            name: string;
+            label: string;
+            testId: string;
+            modelValue: string;
+        }, {}, string> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import("vue").nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: import("vue").WatchOptions<boolean>): import("vue").WatchStopHandle;
+    } & Readonly<import("vue").ExtractPropTypes<{
+        value: {
+            type: import("vue").PropType<unknown>;
+            required: true;
+        };
+        name: {
+            type: import("vue").PropType<string>;
+            default: string;
+        };
+        label: {
+            type: import("vue").PropType<string>;
+            required: true;
+            default: string;
+        };
+        testId: {
+            type: import("vue").PropType<string>;
+            default: string;
+        };
+        modelValue: {
+            type: import("vue").PropType<string>;
+            default: any;
+        };
+    }>> & {
+        onChange?: (...args: any[]) => any;
+        "onUpdate:modelValue"?: (...args: any[]) => any;
+    } & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties & {};
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+    value: {
+        type: import("vue").PropType<unknown>;
+        required: true;
+    };
+    name: {
+        type: import("vue").PropType<string>;
+        default: string;
+    };
+    label: {
+        type: import("vue").PropType<string>;
+        required: true;
+        default: string;
+    };
+    testId: {
+        type: import("vue").PropType<string>;
+        default: string;
+    };
+    modelValue: {
+        type: import("vue").PropType<string>;
+        default: any;
+    };
+}>> & {
+    onChange?: (...args: any[]) => any;
+    "onUpdate:modelValue"?: (...args: any[]) => any;
+}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (...args: any[]) => void;
+    change: (...args: any[]) => void;
+}, string, {
+    name: string;
+    label: string;
+    testId: string;
+    modelValue: string;
+}, {}, string> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+    $slots: {
+        default?(_: {}): any;
+    };
+})) | ({
+    new (...args: any[]): {
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{
+            name: string;
+            testId: string;
+            disabled: boolean;
+            row: boolean;
+        }> & Omit<Readonly<import("vue").ExtractPropTypes<{
+            name: {
+                type: import("vue").PropType<string>;
+                default: string;
+            };
+            testId: {
+                type: import("vue").PropType<string>;
+                default: string;
+            };
+            disabled: {
+                type: import("vue").PropType<boolean>;
+                default: boolean;
+            };
+            modelValue: {
+                type: import("vue").PropType<string>;
+                required: true;
+            };
+            row: {
+                type: import("vue").PropType<boolean>;
+                default: boolean;
+            };
+        }>> & {
+            onChange?: (...args: any[]) => any;
+            "onUpdate:modelValue"?: (...args: any[]) => any;
+        } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "name" | "testId" | "disabled" | "row">;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import("vue").Slot;
+        }>;
+        $root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>;
+        $parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>;
+        $emit: ((event: "update:modelValue", ...args: any[]) => void) & ((event: "change", ...args: any[]) => void);
+        $el: any;
+        $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+            name: {
+                type: import("vue").PropType<string>;
+                default: string;
+            };
+            testId: {
+                type: import("vue").PropType<string>;
+                default: string;
+            };
+            disabled: {
+                type: import("vue").PropType<boolean>;
+                default: boolean;
+            };
+            modelValue: {
+                type: import("vue").PropType<string>;
+                required: true;
+            };
+            row: {
+                type: import("vue").PropType<boolean>;
+                default: boolean;
+            };
+        }>> & {
+            onChange?: (...args: any[]) => any;
+            "onUpdate:modelValue"?: (...args: any[]) => any;
+        }, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            "update:modelValue": (...args: any[]) => void;
+            change: (...args: any[]) => void;
+        }, string, {
+            name: string;
+            testId: string;
+            disabled: boolean;
+            row: boolean;
+        }, {}, string> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import("vue").nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: import("vue").WatchOptions<boolean>): import("vue").WatchStopHandle;
+    } & Readonly<import("vue").ExtractPropTypes<{
+        name: {
+            type: import("vue").PropType<string>;
+            default: string;
+        };
+        testId: {
+            type: import("vue").PropType<string>;
+            default: string;
+        };
+        disabled: {
+            type: import("vue").PropType<boolean>;
+            default: boolean;
+        };
+        modelValue: {
+            type: import("vue").PropType<string>;
+            required: true;
+        };
+        row: {
+            type: import("vue").PropType<boolean>;
+            default: boolean;
+        };
+    }>> & {
+        onChange?: (...args: any[]) => any;
+        "onUpdate:modelValue"?: (...args: any[]) => any;
+    } & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties & {};
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+    name: {
+        type: import("vue").PropType<string>;
+        default: string;
+    };
+    testId: {
+        type: import("vue").PropType<string>;
+        default: string;
+    };
+    disabled: {
+        type: import("vue").PropType<boolean>;
+        default: boolean;
+    };
+    modelValue: {
+        type: import("vue").PropType<string>;
+        required: true;
+    };
+    row: {
+        type: import("vue").PropType<boolean>;
+        default: boolean;
+    };
+}>> & {
+    onChange?: (...args: any[]) => any;
+    "onUpdate:modelValue"?: (...args: any[]) => any;
+}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (...args: any[]) => void;
+    change: (...args: any[]) => void;
+}, string, {
+    name: string;
+    testId: string;
+    disabled: boolean;
+    row: boolean;
+}, {}, string> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+    $slots: {
+        default?(_: {}): any;
+    };
+})))[];
+export { RadioButton, RadioGroup, RadioButtonTypes };

package/components/radioButton/v4/index.js

@@ -0,0 +1,8 @@
+import o from "./RadioButtonV4.vue.js";
+import t from "./RadioGroupV4.vue.js";
+const p = () => [o, t];
+export {
+  o as RadioButton,
+  p as RadioButtonTypes,
+  t as RadioGroup
+};

package/components/snackbar/common/notify.d.ts

@@ -0,0 +1,3 @@
+import type { Notify } from './snackbar.types';
+declare const createNotify: (constructorComponent: any) => Notify;
+export default createNotify;

package/components/snackbar/common/notify.js

@@ -0,0 +1,82 @@
+import { isVNode as x, createVNode as N, render as v } from "vue";
+import { snackbarTypes as C } from "./snackbar.types.js";
+const p = {
+  "top-left": [],
+  "top-right": [],
+  "bottom-left": [],
+  "bottom-right": []
+}, g = 16;
+let A = 1;
+const E = 2e3, H = (h) => {
+  const i = function(e = {}, t = null) {
+    (typeof e == "string" || x(e)) && (e = { message: e });
+    const o = e.position || "top-right";
+    let n = e.zIndex || E, s = p[o].reduce(
+      (m, { vm: b }) => m + (b.el?.offsetHeight || 0) + g,
+      e.offset || 0
+    );
+    s += g;
+    const l = () => n++, d = `notification_${A++}`, u = e.onClose, f = {
+      ...e,
+      zIndex: l(),
+      offset: s,
+      id: d,
+      onClose: () => {
+        y(d, o, u);
+      }
+    }, c = document.body, a = document.createElement("div"), r = N(
+      h,
+      f,
+      x(f.message) ? {
+        default: () => f.message
+      } : null
+    );
+    return r.appContext = t ?? i._context, r.props.onDestroy = () => {
+      v(null, a);
+    }, v(r, a), p[o].push({ vm: r }), c.appendChild(a?.firstElementChild), {
+      // instead of calling the onClose function directly, setting this value so that we can have the full lifecycle
+      // for out component, so that all closing steps will not be skipped.
+      close: () => {
+        const m = r.component?.proxy;
+        m && (m.visible = !1);
+      }
+    };
+  };
+  function y(e, t, o) {
+    const n = p[t], s = n.findIndex(
+      ({ vm: c }) => c.component?.props.id === e
+    );
+    if (s === -1)
+      return;
+    const { vm: l } = n[s];
+    if (!l)
+      return;
+    o?.(l);
+    const d = l.el?.offsetHeight, u = t.split("-")[0];
+    n.splice(s, 1);
+    const f = n.length;
+    for (let c = s; c < f; c++) {
+      const { el: a, component: r } = n[c].vm;
+      r.props.offset = Number.parseInt(a.style[u], 10) - d - g;
+    }
+  }
+  C.forEach((e) => {
+    i[e] = (t = {}) => ((typeof t == "string" || x(t)) && (t = {
+      message: t
+    }), i({
+      ...t,
+      type: e
+    }));
+  });
+  function I() {
+    for (const e of Object.values(p))
+      e.forEach(({ vm: t }) => {
+        const o = t.component?.proxy;
+        o && (o.visible = !1);
+      });
+  }
+  return i.closeAll = I, i._context = null, i;
+};
+export {
+  H as default
+};

package/components/snackbar/common/snackbar.common.d.ts

@@ -0,0 +1,11 @@
+import type { CSSProperties } from 'vue';
+export declare const snackbarCommon: (props: any) => {
+    visible: import("vue").Ref<boolean>;
+    horizontalClass: import("vue").ComputedRef<"right" | "left">;
+    positionStyle: import("vue").ComputedRef<CSSProperties>;
+    clearTimer: () => void;
+    startTimer: () => void;
+    iconComponent: import("vue").ComputedRef<any>;
+    typeClass: import("vue").ComputedRef<any>;
+    close: () => void;
+};

package/components/snackbar/common/snackbar.common.js

@@ -0,0 +1,51 @@
+import { ref as v, computed as n, onMounted as p } from "vue";
+import { useEventListener as C, useTimeoutFn as h } from "@vueuse/core";
+import k from "../../icon/v3/icons/Close.vue.js";
+import x from "../../icon/v3/icons/Check.vue.js";
+const w = (t) => {
+  const r = {
+    success: x,
+    error: k
+  }, o = v(!1);
+  let c;
+  const a = n(() => {
+    const e = t.type;
+    return e && r[t.type] ? e : "";
+  }), l = n(() => r[t.type] || t.icon || ""), f = n(
+    () => t.position.endsWith("right") ? "right" : "left"
+  ), m = n(
+    () => t.position.startsWith("top") ? "top" : "bottom"
+  ), y = n(() => ({
+    [m.value]: `${t.offset}px`,
+    zIndex: t.zIndex
+  }));
+  function i() {
+    t.duration > 0 && ({ stop: c } = h(() => {
+      o.value && s();
+    }, t.duration));
+  }
+  function u() {
+    c?.();
+  }
+  function s() {
+    o.value = !1;
+  }
+  function d({ code: e }) {
+    e === "Delete" || e === "Backspace" ? u() : e === "Escape" ? o.value && s() : i();
+  }
+  return p(() => {
+    i(), o.value = !0;
+  }), C(document, "keydown", d), {
+    visible: o,
+    horizontalClass: f,
+    positionStyle: y,
+    clearTimer: u,
+    startTimer: i,
+    iconComponent: l,
+    typeClass: a,
+    close: s
+  };
+};
+export {
+  w as snackbarCommon
+};

package/components/snackbar/v3/Snackbar.vue.js

@@ -0,0 +1,7 @@
+import o from "./Snackbar.vue2.js";
+/* empty css               */import e from "../../../_virtual/_plugin-vue_export-helper.js";
+// import "../../../Snackbar.vue_vue_type_style_index_0_scoped_cec4f8e5_lang.css"; //*');
+const r = /* @__PURE__ */ e(o, [["__scopeId", "data-v-cec4f8e5"]]);
+export {
+  r as default
+};

package/components/snackbar/v3/Snackbar.vue2.js

@@ -0,0 +1,129 @@
+ import "../../../Snackbar.vue_vue_type_style_index_0_scoped_cec4f8e5_lang.css"; import { defineComponent as w, openBlock as n, createBlock as s, Transition as x, withCtx as i, withDirectives as k, createElementVNode as a, normalizeClass as y, unref as e, normalizeStyle as v, createElementBlock as g, createVNode as r, resolveDynamicComponent as H, createCommentVNode as m, renderSlot as N, createTextVNode as V, toDisplayString as p, vShow as z, withModifiers as D } from "vue";
+import T from "../../icon/v3/Icon.vue.js";
+import I from "../../icon/v3/icons/Close.vue.js";
+import "../../button/v3/Button.vue.js";
+import $ from "../../button/v3/IconButton.vue.js";
+import "../../button/v3/ScrollButton.vue.js";
+import B from "../../typography/Text.vue.js";
+import { snackbarCommon as E } from "../common/snackbar.common.js";
+const U = ["id"], A = { class: "container" }, j = { class: "texts" }, q = ["innerHTML"], W = /* @__PURE__ */ w({
+  __name: "Snackbar",
+  props: {
+    customClass: null,
+    dangerouslyUseHTMLString: { type: Boolean },
+    duration: { default: 3e3 },
+    icon: null,
+    id: null,
+    message: null,
+    offset: null,
+    onClick: null,
+    onClose: null,
+    type: { default: null },
+    position: { default: "top-right" },
+    showClose: { type: Boolean, default: !0 },
+    title: { default: "" },
+    zIndex: { default: 0 }
+  },
+  emits: ["destroy"],
+  setup(t) {
+    const S = t, {
+      visible: b,
+      horizontalClass: h,
+      positionStyle: L,
+      clearTimer: d,
+      startTimer: u,
+      iconComponent: c,
+      typeClass: f,
+      close: M
+    } = E(S);
+    return (C, o) => (n(), s(x, {
+      name: "snackbar",
+      onBeforeLeave: t.onClose,
+      onAfterLeave: o[3] || (o[3] = (l) => C.$emit("destroy"))
+    }, {
+      default: i(() => [
+        k(a("div", {
+          id: t.id,
+          class: y(["snackbar", [t.customClass, e(h)]]),
+          style: v(e(L)),
+          role: "alert",
+          onMouseenter: o[0] || (o[0] = //@ts-ignore
+          (...l) => e(d) && e(d)(...l)),
+          onMouseleave: o[1] || (o[1] = //@ts-ignore
+          (...l) => e(u) && e(u)(...l)),
+          onClick: o[2] || (o[2] = //@ts-ignore
+          (...l) => t.onClick && t.onClick(...l))
+        }, [
+          e(c) ? (n(), g("div", {
+            key: 0,
+            class: y(["start-icon-container", [e(f)]])
+          }, [
+            r(e(T), {
+              "font-size": e(f) ? "sm" : "lg"
+            }, {
+              default: i(() => [
+                (n(), s(H(e(c))))
+              ]),
+              _: 1
+            }, 8, ["font-size"])
+          ], 2)) : m("", !0),
+          a("div", A, [
+            a("div", j, [
+              t.title ? (n(), s(B, {
+                key: 0,
+                size: "md",
+                strong: "",
+                class: "title"
+              })) : m("", !0),
+              k(a("div", {
+                class: "message",
+                style: v(t.title ? void 0 : { margin: 0 })
+              }, [
+                N(C.$slots, "default", {}, () => [
+                  t.dangerouslyUseHTMLString ? (n(), g("div", {
+                    key: 1,
+                    innerHTML: t.message
+                  }, null, 8, q)) : (n(), s(B, {
+                    key: 0,
+                    size: "sm"
+                  }, {
+                    default: i(() => [
+                      V(p(t.message), 1)
+                    ]),
+                    _: 1
+                  }))
+                ], !0)
+              ], 4), [
+                [z, t.message]
+              ])
+            ]),
+            t.showClose ? (n(), s(e($), {
+              key: 0,
+              theme: "third",
+              size: "sm",
+              class: "snackbar-close-button",
+              variant: "colorized",
+              onClick: D(e(M), ["stop"])
+            }, {
+              default: i(() => [
+                r(e(T), null, {
+                  default: i(() => [
+                    r(I)
+                  ]),
+                  _: 1
+                })
+              ]),
+              _: 1
+            }, 8, ["onClick"])) : m("", !0)
+          ])
+        ], 46, U), [
+          [z, e(b)]
+        ])
+      ]),
+      _: 3
+    }, 8, ["onBeforeLeave"]));
+  }
+});
+export {
+  W as default
+};

package/components/snackbar/v3/index.d.ts

@@ -0,0 +1,3 @@
+export declare const Snackbar: import("../common/snackbar.types").Notify;
+export default Snackbar;
+export * from '../common/snackbar.types';

package/components/snackbar/v3/index.js

@@ -0,0 +1,10 @@
+import r from "./Snackbar.vue.js";
+import a from "../common/notify.js";
+import { snackbarEmits as m, snackbarTypes as n } from "../common/snackbar.types.js";
+const c = a(r);
+export {
+  c as Snackbar,
+  c as default,
+  m as snackbarEmits,
+  n as snackbarTypes
+};