/******/ (() => { // webpackBootstrap
/******/ 	"use strict";
/******/ 	var __webpack_modules__ = ({

/***/ "./src/elementor/js/animated-heading/construct-word.js":
/*!*************************************************************!*\
  !*** ./src/elementor/js/animated-heading/construct-word.js ***!
  \*************************************************************/
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   initConstructWordSequence: () => (/* binding */ initConstructWordSequence)
/* harmony export */ });
// Use global jQuery
const $ = window.jQuery;

/**
 * Animates a single word using a randomized zigzag motion (jQuery version).
 * @param {jQuery} $targetContainer - jQuery element to inject animated spans
 * @param {string} word - The word to animate
 * @param {number} animationDuration - Duration of each character animation in ms
 * @param {number} characterDelay - Delay between character animations in ms
 * @param {number} loopPauseSeconds - Pause duration after word animation in seconds
 * @returns {Promise<void>} - Resolves after the animation cycle
 */
function animateConstructWord($targetContainer, word, animationDuration, characterDelay, loopPauseSeconds, isPauseOnHover) {
  return new Promise(resolve => {
    const directions = ["left", "right", "top", "bottom", "topleft", "topright", "bottomleft", "bottomright"];
    $targetContainer.empty();
    if (isPauseOnHover === "yes") {
      $targetContainer.addClass("marqueex-pause-on-hover");
    }
    [...word].forEach((char, i) => {
      const $span = $("<span></span>").text(char === " " ? "\u00A0" : char);
      const dir = directions[Math.floor(Math.random() * directions.length)];
      const offset = () => Math.floor(Math.random() * 100) + 20;
      let offsetX = 0;
      let offsetY = 0;
      switch (dir) {
        case "left":
          offsetX = -offset();
          break;
        case "right":
          offsetX = offset();
          break;
        case "top":
          offsetY = -offset();
          break;
        case "bottom":
          offsetY = offset();
          break;
        case "topleft":
          offsetX = -offset();
          offsetY = -offset();
          break;
        case "topright":
          offsetX = offset();
          offsetY = -offset();
          break;
        case "bottomleft":
          offsetX = -offset();
          offsetY = offset();
          break;
        case "bottomright":
          offsetX = offset();
          offsetY = offset();
          break;
      }
      $span.css({
        "--x": `${offsetX}px`,
        "--y": `${offsetY}px`,
        animationName: "deensimcConstructWord",
        animationDuration: `${animationDuration}ms`,
        animationDelay: `${i * characterDelay}ms`,
        animationTimingFunction: "ease",
        animationIterationCount: "1"
      });
      $targetContainer.append($span);
    });

    // --- Hover Pause Logic ---
    let timeoutId;
    let startTime;
    let remainingTime;
    const totalTime = (word.length - 1) * characterDelay + animationDuration + loopPauseSeconds * 1000;
    function startTimer() {
      startTime = Date.now();
      timeoutId = setTimeout(() => {
        $targetContainer.off("mouseenter mouseleave"); // Remove event listeners once resolved
        resolve();
      }, remainingTime);
    }

    // Initialize with totalTime
    remainingTime = totalTime;
    startTimer();
    if (isPauseOnHover === "yes") {
      $targetContainer.on("mouseenter", function () {
        clearTimeout(timeoutId); // Clear the current timer
        // Calculate elapsed time and set remaining time for when hover ends
        remainingTime -= Date.now() - startTime;
      });
      $targetContainer.on("mouseleave", function () {
        startTimer();
      });
    }
    // --- End Hover Pause Logic ---
  });
}

/**
 * Loops through and animates multiple words inside a container.
 * @param {Object} config - Settings
 */
async function initConstructWordSequence({
  $element,
  animationSpeed = 3,
  delayPerCharacter = 150,
  pauseBetweenWords = 1,
  isPauseOnHover
}) {
  const $wordElements = $element.find(".marqueex-animated-text");
  const wordList = $wordElements.map((_, el) => $(el).text().trim()).get();
  const $measurer = $("<span></span>").css({
    position: "fixed",
    visibility: "hidden",
    whiteSpace: "nowrap",
    pointerEvents: "none",
    top: "-200px",
    left: 0
  });
  const $animatedWrapper = $("<span></span>");
  $element.empty().append($animatedWrapper).append($measurer);
  const baseDuration = 10000;
  const animationDuration = Math.max(100, baseDuration / animationSpeed);
  let index = 0;
  while (true) {
    const word = wordList[index];
    $measurer.text(word);
    const targetWidth = $measurer.outerWidth();
    $element.stop().animate({
      width: Math.round(targetWidth)
    }, 300);
    await animateConstructWord($animatedWrapper, word, animationDuration, delayPerCharacter, pauseBetweenWords, isPauseOnHover);
    index = (index + 1) % wordList.length;
  }
}

// Export for ES6 modules


// Also attach to window for backward compatibility  
if (typeof window !== 'undefined') {
  window.initConstructWordSequence = initConstructWordSequence;
}

/***/ }),

