# elementor/4.3.2/assets/js/interactions.js

Elementor Website Builder – more than just a page builder, version 4.3.2. 649 lines.

- Page: https://pluginprobe.com/plugins/elementor/4.3.2/code/assets/js/interactions.js
- Raw: https://pluginprobe.com/plugins/elementor/4.3.2/raw/assets/js/interactions.js
- Modified: 2026-09-01T11:47:36+00:00

Line numbers below start at 1. Link to a line or a range by appending a fragment to the
page URL, for example `https://pluginprobe.com/plugins/elementor/4.3.2/code/assets/js/interactions.js#L10-L20`.

```javascript
'use strict';

(function() {

//#region \0rolldown/runtime.js
	var __defProp = Object.defineProperty;
	var __name = (target, value) => __defProp(target, "name", {
		value,
		configurable: true
	});

//#endregion

//#region node_modules/@babel/runtime/helpers/esm/arrayWithHoles.js
	function _arrayWithHoles(r) {
		if (Array.isArray(r)) return r;
	}

//#endregion
//#region node_modules/@babel/runtime/helpers/esm/iterableToArrayLimit.js
	function _iterableToArrayLimit(r, l) {
		var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
		if (null != t) {
			var e;
			var n;
			var i;
			var u;
			var a = [];
			var f = !0;
			var o = !1;
			try {
				if (i = (t = t.call(r)).next, 0 === l) {
					if (Object(t) !== t) return;
					f = !1;
				} else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
			} catch (r) {
				o = !0, n = r;
			} finally {
				try {
					if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return;
				} finally {
					if (o) throw n;
				}
			}
			return a;
		}
	}

//#endregion
//#region node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js
	function _arrayLikeToArray$1(r, a) {
		(null == a || a > r.length) && (a = r.length);
		for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
		return n;
	}
	__name(_arrayLikeToArray$1, "_arrayLikeToArray");

//#endregion
//#region node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js
	function _unsupportedIterableToArray$1(r, a) {
		if (r) {
			if ("string" == typeof r) return _arrayLikeToArray$1(r, a);
			var t = {}.toString.call(r).slice(8, -1);
			return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray$1(r, a) : void 0;
		}
	}
	__name(_unsupportedIterableToArray$1, "_unsupportedIterableToArray");

//#endregion
//#region node_modules/@babel/runtime/helpers/esm/nonIterableRest.js
	function _nonIterableRest() {
		throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
	}

//#endregion
//#region node_modules/@babel/runtime/helpers/esm/slicedToArray.js
	function _slicedToArray(r, e) {
		return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray$1(r, e) || _nonIterableRest();
	}

//#endregion
//#region node_modules/@babel/runtime/helpers/esm/typeof.js
	function _typeof(o) {
		"@babel/helpers - typeof";
		return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
			return typeof o;
		} : function(o) {
			return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
		}, _typeof(o);
	}

//#endregion
//#region node_modules/@babel/runtime/helpers/esm/toPrimitive.js
	function toPrimitive(t, r) {
		if ("object" != _typeof(t) || !t) return t;
		var e = t[Symbol.toPrimitive];
		if (void 0 !== e) {
			var i = e.call(t, r || "default");
			if ("object" != _typeof(i)) return i;
			throw new TypeError("@@toPrimitive must return a primitive value.");
		}
		return ("string" === r ? String : Number)(t);
	}

//#endregion
//#region node_modules/@babel/runtime/helpers/esm/toPropertyKey.js
	function toPropertyKey(t) {
		var i = toPrimitive(t, "string");
		return "symbol" == _typeof(i) ? i : i + "";
	}

//#endregion
//#region node_modules/@babel/runtime/helpers/esm/defineProperty.js
	function _defineProperty(e, r, t) {
		return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
			value: t,
			enumerable: !0,
			configurable: !0,
			writable: !0
		}) : e[r] = t, e;
	}

//#endregion
//#region modules/interactions/assets/js/interactions-breakpoints.js
	var RESIZE_DEBOUNCE_TIMEOUT = 100;
	var breakpoints = {
		list: {},
		active: {},
		onChange: function onChange() {}
	};
	function getActiveBreakpoint() {
		return breakpoints.active;
	}
	function matchBreakpoint(width) {
		for (var label in breakpoints.list) {
			var breakpoint = breakpoints.list[label];
			if ("min" === breakpoint.direction && width >= breakpoint.value) return label;
			if ("max" === breakpoint.direction && breakpoint.value >= width) return label;
		}
		return "desktop";
	}
	function attachEventListeners() {
		var timeout = null;
		window.addEventListener("resize", function onResize() {
			if (timeout) {
				window.clearTimeout(timeout);
				timeout = null;
			}
			timeout = window.setTimeout(function() {
				var currentBreakpoint = matchBreakpoint(window.innerWidth);
				if (currentBreakpoint === breakpoints.active) return;
				breakpoints.active = currentBreakpoint;
				if ("function" === typeof breakpoints.onChange) breakpoints.onChange(breakpoints.active);
			}, RESIZE_DEBOUNCE_TIMEOUT);
		});
	}
	function getBreakpointsList() {
		var _ElementorInteraction;
		return ((_ElementorInteraction = ElementorInteractionsConfig) === null || _ElementorInteraction === void 0 ? void 0 : _ElementorInteraction.breakpoints) || {};
	}
	function initBreakpoints() {
		var onChange = (arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}).onChange;
		breakpoints.list = getBreakpointsList();
		breakpoints.active = matchBreakpoint(window.innerWidth);
		if ("function" === typeof onChange) breakpoints.onChange = onChange;
		attachEventListeners();
	}

//#endregion
//#region modules/interactions/assets/js/interactions-shared-utils.js
	function ownKeys(e, r) {
		var t = Object.keys(e);
		if (Object.getOwnPropertySymbols) {
			var o = Object.getOwnPropertySymbols(e);
			r && (o = o.filter(function(r) {
				return Object.getOwnPropertyDescriptor(e, r).enumerable;
			})), t.push.apply(t, o);
		}
		return t;
	}
	function _objectSpread(e) {
		for (var r = 1; r < arguments.length; r++) {
			var t = null != arguments[r] ? arguments[r] : {};
			r % 2 ? ownKeys(Object(t), !0).forEach(function(r) {
				_defineProperty(e, r, t[r]);
			}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r) {
				Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
			});
		}
		return e;
	}
	function _createForOfIteratorHelper(r, e) {
		var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
		if (!t) {
			if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) {
				t && (r = t);
				var _n = 0;
				var F = function F() {};
				return {
					s: F,
					n: function n() {
						return _n >= r.length ? { done: !0 } : {
							done: !1,
							value: r[_n++]
						};
					},
					e: function e(r) {
						throw r;
					},
					f: F
				};
			}
			throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
		}
		var o;
		var a = !0;
		var u = !1;
		return {
			s: function s() {
				t = t.call(r);
			},
			n: function n() {
				var r = t.next();
				return a = r.done, r;
			},
			e: function e(r) {
				u = !0, o = r;
			},
			f: function f() {
				try {
					a || null == t.return || t.return();
				} finally {
					if (u) throw o;
				}
			}
		};
	}
	function _unsupportedIterableToArray(r, a) {
		if (r) {
			if ("string" == typeof r) return _arrayLikeToArray(r, a);
			var t = {}.toString.call(r).slice(8, -1);
			return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
		}
	}
	function _arrayLikeToArray(r, a) {
		(null == a || a > r.length) && (a = r.length);
		for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
		return n;
	}
	function config() {
		var _window$ElementorInte;
		var _window$ElementorInte2;
		return (_window$ElementorInte = (_window$ElementorInte2 = window.ElementorInteractionsConfig) === null || _window$ElementorInte2 === void 0 ? void 0 : _window$ElementorInte2.constants) !== null && _window$ElementorInte !== void 0 ? _window$ElementorInte : {};
	}
	function skipInteraction$1(interaction) {
		var _interaction$breakpoi;
		var breakpoint = getActiveBreakpoint();
		return interaction === null || interaction === void 0 || (_interaction$breakpoi = interaction.breakpoints) === null || _interaction$breakpoi === void 0 || (_interaction$breakpoi = _interaction$breakpoi.excluded) === null || _interaction$breakpoi === void 0 ? void 0 : _interaction$breakpoi.includes(breakpoint);
	}
	__name(skipInteraction$1, "skipInteraction");
	function extractInteractionId(interaction) {
		if ("interaction-item" === (interaction === null || interaction === void 0 ? void 0 : interaction.$$type) && interaction !== null && interaction !== void 0 && interaction.value) {
			var _interaction$value$in;
			return ((_interaction$value$in = interaction.value.interaction_id) === null || _interaction$value$in === void 0 ? void 0 : _interaction$value$in.value) || null;
		}
		return null;
	}
	function motionFunc(name) {
		var _window;
		var _window2;
		if ("function" !== typeof ((_window = window) === null || _window === void 0 || (_window = _window.Motion) === null || _window === void 0 ? void 0 : _window[name])) return;
		return (_window2 = window) === null || _window2 === void 0 || (_window2 = _window2.Motion) === null || _window2 === void 0 ? void 0 : _window2[name];
	}
	function getAnimateFunction() {
		return motionFunc("animate");
	}
	function getInViewFunction() {
		return motionFunc("inView");
	}
	function waitForAnimateFunction(callback) {
		var maxAttempts = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 10;
		if (getAnimateFunction()) {
			callback();
			return;
		}
		if (maxAttempts > 0) setTimeout(function() {
			return waitForAnimateFunction(callback, maxAttempts - 1);
		}, 100);
	}
	function parseInteractionsData(data) {
		if ("string" === typeof data) try {
			return JSON.parse(data);
		} catch (_unused) {
			return null;
		}
		return data;
	}
	function unwrapInteractionValue(propValue) {
		var fallback = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : null;
		if (propValue && "object" === _typeof(propValue) && "$$type" in propValue) return propValue.value;
		return propValue !== null && propValue !== void 0 ? propValue : fallback;
	}
	function timingValueToMs(timingValue, fallbackMs) {
		if (null === timingValue || void 0 === timingValue) return fallbackMs;
		var unwrapped = unwrapInteractionValue(timingValue);
		if ("number" === typeof unwrapped) return unwrapped;
		var sizeObj = unwrapInteractionValue(unwrapped);
		var size = sizeObj === null || sizeObj === void 0 ? void 0 : sizeObj.size;
		var unit = (sizeObj === null || sizeObj === void 0 ? void 0 : sizeObj.unit) || "ms";
		if ("number" !== typeof size) return fallbackMs;
		if ("s" === unit) return size * 1e3;
		return size;
	}
	function resetElementStyles(element) {
		if (!element) return;
		element.style.transition = "";
		element.style.transform = "";
		element.style.opacity = "";
	}
	var TRANSFORM_EPSILON = .001;
	var radiansToDegrees = function radiansToDegrees(radians) {
		return radians * (180 / Math.PI);
	};
	var isNear = function isNear(value, expected) {
		return Math.abs(value - expected) <= TRANSFORM_EPSILON;
	};
	var isNearZero = function isNearZero(value) {
		return isNear(value, 0);
	};
	var isNearOne = function isNearOne(value) {
		return isNear(value, 1);
	};
	function parseMatrixValues(transformValue) {
		var match = transformValue.match(/^matrix(3d)?\((.+)\)$/);
		if (!match) return null;
		return match[2].split(",").map(function(token) {
			return Number.parseFloat(token.trim());
		}).filter(function(value) {
			return Number.isFinite(value);
		});
	}
	function createMatrixFromTransform(transformValue) {
		if (!transformValue || "none" === transformValue) return null;
		var _iterator = _createForOfIteratorHelper([window.DOMMatrixReadOnly, window.DOMMatrix].filter(function(Factory) {
			return "function" === typeof Factory;
		}));
		var _step;
		try {
			for (_iterator.s(); !(_step = _iterator.n()).done;) {
				var MatrixFactory = _step.value;
				try {
					var _ref;
					var _matrix$a;
					var _ref2;
					var _matrix$b;
					var _ref3;
					var _matrix$c;
					var _ref4;
					var _matrix$d;
					var _ref5;
					var _matrix$e;
					var _ref6;
					var _matrix$f;
					var matrix = new MatrixFactory(transformValue);
					var compactMatrix = {
						matrixXfromX: (_ref = (_matrix$a = matrix.a) !== null && _matrix$a !== void 0 ? _matrix$a : matrix.m11) !== null && _ref !== void 0 ? _ref : 1,
						matrixYfromX: (_ref2 = (_matrix$b = matrix.b) !== null && _matrix$b !== void 0 ? _matrix$b : matrix.m12) !== null && _ref2 !== void 0 ? _ref2 : 0,
						matrixXfromY: (_ref3 = (_matrix$c = matrix.c) !== null && _matrix$c !== void 0 ? _matrix$c : matrix.m21) !== null && _ref3 !== void 0 ? _ref3 : 0,
						matrixYfromY: (_ref4 = (_matrix$d = matrix.d) !== null && _matrix$d !== void 0 ? _matrix$d : matrix.m22) !== null && _ref4 !== void 0 ? _ref4 : 1,
						matrixTranslateX: (_ref5 = (_matrix$e = matrix.e) !== null && _matrix$e !== void 0 ? _matrix$e : matrix.m41) !== null && _ref5 !== void 0 ? _ref5 : 0,
						matrixTranslateY: (_ref6 = (_matrix$f = matrix.f) !== null && _matrix$f !== void 0 ? _matrix$f : matrix.m42) !== null && _ref6 !== void 0 ? _ref6 : 0
					};
					if (Object.values(compactMatrix).every(Number.isFinite)) return compactMatrix;
				} catch (_unused2) {}
			}
		} catch (err) {
			_iterator.e(err);
		} finally {
			_iterator.f();
		}
		var parsedValues = parseMatrixValues(transformValue);
		if (!parsedValues) return null;
		if (6 === parsedValues.length) {
			var _parsedValues = _slicedToArray(parsedValues, 6);
			return {
				matrixXfromX: _parsedValues[0],
				matrixYfromX: _parsedValues[1],
				matrixXfromY: _parsedValues[2],
				matrixYfromY: _parsedValues[3],
				matrixTranslateX: _parsedValues[4],
				matrixTranslateY: _parsedValues[5]
			};
		}
		if (16 === parsedValues.length) {
			var _parsedValues2 = _slicedToArray(parsedValues, 14);
			return {
				matrixXfromX: _parsedValues2[0],
				matrixYfromX: _parsedValues2[1],
				matrixXfromY: _parsedValues2[4],
				matrixYfromY: _parsedValues2[5],
				matrixTranslateX: _parsedValues2[12],
				matrixTranslateY: _parsedValues2[13]
			};
		}
		return null;
	}
	function getTransformBaselineFromComputedStyle(element) {
		if (!element) return null;
		var computedStyle = window.getComputedStyle(element);
		var matrix = createMatrixFromTransform((computedStyle === null || computedStyle === void 0 ? void 0 : computedStyle.transform) || "");
		if (!matrix) return null;
		var matrixXfromX = matrix.matrixXfromX;
		var matrixYfromX = matrix.matrixYfromX;
		var matrixXfromY = matrix.matrixXfromY;
		var matrixYfromY = matrix.matrixYfromY;
		var matrixTranslateX = matrix.matrixTranslateX;
		var matrixTranslateY = matrix.matrixTranslateY;
		var scaleX = Math.hypot(matrixXfromX, matrixYfromX);
		var determinant = matrixXfromX * matrixYfromY - matrixYfromX * matrixXfromY;
		var scaleY = scaleX ? determinant / scaleX : Math.hypot(matrixXfromY, matrixYfromY);
		var rotate = radiansToDegrees(Math.atan2(matrixYfromX, matrixXfromX));
		var shear = scaleX ? (matrixXfromX * matrixXfromY + matrixYfromX * matrixYfromY) / (scaleX * scaleX) : 0;
		var skewX = radiansToDegrees(Math.atan(shear));
		return {
			x: matrixTranslateX,
			y: matrixTranslateY,
			scaleX: Number.isFinite(scaleX) ? scaleX : 1,
			scaleY: Number.isFinite(scaleY) ? scaleY : 1,
			rotate: Number.isFinite(rotate) ? rotate : 0,
			skewX: Number.isFinite(skewX) ? skewX : 0
		};
	}
	function preserveTransformKeyframes(keyframes, baseline) {
		if (!baseline) return keyframes;
		var mergedKeyframes = _objectSpread({}, keyframes);
		var hasScaleShorthand = mergedKeyframes.scale !== void 0;
		var canSetScaleX = mergedKeyframes.scaleX === void 0 && !isNearOne(baseline.scaleX);
		var canSetScaleY = mergedKeyframes.scaleY === void 0 && !isNearOne(baseline.scaleY);
		if (mergedKeyframes.x === void 0 && !isNearZero(baseline.x)) mergedKeyframes.x = [baseline.x, baseline.x];
		if (mergedKeyframes.y === void 0 && !isNearZero(baseline.y)) mergedKeyframes.y = [baseline.y, baseline.y];
		if (!hasScaleShorthand) if (canSetScaleX && canSetScaleY && isNear(baseline.scaleX, baseline.scaleY)) mergedKeyframes.scale = [baseline.scaleX, baseline.scaleX];
		else {
			if (canSetScaleX) mergedKeyframes.scaleX = [baseline.scaleX, baseline.scaleX];
			if (canSetScaleY) mergedKeyframes.scaleY = [baseline.scaleY, baseline.scaleY];
		}
		if (mergedKeyframes.rotate === void 0 && mergedKeyframes.rotateZ === void 0 && !isNearZero(baseline.rotate)) mergedKeyframes.rotate = [baseline.rotate, baseline.rotate];
		if (mergedKeyframes.skew === void 0 && mergedKeyframes.skewX === void 0 && !isNearZero(baseline.skewX)) mergedKeyframes.skewX = [baseline.skewX, baseline.skewX];
		return mergedKeyframes;
	}
	window.elementorModules = window.elementorModules || {};
	window.elementorModules.interactions = {
		config,
		skipInteraction: skipInteraction$1,
		extractInteractionId,
		getAnimateFunction,
		getInViewFunction,
		waitForAnimateFunction,
		parseInteractionsData,
		unwrapInteractionValue,
		timingValueToMs,
		resetElementStyles,
		getTransformBaselineFromComputedStyle,
		preserveTransformKeyframes
	};

//#endregion
//#region modules/interactions/assets/js/interactions-utils.js
	function isSupportedInteraction(animationConfig) {
		if (![
			"load",
			"scrollIn",
			"scrollOut"
		].includes(animationConfig.trigger)) return false;
		if ("custom" === animationConfig.effect) return false;
		return true;
	}
	function skipInteraction(animationConfig) {
		if (!isSupportedInteraction(animationConfig)) return true;
		return skipInteraction$1(animationConfig);
	}
	function getKeyframes(effect, type, direction) {
		var isIn = "in" === type;
		var keyframes = {};
		if ("fade" === effect) keyframes.opacity = isIn ? [0, 1] : [1, 0];
		var config$1 = config();
		if ("scale" === effect) keyframes.scale = isIn ? [config$1.scaleStart, 1] : [1, config$1.scaleStart];
		if (direction && "string" === typeof direction) {
			var distance = config$1.slideDistance;
			var movement = {
				left: { x: isIn ? [-distance, 0] : [0, -distance] },
				right: { x: isIn ? [distance, 0] : [0, distance] },
				top: { y: isIn ? [-distance, 0] : [0, -distance] },
				bottom: { y: isIn ? [distance, 0] : [0, distance] }
			};
			direction.split("-").forEach(function(part) {
				if (movement[part]) Object.assign(keyframes, movement[part]);
			});
		}
		return keyframes;
	}
	function parseAnimationName(name) {
		var _name$split2 = _slicedToArray(name.split("-"), 8);
		var trigger = _name$split2[0];
		var effect = _name$split2[1];
		var type = _name$split2[2];
		var direction = _name$split2[3];
		var duration = _name$split2[4];
		var delay = _name$split2[5];
		var config$2 = config();
		return {
			trigger,
			effect,
			type,
			direction: direction || null,
			duration: duration ? parseInt(duration, 10) : config$2.defaultDuration,
			delay: delay ? parseInt(delay, 10) : config$2.defaultDelay,
			replay: false,
			easing: config$2.defaultEasing
		};
	}
	function unwrapInteractionBreakpoints(propValue) {
		var breakpointsConfig = unwrapInteractionValue(propValue, {});
		var excluded = unwrapInteractionValue(breakpointsConfig === null || breakpointsConfig === void 0 ? void 0 : breakpointsConfig.excluded, []);
		if (1 > excluded.length) return {};
		return { excluded: excluded.map(function(breakpoint) {
			return unwrapInteractionValue(breakpoint, "");
		}) };
	}
	function extractAnimationConfig(interaction) {
		var _payload$animation;
		if ("string" === typeof interaction) return parseAnimationName(interaction);
		var payload = "interaction-item" === (interaction === null || interaction === void 0 ? void 0 : interaction.$$type) && interaction !== null && interaction !== void 0 && interaction.value ? interaction.value : interaction;
		if (!payload) return null;
		if (payload !== null && payload !== void 0 && (_payload$animation = payload.animation) !== null && _payload$animation !== void 0 && _payload$animation.animation_id) return parseAnimationName(payload.animation.animation_id);
		var trigger = unwrapInteractionValue(payload.trigger) || payload.trigger || "load";
		var animation = payload.animation;
		animation = unwrapInteractionValue(animation);
		if (!animation) return null;
		var breakpoints = unwrapInteractionBreakpoints(payload.breakpoints);
		var config$3 = config();
		var effect = unwrapInteractionValue(animation.effect) || animation.effect || "fade";
		var type = unwrapInteractionValue(animation.type) || animation.type || "in";
		var directionUnwrapped = unwrapInteractionValue(animation.direction);
		var direction = "string" === typeof directionUnwrapped ? directionUnwrapped : "";
		var easing = config$3.defaultEasing;
		var replay = false;
		var timingConfig = unwrapInteractionValue(animation.timing_config) || animation.timing_config || {};
		return {
			trigger,
			breakpoints,
			effect,
			type,
			direction,
			duration: timingValueToMs(timingConfig === null || timingConfig === void 0 ? void 0 : timingConfig.duration, config$3.defaultDuration),
			delay: timingValueToMs(timingConfig === null || timingConfig === void 0 ? void 0 : timingConfig.delay, config$3.defaultDelay),
			easing,
			replay
		};
	}

//#endregion
//#region modules/interactions/assets/js/interactions.js
	function scrollOutAnimation(element, transition, animConfig, keyframes, resetKeyframes, options, animateFunc, inViewFunc) {
		var viewOptions = {
			amount: .85,
			root: null
		};
		animateFunc(element, resetKeyframes, { duration: 0 });
		var stop = inViewFunc(element, function() {
			return function() {
				animateFunc(element, keyframes, options).then(function() {
					element.style.transition = transition;
				});
				if (false === animConfig.replay) Promise.resolve().then(function() {
					return stop();
				});
			};
		}, viewOptions);
	}
	function scrollInAnimation(element, transition, animConfig, keyframes, options, animateFunc, inViewFunc) {
		var stop = inViewFunc(element, function() {
			animateFunc(element, keyframes, options).then(function() {
				element.style.transition = transition;
			});
			if (false === animConfig.replay) stop();
		}, {
			amount: 0,
			root: null
		});
	}
	function defaultAnimation(element, transition, keyframes, options, animateFunc) {
		animateFunc(element, keyframes, options).then(function() {
			element.style.transition = transition;
		});
	}
	function applyAnimation(element, animConfig, animateFunc, inViewFunc) {
		var baseline = getTransformBaselineFromComputedStyle(element);
		var keyframes = preserveTransformKeyframes(getKeyframes(animConfig.effect, animConfig.type, animConfig.direction), baseline);
		var resetKeyframes = preserveTransformKeyframes(getKeyframes(animConfig.effect, "in", animConfig.direction), baseline);
		var options = {
			duration: animConfig.duration / 1e3,
			delay: animConfig.delay / 1e3,
			ease: config().defaultEasing
		};
		var transition = element.style.transition;
		element.style.transition = "none";
		if ("scrollOut" === animConfig.trigger) scrollOutAnimation(element, transition, animConfig, keyframes, resetKeyframes, options, animateFunc, inViewFunc);
		else if ("scrollIn" === animConfig.trigger) scrollInAnimation(element, transition, animConfig, keyframes, options, animateFunc, inViewFunc);
		else defaultAnimation(element, transition, keyframes, options, animateFunc);
	}
	function processElementInteractions(element, interactions, animateFunc, inViewFunc) {
		if (!interactions || !Array.isArray(interactions)) return;
		interactions.forEach(function(interaction) {
			var animConfig = extractAnimationConfig(interaction);
			if (animConfig && !skipInteraction(animConfig)) applyAnimation(element, animConfig, animateFunc, inViewFunc);
		});
	}
	function initInteractions() {
		waitForAnimateFunction(function() {
			var animateFunc = getAnimateFunction();
			var inViewFunc = getInViewFunction();
			if (!inViewFunc || !animateFunc) return;
			var dataScript = document.getElementById("elementor-interactions-data");
			if (dataScript) {
				JSON.parse(dataScript.textContent).forEach(function(elementData) {
					var elementId = elementData.elementId;
					var interactions = elementData.interactions;
					if (!elementId || !interactions || !Array.isArray(interactions)) return;
					document.querySelectorAll("[data-interaction-id=\"".concat(elementId, "\"]")).forEach(function(element) {
						processElementInteractions(element, interactions, animateFunc, inViewFunc);
					});
				});
				return;
			}
			document.querySelectorAll("[data-interactions]").forEach(function(element) {
				processElementInteractions(element, parseInteractionsData(element.getAttribute("data-interactions")), animateFunc, inViewFunc);
			});
		});
	}
	function init() {
		initBreakpoints();
		initInteractions();
	}
	if ("loading" === document.readyState) document.addEventListener("DOMContentLoaded", init);
	else init();

//#endregion
})();
//# sourceMappingURL=interactions.js.map
```