@ironsource/shared-ui 1.4.2-test.19 → 1.4.2-test.3

package/components/datePicker/index.d.ts

@@ -1,65 +1,165 @@
-declare const DatePickerTypes: () => import("vue").DefineComponent<{
-    modelValue: {
-        type: import("vue").PropType<string | Date>;
-    } & {
-        default: any;
-    };
+declare const DatePickerTypes: () => ({
+    new (...args: any[]): {
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{
+            placeholder: string;
+            modelValue: string | Date;
+            uniqueId: string | number;
+            allowFutureDates: boolean;
+            dateFormat: string;
+        }> & Omit<Readonly<import("vue").ExtractPropTypes<{
+            placeholder: {
+                type: import("vue").PropType<string>;
+                default: string;
+            };
+            modelValue: {
+                type: import("vue").PropType<string | Date>;
+                default: any;
+            };
+            uniqueId: {
+                type: import("vue").PropType<string | number>;
+                default: number;
+            };
+            allowFutureDates: {
+                type: import("vue").PropType<boolean>;
+                default: boolean;
+            };
+            dateFormat: {
+                type: import("vue").PropType<string>;
+                default: string;
+            };
+        }>> & {
+            "onUpdate:modelValue"?: (val: string | Date) => any;
+        } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "placeholder" | "modelValue" | "uniqueId" | "allowFutureDates" | "dateFormat">;
+        $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", val: string | Date) => void;
+        $el: any;
+        $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+            placeholder: {
+                type: import("vue").PropType<string>;
+                default: string;
+            };
+            modelValue: {
+                type: import("vue").PropType<string | Date>;
+                default: any;
+            };
+            uniqueId: {
+                type: import("vue").PropType<string | number>;
+                default: number;
+            };
+            allowFutureDates: {
+                type: import("vue").PropType<boolean>;
+                default: boolean;
+            };
+            dateFormat: {
+                type: import("vue").PropType<string>;
+                default: string;
+            };
+        }>> & {
+            "onUpdate:modelValue"?: (val: string | Date) => any;
+        }, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            "update:modelValue": (val: string | Date) => void;
+        }, string, {
+            placeholder: string;
+            modelValue: string | Date;
+            uniqueId: string | number;
+            allowFutureDates: boolean;
+            dateFormat: 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<{
+        placeholder: {
+            type: import("vue").PropType<string>;
+            default: string;
+        };
+        modelValue: {
+            type: import("vue").PropType<string | Date>;
+            default: any;
+        };
+        uniqueId: {
+            type: import("vue").PropType<string | number>;
+            default: number;
+        };
+        allowFutureDates: {
+            type: import("vue").PropType<boolean>;
+            default: boolean;
+        };
+        dateFormat: {
+            type: import("vue").PropType<string>;
+            default: string;
+        };
+    }>> & {
+        "onUpdate:modelValue"?: (val: string | Date) => any;
+    } & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties & {};
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
     placeholder: {
         type: import("vue").PropType<string>;
-    } & {
         default: string;
     };
-    uniqueId: {
-        type: import("vue").PropType<string | number>;
-    } & {
-        default: number;
-    };
-    allowFutureDates: {
-        type: import("vue").PropType<boolean>;
-    } & {
-        default: boolean;
-    };
-    dateFormat: {
-        type: import("vue").PropType<string>;
-    } & {
-        default: string;
-    };
-}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    "update:modelValue": (val: string | Date) => void;
-}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
     modelValue: {
         type: import("vue").PropType<string | Date>;
-    } & {
         default: any;
     };
-    placeholder: {
-        type: import("vue").PropType<string>;
-    } & {
-        default: string;
-    };
     uniqueId: {
         type: import("vue").PropType<string | number>;
-    } & {
         default: number;
     };
     allowFutureDates: {
         type: import("vue").PropType<boolean>;
-    } & {
         default: boolean;
     };
     dateFormat: {
         type: import("vue").PropType<string>;
-    } & {
         default: string;
     };
 }>> & {
     "onUpdate:modelValue"?: (val: string | Date) => any;
-}, {
-    modelValue: string | Date;
+}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (val: string | Date) => void;
+}, string, {
     placeholder: string;
+    modelValue: string | Date;
     uniqueId: string | number;
     allowFutureDates: boolean;
     dateFormat: string;
-}>[];
+}, {}, string> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+    $slots: {
+        default?(_: {
+            formattedDate: string | Date;
+        }): any;
+    };
+}))[];
 export { default as DatePicker } from './DatePicker.vue';
 export { DatePickerTypes };