/***/ "./src/elementor/js/animated-heading/lines-animation.js":
/*!**************************************************************!*\
  !*** ./src/elementor/js/animated-heading/lines-animation.js ***!
  \**************************************************************/
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   initiateLineAnimation: () => (/* binding */ initiateLineAnimation)
/* harmony export */ });
// Use global jQuery
const $ = window.jQuery;
const pathsMap = {
  wavyUnderline: [`<path
         d="M0,146
            c10,-8 20,-16 30,-16
            c10,0 12,16 20,16
            c10,0 15,-16 25,-16
            c10,0 12,16 20,16
            c10,0 15,-16 25,-16
            c10,0 12,16 20,16
            c10,0 15,-16 25,-16
            c10,0 12,16 20,16
            c10,0 15,-16 25,-16
            c10,0 12,16 20,16
            c10,0 15,-16 25,-16
            c10,0 12,16 20,16
            c10,0 15,-16 25,-16
            c10,0 12,16 20,16
            c10,0 15,-16 25,-16
            c10,0 12,16 20,16
            c10,0 15,-16 25,-16
            c10,0 12,16 20,16
            c10,0 15,-16 25,-16
            c10,0 12,16 20,16
            c10,0 15,-16 25,-16
            c10,0 12,16 20,16"
       />`],
  doubleUnderline: [`<path
         id="path1"
         d="M5,130.4
            c30.5-3.8,137.9-7.6,177.3-7.6
            c117.2,0,252.2,4.7,312.7,7.6"
       />`, `<path
         id="path2"
         d="M26.9,145.8
            c55.1-6.1,126-6.3,162.2-6.1
            c46.5,0.2,203.9,3.2,268.9,6.4"
       />`],
  singleUnderline: [`<path
         d="M7.7,145.6
            C109,125,299.9,116.2,401,121.3
            c42.1,2.2,87.6,11.8,87.3,25.7"
       />`],
  underlineZigzag: [`<path
         d="M9.3,127.3
            c49.3-3,150.7-7.6,199.7-7.4
            c121.9,0.4,189.9,0.4,282.3,7.2
            C380.1,129.6,181.2,130.6,70,139
            c82.6-2.9,254.2-1,335.9,1.3
            c-56,1.4-137.2-0.3-197.1,9"
       />`],
  circle: [`<path
         d="M325,18
            C228.7-8.3,118.5,8.3,78,21
            C22.4,38.4,4.6,54.6,5.6,77.6
            c1.4,32.4,52.2,54,142.6,63.7
            c66.2,7.1,212.2,7.5,273.5-8.3
            c64.4-16.6,104.3-57.6,33.8-98.2
            C386.7-4.9,179.4-1.4,126.3,20.7"
       />`]
};
function initiateLineAnimation({
  $element,
  animationSpeed,
  delayBeforeErase,
  lineType = "singleUnderline"
}) {
  const $container = $element.find(".marqueex-animated-lines");
  const pathHTML = pathsMap[lineType].join("");
  $container.html(pathHTML);
  const $paths = $container.find("path");
  const baseDuration = 10000;
  const drawDuration = Math.max(100, baseDuration / animationSpeed);
  function resetPaths() {
    $paths.each(function () {
      const length = this.getTotalLength();
      $(this).css({
        strokeDasharray: length,
        strokeDashoffset: length
      });
    });
  }
  function draw($path) {
    $path.css({
      transition: `stroke-dashoffset ${drawDuration}ms linear`,
      strokeDashoffset: 0
    });
  }
  function erase($path) {
    const length = $path[0].getTotalLength();
    $path.css({
      transition: `stroke-dashoffset ${drawDuration}ms linear`,
      strokeDashoffset: length
    });
  }
  function startLoop(index = 0) {
    if (index < $paths.length) {
      const $path = $paths.eq(index);
      draw($path);
      setTimeout(() => startLoop(index + 1), drawDuration);
    } else {
      setTimeout(() => eraseLoop(0), delayBeforeErase * 1000);
    }
  }
  function eraseLoop(index = 0) {
    if (index < $paths.length) {
      const $path = $paths.eq(index);
      erase($path);
      setTimeout(() => eraseLoop(index + 1), drawDuration);
    } else {
      setTimeout(() => startLoop(), delayBeforeErase * 1000);
    }
  }
  resetPaths();
  startLoop();
}

