appmax-client-vue3 5.2.0 → 5.4.0

package/dist/index-BOsWLnPs.js

@@ -0,0 +1,1204 @@
+import { ad as defineComponent, aA as inject, x as reactive, r as ref, e as computed, aB as h, aC as provide, o as onMounted, L as nextTick, Q as onUnmounted, z as watch, aD as cloneVNode, F as Fragment, aE as s, aF as watchEffect, q as createBlock, h as openBlock, w as withCtx, g as createElementBlock, p as renderList, l as unref, j as createBaseVNode, a6 as renderSlot, k as createCommentVNode, D as mergeProps, i as createVNode, K as script, aG as getCurrentScope, aH as onScopeDispose, m as createTextVNode, t as toDisplayString, y, P, aa as createSlots, $ as $$1, n as normalizeClass, aI as getCurrentInstance } from "./main-B2MCvgMD.js";
+/**
+ * Vue 3 Carousel 0.3.3
+ * (c) 2024
+ * @license MIT
+ */
+const defaultConfigs = {
+  itemsToShow: 1,
+  itemsToScroll: 1,
+  modelValue: 0,
+  transition: 300,
+  autoplay: 0,
+  snapAlign: "center",
+  wrapAround: false,
+  throttle: 16,
+  pauseAutoplayOnHover: false,
+  mouseDrag: true,
+  touchDrag: true,
+  dir: "ltr",
+  breakpoints: void 0,
+  i18n: {
+    ariaNextSlide: "Navigate to next slide",
+    ariaPreviousSlide: "Navigate to previous slide",
+    ariaNavigateToSlide: "Navigate to slide {slideNumber}",
+    ariaGallery: "Gallery",
+    itemXofY: "Item {currentSlide} of {slidesCount}",
+    iconArrowUp: "Arrow pointing upwards",
+    iconArrowDown: "Arrow pointing downwards",
+    iconArrowRight: "Arrow pointing to the right",
+    iconArrowLeft: "Arrow pointing to the left"
+  }
+};
+const carouselProps = {
+  // count of items to showed per view
+  itemsToShow: {
+    default: defaultConfigs.itemsToShow,
+    type: Number
+  },
+  // count of items to be scrolled
+  itemsToScroll: {
+    default: defaultConfigs.itemsToScroll,
+    type: Number
+  },
+  // control infinite scrolling mode
+  wrapAround: {
+    default: defaultConfigs.wrapAround,
+    type: Boolean
+  },
+  // control max drag
+  throttle: {
+    default: defaultConfigs.throttle,
+    type: Number
+  },
+  // control snap position alignment
+  snapAlign: {
+    default: defaultConfigs.snapAlign,
+    validator(value) {
+      return ["start", "end", "center", "center-even", "center-odd"].includes(value);
+    }
+  },
+  // sliding transition time in ms
+  transition: {
+    default: defaultConfigs.transition,
+    type: Number
+  },
+  // an object to store breakpoints
+  breakpoints: {
+    default: defaultConfigs.breakpoints,
+    type: Object
+  },
+  // time to auto advance slides in ms
+  autoplay: {
+    default: defaultConfigs.autoplay,
+    type: Number
+  },
+  // pause autoplay when mouse hover over the carousel
+  pauseAutoplayOnHover: {
+    default: defaultConfigs.pauseAutoplayOnHover,
+    type: Boolean
+  },
+  // slide number number of initial slide
+  modelValue: {
+    default: void 0,
+    type: Number
+  },
+  // toggle mouse dragging.
+  mouseDrag: {
+    default: defaultConfigs.mouseDrag,
+    type: Boolean
+  },
+  // toggle mouse dragging.
+  touchDrag: {
+    default: defaultConfigs.touchDrag,
+    type: Boolean
+  },
+  // control snap position alignment
+  dir: {
+    default: defaultConfigs.dir,
+    validator(value) {
+      return ["rtl", "ltr"].includes(value);
+    }
+  },
+  // aria-labels and additional text labels
+  i18n: {
+    default: defaultConfigs.i18n,
+    type: Object
+  },
+  // an object to pass all settings
+  settings: {
+    default() {
+      return {};
+    },
+    type: Object
+  }
+};
+function getMaxSlideIndex({ config, slidesCount }) {
+  const { snapAlign, wrapAround, itemsToShow = 1 } = config;
+  if (wrapAround) {
+    return Math.max(slidesCount - 1, 0);
+  }
+  let output;
+  switch (snapAlign) {
+    case "start":
+      output = slidesCount - itemsToShow;
+      break;
+    case "end":
+      output = slidesCount - 1;
+      break;
+    case "center":
+    case "center-odd":
+      output = slidesCount - Math.ceil((itemsToShow - 0.5) / 2);
+      break;
+    case "center-even":
+      output = slidesCount - Math.ceil(itemsToShow / 2);
+      break;
+    default:
+      output = 0;
+      break;
+  }
+  return Math.max(output, 0);
+}
+function getMinSlideIndex({ config, slidesCount }) {
+  const { wrapAround, snapAlign, itemsToShow = 1 } = config;
+  let output = 0;
+  if (wrapAround || itemsToShow > slidesCount) {
+    return output;
+  }
+  switch (snapAlign) {
+    case "start":
+      output = 0;
+      break;
+    case "end":
+      output = itemsToShow - 1;
+      break;
+    case "center":
+    case "center-odd":
+      output = Math.floor((itemsToShow - 1) / 2);
+      break;
+    case "center-even":
+      output = Math.floor((itemsToShow - 2) / 2);
+      break;
+    default:
+      output = 0;
+      break;
+  }
+  return output;
+}
+function getNumberInRange({ val, max, min }) {
+  if (max < min) {
+    return val;
+  }
+  return Math.min(Math.max(val, min), max);
+}
+function getSlidesToScroll({ config, currentSlide, slidesCount }) {
+  const { snapAlign, wrapAround, itemsToShow = 1 } = config;
+  let output = currentSlide;
+  switch (snapAlign) {
+    case "center":
+    case "center-odd":
+      output -= (itemsToShow - 1) / 2;
+      break;
+    case "center-even":
+      output -= (itemsToShow - 2) / 2;
+      break;
+    case "end":
+      output -= itemsToShow - 1;
+      break;
+  }
+  if (wrapAround) {
+    return output;
+  }
+  return getNumberInRange({
+    val: output,
+    max: slidesCount - itemsToShow,
+    min: 0
+  });
+}
+function getSlidesVNodes(vNode) {
+  if (!vNode)
+    return [];
+  return vNode.reduce((acc, node) => {
+    var _a;
+    if (node.type === Fragment) {
+      return [...acc, ...getSlidesVNodes(node.children)];
+    }
+    if (((_a = node.type) === null || _a === void 0 ? void 0 : _a.name) === "CarouselSlide") {
+      return [...acc, node];
+    }
+    return acc;
+  }, []);
+}
+function mapNumberToRange({ val, max, min = 0 }) {
+  if (val > max) {
+    return mapNumberToRange({ val: val - (max + 1), max, min });
+  }
+  if (val < min) {
+    return mapNumberToRange({ val: val + (max + 1), max, min });
+  }
+  return val;
+}
+function throttle(fn, limit) {
+  let inThrottle;
+  if (!limit) {
+    return fn;
+  }
+  return function(...args) {
+    const self = this;
+    if (!inThrottle) {
+      fn.apply(self, args);
+      inThrottle = true;
+      setTimeout(() => inThrottle = false, limit);
+    }
+  };
+}
+function debounce(fn, delay) {
+  let timerId;
+  return function(...args) {
+    if (timerId) {
+      clearTimeout(timerId);
+    }
+    timerId = setTimeout(() => {
+      fn(...args);
+      timerId = null;
+    }, delay);
+  };
+}
+function i18nFormatter(string = "", values = {}) {
+  return Object.entries(values).reduce((acc, [key, value]) => acc.replace(`{${key}}`, String(value)), string);
+}
+var ARIAComponent = defineComponent({
+  name: "ARIA",
+  setup() {
+    const config = inject("config", reactive(Object.assign({}, defaultConfigs)));
+    const currentSlide = inject("currentSlide", ref(0));
+    const slidesCount = inject("slidesCount", ref(0));
+    return () => h("div", {
+      class: ["carousel__liveregion", "carousel__sr-only"],
+      "aria-live": "polite",
+      "aria-atomic": "true"
+    }, i18nFormatter(config.i18n["itemXofY"], {
+      currentSlide: currentSlide.value + 1,
+      slidesCount: slidesCount.value
+    }));
+  }
+});
+var Carousel = defineComponent({
+  name: "Carousel",
+  props: carouselProps,
+  setup(props, { slots, emit, expose }) {
+    var _a;
+    const root = ref(null);
+    const slides = ref([]);
+    const slideWidth = ref(0);
+    const slidesCount = ref(0);
+    const config = reactive(Object.assign({}, defaultConfigs));
+    let __defaultConfig = Object.assign({}, defaultConfigs);
+    let breakpoints;
+    const currentSlideIndex = ref((_a = props.modelValue) !== null && _a !== void 0 ? _a : 0);
+    const prevSlideIndex = ref(0);
+    const middleSlideIndex = ref(0);
+    const maxSlideIndex = ref(0);
+    const minSlideIndex = ref(0);
+    let autoplayTimer;
+    let transitionTimer;
+    provide("config", config);
+    provide("slidesCount", slidesCount);
+    provide("currentSlide", currentSlideIndex);
+    provide("maxSlide", maxSlideIndex);
+    provide("minSlide", minSlideIndex);
+    provide("slideWidth", slideWidth);
+    function initDefaultConfigs() {
+      breakpoints = Object.assign({}, props.breakpoints);
+      __defaultConfig = Object.assign(Object.assign(Object.assign({}, __defaultConfig), props), { i18n: Object.assign(Object.assign({}, __defaultConfig.i18n), props.i18n), breakpoints: void 0 });
+      bindConfigs(__defaultConfig);
+    }
+    function updateBreakpointsConfigs() {
+      if (!breakpoints || !Object.keys(breakpoints).length)
+        return;
+      const breakpointsArray = Object.keys(breakpoints).map((key) => Number(key)).sort((a, b) => +b - +a);
+      let newConfig = Object.assign({}, __defaultConfig);
+      breakpointsArray.some((breakpoint) => {
+        const isMatched = window.matchMedia(`(min-width: ${breakpoint}px)`).matches;
+        if (isMatched) {
+          newConfig = Object.assign(Object.assign({}, newConfig), breakpoints[breakpoint]);
+        }
+        return isMatched;
+      });
+      bindConfigs(newConfig);
+    }
+    function bindConfigs(newConfig) {
+      Object.entries(newConfig).forEach(([key, val]) => config[key] = val);
+    }
+    const handleWindowResize = debounce(() => {
+      updateBreakpointsConfigs();
+      updateSlidesData();
+      updateSlideWidth();
+    }, 16);
+    function updateSlideWidth() {
+      if (!root.value)
+        return;
+      const rect = root.value.getBoundingClientRect();
+      slideWidth.value = rect.width / config.itemsToShow;
+    }
+    function updateSlidesData() {
+      if (slidesCount.value <= 0)
+        return;
+      middleSlideIndex.value = Math.ceil((slidesCount.value - 1) / 2);
+      maxSlideIndex.value = getMaxSlideIndex({ config, slidesCount: slidesCount.value });
+      minSlideIndex.value = getMinSlideIndex({ config, slidesCount: slidesCount.value });
+      if (!config.wrapAround) {
+        currentSlideIndex.value = getNumberInRange({
+          val: currentSlideIndex.value,
+          max: maxSlideIndex.value,
+          min: minSlideIndex.value
+        });
+      }
+    }
+    onMounted(() => {
+      nextTick(() => updateSlideWidth());
+      setTimeout(() => updateSlideWidth(), 1e3);
+      updateBreakpointsConfigs();
+      initAutoplay();
+      window.addEventListener("resize", handleWindowResize, { passive: true });
+      emit("init");
+    });
+    onUnmounted(() => {
+      if (transitionTimer) {
+        clearTimeout(transitionTimer);
+      }
+      if (autoplayTimer) {
+        clearInterval(autoplayTimer);
+      }
+      window.removeEventListener("resize", handleWindowResize, {
+        passive: true
+      });
+    });
+    let isTouch = false;
+    const startPosition = { x: 0, y: 0 };
+    const endPosition = { x: 0, y: 0 };
+    const dragged = reactive({ x: 0, y: 0 });
+    const isHover = ref(false);
+    const isDragging = ref(false);
+    const handleMouseEnter = () => {
+      isHover.value = true;
+    };
+    const handleMouseLeave = () => {
+      isHover.value = false;
+    };
+    function handleDragStart(event) {
+      if (["INPUT", "TEXTAREA", "SELECT"].includes(event.target.tagName)) {
+        return;
+      }
+      isTouch = event.type === "touchstart";
+      if (!isTouch) {
+        event.preventDefault();
+      }
+      if (!isTouch && event.button !== 0 || isSliding.value) {
+        return;
+      }
+      startPosition.x = isTouch ? event.touches[0].clientX : event.clientX;
+      startPosition.y = isTouch ? event.touches[0].clientY : event.clientY;
+      document.addEventListener(isTouch ? "touchmove" : "mousemove", handleDragging, true);
+      document.addEventListener(isTouch ? "touchend" : "mouseup", handleDragEnd, true);
+    }
+    const handleDragging = throttle((event) => {
+      isDragging.value = true;
+      endPosition.x = isTouch ? event.touches[0].clientX : event.clientX;
+      endPosition.y = isTouch ? event.touches[0].clientY : event.clientY;
+      const deltaX = endPosition.x - startPosition.x;
+      const deltaY = endPosition.y - startPosition.y;
+      dragged.y = deltaY;
+      dragged.x = deltaX;
+    }, config.throttle);
+    function handleDragEnd() {
+      const direction = config.dir === "rtl" ? -1 : 1;
+      const tolerance = Math.sign(dragged.x) * 0.4;
+      const draggedSlides = Math.round(dragged.x / slideWidth.value + tolerance) * direction;
+      if (draggedSlides && !isTouch) {
+        const captureClick = (e) => {
+          window.removeEventListener("click", captureClick, true);
+        };
+        window.addEventListener("click", captureClick, true);
+      }
+      slideTo(currentSlideIndex.value - draggedSlides);
+      dragged.x = 0;
+      dragged.y = 0;
+      isDragging.value = false;
+      document.removeEventListener(isTouch ? "touchmove" : "mousemove", handleDragging, true);
+      document.removeEventListener(isTouch ? "touchend" : "mouseup", handleDragEnd, true);
+    }
+    function initAutoplay() {
+      if (!config.autoplay || config.autoplay <= 0) {
+        return;
+      }
+      autoplayTimer = setInterval(() => {
+        if (config.pauseAutoplayOnHover && isHover.value) {
+          return;
+        }
+        next();
+      }, config.autoplay);
+    }
+    function resetAutoplay() {
+      if (autoplayTimer) {
+        clearInterval(autoplayTimer);
+        autoplayTimer = null;
+      }
+      initAutoplay();
+    }
+    const isSliding = ref(false);
+    function slideTo(slideIndex) {
+      const currentVal = config.wrapAround ? slideIndex : getNumberInRange({
+        val: slideIndex,
+        max: maxSlideIndex.value,
+        min: minSlideIndex.value
+      });
+      if (currentSlideIndex.value === currentVal || isSliding.value) {
+        return;
+      }
+      emit("slide-start", {
+        slidingToIndex: slideIndex,
+        currentSlideIndex: currentSlideIndex.value,
+        prevSlideIndex: prevSlideIndex.value,
+        slidesCount: slidesCount.value
+      });
+      isSliding.value = true;
+      prevSlideIndex.value = currentSlideIndex.value;
+      currentSlideIndex.value = currentVal;
+      transitionTimer = setTimeout(() => {
+        if (config.wrapAround) {
+          const mappedNumber = mapNumberToRange({
+            val: currentVal,
+            max: maxSlideIndex.value,
+            min: 0
+          });
+          if (mappedNumber !== currentSlideIndex.value) {
+            currentSlideIndex.value = mappedNumber;
+            emit("loop", {
+              currentSlideIndex: currentSlideIndex.value,
+              slidingToIndex: slideIndex
+            });
+          }
+        }
+        emit("update:modelValue", currentSlideIndex.value);
+        emit("slide-end", {
+          currentSlideIndex: currentSlideIndex.value,
+          prevSlideIndex: prevSlideIndex.value,
+          slidesCount: slidesCount.value
+        });
+        isSliding.value = false;
+        resetAutoplay();
+      }, config.transition);
+    }
+    function next() {
+      slideTo(currentSlideIndex.value + config.itemsToScroll);
+    }
+    function prev() {
+      slideTo(currentSlideIndex.value - config.itemsToScroll);
+    }
+    const nav = { slideTo, next, prev };
+    provide("nav", nav);
+    provide("isSliding", isSliding);
+    const slidesToScroll = computed(() => getSlidesToScroll({
+      config,
+      currentSlide: currentSlideIndex.value,
+      slidesCount: slidesCount.value
+    }));
+    provide("slidesToScroll", slidesToScroll);
+    const trackStyle = computed(() => {
+      const direction = config.dir === "rtl" ? -1 : 1;
+      const xScroll = slidesToScroll.value * slideWidth.value * direction;
+      return {
+        transform: `translateX(${dragged.x - xScroll}px)`,
+        transition: `${isSliding.value ? config.transition : 0}ms`,
+        margin: config.wrapAround ? `0 -${slidesCount.value * slideWidth.value}px` : "",
+        width: `100%`
+      };
+    });
+    function restartCarousel() {
+      initDefaultConfigs();
+      updateBreakpointsConfigs();
+      updateSlidesData();
+      updateSlideWidth();
+      resetAutoplay();
+    }
+    Object.keys(carouselProps).forEach((prop) => {
+      if (["modelValue"].includes(prop))
+        return;
+      watch(() => props[prop], restartCarousel);
+    });
+    watch(() => props["modelValue"], (val) => {
+      if (val === currentSlideIndex.value) {
+        return;
+      }
+      slideTo(Number(val));
+    });
+    watch(slidesCount, updateSlidesData);
+    emit("before-init");
+    initDefaultConfigs();
+    const data = {
+      config,
+      slidesCount,
+      slideWidth,
+      next,
+      prev,
+      slideTo,
+      currentSlide: currentSlideIndex,
+      maxSlide: maxSlideIndex,
+      minSlide: minSlideIndex,
+      middleSlide: middleSlideIndex
+    };
+    expose({
+      updateBreakpointsConfigs,
+      updateSlidesData,
+      updateSlideWidth,
+      initDefaultConfigs,
+      restartCarousel,
+      slideTo,
+      next,
+      prev,
+      nav,
+      data
+    });
+    const slotSlides = slots.default || slots.slides;
+    const slotAddons = slots.addons;
+    const slotsProps = reactive(data);
+    return () => {
+      const slidesElements = getSlidesVNodes(slotSlides === null || slotSlides === void 0 ? void 0 : slotSlides(slotsProps));
+      const addonsElements = (slotAddons === null || slotAddons === void 0 ? void 0 : slotAddons(slotsProps)) || [];
+      slidesElements.forEach((el, index) => el.props.index = index);
+      let output = slidesElements;
+      if (config.wrapAround) {
+        const slidesBefore = slidesElements.map((el, index) => cloneVNode(el, {
+          index: -slidesElements.length + index,
+          isClone: true,
+          key: `clone-before-${index}`
+        }));
+        const slidesAfter = slidesElements.map((el, index) => cloneVNode(el, {
+          index: slidesElements.length + index,
+          isClone: true,
+          key: `clone-after-${index}`
+        }));
+        output = [...slidesBefore, ...slidesElements, ...slidesAfter];
+      }
+      slides.value = slidesElements;
+      slidesCount.value = Math.max(slidesElements.length, 1);
+      const trackEl = h("ol", {
+        class: "carousel__track",
+        style: trackStyle.value,
+        onMousedownCapture: config.mouseDrag ? handleDragStart : null,
+        onTouchstartPassiveCapture: config.touchDrag ? handleDragStart : null
+      }, output);
+      const viewPortEl = h("div", { class: "carousel__viewport" }, trackEl);
+      return h("section", {
+        ref: root,
+        class: {
+          carousel: true,
+          "is-sliding": isSliding.value,
+          "is-dragging": isDragging.value,
+          "is-hover": isHover.value,
+          "carousel--rtl": config.dir === "rtl"
+        },
+        dir: config.dir,
+        "aria-label": config.i18n["ariaGallery"],
+        tabindex: "0",
+        onMouseenter: handleMouseEnter,
+        onMouseleave: handleMouseLeave
+      }, [viewPortEl, addonsElements, h(ARIAComponent)]);
+    };
+  }
+});
+var IconName;
+(function(IconName2) {
+  IconName2["arrowUp"] = "arrowUp";
+  IconName2["arrowDown"] = "arrowDown";
+  IconName2["arrowRight"] = "arrowRight";
+  IconName2["arrowLeft"] = "arrowLeft";
+})(IconName || (IconName = {}));
+const icons = {
+  arrowUp: "M7.41 15.41L12 10.83l4.59 4.58L18 14l-6-6-6 6z",
+  arrowDown: "M7.41 8.59L12 13.17l4.59-4.58L18 10l-6 6-6-6 1.41-1.41z",
+  arrowRight: "M8.59 16.59L13.17 12 8.59 7.41 10 6l6 6-6 6-1.41-1.41z",
+  arrowLeft: "M15.41 16.59L10.83 12l4.58-4.59L14 6l-6 6 6 6 1.41-1.41z"
+};
+function isIconName(candidate) {
+  return candidate in IconName;
+}
+const Icon = (props) => {
+  const config = inject("config", reactive(Object.assign({}, defaultConfigs)));
+  const iconName = String(props.name);
+  const iconI18n = `icon${iconName.charAt(0).toUpperCase() + iconName.slice(1)}`;
+  if (!iconName || typeof iconName !== "string" || !isIconName(iconName)) {
+    return;
+  }
+  const path = icons[iconName];
+  const pathEl = h("path", { d: path });
+  const iconTitle = config.i18n[iconI18n] || props.title || iconName;
+  const titleEl = h("title", iconTitle);
+  return h("svg", {
+    class: "carousel__icon",
+    viewBox: "0 0 24 24",
+    role: "img",
+    "aria-label": iconTitle
+  }, [titleEl, pathEl]);
+};
+Icon.props = { name: String, title: String };
+const Navigation = (props, { slots, attrs }) => {
+  const { next: slotNext, prev: slotPrev } = slots || {};
+  const config = inject("config", reactive(Object.assign({}, defaultConfigs)));
+  const maxSlide = inject("maxSlide", ref(1));
+  const minSlide = inject("minSlide", ref(1));
+  const currentSlide = inject("currentSlide", ref(1));
+  const nav = inject("nav", {});
+  const { dir, wrapAround, i18n } = config;
+  const isRTL = dir === "rtl";
+  const prevButton = h("button", {
+    type: "button",
+    class: [
+      "carousel__prev",
+      !wrapAround && currentSlide.value <= minSlide.value && "carousel__prev--disabled",
+      attrs === null || attrs === void 0 ? void 0 : attrs.class
+    ],
+    "aria-label": i18n["ariaPreviousSlide"],
+    onClick: nav.prev
+  }, (slotPrev === null || slotPrev === void 0 ? void 0 : slotPrev()) || h(Icon, { name: isRTL ? "arrowRight" : "arrowLeft" }));
+  const nextButton = h("button", {
+    type: "button",
+    class: [
+      "carousel__next",
+      !wrapAround && currentSlide.value >= maxSlide.value && "carousel__next--disabled",
+      attrs === null || attrs === void 0 ? void 0 : attrs.class
+    ],
+    "aria-label": i18n["ariaNextSlide"],
+    onClick: nav.next
+  }, (slotNext === null || slotNext === void 0 ? void 0 : slotNext()) || h(Icon, { name: isRTL ? "arrowLeft" : "arrowRight" }));
+  return [prevButton, nextButton];
+};
+const Pagination = () => {
+  const config = inject("config", reactive(Object.assign({}, defaultConfigs)));
+  const maxSlide = inject("maxSlide", ref(1));
+  const minSlide = inject("minSlide", ref(1));
+  const currentSlide = inject("currentSlide", ref(1));
+  const nav = inject("nav", {});
+  const isActive = (slide) => mapNumberToRange({
+    val: currentSlide.value,
+    max: maxSlide.value,
+    min: 0
+  }) === slide;
+  const children = [];
+  for (let slide = minSlide.value; slide < maxSlide.value + 1; slide++) {
+    const button = h("button", {
+      type: "button",
+      class: {
+        "carousel__pagination-button": true,
+        "carousel__pagination-button--active": isActive(slide)
+      },
+      "aria-label": i18nFormatter(config.i18n["ariaNavigateToSlide"], {
+        slideNumber: slide + 1
+      }),
+      onClick: () => nav.slideTo(slide)
+    });
+    const item = h("li", { class: "carousel__pagination-item", key: slide }, button);
+    children.push(item);
+  }
+  return h("ol", { class: "carousel__pagination" }, children);
+};
+var Slide = defineComponent({
+  name: "CarouselSlide",
+  props: {
+    index: {
+      type: Number,
+      default: 1
+    },
+    isClone: {
+      type: Boolean,
+      default: false
+    }
+  },
+  setup(props, { slots }) {
+    const config = inject("config", reactive(Object.assign({}, defaultConfigs)));
+    const currentSlide = inject("currentSlide", ref(0));
+    const slidesToScroll = inject("slidesToScroll", ref(0));
+    const isSliding = inject("isSliding", ref(false));
+    const isActive = computed(() => props.index === currentSlide.value);
+    const isPrev = computed(() => props.index === currentSlide.value - 1);
+    const isNext = computed(() => props.index === currentSlide.value + 1);
+    const isVisible = computed(() => {
+      const min = Math.floor(slidesToScroll.value);
+      const max = Math.ceil(slidesToScroll.value + config.itemsToShow - 1);
+      return props.index >= min && props.index <= max;
+    });
+    return () => {
+      var _a;
+      return h("li", {
+        style: { width: `${100 / config.itemsToShow}%` },
+        class: {
+          carousel__slide: true,
+          "carousel__slide--clone": props.isClone,
+          "carousel__slide--visible": isVisible.value,
+          "carousel__slide--active": isActive.value,
+          "carousel__slide--prev": isPrev.value,
+          "carousel__slide--next": isNext.value,
+          "carousel__slide--sliding": isSliding.value
+        },
+        "aria-hidden": !isVisible.value
+      }, (_a = slots.default) === null || _a === void 0 ? void 0 : _a.call(slots, {
+        isActive: isActive.value,
+        isClone: props.isClone,
+        isPrev: isPrev.value,
+        isNext: isNext.value,
+        isSliding: isSliding.value,
+        isVisible: isVisible.value
+      }));
+    };
+  }
+});
+const N = { class: "carousel__item" }, x = defineComponent({
+  name: "AmSlider",
+  components: {
+    Pagination,
+    Carousel,
+    Slide,
+    Navigation
+  }
+}), T = /* @__PURE__ */ defineComponent({
+  ...x,
+  props: {
+    // Slots e visualização
+    slotNames: {
+      type: Array,
+      default: () => []
+    },
+    slidesPerView: {
+      type: Number,
+      default: 1,
+      validator: (r) => r > 0
+    },
+    // Navegação
+    pagination: {
+      type: Boolean,
+      default: true
+    },
+    navigation: {
+      type: Boolean,
+      default: false
+    },
+    infinite: {
+      type: Boolean,
+      default: false
+    },
+    centeredSlides: {
+      type: Boolean,
+      default: true
+    },
+    // Autoplay
+    autoplay: {
+      type: Number,
+      default: 0
+    },
+    autoplayTimeout: {
+      type: Number,
+      default: 2e3
+    },
+    pauseAutoplayOnHover: {
+      type: Boolean,
+      default: false
+    },
+    // Interação
+    mouseDrag: {
+      type: Boolean,
+      default: true
+    },
+    touchDrag: {
+      type: Boolean,
+      default: true
+    },
+    preventSlideOnSwipe: {
+      type: Boolean,
+      default: false
+    },
+    // Transição
+    transition: {
+      type: Number,
+      default: 300
+    },
+    // Direção
+    dir: {
+      type: String,
+      default: "ltr"
+    },
+    // Responsividade
+    breakpoints: {
+      type: Object,
+      default: () => ({})
+    }
+  },
+  emits: ["onChange"],
+  setup(r, { expose: v, emit: S }) {
+    const e = r, t = ref({
+      pagination: e.pagination,
+      navigation: e.navigation,
+      itemsToShow: e.slidesPerView,
+      snapAlign: e.centeredSlides ? "center" : "start",
+      wrapAround: e.infinite,
+      breakpoints: e.breakpoints,
+      autoplay: e.autoplay,
+      autoplayTimeout: e.autoplayTimeout,
+      pauseAutoplayOnHover: e.pauseAutoplayOnHover,
+      transition: e.transition,
+      mouseDrag: e.mouseDrag,
+      touchDrag: e.touchDrag,
+      dir: e.dir,
+      preventSlideOnSwipe: e.preventSlideOnSwipe
+    }), a = ref(null);
+    watchEffect(() => {
+      t.value = {
+        pagination: e.pagination,
+        navigation: e.navigation,
+        itemsToShow: e.slidesPerView,
+        snapAlign: e.centeredSlides ? "center" : "start",
+        wrapAround: e.infinite,
+        breakpoints: e.breakpoints,
+        autoplay: e.autoplay,
+        autoplayTimeout: e.autoplayTimeout,
+        pauseAutoplayOnHover: e.pauseAutoplayOnHover,
+        transition: e.transition,
+        mouseDrag: e.mouseDrag,
+        touchDrag: e.touchDrag,
+        dir: e.dir,
+        preventSlideOnSwipe: e.preventSlideOnSwipe
+      };
+    });
+    const _ = S, w = (l) => {
+      _("onChange", l);
+    };
+    return v({
+      prevSlide: () => {
+        a.value ? a.value.prev() : console.warn("myCarousel ref is null");
+      },
+      nextSlide: () => {
+        a.value ? a.value.next() : console.warn("myCarousel ref is null");
+      }
+    }), (l, V) => (openBlock(), createBlock(unref(Carousel), mergeProps(t.value, {
+      ref_key: "myCarousel",
+      ref: a,
+      breakpoints: t.value.breakpoints,
+      onSlideStart: w
+    }), {
+      addons: withCtx(() => [
+        t.value.pagination ? (openBlock(), createBlock(unref(Pagination), { key: 0 })) : createCommentVNode("", true),
+        t.value.navigation ? (openBlock(), createBlock(unref(Navigation), { key: 1 })) : createCommentVNode("", true)
+      ]),
+      default: withCtx(() => [
+        (openBlock(true), createElementBlock(Fragment, null, renderList(e.slotNames, (s2) => (openBlock(), createBlock(unref(Slide), { key: s2 }, {
+          default: withCtx(() => [
+            createBaseVNode("div", N, [
+              renderSlot(l.$slots, s2, {}, void 0, true)
+            ])
+          ]),
+          _: 2
+        }, 1024))), 128))
+      ]),
+      _: 3
+    }, 16, ["breakpoints"]));
+  }
+}), L = /* @__PURE__ */ s(T, [["__scopeId", "data-v-2af8c459"]]);
+function U(o) {
+  return getCurrentScope() ? (onScopeDispose(o), true) : false;
+}
+function q(o) {
+  return false ? o() : unref(o);
+}
+const F = typeof window < "u" && typeof document < "u";
+typeof WorkerGlobalScope < "u" && globalThis instanceof WorkerGlobalScope;
+const J = F ? window : void 0;
+function K() {
+  const o = ref(false), i = getCurrentInstance();
+  return i && onMounted(() => {
+    o.value = true;
+  }, i), o;
+}
+function X(o) {
+  const i = K();
+  return computed(() => (i.value, !!o()));
+}
+function $(o, i = {}) {
+  const { window: t = J } = i, n = X(() => t && "matchMedia" in t && typeof t.matchMedia == "function");
+  let e;
+  const a = ref(false), s2 = (v) => {
+    a.value = v.matches;
+  }, m = () => {
+    e && ("removeEventListener" in e ? e.removeEventListener("change", s2) : e.removeListener(s2));
+  }, x2 = watchEffect(() => {
+    n.value && (m(), e = t.matchMedia(q(o)), "addEventListener" in e ? e.addEventListener("change", s2) : e.addListener(s2), a.value = e.matches);
+  });
+  return U(() => {
+    x2(), m(), e = void 0;
+  }), a;
+}
+const Y = { class: "briefing-modal" }, Z = { class: "briefing-modal-title" }, ee = { class: "child-body" }, te = { class: "child-body-button-container" }, ne = { class: "child-body" }, oe = ["src"], ie = { name: "Briefing" }, se = /* @__PURE__ */ defineComponent({
+  ...ie,
+  props: {
+    title: {},
+    subtitle: {},
+    description: {},
+    buttonTitle: {},
+    buttonLabel: {},
+    image: {}
+  },
+  emits: ["nextStep", "closeModal"],
+  setup(o, { emit: i }) {
+    const t = o, n = $("(max-width: 775px)"), e = i;
+    return (a, s2) => (openBlock(), createElementBlock("div", Y, [
+      createBaseVNode("div", Z, [
+        createVNode(y, {
+          variant: "subtitle",
+          size: "large"
+        }, {
+          default: withCtx(() => [
+            createTextVNode(toDisplayString(t.title), 1)
+          ]),
+          _: 1
+        }),
+        createVNode(P, {
+          icon: "close",
+          size: "md",
+          onClick: s2[0] || (s2[0] = (m) => e("closeModal"))
+        })
+      ]),
+      createBaseVNode("div", {
+        class: normalizeClass(["briefing-modal-body", { "briefing-modal-body-mobile": unref(n) }])
+      }, [
+        createBaseVNode("div", ee, [
+          createVNode(y, {
+            variant: "title",
+            isStrong: "",
+            size: "medium",
+            class: "title"
+          }, {
+            default: withCtx(() => [
+              createTextVNode(toDisplayString(t.subtitle), 1)
+            ]),
+            _: 1
+          }),
+          createVNode(y, {
+            class: "mt-4",
+            variant: "body"
+          }, {
+            default: withCtx(() => [
+              createTextVNode(toDisplayString(t.description), 1)
+            ]),
+            _: 1
+          }),
+          createVNode(y, {
+            class: "mt-4",
+            variant: "body"
+          }, {
+            default: withCtx(() => [
+              createTextVNode(toDisplayString(t.buttonTitle), 1)
+            ]),
+            _: 1
+          }),
+          createBaseVNode("div", te, [
+            createVNode($$1, {
+              label: t.buttonLabel,
+              onClick: s2[1] || (s2[1] = (m) => e("nextStep"))
+            }, null, 8, ["label"])
+          ])
+        ]),
+        createBaseVNode("div", ne, [
+          createBaseVNode("img", {
+            src: t.image
+          }, null, 8, oe)
+        ])
+      ], 2)
+    ]));
+  }
+}), le = /* @__PURE__ */ s(se, [["__scopeId", "data-v-2607cf0e"]]), ae = { class: "whats-new" }, re = { class: "whats-new-img-container" }, ue = ["src"], de = ["href"], ce = { name: "GenericStepper" }, me = /* @__PURE__ */ defineComponent({
+  ...ce,
+  props: {
+    slotObj: {}
+  },
+  setup(o) {
+    const i = o, t = $("(max-width: 775px)");
+    return (n, e) => (openBlock(), createElementBlock("div", ae, [
+      createBaseVNode("div", re, [
+        createBaseVNode("img", {
+          class: "whats-new-img",
+          src: unref(t) ? i.slotObj.image.replace(/(\.webp)$/, "-mobile$1") : i.slotObj.image
+        }, null, 8, ue)
+      ]),
+      createVNode(y, {
+        class: "whats-new-title",
+        variant: "subtitle",
+        size: "medium",
+        isStrong: ""
+      }, {
+        default: withCtx(() => [
+          createTextVNode(toDisplayString(i.slotObj.subtitle), 1)
+        ]),
+        _: 1
+      }),
+      createVNode(y, {
+        class: "whats-new-description",
+        variant: "body",
+        size: "medium"
+      }, {
+        default: withCtx(() => {
+          var a;
+          return [
+            createTextVNode(toDisplayString(i.slotObj.description) + " ", 1),
+            (a = i.slotObj) != null && a.url ? (openBlock(), createElementBlock("a", {
+              key: 0,
+              target: "_blank",
+              href: i.slotObj.url
+            }, toDisplayString(i.slotObj.linkHint), 9, de)) : createCommentVNode("", true)
+          ];
+        }),
+        _: 1
+      })
+    ]));
+  }
+}), fe = /* @__PURE__ */ s(me, [["__scopeId", "data-v-f570da73"]]), pe = { class: "internationalization-modal" }, ve = { class: "internationalization-modal-title" }, be = { class: "internationalization-modal-body" }, _e = { name: "WhatsNew" }, he = /* @__PURE__ */ defineComponent({
+  ..._e,
+  props: {
+    title: {},
+    finishButtonText: {},
+    backButtonText: {},
+    nextButtonText: {},
+    integrationMenuButtonText: {},
+    showBriefing: { type: Boolean },
+    pagination: { type: Boolean, default: true },
+    items: {}
+  },
+  emits: ["closeModal", "returnStep", "nextStep", "slideChange"],
+  setup(o, { expose: i, emit: t }) {
+    const n = o, e = $("(max-width: 775px)"), a = t, s2 = ref(0), m = n.items.map((l) => l.subtitle), x2 = ({ slidingToIndex: l }) => {
+      s2.value = l, a("slideChange", l);
+    }, v = ref(), d = () => {
+      var l;
+      if (s2.value === n.items.length - 1) {
+        a("nextStep"), a("closeModal");
+        return;
+      }
+      (l = v.value) == null || l.nextSlide();
+    }, r = () => {
+      var l;
+      if (s2.value === 0)
+        return a("returnStep");
+      if (s2.value === n.items.length - 1)
+        return a("closeModal");
+      (l = v.value) == null || l.prevSlide();
+    };
+    return i({
+      nextSlide: d,
+      prevSlide: r
+    }), (l, N2) => (openBlock(), createElementBlock("div", pe, [
+      createBaseVNode("div", ve, [
+        createVNode(y, {
+          variant: "title",
+          size: "small",
+          isStrong: ""
+        }, {
+          default: withCtx(() => [
+            createTextVNode(toDisplayString(n.title), 1)
+          ]),
+          _: 1
+        }),
+        createVNode(P, {
+          icon: "close",
+          size: "md",
+          onClick: N2[0] || (N2[0] = (M) => a("closeModal"))
+        })
+      ]),
+      unref(m).length > 0 ? (openBlock(), createBlock(L, {
+        key: 0,
+        ref_key: "sliderRef",
+        ref: v,
+        "slot-names": unref(m),
+        "slides-per-view": 1,
+        pagination: true,
+        navigation: false,
+        infinite: false,
+        "centered-slides": true,
+        onOnChange: x2
+      }, createSlots({ _: 2 }, [
+        renderList(n.items, (M, Se) => ({
+          name: M.subtitle,
+          fn: withCtx(() => [
+            createBaseVNode("div", be, [
+              createVNode(fe, { "slot-obj": M }, null, 8, ["slot-obj"])
+            ])
+          ])
+        }))
+      ]), 1032, ["slot-names"])) : createCommentVNode("", true),
+      createBaseVNode("div", {
+        class: normalizeClass(["internationalization-modal-button-container", { "mobile-alignment": unref(e) }])
+      }, [
+        renderSlot(l.$slots, "buttons", {}, () => [
+          !(s2.value === 0 && !n.showBriefing) && (s2.value !== n.items.length - 1 || n.finishButtonText) ? (openBlock(), createBlock($$1, {
+            key: 0,
+            label: s2.value === n.items.length - 1 ? n.finishButtonText : n.backButtonText,
+            severity: "secondary",
+            outlined: "",
+            onClick: r
+          }, null, 8, ["label"])) : createCommentVNode("", true),
+          createVNode($$1, {
+            label: s2.value === n.items.length - 1 ? n.integrationMenuButtonText : n.nextButtonText,
+            onClick: d
+          }, null, 8, ["label"])
+        ], true)
+      ], 2)
+    ]));
+  }
+}), ge = /* @__PURE__ */ s(he, [["__scopeId", "data-v-8bac2650"]]), we = { key: 0 }, xe = { name: "AmInternationalizationModal" }, Te = /* @__PURE__ */ defineComponent({
+  ...xe,
+  props: {
+    modelValue: { type: Boolean, default: false },
+    showBriefing: { type: Boolean, default: true },
+    briefingProps: {},
+    whatsNewProps: {}
+  },
+  emits: ["update:modelValue", "nextStep", "slideChange"],
+  setup(o, { emit: i }) {
+    const t = o, n = i, e = ref(t.modelValue), a = ref(!t.showBriefing), s2 = ref(), m = $("(max-width: 775px)"), x2 = () => {
+      e.value = false, setTimeout(() => {
+        a.value = !t.showBriefing;
+      }, 500);
+    };
+    watch(
+      () => t.modelValue,
+      (d) => {
+        e.value = d;
+      }
+    ), watch(
+      () => t.showBriefing,
+      (d) => {
+        a.value = !d;
+      },
+      { immediate: true }
+    ), watch(
+      () => e.value,
+      (d) => {
+        n("update:modelValue", d);
+      }
+    );
+    const v = (d) => {
+      e.value = false, setTimeout(() => {
+        a.value = d, e.value = true;
+      }, 300);
+    };
+    return (d, r) => (openBlock(), createBlock(unref(script), {
+      visible: e.value,
+      "onUpdate:visible": r[5] || (r[5] = (l) => e.value = l),
+      style: { width: "800px" },
+      modal: true,
+      closable: false,
+      maximized: unref(m),
+      closeOnEscape: true,
+      class: "p-dialog-custom internationalization-dialog"
+    }, {
+      default: withCtx(() => [
+        a.value ? (openBlock(), createBlock(ge, mergeProps({
+          key: 1,
+          ref_key: "whatsNewRef",
+          ref: s2
+        }, { ...t.whatsNewProps, showBriefing: t.showBriefing }, {
+          onNextStep: r[2] || (r[2] = (l) => n("nextStep", true)),
+          onReturnStep: r[3] || (r[3] = (l) => v(false)),
+          onCloseModal: x2,
+          onSlideChange: r[4] || (r[4] = (l) => n("slideChange", l))
+        }), null, 16)) : (openBlock(), createElementBlock("div", we, [
+          createVNode(le, mergeProps(t.briefingProps, {
+            onCloseModal: r[0] || (r[0] = (l) => e.value = false),
+            onNextStep: r[1] || (r[1] = (l) => v(true))
+          }), null, 16)
+        ]))
+      ]),
+      _: 1
+    }, 8, ["visible", "maximized"]));
+  }
+});
+export {
+  Te as T
+};