package/components/datePicker/index.js

@@ -0,0 +1,6 @@
+import e from "./DatePicker.vue.js";
+const t = () => [e];
+export {
+  e as DatePicker,
+  t as DatePickerTypes
+};

package/components/dateRange/CalendarMonth.vue.d.ts

@@ -1,45 +1,97 @@
 import { Day } from './DateServices';
-declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
-    year: number;
-    days: Record<string, Day>;
-    weeks: Day[][];
-    month: number;
-    navigation: 'next' | 'previous' | 'all';
+declare const _default: import("vue").DefineComponent<{
+    type: {
+        type: import("vue").PropType<"date" | "week" | "month">;
+        required: true;
+    };
+    id: {
+        type: import("vue").PropType<string | number>;
+        default: number;
+    };
+    month: {
+        type: import("vue").PropType<number>;
+        required: true;
+    };
+    year: {
+        type: import("vue").PropType<number>;
+        required: true;
+    };
+    days: {
+        type: import("vue").PropType<Record<string, Day>>;
+        required: true;
+    };
+    weeks: {
+        type: import("vue").PropType<Day[][]>;
+        required: true;
+    };
+    navigation: {
+        type: import("vue").PropType<"previous" | "next" | "all">;
+        required: true;
+    };
     range: {
-        fromStart: Date;
-        fromEnd: Date;
-        toEnd: Date;
-        toStart: Date;
-    };
-    type: 'date' | 'week' | 'month';
-    id?: string | number;
-    allowedDays?: number;
-    maxAllowedDate?: Date;
-}>, {
-    id: number;
-    allowedDays: any;
-    maxAllowedDate: any;
-}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("navigation" | "selectionChanged")[], "navigation" | "selectionChanged", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
-    year: number;
-    days: Record<string, Day>;
-    weeks: Day[][];
-    month: number;
-    navigation: 'next' | 'previous' | 'all';
+        type: import("vue").PropType<{
+            fromStart: Date;
+            fromEnd: Date;
+            toEnd: Date;
+            toStart: Date;
+        }>;
+        required: true;
+    };
+    allowedDays: {
+        type: import("vue").PropType<number>;
+        default: any;
+    };
+    maxAllowedDate: {
+        type: import("vue").PropType<Date>;
+        default: any;
+    };
+}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("navigation" | "selectionChanged")[], "navigation" | "selectionChanged", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    type: {
+        type: import("vue").PropType<"date" | "week" | "month">;
+        required: true;
+    };
+    id: {
+        type: import("vue").PropType<string | number>;
+        default: number;
+    };
+    month: {
+        type: import("vue").PropType<number>;
+        required: true;
+    };
+    year: {
+        type: import("vue").PropType<number>;
+        required: true;
+    };
+    days: {
+        type: import("vue").PropType<Record<string, Day>>;
+        required: true;
+    };
+    weeks: {
+        type: import("vue").PropType<Day[][]>;
+        required: true;
+    };
+    navigation: {
+        type: import("vue").PropType<"previous" | "next" | "all">;
+        required: true;
+    };
     range: {
-        fromStart: Date;
-        fromEnd: Date;
-        toEnd: Date;
-        toStart: Date;
-    };
-    type: 'date' | 'week' | 'month';
-    id?: string | number;
-    allowedDays?: number;
-    maxAllowedDate?: Date;
-}>, {
-    id: number;
-    allowedDays: any;
-    maxAllowedDate: any;
-}>>> & {
+        type: import("vue").PropType<{
+            fromStart: Date;
+            fromEnd: Date;
+            toEnd: Date;
+            toStart: Date;
+        }>;
+        required: true;
+    };
+    allowedDays: {
+        type: import("vue").PropType<number>;
+        default: any;
+    };
+    maxAllowedDate: {
+        type: import("vue").PropType<Date>;
+        default: any;
+    };
+}>> & {
     onNavigation?: (...args: any[]) => any;
     onSelectionChanged?: (...args: any[]) => any;
 }, {
@@ -48,17 +100,3 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
     maxAllowedDate: Date;
 }>;
 export default _default;