window.initiateLineAnimation = initiateLineAnimation;

/***/ }),

/***/ "./src/elementor/js/animated-heading/rotation-3d.js":
/*!**********************************************************!*\
  !*** ./src/elementor/js/animated-heading/rotation-3d.js ***!
  \**********************************************************/
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   init3DRotation: () => (/* binding */ init3DRotation)
/* harmony export */ });
// Use global jQuery
const $ = window.jQuery;
function init3DRotation({
  $element,
  animationSpeed = 10,
  isPauseOnHover
}) {
  let wordsToCycle = $element.find(".marqueex-animated-text").map(function () {
    return $(this).text().trim();
  }).get();
  if (wordsToCycle.length === 0) return;
  const faceCount = 3;
  let lastUpdatedFace = -1;
  let currentRotation = 0;
  const anglePerFace = 360 / faceCount;
  const rotationSpeed = animationSpeed / 10;
  const tolerance = 10;

  // Ensure at least 3 words
  while (wordsToCycle.length < faceCount) {
    wordsToCycle = [...wordsToCycle, ...wordsToCycle].slice(0, faceCount);
  }
  $element.empty();
  let wordIndex = 0;
  const faces = [];

  // Create a hidden temp span for measuring word widths
  const $tempSpan = $("<span>").css({
    visibility: "hidden",
    position: "absolute",
    whiteSpace: "nowrap"
  }).appendTo($element);
  let maxWidth = 0;
  wordsToCycle.forEach(word => {
    $tempSpan.text(word);
    maxWidth = Math.max(maxWidth, Math.ceil($tempSpan.outerWidth()));
  });
  $tempSpan.remove();

  // Set element width based on max word
  $element.css("width", `${maxWidth}px`);

  // Create faces
  for (let i = 0; i < faceCount; i++) {
    const $face = $("<span>").addClass("marqueex-animated-text").attr("data-index", i).css("visibility", "visible").text(wordsToCycle[wordIndex]).appendTo($element);
    faces.push($face);
    wordIndex = (wordIndex + 1) % wordsToCycle.length;
  }

  // ✅ Handle pause on hover
  let isPaused = false;
  if (isPauseOnHover === "yes") {
    $element.on("mouseenter", () => isPaused = true);
    $element.on("mouseleave", () => isPaused = false);
  }
  function rotate() {
    if (!isPaused) {
      currentRotation = (currentRotation + rotationSpeed) % 360;
      $element.css("transform", `rotateX(${currentRotation}deg)`);
      let backFaceIndex = -1;
      let frontFaceIndex = -1;
      let minAngleDiff = 360;
      faces.forEach(($face, i) => {
        const initialAngle = i * anglePerFace;
        const faceAngle = (initialAngle + currentRotation) % 360;
        $face.css("transform", `rotateX(${initialAngle}deg) translateZ(0.33em)`);
        if (faceAngle > 180 - tolerance && faceAngle < 180 + tolerance) {
          backFaceIndex = i;
        }
        const angleToFront = Math.min(faceAngle, 360 - faceAngle);
        if (angleToFront < minAngleDiff) {
          minAngleDiff = angleToFront;
          frontFaceIndex = i;
        }
      });
      if (backFaceIndex !== -1 && backFaceIndex !== lastUpdatedFace) {
        lastUpdatedFace = backFaceIndex;
        faces[backFaceIndex].text(wordsToCycle[wordIndex]);
        wordIndex = (wordIndex + 1) % wordsToCycle.length;
      }
      if (frontFaceIndex !== -1) {
        $element.css("width", `${faces[frontFaceIndex].outerWidth()}px`);
      }
    }
    requestAnimationFrame(rotate);
  }
  requestAnimationFrame(rotate);
}
window.init3DRotation = init3DRotation;


/***/ }),

