@jbpark/ui-kit 2.3.3 → 2.3.4

package/dist/node_modules/gsap/CSSPlugin.mjs

@@ -0,0 +1,920 @@
+import { GSCache, PropTween, _checkPlugin, _colorExp, _colorStringFilter, _config, _forEachName, _getCache, _getProperty, _getSetter, _isString, _isUndefined, _missingPlugin, _numExp, _numWithUnitExp, _parseRelative, _plugins, _relExp, _renderComplexString, _replaceRandom, _round, _sortPropTweensByPriority, _ticker, getUnit, gsap } from "./gsap-core.mjs";
+
+//#region ../../node_modules/gsap/CSSPlugin.js
+/*!
+* CSSPlugin 3.14.2
+* https://gsap.com
+*
+* Copyright 2008-2025, GreenSock. All rights reserved.
+* Subject to the terms at https://gsap.com/standard-license
+* @author: Jack Doyle, jack@greensock.com
+*/
+var _win, _doc, _docElement, _pluginInitted, _tempDiv, _recentSetterPlugin, _reverting, _windowExists = function _windowExists() {
+	return typeof window !== "undefined";
+}, _transformProps = {}, _RAD2DEG = 180 / Math.PI, _DEG2RAD = Math.PI / 180, _atan2 = Math.atan2, _bigNum = 1e8, _capsExp = /([A-Z])/g, _horizontalExp = /(left|right|width|margin|padding|x)/i, _complexExp = /[\s,\(]\S/, _propertyAliases = {
+	autoAlpha: "opacity,visibility",
+	scale: "scaleX,scaleY",
+	alpha: "opacity"
+}, _renderCSSProp = function _renderCSSProp(ratio, data) {
+	return data.set(data.t, data.p, Math.round((data.s + data.c * ratio) * 1e4) / 1e4 + data.u, data);
+}, _renderPropWithEnd = function _renderPropWithEnd(ratio, data) {
+	return data.set(data.t, data.p, ratio === 1 ? data.e : Math.round((data.s + data.c * ratio) * 1e4) / 1e4 + data.u, data);
+}, _renderCSSPropWithBeginning = function _renderCSSPropWithBeginning(ratio, data) {
+	return data.set(data.t, data.p, ratio ? Math.round((data.s + data.c * ratio) * 1e4) / 1e4 + data.u : data.b, data);
+}, _renderCSSPropWithBeginningAndEnd = function _renderCSSPropWithBeginningAndEnd(ratio, data) {
+	return data.set(data.t, data.p, ratio === 1 ? data.e : ratio ? Math.round((data.s + data.c * ratio) * 1e4) / 1e4 + data.u : data.b, data);
+}, _renderRoundedCSSProp = function _renderRoundedCSSProp(ratio, data) {
+	var value = data.s + data.c * ratio;
+	data.set(data.t, data.p, ~~(value + (value < 0 ? -.5 : .5)) + data.u, data);
+}, _renderNonTweeningValue = function _renderNonTweeningValue(ratio, data) {
+	return data.set(data.t, data.p, ratio ? data.e : data.b, data);
+}, _renderNonTweeningValueOnlyAtEnd = function _renderNonTweeningValueOnlyAtEnd(ratio, data) {
+	return data.set(data.t, data.p, ratio !== 1 ? data.b : data.e, data);
+}, _setterCSSStyle = function _setterCSSStyle(target, property, value) {
+	return target.style[property] = value;
+}, _setterCSSProp = function _setterCSSProp(target, property, value) {
+	return target.style.setProperty(property, value);
+}, _setterTransform = function _setterTransform(target, property, value) {
+	return target._gsap[property] = value;
+}, _setterScale = function _setterScale(target, property, value) {
+	return target._gsap.scaleX = target._gsap.scaleY = value;
+}, _setterScaleWithRender = function _setterScaleWithRender(target, property, value, data, ratio) {
+	var cache = target._gsap;
+	cache.scaleX = cache.scaleY = value;
+	cache.renderTransform(ratio, cache);
+}, _setterTransformWithRender = function _setterTransformWithRender(target, property, value, data, ratio) {
+	var cache = target._gsap;
+	cache[property] = value;
+	cache.renderTransform(ratio, cache);
+}, _transformProp = "transform", _transformOriginProp = _transformProp + "Origin", _saveStyle = function _saveStyle(property, isNotCSS) {
+	var _this = this;
+	var target = this.target, style = target.style, cache = target._gsap;
+	if (property in _transformProps && style) {
+		this.tfm = this.tfm || {};
+		if (property !== "transform") {
+			property = _propertyAliases[property] || property;
+			~property.indexOf(",") ? property.split(",").forEach(function(a) {
+				return _this.tfm[a] = _get(target, a);
+			}) : this.tfm[property] = cache.x ? cache[property] : _get(target, property);
+			property === _transformOriginProp && (this.tfm.zOrigin = cache.zOrigin);
+		} else return _propertyAliases.transform.split(",").forEach(function(p) {
+			return _saveStyle.call(_this, p, isNotCSS);
+		});
+		if (this.props.indexOf(_transformProp) >= 0) return;
+		if (cache.svg) {
+			this.svgo = target.getAttribute("data-svg-origin");
+			this.props.push(_transformOriginProp, isNotCSS, "");
+		}
+		property = _transformProp;
+	}
+	(style || isNotCSS) && this.props.push(property, isNotCSS, style[property]);
+}, _removeIndependentTransforms = function _removeIndependentTransforms(style) {
+	if (style.translate) {
+		style.removeProperty("translate");
+		style.removeProperty("scale");
+		style.removeProperty("rotate");
+	}
+}, _revertStyle = function _revertStyle() {
+	var props = this.props, target = this.target, style = target.style, cache = target._gsap, i, p;
+	for (i = 0; i < props.length; i += 3) if (!props[i + 1]) props[i + 2] ? style[props[i]] = props[i + 2] : style.removeProperty(props[i].substr(0, 2) === "--" ? props[i] : props[i].replace(_capsExp, "-$1").toLowerCase());
+	else if (props[i + 1] === 2) target[props[i]](props[i + 2]);
+	else target[props[i]] = props[i + 2];
+	if (this.tfm) {
+		for (p in this.tfm) cache[p] = this.tfm[p];
+		if (cache.svg) {
+			cache.renderTransform();
+			target.setAttribute("data-svg-origin", this.svgo || "");
+		}
+		i = _reverting();
+		if ((!i || !i.isStart) && !style[_transformProp]) {
+			_removeIndependentTransforms(style);
+			if (cache.zOrigin && style[_transformOriginProp]) {
+				style[_transformOriginProp] += " " + cache.zOrigin + "px";
+				cache.zOrigin = 0;
+				cache.renderTransform();
+			}
+			cache.uncache = 1;
+		}
+	}
+}, _getStyleSaver = function _getStyleSaver(target, properties) {
+	var saver = {
+		target,
+		props: [],
+		revert: _revertStyle,
+		save: _saveStyle
+	};
+	target._gsap || gsap.core.getCache(target);
+	properties && target.style && target.nodeType && properties.split(",").forEach(function(p) {
+		return saver.save(p);
+	});
+	return saver;
+}, _supports3D, _createElement = function _createElement(type, ns) {
+	var e = _doc.createElementNS ? _doc.createElementNS((ns || "http://www.w3.org/1999/xhtml").replace(/^https/, "http"), type) : _doc.createElement(type);
+	return e && e.style ? e : _doc.createElement(type);
+}, _getComputedProperty = function _getComputedProperty(target, property, skipPrefixFallback) {
+	var cs = getComputedStyle(target);
+	return cs[property] || cs.getPropertyValue(property.replace(_capsExp, "-$1").toLowerCase()) || cs.getPropertyValue(property) || !skipPrefixFallback && _getComputedProperty(target, _checkPropPrefix(property) || property, 1) || "";
+}, _prefixes = "O,Moz,ms,Ms,Webkit".split(","), _checkPropPrefix = function _checkPropPrefix(property, element, preferPrefix) {
+	var s = (element || _tempDiv).style, i = 5;
+	if (property in s && !preferPrefix) return property;
+	property = property.charAt(0).toUpperCase() + property.substr(1);
+	while (i-- && !(_prefixes[i] + property in s));
+	return i < 0 ? null : (i === 3 ? "ms" : i >= 0 ? _prefixes[i] : "") + property;
+}, _initCore = function _initCore() {
+	if (_windowExists() && window.document) {
+		_win = window;
+		_doc = _win.document;
+		_docElement = _doc.documentElement;
+		_tempDiv = _createElement("div") || { style: {} };
+		_createElement("div");
+		_transformProp = _checkPropPrefix(_transformProp);
+		_transformOriginProp = _transformProp + "Origin";
+		_tempDiv.style.cssText = "border-width:0;line-height:0;position:absolute;padding:0";
+		_supports3D = !!_checkPropPrefix("perspective");
+		_reverting = gsap.core.reverting;
+		_pluginInitted = 1;
+	}
+}, _getReparentedCloneBBox = function _getReparentedCloneBBox(target) {
+	var owner = target.ownerSVGElement, svg = _createElement("svg", owner && owner.getAttribute("xmlns") || "http://www.w3.org/2000/svg"), clone = target.cloneNode(true), bbox;
+	clone.style.display = "block";
+	svg.appendChild(clone);
+	_docElement.appendChild(svg);
+	try {
+		bbox = clone.getBBox();
+	} catch (e) {}
+	svg.removeChild(clone);
+	_docElement.removeChild(svg);
+	return bbox;
+}, _getAttributeFallbacks = function _getAttributeFallbacks(target, attributesArray) {
+	var i = attributesArray.length;
+	while (i--) if (target.hasAttribute(attributesArray[i])) return target.getAttribute(attributesArray[i]);
+}, _getBBox = function _getBBox(target) {
+	var bounds, cloned;
+	try {
+		bounds = target.getBBox();
+	} catch (error) {
+		bounds = _getReparentedCloneBBox(target);
+		cloned = 1;
+	}
+	bounds && (bounds.width || bounds.height) || cloned || (bounds = _getReparentedCloneBBox(target));
+	return bounds && !bounds.width && !bounds.x && !bounds.y ? {
+		x: +_getAttributeFallbacks(target, [
+			"x",
+			"cx",
+			"x1"
+		]) || 0,
+		y: +_getAttributeFallbacks(target, [
+			"y",
+			"cy",
+			"y1"
+		]) || 0,
+		width: 0,
+		height: 0
+	} : bounds;
+}, _isSVG = function _isSVG(e) {
+	return !!(e.getCTM && (!e.parentNode || e.ownerSVGElement) && _getBBox(e));
+}, _removeProperty = function _removeProperty(target, property) {
+	if (property) {
+		var style = target.style, first2Chars;
+		if (property in _transformProps && property !== _transformOriginProp) property = _transformProp;
+		if (style.removeProperty) {
+			first2Chars = property.substr(0, 2);
+			if (first2Chars === "ms" || property.substr(0, 6) === "webkit") property = "-" + property;
+			style.removeProperty(first2Chars === "--" ? property : property.replace(_capsExp, "-$1").toLowerCase());
+		} else style.removeAttribute(property);
+	}
+}, _addNonTweeningPT = function _addNonTweeningPT(plugin, target, property, beginning, end, onlySetAtEnd) {
+	var pt = new PropTween(plugin._pt, target, property, 0, 1, onlySetAtEnd ? _renderNonTweeningValueOnlyAtEnd : _renderNonTweeningValue);
+	plugin._pt = pt;
+	pt.b = beginning;
+	pt.e = end;
+	plugin._props.push(property);
+	return pt;
+}, _nonConvertibleUnits = {
+	deg: 1,
+	rad: 1,
+	turn: 1
+}, _nonStandardLayouts = {
+	grid: 1,
+	flex: 1
+}, _convertToUnit = function _convertToUnit(target, property, value, unit) {
+	var curValue = parseFloat(value) || 0, curUnit = (value + "").trim().substr((curValue + "").length) || "px", style = _tempDiv.style, horizontal = _horizontalExp.test(property), isRootSVG = target.tagName.toLowerCase() === "svg", measureProperty = (isRootSVG ? "client" : "offset") + (horizontal ? "Width" : "Height"), amount = 100, toPixels = unit === "px", toPercent = unit === "%", px, parent, cache, isSVG;
+	if (unit === curUnit || !curValue || _nonConvertibleUnits[unit] || _nonConvertibleUnits[curUnit]) return curValue;
+	curUnit !== "px" && !toPixels && (curValue = _convertToUnit(target, property, value, "px"));
+	isSVG = target.getCTM && _isSVG(target);
+	if ((toPercent || curUnit === "%") && (_transformProps[property] || ~property.indexOf("adius"))) {
+		px = isSVG ? target.getBBox()[horizontal ? "width" : "height"] : target[measureProperty];
+		return _round(toPercent ? curValue / px * amount : curValue / 100 * px);
+	}
+	style[horizontal ? "width" : "height"] = amount + (toPixels ? curUnit : unit);
+	parent = unit !== "rem" && ~property.indexOf("adius") || unit === "em" && target.appendChild && !isRootSVG ? target : target.parentNode;
+	if (isSVG) parent = (target.ownerSVGElement || {}).parentNode;
+	if (!parent || parent === _doc || !parent.appendChild) parent = _doc.body;
+	cache = parent._gsap;
+	if (cache && toPercent && cache.width && horizontal && cache.time === _ticker.time && !cache.uncache) return _round(curValue / cache.width * amount);
+	else {
+		if (toPercent && (property === "height" || property === "width")) {
+			var v = target.style[property];
+			target.style[property] = amount + unit;
+			px = target[measureProperty];
+			v ? target.style[property] = v : _removeProperty(target, property);
+		} else {
+			(toPercent || curUnit === "%") && !_nonStandardLayouts[_getComputedProperty(parent, "display")] && (style.position = _getComputedProperty(target, "position"));
+			parent === target && (style.position = "static");
+			parent.appendChild(_tempDiv);
+			px = _tempDiv[measureProperty];
+			parent.removeChild(_tempDiv);
+			style.position = "absolute";
+		}
+		if (horizontal && toPercent) {
+			cache = _getCache(parent);
+			cache.time = _ticker.time;
+			cache.width = parent[measureProperty];
+		}
+	}
+	return _round(toPixels ? px * curValue / amount : px && curValue ? amount / px * curValue : 0);
+}, _get = function _get(target, property, unit, uncache) {
+	var value;
+	_pluginInitted || _initCore();
+	if (property in _propertyAliases && property !== "transform") {
+		property = _propertyAliases[property];
+		if (~property.indexOf(",")) property = property.split(",")[0];
+	}
+	if (_transformProps[property] && property !== "transform") {
+		value = _parseTransform(target, uncache);
+		value = property !== "transformOrigin" ? value[property] : value.svg ? value.origin : _firstTwoOnly(_getComputedProperty(target, _transformOriginProp)) + " " + value.zOrigin + "px";
+	} else {
+		value = target.style[property];
+		if (!value || value === "auto" || uncache || ~(value + "").indexOf("calc(")) value = _specialProps[property] && _specialProps[property](target, property, unit) || _getComputedProperty(target, property) || _getProperty(target, property) || (property === "opacity" ? 1 : 0);
+	}
+	return unit && !~(value + "").trim().indexOf(" ") ? _convertToUnit(target, property, value, unit) + unit : value;
+}, _tweenComplexCSSString = function _tweenComplexCSSString(target, prop, start, end) {
+	if (!start || start === "none") {
+		var p = _checkPropPrefix(prop, target, 1), s = p && _getComputedProperty(target, p, 1);
+		if (s && s !== start) {
+			prop = p;
+			start = s;
+		} else if (prop === "borderColor") start = _getComputedProperty(target, "borderTopColor");
+	}
+	var pt = new PropTween(this._pt, target.style, prop, 0, 1, _renderComplexString), index = 0, matchIndex = 0, a, result, startValues, startNum, color, startValue, endValue, endNum, chunk, endUnit, startUnit, endValues;
+	pt.b = start;
+	pt.e = end;
+	start += "";
+	end += "";
+	if (end.substring(0, 6) === "var(--") end = _getComputedProperty(target, end.substring(4, end.indexOf(")")));
+	if (end === "auto") {
+		startValue = target.style[prop];
+		target.style[prop] = end;
+		end = _getComputedProperty(target, prop) || end;
+		startValue ? target.style[prop] = startValue : _removeProperty(target, prop);
+	}
+	a = [start, end];
+	_colorStringFilter(a);
+	start = a[0];
+	end = a[1];
+	startValues = start.match(_numWithUnitExp) || [];
+	endValues = end.match(_numWithUnitExp) || [];
+	if (endValues.length) {
+		while (result = _numWithUnitExp.exec(end)) {
+			endValue = result[0];
+			chunk = end.substring(index, result.index);
+			if (color) color = (color + 1) % 5;
+			else if (chunk.substr(-5) === "rgba(" || chunk.substr(-5) === "hsla(") color = 1;
+			if (endValue !== (startValue = startValues[matchIndex++] || "")) {
+				startNum = parseFloat(startValue) || 0;
+				startUnit = startValue.substr((startNum + "").length);
+				endValue.charAt(1) === "=" && (endValue = _parseRelative(startNum, endValue) + startUnit);
+				endNum = parseFloat(endValue);
+				endUnit = endValue.substr((endNum + "").length);
+				index = _numWithUnitExp.lastIndex - endUnit.length;
+				if (!endUnit) {
+					endUnit = endUnit || _config.units[prop] || startUnit;
+					if (index === end.length) {
+						end += endUnit;
+						pt.e += endUnit;
+					}
+				}
+				if (startUnit !== endUnit) startNum = _convertToUnit(target, prop, startValue, endUnit) || 0;
+				pt._pt = {
+					_next: pt._pt,
+					p: chunk || matchIndex === 1 ? chunk : ",",
+					s: startNum,
+					c: endNum - startNum,
+					m: color && color < 4 || prop === "zIndex" ? Math.round : 0
+				};
+			}
+		}
+		pt.c = index < end.length ? end.substring(index, end.length) : "";
+	} else pt.r = prop === "display" && end === "none" ? _renderNonTweeningValueOnlyAtEnd : _renderNonTweeningValue;
+	_relExp.test(end) && (pt.e = 0);
+	this._pt = pt;
+	return pt;
+}, _keywordToPercent = {
+	top: "0%",
+	bottom: "100%",
+	left: "0%",
+	right: "100%",
+	center: "50%"
+}, _convertKeywordsToPercentages = function _convertKeywordsToPercentages(value) {
+	var split = value.split(" "), x = split[0], y = split[1] || "50%";
+	if (x === "top" || x === "bottom" || y === "left" || y === "right") {
+		value = x;
+		x = y;
+		y = value;
+	}
+	split[0] = _keywordToPercent[x] || x;
+	split[1] = _keywordToPercent[y] || y;
+	return split.join(" ");
+}, _renderClearProps = function _renderClearProps(ratio, data) {
+	if (data.tween && data.tween._time === data.tween._dur) {
+		var target = data.t, style = target.style, props = data.u, cache = target._gsap, prop, clearTransforms, i;
+		if (props === "all" || props === true) {
+			style.cssText = "";
+			clearTransforms = 1;
+		} else {
+			props = props.split(",");
+			i = props.length;
+			while (--i > -1) {
+				prop = props[i];
+				if (_transformProps[prop]) {
+					clearTransforms = 1;
+					prop = prop === "transformOrigin" ? _transformOriginProp : _transformProp;
+				}
+				_removeProperty(target, prop);
+			}
+		}
+		if (clearTransforms) {
+			_removeProperty(target, _transformProp);
+			if (cache) {
+				cache.svg && target.removeAttribute("transform");
+				style.scale = style.rotate = style.translate = "none";
+				_parseTransform(target, 1);
+				cache.uncache = 1;
+				_removeIndependentTransforms(style);
+			}
+		}
+	}
+}, _specialProps = { clearProps: function clearProps(plugin, target, property, endValue, tween) {
+	if (tween.data !== "isFromStart") {
+		var pt = plugin._pt = new PropTween(plugin._pt, target, property, 0, 0, _renderClearProps);
+		pt.u = endValue;
+		pt.pr = -10;
+		pt.tween = tween;
+		plugin._props.push(property);
+		return 1;
+	}
+} }, _identity2DMatrix = [
+	1,
+	0,
+	0,
+	1,
+	0,
+	0
+], _rotationalProperties = {}, _isNullTransform = function _isNullTransform(value) {
+	return value === "matrix(1, 0, 0, 1, 0, 0)" || value === "none" || !value;
+}, _getComputedTransformMatrixAsArray = function _getComputedTransformMatrixAsArray(target) {
+	var matrixString = _getComputedProperty(target, _transformProp);
+	return _isNullTransform(matrixString) ? _identity2DMatrix : matrixString.substr(7).match(_numExp).map(_round);
+}, _getMatrix = function _getMatrix(target, force2D) {
+	var cache = target._gsap || _getCache(target), style = target.style, matrix = _getComputedTransformMatrixAsArray(target), parent, nextSibling, temp, addedToDOM;
+	if (cache.svg && target.getAttribute("transform")) {
+		temp = target.transform.baseVal.consolidate().matrix;
+		matrix = [
+			temp.a,
+			temp.b,
+			temp.c,
+			temp.d,
+			temp.e,
+			temp.f
+		];
+		return matrix.join(",") === "1,0,0,1,0,0" ? _identity2DMatrix : matrix;
+	} else if (matrix === _identity2DMatrix && !target.offsetParent && target !== _docElement && !cache.svg) {
+		temp = style.display;
+		style.display = "block";
+		parent = target.parentNode;
+		if (!parent || !target.offsetParent && !target.getBoundingClientRect().width) {
+			addedToDOM = 1;
+			nextSibling = target.nextElementSibling;
+			_docElement.appendChild(target);
+		}
+		matrix = _getComputedTransformMatrixAsArray(target);
+		temp ? style.display = temp : _removeProperty(target, "display");
+		if (addedToDOM) nextSibling ? parent.insertBefore(target, nextSibling) : parent ? parent.appendChild(target) : _docElement.removeChild(target);
+	}
+	return force2D && matrix.length > 6 ? [
+		matrix[0],
+		matrix[1],
+		matrix[4],
+		matrix[5],
+		matrix[12],
+		matrix[13]
+	] : matrix;
+}, _applySVGOrigin = function _applySVGOrigin(target, origin, originIsAbsolute, smooth, matrixArray, pluginToAddPropTweensTo) {
+	var cache = target._gsap, matrix = matrixArray || _getMatrix(target, true), xOriginOld = cache.xOrigin || 0, yOriginOld = cache.yOrigin || 0, xOffsetOld = cache.xOffset || 0, yOffsetOld = cache.yOffset || 0, a = matrix[0], b = matrix[1], c = matrix[2], d = matrix[3], tx = matrix[4], ty = matrix[5], originSplit = origin.split(" "), xOrigin = parseFloat(originSplit[0]) || 0, yOrigin = parseFloat(originSplit[1]) || 0, bounds, determinant, x, y;
+	if (!originIsAbsolute) {
+		bounds = _getBBox(target);
+		xOrigin = bounds.x + (~originSplit[0].indexOf("%") ? xOrigin / 100 * bounds.width : xOrigin);
+		yOrigin = bounds.y + (~(originSplit[1] || originSplit[0]).indexOf("%") ? yOrigin / 100 * bounds.height : yOrigin);
+	} else if (matrix !== _identity2DMatrix && (determinant = a * d - b * c)) {
+		x = xOrigin * (d / determinant) + yOrigin * (-c / determinant) + (c * ty - d * tx) / determinant;
+		y = xOrigin * (-b / determinant) + yOrigin * (a / determinant) - (a * ty - b * tx) / determinant;
+		xOrigin = x;
+		yOrigin = y;
+	}
+	if (smooth || smooth !== false && cache.smooth) {
+		tx = xOrigin - xOriginOld;
+		ty = yOrigin - yOriginOld;
+		cache.xOffset = xOffsetOld + (tx * a + ty * c) - tx;
+		cache.yOffset = yOffsetOld + (tx * b + ty * d) - ty;
+	} else cache.xOffset = cache.yOffset = 0;
+	cache.xOrigin = xOrigin;
+	cache.yOrigin = yOrigin;
+	cache.smooth = !!smooth;
+	cache.origin = origin;
+	cache.originIsAbsolute = !!originIsAbsolute;
+	target.style[_transformOriginProp] = "0px 0px";
+	if (pluginToAddPropTweensTo) {
+		_addNonTweeningPT(pluginToAddPropTweensTo, cache, "xOrigin", xOriginOld, xOrigin);
+		_addNonTweeningPT(pluginToAddPropTweensTo, cache, "yOrigin", yOriginOld, yOrigin);
+		_addNonTweeningPT(pluginToAddPropTweensTo, cache, "xOffset", xOffsetOld, cache.xOffset);
+		_addNonTweeningPT(pluginToAddPropTweensTo, cache, "yOffset", yOffsetOld, cache.yOffset);
+	}
+	target.setAttribute("data-svg-origin", xOrigin + " " + yOrigin);
+}, _parseTransform = function _parseTransform(target, uncache) {
+	var cache = target._gsap || new GSCache(target);
+	if ("x" in cache && !uncache && !cache.uncache) return cache;
+	var style = target.style, invertedScaleX = cache.scaleX < 0, px = "px", deg = "deg", cs = getComputedStyle(target), origin = _getComputedProperty(target, _transformOriginProp) || "0", x = y = z = rotation = rotationX = rotationY = skewX = skewY = perspective = 0, y, z, scaleX = scaleY = 1, scaleY, rotation, rotationX, rotationY, skewX, skewY, perspective, xOrigin, yOrigin, matrix, angle, cos, sin, a, b, c, d, a12, a22, t1, t2, t3, a13, a23, a33, a42, a43, a32;
+	cache.svg = !!(target.getCTM && _isSVG(target));
+	if (cs.translate) {
+		if (cs.translate !== "none" || cs.scale !== "none" || cs.rotate !== "none") style[_transformProp] = (cs.translate !== "none" ? "translate3d(" + (cs.translate + " 0 0").split(" ").slice(0, 3).join(", ") + ") " : "") + (cs.rotate !== "none" ? "rotate(" + cs.rotate + ") " : "") + (cs.scale !== "none" ? "scale(" + cs.scale.split(" ").join(",") + ") " : "") + (cs[_transformProp] !== "none" ? cs[_transformProp] : "");
+		style.scale = style.rotate = style.translate = "none";
+	}
+	matrix = _getMatrix(target, cache.svg);
+	if (cache.svg) {
+		if (cache.uncache) {
+			t2 = target.getBBox();
+			origin = cache.xOrigin - t2.x + "px " + (cache.yOrigin - t2.y) + "px";
+			t1 = "";
+		} else t1 = !uncache && target.getAttribute("data-svg-origin");
+		_applySVGOrigin(target, t1 || origin, !!t1 || cache.originIsAbsolute, cache.smooth !== false, matrix);
+	}
+	xOrigin = cache.xOrigin || 0;
+	yOrigin = cache.yOrigin || 0;
+	if (matrix !== _identity2DMatrix) {
+		a = matrix[0];
+		b = matrix[1];
+		c = matrix[2];
+		d = matrix[3];
+		x = a12 = matrix[4];
+		y = a22 = matrix[5];
+		if (matrix.length === 6) {
+			scaleX = Math.sqrt(a * a + b * b);
+			scaleY = Math.sqrt(d * d + c * c);
+			rotation = a || b ? _atan2(b, a) * _RAD2DEG : 0;
+			skewX = c || d ? _atan2(c, d) * _RAD2DEG + rotation : 0;
+			skewX && (scaleY *= Math.abs(Math.cos(skewX * _DEG2RAD)));
+			if (cache.svg) {
+				x -= xOrigin - (xOrigin * a + yOrigin * c);
+				y -= yOrigin - (xOrigin * b + yOrigin * d);
+			}
+		} else {
+			a32 = matrix[6];
+			a42 = matrix[7];
+			a13 = matrix[8];
+			a23 = matrix[9];
+			a33 = matrix[10];
+			a43 = matrix[11];
+			x = matrix[12];
+			y = matrix[13];
+			z = matrix[14];
+			angle = _atan2(a32, a33);
+			rotationX = angle * _RAD2DEG;
+			if (angle) {
+				cos = Math.cos(-angle);
+				sin = Math.sin(-angle);
+				t1 = a12 * cos + a13 * sin;
+				t2 = a22 * cos + a23 * sin;
+				t3 = a32 * cos + a33 * sin;
+				a13 = a12 * -sin + a13 * cos;
+				a23 = a22 * -sin + a23 * cos;
+				a33 = a32 * -sin + a33 * cos;
+				a43 = a42 * -sin + a43 * cos;
+				a12 = t1;
+				a22 = t2;
+				a32 = t3;
+			}
+			angle = _atan2(-c, a33);
+			rotationY = angle * _RAD2DEG;
+			if (angle) {
+				cos = Math.cos(-angle);
+				sin = Math.sin(-angle);
+				t1 = a * cos - a13 * sin;
+				t2 = b * cos - a23 * sin;
+				t3 = c * cos - a33 * sin;
+				a43 = d * sin + a43 * cos;
+				a = t1;
+				b = t2;
+				c = t3;
+			}
+			angle = _atan2(b, a);
+			rotation = angle * _RAD2DEG;
+			if (angle) {
+				cos = Math.cos(angle);
+				sin = Math.sin(angle);
+				t1 = a * cos + b * sin;
+				t2 = a12 * cos + a22 * sin;
+				b = b * cos - a * sin;
+				a22 = a22 * cos - a12 * sin;
+				a = t1;
+				a12 = t2;
+			}
+			if (rotationX && Math.abs(rotationX) + Math.abs(rotation) > 359.9) {
+				rotationX = rotation = 0;
+				rotationY = 180 - rotationY;
+			}
+			scaleX = _round(Math.sqrt(a * a + b * b + c * c));
+			scaleY = _round(Math.sqrt(a22 * a22 + a32 * a32));
+			angle = _atan2(a12, a22);
+			skewX = Math.abs(angle) > 2e-4 ? angle * _RAD2DEG : 0;
+			perspective = a43 ? 1 / (a43 < 0 ? -a43 : a43) : 0;
+		}
+		if (cache.svg) {
+			t1 = target.getAttribute("transform");
+			cache.forceCSS = target.setAttribute("transform", "") || !_isNullTransform(_getComputedProperty(target, _transformProp));
+			t1 && target.setAttribute("transform", t1);
+		}
+	}
+	if (Math.abs(skewX) > 90 && Math.abs(skewX) < 270) if (invertedScaleX) {
+		scaleX *= -1;
+		skewX += rotation <= 0 ? 180 : -180;
+		rotation += rotation <= 0 ? 180 : -180;
+	} else {
+		scaleY *= -1;
+		skewX += skewX <= 0 ? 180 : -180;
+	}
+	uncache = uncache || cache.uncache;
+	cache.x = x - ((cache.xPercent = x && (!uncache && cache.xPercent || (Math.round(target.offsetWidth / 2) === Math.round(-x) ? -50 : 0))) ? target.offsetWidth * cache.xPercent / 100 : 0) + px;
+	cache.y = y - ((cache.yPercent = y && (!uncache && cache.yPercent || (Math.round(target.offsetHeight / 2) === Math.round(-y) ? -50 : 0))) ? target.offsetHeight * cache.yPercent / 100 : 0) + px;
+	cache.z = z + px;
+	cache.scaleX = _round(scaleX);
+	cache.scaleY = _round(scaleY);
+	cache.rotation = _round(rotation) + deg;
+	cache.rotationX = _round(rotationX) + deg;
+	cache.rotationY = _round(rotationY) + deg;
+	cache.skewX = skewX + deg;
+	cache.skewY = skewY + deg;
+	cache.transformPerspective = perspective + px;
+	if (cache.zOrigin = parseFloat(origin.split(" ")[2]) || !uncache && cache.zOrigin || 0) style[_transformOriginProp] = _firstTwoOnly(origin);
+	cache.xOffset = cache.yOffset = 0;
+	cache.force3D = _config.force3D;
+	cache.renderTransform = cache.svg ? _renderSVGTransforms : _supports3D ? _renderCSSTransforms : _renderNon3DTransforms;
+	cache.uncache = 0;
+	return cache;
+}, _firstTwoOnly = function _firstTwoOnly(value) {
+	return (value = value.split(" "))[0] + " " + value[1];
+}, _addPxTranslate = function _addPxTranslate(target, start, value) {
+	var unit = getUnit(start);
+	return _round(parseFloat(start) + parseFloat(_convertToUnit(target, "x", value + "px", unit))) + unit;
+}, _renderNon3DTransforms = function _renderNon3DTransforms(ratio, cache) {
+	cache.z = "0px";
+	cache.rotationY = cache.rotationX = "0deg";
+	cache.force3D = 0;
+	_renderCSSTransforms(ratio, cache);
+}, _zeroDeg = "0deg", _zeroPx = "0px", _endParenthesis = ") ", _renderCSSTransforms = function _renderCSSTransforms(ratio, cache) {
+	var _ref = cache || this, xPercent = _ref.xPercent, yPercent = _ref.yPercent, x = _ref.x, y = _ref.y, z = _ref.z, rotation = _ref.rotation, rotationY = _ref.rotationY, rotationX = _ref.rotationX, skewX = _ref.skewX, skewY = _ref.skewY, scaleX = _ref.scaleX, scaleY = _ref.scaleY, transformPerspective = _ref.transformPerspective, force3D = _ref.force3D, target = _ref.target, zOrigin = _ref.zOrigin, transforms = "", use3D = force3D === "auto" && ratio && ratio !== 1 || force3D === true;
+	if (zOrigin && (rotationX !== _zeroDeg || rotationY !== _zeroDeg)) {
+		var angle = parseFloat(rotationY) * _DEG2RAD, a13 = Math.sin(angle), a33 = Math.cos(angle), cos;
+		angle = parseFloat(rotationX) * _DEG2RAD;
+		cos = Math.cos(angle);
+		x = _addPxTranslate(target, x, a13 * cos * -zOrigin);
+		y = _addPxTranslate(target, y, -Math.sin(angle) * -zOrigin);
+		z = _addPxTranslate(target, z, a33 * cos * -zOrigin + zOrigin);
+	}
+	if (transformPerspective !== _zeroPx) transforms += "perspective(" + transformPerspective + _endParenthesis;
+	if (xPercent || yPercent) transforms += "translate(" + xPercent + "%, " + yPercent + "%) ";
+	if (use3D || x !== _zeroPx || y !== _zeroPx || z !== _zeroPx) transforms += z !== _zeroPx || use3D ? "translate3d(" + x + ", " + y + ", " + z + ") " : "translate(" + x + ", " + y + _endParenthesis;
+	if (rotation !== _zeroDeg) transforms += "rotate(" + rotation + _endParenthesis;
+	if (rotationY !== _zeroDeg) transforms += "rotateY(" + rotationY + _endParenthesis;
+	if (rotationX !== _zeroDeg) transforms += "rotateX(" + rotationX + _endParenthesis;
+	if (skewX !== _zeroDeg || skewY !== _zeroDeg) transforms += "skew(" + skewX + ", " + skewY + _endParenthesis;
+	if (scaleX !== 1 || scaleY !== 1) transforms += "scale(" + scaleX + ", " + scaleY + _endParenthesis;
+	target.style[_transformProp] = transforms || "translate(0, 0)";
+}, _renderSVGTransforms = function _renderSVGTransforms(ratio, cache) {
+	var _ref2 = cache || this, xPercent = _ref2.xPercent, yPercent = _ref2.yPercent, x = _ref2.x, y = _ref2.y, rotation = _ref2.rotation, skewX = _ref2.skewX, skewY = _ref2.skewY, scaleX = _ref2.scaleX, scaleY = _ref2.scaleY, target = _ref2.target, xOrigin = _ref2.xOrigin, yOrigin = _ref2.yOrigin, xOffset = _ref2.xOffset, yOffset = _ref2.yOffset, forceCSS = _ref2.forceCSS, tx = parseFloat(x), ty = parseFloat(y), a11, a21, a12, a22, temp;
+	rotation = parseFloat(rotation);
+	skewX = parseFloat(skewX);
+	skewY = parseFloat(skewY);
+	if (skewY) {
+		skewY = parseFloat(skewY);
+		skewX += skewY;
+		rotation += skewY;
+	}
+	if (rotation || skewX) {
+		rotation *= _DEG2RAD;
+		skewX *= _DEG2RAD;
+		a11 = Math.cos(rotation) * scaleX;
+		a21 = Math.sin(rotation) * scaleX;
+		a12 = Math.sin(rotation - skewX) * -scaleY;
+		a22 = Math.cos(rotation - skewX) * scaleY;
+		if (skewX) {
+			skewY *= _DEG2RAD;
+			temp = Math.tan(skewX - skewY);
+			temp = Math.sqrt(1 + temp * temp);
+			a12 *= temp;
+			a22 *= temp;
+			if (skewY) {
+				temp = Math.tan(skewY);
+				temp = Math.sqrt(1 + temp * temp);
+				a11 *= temp;
+				a21 *= temp;
+			}
+		}
+		a11 = _round(a11);
+		a21 = _round(a21);
+		a12 = _round(a12);
+		a22 = _round(a22);
+	} else {
+		a11 = scaleX;
+		a22 = scaleY;
+		a21 = a12 = 0;
+	}
+	if (tx && !~(x + "").indexOf("px") || ty && !~(y + "").indexOf("px")) {
+		tx = _convertToUnit(target, "x", x, "px");
+		ty = _convertToUnit(target, "y", y, "px");
+	}
+	if (xOrigin || yOrigin || xOffset || yOffset) {
+		tx = _round(tx + xOrigin - (xOrigin * a11 + yOrigin * a12) + xOffset);
+		ty = _round(ty + yOrigin - (xOrigin * a21 + yOrigin * a22) + yOffset);
+	}
+	if (xPercent || yPercent) {
+		temp = target.getBBox();
+		tx = _round(tx + xPercent / 100 * temp.width);
+		ty = _round(ty + yPercent / 100 * temp.height);
+	}
+	temp = "matrix(" + a11 + "," + a21 + "," + a12 + "," + a22 + "," + tx + "," + ty + ")";
+	target.setAttribute("transform", temp);
+	forceCSS && (target.style[_transformProp] = temp);
+}, _addRotationalPropTween = function _addRotationalPropTween(plugin, target, property, startNum, endValue) {
+	var cap = 360, isString = _isString(endValue), change = parseFloat(endValue) * (isString && ~endValue.indexOf("rad") ? _RAD2DEG : 1) - startNum, finalValue = startNum + change + "deg", direction, pt;
+	if (isString) {
+		direction = endValue.split("_")[1];
+		if (direction === "short") {
+			change %= cap;
+			if (change !== change % (cap / 2)) change += change < 0 ? cap : -cap;
+		}
+		if (direction === "cw" && change < 0) change = (change + cap * _bigNum) % cap - ~~(change / cap) * cap;
+		else if (direction === "ccw" && change > 0) change = (change - cap * _bigNum) % cap - ~~(change / cap) * cap;
+	}
+	plugin._pt = pt = new PropTween(plugin._pt, target, property, startNum, change, _renderPropWithEnd);
+	pt.e = finalValue;
+	pt.u = "deg";
+	plugin._props.push(property);
+	return pt;
+}, _assign = function _assign(target, source) {
+	for (var p in source) target[p] = source[p];
+	return target;
+}, _addRawTransformPTs = function _addRawTransformPTs(plugin, transforms, target) {
+	var startCache = _assign({}, target._gsap), exclude = "perspective,force3D,transformOrigin,svgOrigin", style = target.style, endCache, p, startValue, endValue, startNum, endNum, startUnit, endUnit;
+	if (startCache.svg) {
+		startValue = target.getAttribute("transform");
+		target.setAttribute("transform", "");
+		style[_transformProp] = transforms;
+		endCache = _parseTransform(target, 1);
+		_removeProperty(target, _transformProp);
+		target.setAttribute("transform", startValue);
+	} else {
+		startValue = getComputedStyle(target)[_transformProp];
+		style[_transformProp] = transforms;
+		endCache = _parseTransform(target, 1);
+		style[_transformProp] = startValue;
+	}
+	for (p in _transformProps) {
+		startValue = startCache[p];
+		endValue = endCache[p];
+		if (startValue !== endValue && exclude.indexOf(p) < 0) {
+			startUnit = getUnit(startValue);
+			endUnit = getUnit(endValue);
+			startNum = startUnit !== endUnit ? _convertToUnit(target, p, startValue, endUnit) : parseFloat(startValue);
+			endNum = parseFloat(endValue);
+			plugin._pt = new PropTween(plugin._pt, endCache, p, startNum, endNum - startNum, _renderCSSProp);
+			plugin._pt.u = endUnit || 0;
+			plugin._props.push(p);
+		}
+	}
+	_assign(endCache, startCache);
+};
+_forEachName("padding,margin,Width,Radius", function(name, index) {
+	var t = "Top", r = "Right", b = "Bottom", l = "Left", props = (index < 3 ? [
+		t,
+		r,
+		b,
+		l
+	] : [
+		t + l,
+		t + r,
+		b + r,
+		b + l
+	]).map(function(side) {
+		return index < 2 ? name + side : "border" + side + name;
+	});
+	_specialProps[index > 1 ? "border" + name : name] = function(plugin, target, property, endValue, tween) {
+		var a, vars;
+		if (arguments.length < 4) {
+			a = props.map(function(prop) {
+				return _get(plugin, prop, property);
+			});
+			vars = a.join(" ");
+			return vars.split(a[0]).length === 5 ? a[0] : vars;
+		}
+		a = (endValue + "").split(" ");
+		vars = {};
+		props.forEach(function(prop, i) {
+			return vars[prop] = a[i] = a[i] || a[(i - 1) / 2 | 0];
+		});
+		plugin.init(target, vars, tween);
+	};
+});
+var CSSPlugin = {
+	name: "css",
+	register: _initCore,
+	targetTest: function targetTest(target) {
+		return target.style && target.nodeType;
+	},
+	init: function init(target, vars, tween, index, targets) {
+		var props = this._props, style = target.style, startAt = tween.vars.startAt, startValue, endValue, endNum, startNum, type, specialProp, p, startUnit, endUnit, relative, isTransformRelated, transformPropTween, cache, smooth, hasPriority, inlineProps, finalTransformValue;
+		_pluginInitted || _initCore();
+		this.styles = this.styles || _getStyleSaver(target);
+		inlineProps = this.styles.props;
+		this.tween = tween;
+		for (p in vars) {
+			if (p === "autoRound") continue;
+			endValue = vars[p];
+			if (_plugins[p] && _checkPlugin(p, vars, tween, index, target, targets)) continue;
+			type = typeof endValue;
+			specialProp = _specialProps[p];
+			if (type === "function") {
+				endValue = endValue.call(tween, index, target, targets);
+				type = typeof endValue;
+			}
+			if (type === "string" && ~endValue.indexOf("random(")) endValue = _replaceRandom(endValue);
+			if (specialProp) specialProp(this, target, p, endValue, tween) && (hasPriority = 1);
+			else if (p.substr(0, 2) === "--") {
+				startValue = (getComputedStyle(target).getPropertyValue(p) + "").trim();
+				endValue += "";
+				_colorExp.lastIndex = 0;
+				if (!_colorExp.test(startValue)) {
+					startUnit = getUnit(startValue);
+					endUnit = getUnit(endValue);
+					endUnit ? startUnit !== endUnit && (startValue = _convertToUnit(target, p, startValue, endUnit) + endUnit) : startUnit && (endValue += startUnit);
+				}
+				this.add(style, "setProperty", startValue, endValue, index, targets, 0, 0, p);
+				props.push(p);
+				inlineProps.push(p, 0, style[p]);
+			} else if (type !== "undefined") {
+				if (startAt && p in startAt) {
+					startValue = typeof startAt[p] === "function" ? startAt[p].call(tween, index, target, targets) : startAt[p];
+					_isString(startValue) && ~startValue.indexOf("random(") && (startValue = _replaceRandom(startValue));
+					getUnit(startValue + "") || startValue === "auto" || (startValue += _config.units[p] || getUnit(_get(target, p)) || "");
+					(startValue + "").charAt(1) === "=" && (startValue = _get(target, p));
+				} else startValue = _get(target, p);
+				startNum = parseFloat(startValue);
+				relative = type === "string" && endValue.charAt(1) === "=" && endValue.substr(0, 2);
+				relative && (endValue = endValue.substr(2));
+				endNum = parseFloat(endValue);
+				if (p in _propertyAliases) {
+					if (p === "autoAlpha") {
+						if (startNum === 1 && _get(target, "visibility") === "hidden" && endNum) startNum = 0;
+						inlineProps.push("visibility", 0, style.visibility);
+						_addNonTweeningPT(this, style, "visibility", startNum ? "inherit" : "hidden", endNum ? "inherit" : "hidden", !endNum);
+					}
+					if (p !== "scale" && p !== "transform") {
+						p = _propertyAliases[p];
+						~p.indexOf(",") && (p = p.split(",")[0]);
+					}
+				}
+				isTransformRelated = p in _transformProps;
+				if (isTransformRelated) {
+					this.styles.save(p);
+					finalTransformValue = endValue;
+					if (type === "string" && endValue.substring(0, 6) === "var(--") {
+						endValue = _getComputedProperty(target, endValue.substring(4, endValue.indexOf(")")));
+						if (endValue.substring(0, 5) === "calc(") {
+							var origPerspective = target.style.perspective;
+							target.style.perspective = endValue;
+							endValue = _getComputedProperty(target, "perspective");
+							origPerspective ? target.style.perspective = origPerspective : _removeProperty(target, "perspective");
+						}
+						endNum = parseFloat(endValue);
+					}
+					if (!transformPropTween) {
+						cache = target._gsap;
+						cache.renderTransform && !vars.parseTransform || _parseTransform(target, vars.parseTransform);
+						smooth = vars.smoothOrigin !== false && cache.smooth;
+						transformPropTween = this._pt = new PropTween(this._pt, style, _transformProp, 0, 1, cache.renderTransform, cache, 0, -1);
+						transformPropTween.dep = 1;
+					}
+					if (p === "scale") {
+						this._pt = new PropTween(this._pt, cache, "scaleY", cache.scaleY, (relative ? _parseRelative(cache.scaleY, relative + endNum) : endNum) - cache.scaleY || 0, _renderCSSProp);
+						this._pt.u = 0;
+						props.push("scaleY", p);
+						p += "X";
+					} else if (p === "transformOrigin") {
+						inlineProps.push(_transformOriginProp, 0, style[_transformOriginProp]);
+						endValue = _convertKeywordsToPercentages(endValue);
+						if (cache.svg) _applySVGOrigin(target, endValue, 0, smooth, 0, this);
+						else {
+							endUnit = parseFloat(endValue.split(" ")[2]) || 0;
+							endUnit !== cache.zOrigin && _addNonTweeningPT(this, cache, "zOrigin", cache.zOrigin, endUnit);
+							_addNonTweeningPT(this, style, p, _firstTwoOnly(startValue), _firstTwoOnly(endValue));
+						}
+						continue;
+					} else if (p === "svgOrigin") {
+						_applySVGOrigin(target, endValue, 1, smooth, 0, this);
+						continue;
+					} else if (p in _rotationalProperties) {
+						_addRotationalPropTween(this, cache, p, startNum, relative ? _parseRelative(startNum, relative + endValue) : endValue);
+						continue;
+					} else if (p === "smoothOrigin") {
+						_addNonTweeningPT(this, cache, "smooth", cache.smooth, endValue);
+						continue;
+					} else if (p === "force3D") {
+						cache[p] = endValue;
+						continue;
+					} else if (p === "transform") {
+						_addRawTransformPTs(this, endValue, target);
+						continue;
+					}
+				} else if (!(p in style)) p = _checkPropPrefix(p) || p;
+				if (isTransformRelated || (endNum || endNum === 0) && (startNum || startNum === 0) && !_complexExp.test(endValue) && p in style) {
+					startUnit = (startValue + "").substr((startNum + "").length);
+					endNum || (endNum = 0);
+					endUnit = getUnit(endValue) || (p in _config.units ? _config.units[p] : startUnit);
+					startUnit !== endUnit && (startNum = _convertToUnit(target, p, startValue, endUnit));
+					this._pt = new PropTween(this._pt, isTransformRelated ? cache : style, p, startNum, (relative ? _parseRelative(startNum, relative + endNum) : endNum) - startNum, !isTransformRelated && (endUnit === "px" || p === "zIndex") && vars.autoRound !== false ? _renderRoundedCSSProp : _renderCSSProp);
+					this._pt.u = endUnit || 0;
+					if (isTransformRelated && finalTransformValue !== endValue) {
+						this._pt.b = startValue;
+						this._pt.e = finalTransformValue;
+						this._pt.r = _renderCSSPropWithBeginningAndEnd;
+					} else if (startUnit !== endUnit && endUnit !== "%") {
+						this._pt.b = startValue;
+						this._pt.r = _renderCSSPropWithBeginning;
+					}
+				} else if (!(p in style)) {
+					if (p in target) this.add(target, p, startValue || target[p], relative ? relative + endValue : endValue, index, targets);
+					else if (p !== "parseTransform") {
+						_missingPlugin(p, endValue);
+						continue;
+					}
+				} else _tweenComplexCSSString.call(this, target, p, startValue, relative ? relative + endValue : endValue);
+				isTransformRelated || (p in style ? inlineProps.push(p, 0, style[p]) : typeof target[p] === "function" ? inlineProps.push(p, 2, target[p]()) : inlineProps.push(p, 1, startValue || target[p]));
+				props.push(p);
+			}
+		}
+		hasPriority && _sortPropTweensByPriority(this);
+	},
+	render: function render(ratio, data) {
+		if (data.tween._time || !_reverting()) {
+			var pt = data._pt;
+			while (pt) {
+				pt.r(ratio, pt.d);
+				pt = pt._next;
+			}
+		} else data.styles.revert();
+	},
+	get: _get,
+	aliases: _propertyAliases,
+	getSetter: function getSetter(target, property, plugin) {
+		var p = _propertyAliases[property];
+		p && p.indexOf(",") < 0 && (property = p);
+		return property in _transformProps && property !== _transformOriginProp && (target._gsap.x || _get(target, "x")) ? plugin && _recentSetterPlugin === plugin ? property === "scale" ? _setterScale : _setterTransform : (_recentSetterPlugin = plugin || {}) && (property === "scale" ? _setterScaleWithRender : _setterTransformWithRender) : target.style && !_isUndefined(target.style[property]) ? _setterCSSStyle : ~property.indexOf("-") ? _setterCSSProp : _getSetter(target, property);
+	},
+	core: {
+		_removeProperty,
+		_getMatrix
+	}
+};
+gsap.utils.checkPrefix = _checkPropPrefix;
+gsap.core.getStyleSaver = _getStyleSaver;
+(function(positionAndScale, rotation, others, aliases) {
+	var all = _forEachName(positionAndScale + "," + rotation + "," + others, function(name) {
+		_transformProps[name] = 1;
+	});
+	_forEachName(rotation, function(name) {
+		_config.units[name] = "deg";
+		_rotationalProperties[name] = 1;
+	});
+	_propertyAliases[all[13]] = positionAndScale + "," + rotation;
+	_forEachName(aliases, function(name) {
+		var split = name.split(":");
+		_propertyAliases[split[1]] = all[split[0]];
+	});
+})("x,y,z,scale,scaleX,scaleY,xPercent,yPercent", "rotation,rotationX,rotationY,skewX,skewY", "transform,transformOrigin,svgOrigin,force3D,smoothOrigin,transformPerspective", "0:translateX,1:translateY,2:translateZ,8:rotate,8:rotationZ,8:rotateZ,9:rotateX,10:rotateY");
+_forEachName("x,y,z,top,right,bottom,left,width,height,fontSize,padding,margin,perspective", function(name) {
+	_config.units[name] = "px";
+});
+gsap.registerPlugin(CSSPlugin);
+
+//#endregion
+export { CSSPlugin };
+//# sourceMappingURL=CSSPlugin.mjs.map