-type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
-type __VLS_TypePropsToRuntimeProps<T> = {
-    [K in keyof T]-?: {} extends Pick<T, K> ? {
-        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
-    } : {
-        type: import('vue').PropType<T[K]>;
-        required: true;
-    };
-};
-type __VLS_WithDefaults<P, D> = {
-    [K in keyof Pick<P, keyof P>]: K extends keyof D ? P[K] & {
-        default: D[K];
-    } : P[K];
-};

package/components/dateRange/CalendarMonth.vue.js

@@ -1,318 +1,7 @@
-import { defineComponent, ref, computed, watch, onMounted, openBlock, createElementBlock, createElementVNode, unref, createBlock, withCtx, createVNode, createCommentVNode, createTextVNode, toDisplayString, Fragment, renderList, normalizeClass } from 'vue';
-import dateServices from './DateServices.vue.js';
-import { navigatePrev, navigateNext } from './consts.vue.js';
-import Heading from '../typography/Heading.vue.js';
-import Text from '../typography/Text.vue.js';
-import Icon from '../icon/Icon.vue.js';
-import _export_sfc from '../../_virtual/plugin-vue_export-helper.vue.js';
-/* empty css                                                                    *//* empty css                                                                */import IconButton from '../button/IconButton.vue.js';
-/* empty css                                                                               */import 'floating-vue';
-/* empty css                                                      *//* empty css                                                                      */import { isBefore, isAfter, isSameDay } from 'date-fns';
-import AngleLeft from '../icon/icons/AngleLeft.vue.js';
-import AngleRight from '../icon/icons/AngleRight.vue.js';
-/* empty css                                                               */
-import "../../CalendarMonth.vue_vue_type_style_index_0_scoped_true_lang.css";
-const _hoisted_1 = ["id"];
-const _hoisted_2 = { class: "month-header" };
-const _hoisted_3 = { class: "days-header" };
-const _hoisted_4 = { class: "days-wrapper" };
-const _sfc_main = /* @__PURE__ */ defineComponent({
-  __name: "CalendarMonth",
-  props: {
-    year: null,
-    days: null,
-    weeks: null,
-    month: null,
-    navigation: null,
-    range: null,
-    type: null,
-    id: { default: Date.now() },
-    allowedDays: { default: null },
-    maxAllowedDate: { default: null }
-  },
-  emits: ["selectionChanged", "navigation"],
-  setup(__props, { emit }) {
-    const props = __props;
-    const months = [
-      "January",
-      "February",
-      "March",
-      "April",
-      "May",
-      "June",
-      "July",
-      "August",
-      "September",
-      "October",
-      "November",
-      "December"
-    ];
-    const dayNames = ["S", "M", "T", "W", "T", "F", "S"];
-    const selectedDays = ref([]);
-    const selectedDaysMap = ref({});
-    const inBetweenMap = ref({});
-    const monthName = computed(() => months[props.month]);
-    const selectDay = (day) => {
-      if (day.value === 0) {
-        return;
-      }
-      emit("selectionChanged", day, props.month, props.year);
-    };
-    const navigate = (navigation) => {
-      emit("navigation", navigation);
-    };
-    const isMonthInRange = () => {
-      if (!props.range.fromStart || !props.range.toEnd) {
-        return false;
-      }
-      const fromMonth = props.range.fromStart.getMonth();
-      const fromYear = props.range.fromStart.getFullYear();
-      const toMonth = props.range.toEnd.getMonth();
-      const toYear = props.range.toEnd.getFullYear();
-      if (props.year < fromYear || props.year > toYear) {
-        return false;
-      }
-      return !(props.year === fromYear && props.month < fromMonth || props.year === toYear && props.month > toMonth);
-    };
-    const getFirstDayInRangeForMonth = (date, month) => {
-      if (date.getMonth() < month.month && date.getFullYear() === month.year || date.getFullYear() < month.year) {
-        return 1;
-      }
-      if (date.getMonth() === month.month && date.getFullYear() === month.year) {
-        return date.getDate();
-      }
-      return dateServices.daysInMonth(month.month, month.year);
-    };
-    const getLastDayInRangeForMonth = (date, month) => {
-      if (date.getMonth() > month.month && date.getFullYear() === month.year || date.getFullYear() > month.year) {
-        return dateServices.daysInMonth(month.month, month.year);
-      }
-      if (date.getMonth() === month.month && date.getFullYear() === month.year) {
-        return date.getDate();
-      }
-      return 1;
-    };
-    const getMinDateInMonth = () => {
-      if (props.allowedDays) {
-        const today = dateServices.getCurrentTimeUTC();
-        today.setDate(today.getDate() - props.allowedDays + 1);
-        let minDate = today;
-        switch (props.type) {
-          case "week":
-            minDate = dateServices.getFirstDayOfWeek(today);
-            break;
-          case "month":
-            minDate.setDate(1);
-            break;
-        }
-        minDate.setHours(0, 0, 0, 0);
-        return minDate;
-      }
-      return null;
-    };
-    const refreshDisabledDays = () => {
-      const minDate = getMinDateInMonth();
-      const maxDate = props.maxAllowedDate;
-      Object.keys(props.days).forEach((dayKey) => {
-        const day = props.days[dayKey];
-        if (minDate && isBefore(day.date, minDate) || maxDate && isAfter(day.date, maxDate)) {
-          day.disabled = true;
-        } else {
-          delete day.disabled;
-        }
-      });
-    };
-    const setSelectionInMonth = (date, day, lowerLimit, upperLimit) => {
-      if (props.year === date.getFullYear() && props.month === date.getMonth() && day >= lowerLimit && day <= upperLimit) {
-        selectedDaysMap.value[day] = true;
-      }
-    };
-    const updateSelection = () => {
-      for (let i = 0; i < selectedDays.value.length; i++) {
-        const day = selectedDays.value[i];
-        delete selectedDaysMap.value[day.value];
-        delete inBetweenMap.value[day.value];
-      }
-      selectedDays.value = [];
-      if (isMonthInRange()) {
-        const thisMonth = { month: props.month, year: props.year };
-        const selectionFromStart = getFirstDayInRangeForMonth(
-          props.range.fromStart,
-          thisMonth
-        );
-        const selectionFromEnd = getLastDayInRangeForMonth(
-          props.range.fromEnd,
-          thisMonth
-        );
-        const selectionToStart = getFirstDayInRangeForMonth(
-          props.range.toStart,
-          thisMonth
-        );
-        const selectionToEnd = getLastDayInRangeForMonth(
-          props.range.toEnd,
-          thisMonth
-        );
-        for (let j = selectionFromStart; j <= selectionToEnd; j++) {
-          inBetweenMap.value[j] = true;
-          setSelectionInMonth(
-            props.range.fromStart,
-            j,
-            selectionFromStart,
-            selectionFromEnd
-          );
-          setSelectionInMonth(
-            props.range.fromEnd,
-            j,
-            selectionFromStart,
-            selectionFromEnd
-          );
-          setSelectionInMonth(
-            props.range.toStart,
-            j,
-            selectionToStart,
-            selectionToEnd
-          );
-          setSelectionInMonth(
-            props.range.toEnd,
-            j,
-            selectionToStart,
-            selectionToEnd
-          );
-          selectedDays.value.push(props.days[j]);
-        }
-      }
-    };
-    const isStartDay = (day) => {
-      if (day.value === 0)
-        return false;
-      return isSameDay(day.date, props.range.fromStart);
-    };
-    const isEndDay = (day) => {
-      if (day.value === 0)
-        return false;
-      return isSameDay(day.date, props.range.toEnd);
-    };
-    watch(
-      () => props.month,
-      () => {
-        updateSelection();
-      }
-    );
-    watch(
-      () => props.range,
-      (newVal, oldVal) => {
-        if (newVal && newVal !== oldVal) {
-          updateSelection();
-        }
-      }
-    );
-    watch(
-      () => props.maxAllowedDate,
-      () => {
-        refreshDisabledDays();
-      }
-    );
-    onMounted(() => {
-      refreshDisabledDays();
-      updateSelection();
-    });
-    return (_ctx, _cache) => {
-      return openBlock(), createElementBlock("div", {
-        id: "datepickerCalendar" + __props.id,
-        class: "calendar-month"
-      }, [
-        createElementVNode("span", {
-          onClick: _cache[0] || (_cache[0] = ($event) => navigate(unref(navigatePrev)))
-        }, [
-          __props.navigation === unref(navigatePrev) || __props.navigation === "all" ? (openBlock(), createBlock(unref(IconButton), {
-            key: 0,
-            variant: "borderless",
-            size: "md",
-            class: "previous"
-          }, {
-            default: withCtx(() => [
-              createVNode(Icon, null, {
-                default: withCtx(() => [
-                  createVNode(AngleLeft)
-                ]),
-                _: 1
-              })
-            ]),
-            _: 1
-          })) : createCommentVNode("", true)
-        ]),
-        createElementVNode("span", {
-          onClick: _cache[1] || (_cache[1] = ($event) => navigate(unref(navigateNext)))
-        }, [
-          __props.navigation === unref(navigateNext) || __props.navigation === "all" ? (openBlock(), createBlock(unref(IconButton), {
-            key: 0,
-            class: "next",
-            variant: "borderless",
-            size: "md"
-          }, {
-            default: withCtx(() => [
-              createVNode(Icon, null, {
-                default: withCtx(() => [
-                  createVNode(AngleRight)
-                ]),
-                _: 1
-              })
-            ]),
-            _: 1
-          })) : createCommentVNode("", true)
-        ]),
-        createElementVNode("div", _hoisted_2, [
-          createVNode(Heading, { level: "6" }, {
-            default: withCtx(() => [
-              createTextVNode(toDisplayString(unref(monthName)) + " " + toDisplayString(__props.year), 1)
-            ]),
-            _: 1
-          }),
-          createElementVNode("div", _hoisted_3, [
-            (openBlock(), createElementBlock(Fragment, null, renderList(dayNames, (weekDay, index) => {
-              return createVNode(unref(Text), {
-                key: index,
-                size: "xs"
-              }, {
-                default: withCtx(() => [
-                  createTextVNode(toDisplayString(weekDay), 1)
-                ]),
-                _: 2
-              }, 1024);
-            }), 64))
-          ])
-        ]),
-        createElementVNode("div", _hoisted_4, [
-          (openBlock(true), createElementBlock(Fragment, null, renderList(__props.weeks, (week, weekIndex) => {
-            return openBlock(), createElementBlock("div", { key: weekIndex }, [
-              (openBlock(true), createElementBlock(Fragment, null, renderList(week, (day, dayIndex) => {
-                return openBlock(), createBlock(unref(Text), {
-                  key: dayIndex,
-                  class: normalizeClass(["day", {
-                    "selected-day": selectedDaysMap.value[day.value],
-                    "selected-day-between": inBetweenMap.value[day.value],
-                    today: day.isToday,
-                    "disabled-day": day.isFuture || day.disabled,
-                    "non-day": day.value === 0,
-                    "start-day": isStartDay(day),
-                    "end-day": isEndDay(day)
-                  }]),
-                  size: "sm",
-                  onClick: ($event) => day.disabled || day.isFuture || selectDay(day)
-                }, {
-                  default: withCtx(() => [
-                    createTextVNode(toDisplayString(day.value), 1)
-                  ]),
-                  _: 2
-                }, 1032, ["class", "onClick"]);
-              }), 128))
-            ]);
-          }), 128))
-        ])
-      ], 8, _hoisted_1);
-    };
-  }
-});
-var CalendarMonth = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-07a23a05"]]);
-
-export { CalendarMonth as default };
+import o from "./CalendarMonth.vue2.js";
+import "./CalendarMonth.vue3.js";
+import t from "../../_virtual/_plugin-vue_export-helper.js";
+const p = /* @__PURE__ */ t(o, [["__scopeId", "data-v-9955a6c5"]]);
+export {
+  p as default
+};