/***/ "./src/elementor/js/animated-heading/slide-word.js":
/*!*********************************************************!*\
  !*** ./src/elementor/js/animated-heading/slide-word.js ***!
  \*********************************************************/
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   initHorizontalWordSlide: () => (/* binding */ initHorizontalWordSlide),
/* harmony export */   initWordSlide: () => (/* binding */ initWordSlide)
/* harmony export */ });
// Use global jQuery
const $ = window.jQuery;
function initWordSlide({
  $element,
  delaySec = 1.5,
  animationSpeed = 10,
  direction = 1,
  isPauseOnHover
}) {
  let height = $element.children().first().outerHeight();
  let isStarted = false;
  const $container = $element.parent();
  const baseDuration = 10000;
  const animationDuration = Math.max(100, baseDuration / animationSpeed);
  const existing = $element.children().toArray();
  while ($element.children().length < 3) {
    existing.forEach(el => {
      if ($element.children().length < 3) {
        $element.append($(el).clone(true));
      }
    });
  }
  $container.css({
    height: `${height}px`,
    display: "inline-block",
    overflow: "hidden",
    transition: `width ${animationDuration}ms ease`
  });
  function updateNextWordWidth(nextIndex = isStarted ? 1 : 0) {
    const $words = $element.children();
    const $next = direction === 1 ? $words.eq(nextIndex % $words.length) : $words.eq(($words.length - nextIndex) % $words.length);
    const wordWidth = $next.outerWidth(true);
    $container.css("width", wordWidth + "px");
    isStarted = true;
  }
  updateNextWordWidth();
  function rotateWord() {
    updateNextWordWidth();
    if (direction === 1) {
      $element.css({
        transition: `transform ${animationDuration}ms ease-in-out`,
        transform: `translateY(-${height}px)`
      });
      setTimeout(() => {
        const $first = $element.children().first();
        $element.append($first);
        $element.css({
          transition: "none",
          transform: "translateY(0)"
        });
      }, animationDuration);
    } else {
      const $last = $element.children().last();
      $last.prependTo($element);
      $element.css({
        transition: "none",
        transform: `translateY(-${height}px)`
      });
      requestAnimationFrame(() => {
        requestAnimationFrame(() => {
          $element.css({
            transition: `transform ${animationDuration}ms ease-in-out`,
            transform: "translateY(0)"
          });
        });
      });
    }
  }
  let interval = setInterval(rotateWord, delaySec * 1000);
  if (isPauseOnHover === "yes") {
    $container.on("mouseenter", () => clearInterval(interval)).on("mouseleave", () => {
      interval = setInterval(rotateWord, delaySec * 1000);
    });
  }
  $(window).on("resize", () => {
    height = $element.children().first().outerHeight();
    $container.css("height", height + "px");
    updateNextWordWidth();
  });
}
function initHorizontalWordSlide({
  $element,
  delaySec,
  direction = 1,
  animationSpeed,
  isPauseOnHover
}) {
  const $parent = $element.parent();
  if (!$element.length || !$parent.length || $element.children().length === 0) {
    return;
  }
  const existing = $element.children().toArray();
  while ($element.children().length < 3) {
    existing.forEach(el => {
      if ($element.children().length < 3) {
        $element.append($(el).clone(true));
      }
    });
  }
  const baseDuration = 2500;
  const transitionDuration = Math.max(100, baseDuration / Math.max(animationSpeed, delaySec));
  $element.css("transition", `transform ${transitionDuration}ms ease-in-out`);
  $parent.css("transition", `width ${transitionDuration}ms ease-in-out`);
  function setParentWidth() {
    const $currentWord = $element.children().first();
    if ($currentWord.length) {
      $parent.css("width", $currentWord.outerWidth());
    }
  }
  function rotateWord() {
    if (direction === 1) {
      // ➤ Right-to-left sliding
      const $firstWord = $element.children().first();
      const $nextWord = $firstWord.next().length ? $firstWord.next() : $firstWord;
      const currentWidth = $firstWord.outerWidth();
      $parent.css("width", $nextWord.outerWidth());
      $element.css("transform", `translateX(-${currentWidth}px)`);
      setTimeout(() => {
        $firstWord.appendTo($element);
        $element.css("transition", "none");
        $element.css("transform", "translateX(0)");
        $element[0].offsetHeight; // Force reflow
        $element.css("transition", `transform ${transitionDuration}ms ease-in-out`);
      }, transitionDuration);
    } else {
      // ➤ Left-to-right sliding
      const $lastWord = $element.children().last();
      const lastWidth = $lastWord.outerWidth();
      $lastWord.prependTo($element);
      $parent.css("width", lastWidth);
      $element.css("transition", "none");
      $element.css("transform", `translateX(-${lastWidth}px)`);
      requestAnimationFrame(() => {
        requestAnimationFrame(() => {
          $element.css("transition", `transform ${transitionDuration}ms ease-in-out`);
          $element.css("transform", "translateX(0)");
        });
      });
    }
  }

  // Initial setup
  setParentWidth();

  // Interval control
  let intervalId = setInterval(rotateWord, delaySec * 1000);

  // Pause on hover (if enabled)
  if (isPauseOnHover === "yes") {
    $parent.on("mouseenter", () => clearInterval(intervalId)).on("mouseleave", () => {
      intervalId = setInterval(rotateWord, delaySec * 1000);
    });
  }

  // Handle resize
  $(window).on("resize", () => {
    $parent.css("transition", "none");
    $element.css("transition", "none");
    setParentWidth();
    setTimeout(() => {
      $parent.css("transition", `width ${transitionDuration}ms ease-in-out`);
      $element.css("transition", `transform ${transitionDuration}ms ease-in-out`);
    }, 50);
  });
}

