framer-motion 7.0.3 → 7.1.2

package/dist/es/render/utils/animation.mjs

@@ -1,37 +1,32 @@
-import { __read, __rest, __assign } from 'tslib';
+import { __rest } from 'tslib';
 import { startAnimation } from '../../animation/utils/transitions.mjs';
 import { setTarget } from './setters.mjs';
 import { resolveVariant } from './variants.mjs';
 import { isTransformProp } from '../html/utils/transform.mjs';
+import { isWillChangeMotionValue } from '../../value/use-will-change/is.mjs';
 
-function animateVisualElement(visualElement, definition, options) {
-    if (options === void 0) { options = {}; }
+function animateVisualElement(visualElement, definition, options = {}) {
     visualElement.notifyAnimationStart(definition);
-    var animation;
+    let animation;
     if (Array.isArray(definition)) {
-        var animations = definition.map(function (variant) {
-            return animateVariant(visualElement, variant, options);
-        });
+        const animations = definition.map((variant) => animateVariant(visualElement, variant, options));
         animation = Promise.all(animations);
     }
     else if (typeof definition === "string") {
         animation = animateVariant(visualElement, definition, options);
     }
     else {
-        var resolvedDefinition = typeof definition === "function"
+        const resolvedDefinition = typeof definition === "function"
             ? resolveVariant(visualElement, definition, options.custom)
             : definition;
         animation = animateTarget(visualElement, resolvedDefinition, options);
     }
-    return animation.then(function () {
-        return visualElement.notifyAnimationComplete(definition);
-    });
+    return animation.then(() => visualElement.notifyAnimationComplete(definition));
 }
-function animateVariant(visualElement, variant, options) {
+function animateVariant(visualElement, variant, options = {}) {
     var _a;
-    if (options === void 0) { options = {}; }
-    var resolved = resolveVariant(visualElement, variant, options.custom);
-    var _b = (resolved || {}).transition, transition = _b === void 0 ? visualElement.getDefaultTransition() || {} : _b;
+    const resolved = resolveVariant(visualElement, variant, options.custom);
+    let { transition = visualElement.getDefaultTransition() || {} } = resolved || {};
     if (options.transitionOverride) {
         transition = options.transitionOverride;
     }
@@ -39,29 +34,28 @@ function animateVariant(visualElement, variant, options) {
      * If we have a variant, create a callback that runs it as an animation.
      * Otherwise, we resolve a Promise immediately for a composable no-op.
      */
-    var getAnimation = resolved
-        ? function () { return animateTarget(visualElement, resolved, options); }
-        : function () { return Promise.resolve(); };
+    const getAnimation = resolved
+        ? () => animateTarget(visualElement, resolved, options)
+        : () => Promise.resolve();
     /**
      * If we have children, create a callback that runs all their animations.
      * Otherwise, we resolve a Promise immediately for a composable no-op.
      */
-    var getChildAnimations = ((_a = visualElement.variantChildren) === null || _a === void 0 ? void 0 : _a.size)
-        ? function (forwardDelay) {
-            if (forwardDelay === void 0) { forwardDelay = 0; }
-            var _a = transition.delayChildren, delayChildren = _a === void 0 ? 0 : _a, staggerChildren = transition.staggerChildren, staggerDirection = transition.staggerDirection;
+    const getChildAnimations = ((_a = visualElement.variantChildren) === null || _a === void 0 ? void 0 : _a.size)
+        ? (forwardDelay = 0) => {
+            const { delayChildren = 0, staggerChildren, staggerDirection, } = transition;
             return animateChildren(visualElement, variant, delayChildren + forwardDelay, staggerChildren, staggerDirection, options);
         }
-        : function () { return Promise.resolve(); };
+        : () => Promise.resolve();
     /**
      * If the transition explicitly defines a "when" option, we need to resolve either
      * this animation or all children animations before playing the other.
      */
-    var when = transition.when;
+    const { when } = transition;
     if (when) {
-        var _c = __read(when === "beforeChildren"
+        const [first, last] = when === "beforeChildren"
             ? [getAnimation, getChildAnimations]
-            : [getChildAnimations, getAnimation], 2), first = _c[0], last = _c[1];
+            : [getChildAnimations, getAnimation];
         return first().then(last);
     }
     else {
@@ -71,61 +65,56 @@ function animateVariant(visualElement, variant, options) {
 /**
  * @internal
  */
-function animateTarget(visualElement, definition, _a) {
-    var _b;
-    var _c = _a === void 0 ? {} : _a, _d = _c.delay, delay = _d === void 0 ? 0 : _d, transitionOverride = _c.transitionOverride, type = _c.type;
-    var _e = visualElement.makeTargetAnimatable(definition), _f = _e.transition, transition = _f === void 0 ? visualElement.getDefaultTransition() : _f, transitionEnd = _e.transitionEnd, target = __rest(_e, ["transition", "transitionEnd"]);
+function animateTarget(visualElement, definition, { delay = 0, transitionOverride, type } = {}) {
+    var _a;
+    let _b = visualElement.makeTargetAnimatable(definition), { transition = visualElement.getDefaultTransition(), transitionEnd } = _b, target = __rest(_b, ["transition", "transitionEnd"]);
+    const willChange = visualElement.getValue("willChange");
     if (transitionOverride)
         transition = transitionOverride;
-    var animations = [];
-    var animationTypeState = type && ((_b = visualElement.animationState) === null || _b === void 0 ? void 0 : _b.getState()[type]);
-    for (var key in target) {
-        var value = visualElement.getValue(key);
-        var valueTarget = target[key];
+    const animations = [];
+    const animationTypeState = type && ((_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.getState()[type]);
+    for (const key in target) {
+        const value = visualElement.getValue(key);
+        const valueTarget = target[key];
         if (!value ||
             valueTarget === undefined ||
             (animationTypeState &&
                 shouldBlockAnimation(animationTypeState, key))) {
             continue;
         }
-        var valueTransition = __assign({ delay: delay }, transition);
+        let valueTransition = Object.assign({ delay }, transition);
         /**
          * Make animation instant if this is a transform prop and we should reduce motion.
          */
         if (visualElement.shouldReduceMotion && isTransformProp(key)) {
-            valueTransition = __assign(__assign({}, valueTransition), { type: false, delay: 0 });
+            valueTransition = Object.assign(Object.assign({}, valueTransition), { type: false, delay: 0 });
+        }
+        let animation = startAnimation(key, value, valueTarget, valueTransition);
+        if (isWillChangeMotionValue(willChange)) {
+            willChange.add(key);
+            animation = animation.then(() => willChange.remove(key));
         }
-        var animation = startAnimation(key, value, valueTarget, valueTransition);
         animations.push(animation);
     }
-    return Promise.all(animations).then(function () {
+    return Promise.all(animations).then(() => {
         transitionEnd && setTarget(visualElement, transitionEnd);
     });
 }
-function animateChildren(visualElement, variant, delayChildren, staggerChildren, staggerDirection, options) {
-    if (delayChildren === void 0) { delayChildren = 0; }
-    if (staggerChildren === void 0) { staggerChildren = 0; }
-    if (staggerDirection === void 0) { staggerDirection = 1; }
-    var animations = [];
-    var maxStaggerDuration = (visualElement.variantChildren.size - 1) * staggerChildren;
-    var generateStaggerDuration = staggerDirection === 1
-        ? function (i) {
-            if (i === void 0) { i = 0; }
-            return i * staggerChildren;
-        }
-        : function (i) {
-            if (i === void 0) { i = 0; }
-            return maxStaggerDuration - i * staggerChildren;
-        };
+function animateChildren(visualElement, variant, delayChildren = 0, staggerChildren = 0, staggerDirection = 1, options) {
+    const animations = [];
+    const maxStaggerDuration = (visualElement.variantChildren.size - 1) * staggerChildren;
+    const generateStaggerDuration = staggerDirection === 1
+        ? (i = 0) => i * staggerChildren
+        : (i = 0) => maxStaggerDuration - i * staggerChildren;
     Array.from(visualElement.variantChildren)
         .sort(sortByTreeOrder)
-        .forEach(function (child, i) {
-        animations.push(animateVariant(child, variant, __assign(__assign({}, options), { delay: delayChildren + generateStaggerDuration(i) })).then(function () { return child.notifyAnimationComplete(variant); }));
+        .forEach((child, i) => {
+        animations.push(animateVariant(child, variant, Object.assign(Object.assign({}, options), { delay: delayChildren + generateStaggerDuration(i) })).then(() => child.notifyAnimationComplete(variant)));
     });
     return Promise.all(animations);
 }
 function stopAnimation(visualElement) {
-    visualElement.forEachValue(function (value) { return value.stop(); });
+    visualElement.forEachValue((value) => value.stop());
 }
 function sortByTreeOrder(a, b) {
     return a.sortNodePosition(b);
@@ -136,9 +125,8 @@ function sortByTreeOrder(a, b) {
  * posed problems if an animation was triggered by afterChildren and protectedKeys
  * had been set to true in the meantime.
  */
-function shouldBlockAnimation(_a, key) {
-    var protectedKeys = _a.protectedKeys, needsAnimating = _a.needsAnimating;
-    var shouldBlock = protectedKeys.hasOwnProperty(key) && needsAnimating[key] !== true;
+function shouldBlockAnimation({ protectedKeys, needsAnimating }, key) {
+    const shouldBlock = protectedKeys.hasOwnProperty(key) && needsAnimating[key] !== true;
     needsAnimating[key] = false;
     return shouldBlock;
 }

package/dist/es/render/utils/compare-by-depth.mjs

@@ -1,5 +1,3 @@
-var compareByDepth = function (a, b) {
-    return a.depth - b.depth;
-};
+const compareByDepth = (a, b) => a.depth - b.depth;
 
 export { compareByDepth };

package/dist/es/render/utils/flat-tree.mjs

@@ -1,25 +1,24 @@
 import { addUniqueItem, removeItem } from '../../utils/array.mjs';
 import { compareByDepth } from './compare-by-depth.mjs';
 
-var FlatTree = /** @class */ (function () {
-    function FlatTree() {
+class FlatTree {
+    constructor() {
         this.children = [];
         this.isDirty = false;
     }
-    FlatTree.prototype.add = function (child) {
+    add(child) {
         addUniqueItem(this.children, child);
         this.isDirty = true;
-    };
-    FlatTree.prototype.remove = function (child) {
+    }
+    remove(child) {
         removeItem(this.children, child);
         this.isDirty = true;
-    };
-    FlatTree.prototype.forEach = function (callback) {
+    }
+    forEach(callback) {
         this.isDirty && this.children.sort(compareByDepth);
         this.isDirty = false;
         this.children.forEach(callback);
-    };
-    return FlatTree;
-}());
+    }
+}
 
 export { FlatTree };

package/dist/es/render/utils/lifecycles.mjs

@@ -1,7 +1,6 @@
-import { __spreadArray, __read } from 'tslib';
 import { SubscriptionManager } from '../../utils/subscription-manager.mjs';
 
-var names = [
+const names = [
     "LayoutMeasure",
     "BeforeLayoutMeasure",
     "LayoutUpdate",
@@ -16,15 +15,15 @@ var names = [
     "Unmount",
 ];
 function createLifecycles() {
-    var managers = names.map(function () { return new SubscriptionManager(); });
-    var propSubscriptions = {};
-    var lifecycles = {
-        clearAllListeners: function () { return managers.forEach(function (manager) { return manager.clear(); }); },
-        updatePropListeners: function (props) {
-            names.forEach(function (name) {
+    const managers = names.map(() => new SubscriptionManager());
+    const propSubscriptions = {};
+    const lifecycles = {
+        clearAllListeners: () => managers.forEach((manager) => manager.clear()),
+        updatePropListeners: (props) => {
+            names.forEach((name) => {
                 var _a;
-                var on = "on" + name;
-                var propListener = props[on];
+                const on = "on" + name;
+                const propListener = props[on];
                 // Unsubscribe existing subscription
                 (_a = propSubscriptions[name]) === null || _a === void 0 ? void 0 : _a.call(propSubscriptions);
                 // Add new subscription
@@ -34,15 +33,9 @@ function createLifecycles() {
             });
         },
     };
-    managers.forEach(function (manager, i) {
-        lifecycles["on" + names[i]] = function (handler) { return manager.add(handler); };
-        lifecycles["notify" + names[i]] = function () {
-            var args = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                args[_i] = arguments[_i];
-            }
-            return manager.notify.apply(manager, __spreadArray([], __read(args), false));
-        };
+    managers.forEach((manager, i) => {
+        lifecycles["on" + names[i]] = (handler) => manager.add(handler);
+        lifecycles["notify" + names[i]] = (...args) => manager.notify(...args);
     });
     return lifecycles;
 }

package/dist/es/render/utils/motion-values.mjs

@@ -1,32 +1,40 @@
+import { isWillChangeMotionValue } from '../../value/use-will-change/is.mjs';
 import { warnOnce } from '../../utils/warn-once.mjs';
 import { motionValue } from '../../value/index.mjs';
 import { isMotionValue } from '../../value/utils/is-motion-value.mjs';
 
 function updateMotionValuesFromProps(element, next, prev) {
     var _a;
-    for (var key in next) {
-        var nextValue = next[key];
-        var prevValue = prev[key];
+    const { willChange } = next;
+    for (const key in next) {
+        const nextValue = next[key];
+        const prevValue = prev[key];
         if (isMotionValue(nextValue)) {
             /**
              * If this is a motion value found in props or style, we want to add it
              * to our visual element's motion value map.
              */
             element.addValue(key, nextValue);
+            if (isWillChangeMotionValue(willChange)) {
+                willChange.add(key);
+            }
             /**
              * Check the version of the incoming motion value with this version
              * and warn against mismatches.
              */
             if (process.env.NODE_ENV === "development") {
-                warnOnce(nextValue.version === "7.0.3", "Attempting to mix Framer Motion versions ".concat(nextValue.version, " with 7.0.3 may not work as expected."));
+                warnOnce(nextValue.version === "7.1.2", `Attempting to mix Framer Motion versions ${nextValue.version} with 7.1.2 may not work as expected.`);
             }
         }
         else if (isMotionValue(prevValue)) {
             /**
-             * If we're swapping to a new motion value, create a new motion value
-             * from that
+             * If we're swapping from a motion value to a static value,
+             * create a new motion value from that
              */
             element.addValue(key, motionValue(nextValue));
+            if (isWillChangeMotionValue(willChange)) {
+                willChange.remove(key);
+            }
         }
         else if (prevValue !== nextValue) {
             /**
@@ -35,7 +43,7 @@ function updateMotionValuesFromProps(element, next, prev) {
              * not handling the value with our animation state.
              */
             if (element.hasValue(key)) {
-                var existingValue = element.getValue(key);
+                const existingValue = element.getValue(key);
                 // TODO: Only update values that aren't being animated or even looked at
                 !existingValue.hasAnimated && existingValue.set(nextValue);
             }
@@ -45,7 +53,7 @@ function updateMotionValuesFromProps(element, next, prev) {
         }
     }
     // Handle removed values
-    for (var key in prev) {
+    for (const key in prev) {
         if (next[key] === undefined)
             element.removeValue(key);
     }

package/dist/es/render/utils/setters.mjs

@@ -1,4 +1,4 @@
-import { __rest, __assign, __spreadArray, __read } from 'tslib';
+import { __rest } from 'tslib';
 import { complex } from 'style-value-types';
 import { isNumericalString } from '../../utils/is-numerical-string.mjs';
 import { isZeroValueString } from '../../utils/is-zero-value-string.mjs';
@@ -21,21 +21,21 @@ function setMotionValue(visualElement, key, value) {
     }
 }
 function setTarget(visualElement, definition) {
-    var resolved = resolveVariant(visualElement, definition);
-    var _a = resolved ? visualElement.makeTargetAnimatable(resolved, false) : {}, _b = _a.transitionEnd, transitionEnd = _b === void 0 ? {} : _b; _a.transition; var target = __rest(_a, ["transitionEnd", "transition"]);
-    target = __assign(__assign({}, target), transitionEnd);
-    for (var key in target) {
-        var value = resolveFinalValueInKeyframes(target[key]);
+    const resolved = resolveVariant(visualElement, definition);
+    let _a = resolved ? visualElement.makeTargetAnimatable(resolved, false) : {}, { transitionEnd = {}, transition = {} } = _a, target = __rest(_a, ["transitionEnd", "transition"]);
+    target = Object.assign(Object.assign({}, target), transitionEnd);
+    for (const key in target) {
+        const value = resolveFinalValueInKeyframes(target[key]);
         setMotionValue(visualElement, key, value);
     }
 }
 function setVariants(visualElement, variantLabels) {
-    var reversedLabels = __spreadArray([], __read(variantLabels), false).reverse();
-    reversedLabels.forEach(function (key) {
+    const reversedLabels = [...variantLabels].reverse();
+    reversedLabels.forEach((key) => {
         var _a;
-        var variant = visualElement.getVariant(key);
+        const variant = visualElement.getVariant(key);
         variant && setTarget(visualElement, variant);
-        (_a = visualElement.variantChildren) === null || _a === void 0 ? void 0 : _a.forEach(function (child) {
+        (_a = visualElement.variantChildren) === null || _a === void 0 ? void 0 : _a.forEach((child) => {
             setVariants(child, variantLabels);
         });
     });
@@ -54,14 +54,14 @@ function setValues(visualElement, definition) {
 function checkTargetForNewValues(visualElement, target, origin) {
     var _a, _b, _c;
     var _d;
-    var newValueKeys = Object.keys(target).filter(function (key) { return !visualElement.hasValue(key); });
-    var numNewValues = newValueKeys.length;
+    const newValueKeys = Object.keys(target).filter((key) => !visualElement.hasValue(key));
+    const numNewValues = newValueKeys.length;
     if (!numNewValues)
         return;
-    for (var i = 0; i < numNewValues; i++) {
-        var key = newValueKeys[i];
-        var targetValue = target[key];
-        var value = null;
+    for (let i = 0; i < numNewValues; i++) {
+        const key = newValueKeys[i];
+        const targetValue = target[key];
+        let value = null;
         /**
          * If the target is a series of keyframes, we can use the first value
          * in the array. If this first value is null, we'll still need to read from the DOM.
@@ -99,13 +99,13 @@ function checkTargetForNewValues(visualElement, target, origin) {
 function getOriginFromTransition(key, transition) {
     if (!transition)
         return;
-    var valueTransition = transition[key] || transition["default"] || transition;
+    const valueTransition = transition[key] || transition["default"] || transition;
     return valueTransition.from;
 }
 function getOrigin(target, transition, visualElement) {
     var _a, _b;
-    var origin = {};
-    for (var key in target) {
+    const origin = {};
+    for (const key in target) {
         origin[key] =
             (_a = getOriginFromTransition(key, transition)) !== null && _a !== void 0 ? _a : (_b = visualElement.getValue(key)) === null || _b === void 0 ? void 0 : _b.get();
     }

package/dist/es/render/utils/variants.mjs

@@ -14,22 +14,20 @@ function isVariantLabel(v) {
  * Creates an object containing the latest state of every MotionValue on a VisualElement
  */
 function getCurrent(visualElement) {
-    var current = {};
-    visualElement.forEachValue(function (value, key) { return (current[key] = value.get()); });
+    const current = {};
+    visualElement.forEachValue((value, key) => (current[key] = value.get()));
     return current;
 }
 /**
  * Creates an object containing the latest velocity of every MotionValue on a VisualElement
  */
 function getVelocity(visualElement) {
-    var velocity = {};
-    visualElement.forEachValue(function (value, key) { return (velocity[key] = value.getVelocity()); });
+    const velocity = {};
+    visualElement.forEachValue((value, key) => (velocity[key] = value.getVelocity()));
     return velocity;
 }
-function resolveVariantFromProps(props, definition, custom, currentValues, currentVelocity) {
+function resolveVariantFromProps(props, definition, custom, currentValues = {}, currentVelocity = {}) {
     var _a;
-    if (currentValues === void 0) { currentValues = {}; }
-    if (currentVelocity === void 0) { currentVelocity = {}; }
     /**
      * If the variant definition is a function, resolve.
      */
@@ -54,7 +52,7 @@ function resolveVariantFromProps(props, definition, custom, currentValues, curre
     return definition;
 }
 function resolveVariant(visualElement, definition, custom) {
-    var props = visualElement.getProps();
+    const props = visualElement.getProps();
     return resolveVariantFromProps(props, definition, custom !== null && custom !== void 0 ? custom : props.custom, getCurrent(visualElement), getVelocity(visualElement));
 }
 function checkIfControllingVariants(props) {

package/dist/es/utils/array.mjs

@@ -1,19 +1,18 @@
-import { __read } from 'tslib';
-
 function addUniqueItem(arr, item) {
-    arr.indexOf(item) === -1 && arr.push(item);
+    if (arr.indexOf(item) === -1)
+        arr.push(item);
 }
 function removeItem(arr, item) {
-    var index = arr.indexOf(item);
-    index > -1 && arr.splice(index, 1);
+    const index = arr.indexOf(item);
+    if (index > -1)
+        arr.splice(index, 1);
 }
 // Adapted from array-move
-function moveItem(_a, fromIndex, toIndex) {
-    var _b = __read(_a), arr = _b.slice(0);
-    var startIndex = fromIndex < 0 ? arr.length + fromIndex : fromIndex;
+function moveItem([...arr], fromIndex, toIndex) {
+    const startIndex = fromIndex < 0 ? arr.length + fromIndex : fromIndex;
     if (startIndex >= 0 && startIndex < arr.length) {
-        var endIndex = toIndex < 0 ? arr.length + toIndex : toIndex;
-        var _c = __read(arr.splice(fromIndex, 1), 1), item = _c[0];
+        const endIndex = toIndex < 0 ? arr.length + toIndex : toIndex;
+        const [item] = arr.splice(fromIndex, 1);
         arr.splice(endIndex, 0, item);
     }
     return arr;

package/dist/es/utils/is-browser.mjs

@@ -1,3 +1,3 @@
-var isBrowser = typeof document !== "undefined";
+const isBrowser = typeof document !== "undefined";
 
 export { isBrowser };

package/dist/es/utils/is-numerical-string.mjs

@@ -1,6 +1,6 @@
 /**
  * Check if value is a numerical string, ie a string that is purely a number eg "100" or "-100.1"
  */
-var isNumericalString = function (v) { return /^\-?\d*\.?\d+$/.test(v); };
+const isNumericalString = (v) => /^\-?\d*\.?\d+$/.test(v);
 
 export { isNumericalString };

package/dist/es/utils/is-zero-value-string.mjs

@@ -1,6 +1,6 @@
 /**
  * Check if the value is a zero value string like "0px" or "0%"
  */
-var isZeroValueString = function (v) { return /^0[^.\s]+$/.test(v); };
+const isZeroValueString = (v) => /^0[^.\s]+$/.test(v);
 
 export { isZeroValueString };

package/dist/es/utils/process.mjs

@@ -1,8 +1,8 @@
 /**
  * Browser-safe usage of process
  */
-var defaultEnvironment = "production";
-var env = typeof process === "undefined" || process.env === undefined
+const defaultEnvironment = "production";
+const env = typeof process === "undefined" || process.env === undefined
     ? defaultEnvironment
     : process.env.NODE_ENV || defaultEnvironment;
 

package/dist/es/utils/resolve-value.mjs

@@ -1,9 +1,9 @@
 import { isKeyframesTarget } from '../animation/utils/is-keyframes-target.mjs';
 
-var isCustomValue = function (v) {
+const isCustomValue = (v) => {
     return Boolean(v && typeof v === "object" && v.mix && v.toValue);
 };
-var resolveFinalValueInKeyframes = function (v) {
+const resolveFinalValueInKeyframes = (v) => {
     // TODO maybe throw if v.length - 1 is placeholder token?
     return isKeyframesTarget(v) ? v[v.length - 1] || 0 : v;
 };

package/dist/es/utils/shallow-compare.mjs

@@ -1,10 +1,10 @@
 function shallowCompare(next, prev) {
     if (!Array.isArray(prev))
         return false;
-    var prevLength = prev.length;
+    const prevLength = prev.length;
     if (prevLength !== next.length)
         return false;
-    for (var i = 0; i < prevLength; i++) {
+    for (let i = 0; i < prevLength; i++) {
         if (prev[i] !== next[i])
             return false;
     }

package/dist/es/utils/subscription-manager.mjs

@@ -1,16 +1,15 @@
 import { addUniqueItem, removeItem } from './array.mjs';
 
-var SubscriptionManager = /** @class */ (function () {
-    function SubscriptionManager() {
+class SubscriptionManager {
+    constructor() {
         this.subscriptions = [];
     }
-    SubscriptionManager.prototype.add = function (handler) {
-        var _this = this;
+    add(handler) {
         addUniqueItem(this.subscriptions, handler);
-        return function () { return removeItem(_this.subscriptions, handler); };
-    };
-    SubscriptionManager.prototype.notify = function (a, b, c) {
-        var numSubscriptions = this.subscriptions.length;
+        return () => removeItem(this.subscriptions, handler);
+    }
+    notify(a, b, c) {
+        const numSubscriptions = this.subscriptions.length;
         if (!numSubscriptions)
             return;
         if (numSubscriptions === 1) {
@@ -20,23 +19,22 @@ var SubscriptionManager = /** @class */ (function () {
             this.subscriptions[0](a, b, c);
         }
         else {
-            for (var i = 0; i < numSubscriptions; i++) {
+            for (let i = 0; i < numSubscriptions; i++) {
                 /**
                  * Check whether the handler exists before firing as it's possible
                  * the subscriptions were modified during this loop running.
                  */
-                var handler = this.subscriptions[i];
+                const handler = this.subscriptions[i];
                 handler && handler(a, b, c);
             }
         }
-    };
-    SubscriptionManager.prototype.getSize = function () {
+    }
+    getSize() {
         return this.subscriptions.length;
-    };
-    SubscriptionManager.prototype.clear = function () {
+    }
+    clear() {
         this.subscriptions.length = 0;
-    };
-    return SubscriptionManager;
-}());
+    }
+}
 
 export { SubscriptionManager };

package/dist/es/utils/time-conversion.mjs

@@ -4,6 +4,6 @@
  * @param seconds - Time in seconds.
  * @return milliseconds - Converted time in milliseconds.
  */
-var secondsToMilliseconds = function (seconds) { return seconds * 1000; };
+const secondsToMilliseconds = (seconds) => seconds * 1000;
 
 export { secondsToMilliseconds };