// Export for ES6 modules


// Also attach to window for backward compatibility
if (typeof window !== 'undefined') {
  window.initWordSlide = initWordSlide;
  window.initHorizontalWordSlide = initHorizontalWordSlide;
}

/***/ }),

/***/ "./src/elementor/js/animated-heading/twisting-text.js":
/*!************************************************************!*\
  !*** ./src/elementor/js/animated-heading/twisting-text.js ***!
  \************************************************************/
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   initiateTwistedText: () => (/* binding */ initiateTwistedText)
/* harmony export */ });
// Use global jQuery
const $ = window.jQuery;
function initiateTwistedText({
  $element,
  animationSpeed = 5,
  delayPerLetter = 150,
  pauseBetweenLoops = 1,
  sync = false,
  isPauseOnHover
}) {
  const baseDuration = 10000;
  const twistDuration = baseDuration / animationSpeed;
  const words = [];
  $element.find("span").each(function () {
    const text = $(this).text().trim();
    if (text) words.push(text);
  });
  if (words.length === 0) {
    console.warn("initiateTwistedText: No words found for animation.");
    return;
  }
  $element.empty();
  const wordWrappers = [];

  // --- State Management ---
  let mainLoopTimeoutId = null;
  let pauseStartTime = 0;
  let remainingTimeOnLoop = 0;
  let isPaused = false;
  let currentWordIndex = 0; // Index of the word currently or about to be animated.

  // --- DOM Setup ---
  words.forEach(word => {
    const $wordWrapper = $("<span></span>").addClass("marqueex-word-wrapper");
    [...word].forEach(char => {
      const $span = $("<span></span>").text(char === " " ? "\u00A0" : char);
      $wordWrapper.append($span);
    });
    $element.append($wordWrapper);
    wordWrappers.push($wordWrapper);
  });

  // --- Core Animation Logic ---

  function getWordAnimationDuration($wordWrapper) {
    const numChars = $wordWrapper.find("span").length;
    if (numChars === 0) return 0;
    return (numChars - 1) * delayPerLetter + twistDuration;
  }

  // Applies the animation to a word using CSS delays.
  // This function should only be called when a word is meant to START its animation.
  function triggerWordAnimation(wordIndex) {
    const $wordWrapper = wordWrappers[wordIndex];
    if (!$wordWrapper) return;
    $wordWrapper.find("span").each(function (i) {
      const $span = $(this);
      // Reset animation properties to ensure it can be re-triggered
      $span.css({
        animation: "none",
        opacity: 1 // Make sure it's visible before animation
      });
      // Force a reflow to apply the reset.
      void $span[0].offsetWidth;
      // Apply the new animation with a delay
      $span.css({
        "animation-name": "deensimcTwist",
        "animation-duration": `${twistDuration}ms`,
        "animation-timing-function": "linear",
        "animation-iteration-count": "1",
        "animation-delay": `${i * delayPerLetter}ms`,
        "animation-fill-mode": "forwards",
        "animation-play-state": "running"
      });
    });
  }

  // --- Main Animation Loops ---

  function scheduleNextAnimation() {
    if (isPaused) return;
    let nextDelay = 0;
    if (sync) {
      // In sync mode, trigger all words at once.
      wordWrappers.forEach((_, index) => {
        triggerWordAnimation(index);
      });
      // The next loop starts after the longest word finishes, plus the pause.
      const longestDuration = Math.max(...wordWrappers.map(getWordAnimationDuration));
      nextDelay = longestDuration + pauseBetweenLoops * 1000;
    } else {
      // In sequential mode, trigger the current word.
      triggerWordAnimation(currentWordIndex);
      const currentWordDuration = getWordAnimationDuration(wordWrappers[currentWordIndex]);

      // Determine the delay for the next word.
      const isLastWord = currentWordIndex === wordWrappers.length - 1;
      nextDelay = currentWordDuration + (isLastWord ? pauseBetweenLoops * 1000 : 0);

      // Set up the index for the next iteration.
      currentWordIndex = (currentWordIndex + 1) % wordWrappers.length;
    }
    remainingTimeOnLoop = nextDelay;
    pauseStartTime = Date.now();
    mainLoopTimeoutId = setTimeout(scheduleNextAnimation, nextDelay);
  }

  // --- Pause/Resume Logic ---

  function pauseAnimation() {
    if (isPaused) return;
    isPaused = true;

    // Stop the timer that schedules the next animation cycle.
    clearTimeout(mainLoopTimeoutId);
    mainLoopTimeoutId = null;

    // Calculate how much time was left on that timer.
    const elapsedTime = Date.now() - pauseStartTime;
    remainingTimeOnLoop = Math.max(0, remainingTimeOnLoop - elapsedTime);

    // Pause all currently running CSS animations.
    $element.find(".marqueex-word-wrapper span").css("animation-play-state", "paused");
  }
  function resumeAnimation() {
    if (!isPaused) return;
    isPaused = false;

    // Resume all paused CSS animations.
    $element.find(".marqueex-word-wrapper span").css("animation-play-state", "running");

    // Restart the timer to schedule the next animation cycle.
    // It will pick up where it left off.
    if (remainingTimeOnLoop > 0) {
      pauseStartTime = Date.now(); // Reset the start time for the new timeout
      mainLoopTimeoutId = setTimeout(scheduleNextAnimation, remainingTimeOnLoop);
    } else {
      // If the timer had already run out, schedule the next one immediately.
      scheduleNextAnimation();
    }
  }

  // --- Event Listeners ---
  if (isPauseOnHover === "yes") {
    $element.on("mouseenter", pauseAnimation);
    $element.on("mouseleave", resumeAnimation);
  }

  // --- Cleanup ---
  $element.on("remove", function () {
    clearTimeout(mainLoopTimeoutId);
    $element.off("mouseenter mouseleave");
  });

  // --- Start the animation ---
  scheduleNextAnimation();
}
window.initiateTwistedText = initiateTwistedText;


/***/ }),

/***/ "./src/elementor/js/animated-heading/waveSwingTiltLeanAnimation.js":
/*!*************************************************************************!*\
  !*** ./src/elementor/js/animated-heading/waveSwingTiltLeanAnimation.js ***!
  \*************************************************************************/
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   animationMap: () => (/* binding */ animationMap),
/* harmony export */   initWaveSwingTiltLeanAnimation: () => (/* binding */ initWaveSwingTiltLeanAnimation),
/* harmony export */   waveSwingTiltLeanAnimation: () => (/* binding */ waveSwingTiltLeanAnimation)
/* harmony export */ });
// Use global jQuery
const $ = window.jQuery;
const animationMap = {
  WAVE: "deensimcWave",
  SWING: "deensimcSwing",
  TILT: "deensimcTilt",
  LEAN: "deensimcLean"
};
const waveSwingTiltLeanAnimation = ["wave", "swing", "tilt", "lean"];

/**
 * Animate each letter of the text inside a container
 * @param {Object} config
 * @param {jQuery} config.$element - The container element (jQuery object)
 * @param {number} [config.animationSpeed=5]
 * @param {number} [config.delayPerLetter=125]
 * @param {string} config.animationName
 */
function initWaveSwingTiltLeanAnimation({
  $element,
  animationSpeed = 5,
  delayPerLetter = 125,
  animationName,
  isPauseOnHover
}) {
  if (!$element.length) return;
  let words = [];
  $element.find("span").each(function () {
    const spanText = $(this).text().trim();
    if (spanText) {
      words.push(spanText);
    }
  });
  if (!words.length) return;
  $element.empty();
  const baseDuration = 10000;
  const animationDuration = Math.max(100, baseDuration / animationSpeed);
  words.forEach((word, wordIndex) => {
    const wordWrapper = $("<span></span>").css("white-space", "nowrap");
    if (isPauseOnHover === "yes") {
      wordWrapper.addClass("marqueex-pause-on-hover");
    }
    [...word].forEach((char, charIndex) => {
      const span = $("<span></span>").text(char === " " ? "\u00A0" : char);
      let transformOrigin = "center";
      if (animationName === animationMap.SWING) {
        transformOrigin = "top";
      } else if (animationName === animationMap.LEAN) {
        transformOrigin = "bottom";
      }
      span.css("transform-origin", transformOrigin);
      span.css({
        "animation-play-state": "running",
        "animation-name": animationName,
        "animation-duration": `${animationDuration}ms`,
        "animation-delay": `${charIndex * delayPerLetter}ms`,
        "animation-iteration-count": "infinite",
        "animation-timing-function": "ease-in-out",
        display: "inline-block" // Ensure animation works
      });
      wordWrapper.append(span);
    });
    $element.append(wordWrapper);

    // Add space between words (non-breaking space wrapper)
    if (wordIndex < words.length - 1) {
      $element.append(document.createTextNode(" "));
    }
  });
}


/***/ })

/******/ 	});
/************************************************************************/
/******/ 	// The module cache
/******/ 	var __webpack_module_cache__ = {};
/******/ 	
/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {
/******/ 		// Check if module is in cache
/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
/******/ 		if (cachedModule !== undefined) {
/******/ 			return cachedModule.exports;
/******/ 		}
/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = __webpack_module_cache__[moduleId] = {
/******/ 			// no module.id needed
/******/ 			// no module.loaded needed
/******/ 			exports: {}
/******/ 		};
/******/ 	
/******/ 		// Execute the module function
/******/ 		__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
/******/ 	
/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}
/******/ 	
/************************************************************************/
/******/ 	/* webpack/runtime/define property getters */
/******/ 	(() => {
/******/ 		// define getter functions for harmony exports
/******/ 		__webpack_require__.d = (exports, definition) => {
/******/ 			for(var key in definition) {
/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
/******/ 				}
/******/ 			}
/******/ 		};
/******/ 	})();
/******/ 	
/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
/******/ 	(() => {
/******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
/******/ 	})();
/******/ 	
/******/ 	/* webpack/runtime/make namespace object */
/******/ 	(() => {
/******/ 		// define __esModule on exports
/******/ 		__webpack_require__.r = (exports) => {
/******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
/******/ 			}
/******/ 			Object.defineProperty(exports, '__esModule', { value: true });
/******/ 		};
/******/ 	})();
/******/ 	
/************************************************************************/
var __webpack_exports__ = {};
// This entry needs to be wrapped in an IIFE because it needs to be isolated against other modules in the chunk.
(() => {
/*!**********************************************!*\
  !*** ./src/elementor/js/animated-heading.js ***!
  \**********************************************/
__webpack_require__.r(__webpack_exports__);
/* harmony import */ var _animated_heading_slide_word_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./animated-heading/slide-word.js */ "./src/elementor/js/animated-heading/slide-word.js");
/* harmony import */ var _animated_heading_rotation_3d_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./animated-heading/rotation-3d.js */ "./src/elementor/js/animated-heading/rotation-3d.js");
/* harmony import */ var _animated_heading_construct_word_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./animated-heading/construct-word.js */ "./src/elementor/js/animated-heading/construct-word.js");
/* harmony import */ var _animated_heading_twisting_text_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./animated-heading/twisting-text.js */ "./src/elementor/js/animated-heading/twisting-text.js");
/* harmony import */ var _animated_heading_lines_animation_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./animated-heading/lines-animation.js */ "./src/elementor/js/animated-heading/lines-animation.js");
/* harmony import */ var _animated_heading_waveSwingTiltLeanAnimation_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./animated-heading/waveSwingTiltLeanAnimation.js */ "./src/elementor/js/animated-heading/waveSwingTiltLeanAnimation.js");
// Import animation functions (webpack will bundle these)






(function ($, window) {
  "use strict";

  // Elementor integration
  $(window).on("elementor/frontend/init", () => {
    elementorFrontend.hooks.addAction("frontend/element_ready/marqueex-animated-heading.default", function ($scope) {
      const $element = $scope.find(".marqueex-texts-wrapper");
      if (!$element.length) return;
      const animationType = $element.data("animation");

      // Common animation attributes with fallbacks
      const animationSpeed = Number($element.data("animation-speed") || 1);
      const isPauseOnHover = $element.data("is-pause-on-hover") || "no";
      const delayPerWord = Number($element.data("delay-per-word") || 1.5);
      const slideDirection = Number($element.data("slide-direction") || 1);
      const pauseBetweenWords = Number($element.data("pause-between-words") || 1.5);
      const pauseAfterTyped = Number($element.data("pause-after-typed") || 1);
      const delayBeforeErase = Number($element.data("delay-before-erase") || 1.5);
      const lineType = $element.data("line-type") || "singleUnderline";

      // Handle animation type
      switch (animationType) {
        case "slide":
          (0,_animated_heading_slide_word_js__WEBPACK_IMPORTED_MODULE_0__.initWordSlide)({
            $element,
            delaySec: delayPerWord,
            direction: slideDirection,
            animationSpeed,
            isPauseOnHover
          });
          break;
        case "slide-horizontal":
          (0,_animated_heading_slide_word_js__WEBPACK_IMPORTED_MODULE_0__.initHorizontalWordSlide)({
            $element,
            delaySec: delayPerWord,
            direction: slideDirection,
            animationSpeed,
            isPauseOnHover
          });
          break;
        case "rotation-3d":
          (0,_animated_heading_rotation_3d_js__WEBPACK_IMPORTED_MODULE_1__.initRotation3D)({
            $element,
            delaySec: delayPerWord,
            animationSpeed,
            isPauseOnHover
          });
          break;
        case "construct":
          (0,_animated_heading_construct_word_js__WEBPACK_IMPORTED_MODULE_2__.initConstructWordSequence)({
            $element,
            animationSpeed,
            delayPerCharacter: 150,
            pauseBetweenWords,
            isPauseOnHover
          });
          break;
        case "typing":
          initiateTypingAnimation({
            $element,
            typingRate: animationSpeed,
            pauseAfterTyped,
            isPauseOnHover
          });
          break;
        case "twist":
          (0,_animated_heading_twisting_text_js__WEBPACK_IMPORTED_MODULE_3__.initiateTwistingAnimation)({
            $element,
            animationSpeed,
            isPauseOnHover
          });
          break;
        case "line":
          (0,_animated_heading_lines_animation_js__WEBPACK_IMPORTED_MODULE_4__.initiateLinesAnimation)({
            $element,
            lineType,
            delayBeforeErase,
            animationSpeed
          });
          break;
        case "wave":
        case "swing":
        case "tilt":
        case "lean":
          (0,_animated_heading_waveSwingTiltLeanAnimation_js__WEBPACK_IMPORTED_MODULE_5__.initiateWaveSwingTiltLeanAnimation)({
            $element,
            animationType,
            animationSpeed,
            isPauseOnHover
          });
          break;
        default:
          console.warn(`Unknown animation type: ${animationType}`);
      }
    });
  });

  // Typing Animation Function
  function initiateTypingAnimation({
    $element,
    typingRate,
    pauseAfterTyped,
    pauseAfterDelete = 0,
    isPauseOnHover
  }) {
    const texts = $element.find(".marqueex-animated-text").map(function () {
      return $(this).text().trim();
    }).get();

    // Safety check: if no texts found, exit early
    if (!texts.length) {
      console.warn('No animated texts found for typing animation');
      return;
    }
    let textIndex = 0;
    let charIndex = 0;
    let isDeleting = false;
    let isPaused = false;
    let currentTimeout = null;
    const typingDelay = 1000 / typingRate;
    const $animatedText = $("<span></span>");
    $element.empty().append($animatedText);
    function typeLoop() {
      if (isPaused) return;
      const currentText = texts[textIndex];
      const displayText = currentText.substring(0, charIndex);
      $animatedText.text(displayText);
      if (!isDeleting) {
        if (charIndex < currentText.length) {
          charIndex++;
          currentTimeout = setTimeout(typeLoop, typingDelay);
        } else {
          isDeleting = true;
          currentTimeout = setTimeout(typeLoop, pauseAfterTyped * 1000);
        }
      } else {
        if (charIndex > 0) {
          charIndex--;
          currentTimeout = setTimeout(typeLoop, typingDelay / 2);
        } else {
          isDeleting = false;
          textIndex = (textIndex + 1) % texts.length;
          currentTimeout = setTimeout(typeLoop, pauseAfterDelete * 1000);
        }
      }
    }

    // Handle pause on hover
    if (isPauseOnHover === "yes") {
      $element.on("mouseenter", function () {
        isPaused = true;
        clearTimeout(currentTimeout);
      });
      $element.on("mouseleave", function () {
        if (isPaused) {
          isPaused = false;
          typeLoop();
        }
      });
    }
    typeLoop();
  }

  // All animation functions are now imported and bundled by webpack
})(jQuery, window);
})();

/******/ })()
;