@nova-design-system/nova-webcomponents 3.11.0 → 3.13.0

package/dist/components/{p-09cdd71f.js → p-42ea6b74.js}

@@ -648,8 +648,9 @@ const DEFAULT_OVERSHOOT_STRENGTH = 1.525;
 const BOUNCE_FIRST_THRESHOLD = 4.0 / 11.0;
 const BOUNCE_SECOND_THRESHOLD = 8.0 / 11.0;
 const BOUNCE_THIRD_THRESHOLD = 9.0 / 10.0;
+const linear = p => p;
 const easeIn = createExpoIn(2);
-reverseEasing(easeIn);
+const easeOut = reverseEasing(easeIn);
 const easeInOut = mirrorEasing(easeIn);
 const circIn = p => 1 - Math.sin(Math.acos(p));
 const circOut = reverseEasing(circIn);
@@ -756,7 +757,7 @@ const defaultTimestep = (1 / 60) * 1000;
 const getCurrentTime = typeof performance !== "undefined"
     ? () => performance.now()
     : () => Date.now();
-const onNextFrame$1 = typeof window !== "undefined"
+const onNextFrame = typeof window !== "undefined"
     ? (callback) => window.requestAnimationFrame(callback)
     : (callback) => setTimeout(() => callback(getCurrentTime()), defaultTimestep);
 
@@ -815,65 +816,65 @@ function createRenderStep(runNextFrame) {
     return step;
 }
 
-const maxElapsed$1 = 40;
-let useDefaultElapsed$1 = true;
+const maxElapsed = 40;
+let useDefaultElapsed = true;
 let runNextFrame = false;
-let isProcessing$1 = false;
-const frame$1 = {
+let isProcessing = false;
+const frame = {
     delta: 0,
     timestamp: 0,
 };
-const stepsOrder$1 = [
+const stepsOrder = [
     "read",
     "update",
     "preRender",
     "render",
     "postRender",
 ];
-const steps$1 = stepsOrder$1.reduce((acc, key) => {
+const steps = stepsOrder.reduce((acc, key) => {
     acc[key] = createRenderStep(() => (runNextFrame = true));
     return acc;
 }, {});
-const sync$1 = stepsOrder$1.reduce((acc, key) => {
-    const step = steps$1[key];
+const sync = stepsOrder.reduce((acc, key) => {
+    const step = steps[key];
     acc[key] = (process, keepAlive = false, immediate = false) => {
         if (!runNextFrame)
-            startLoop$1();
+            startLoop();
         return step.schedule(process, keepAlive, immediate);
     };
     return acc;
 }, {});
-const cancelSync = stepsOrder$1.reduce((acc, key) => {
-    acc[key] = steps$1[key].cancel;
+const cancelSync = stepsOrder.reduce((acc, key) => {
+    acc[key] = steps[key].cancel;
     return acc;
 }, {});
-stepsOrder$1.reduce((acc, key) => {
-    acc[key] = () => steps$1[key].process(frame$1);
+stepsOrder.reduce((acc, key) => {
+    acc[key] = () => steps[key].process(frame);
     return acc;
 }, {});
-const processStep$1 = (stepId) => steps$1[stepId].process(frame$1);
-const processFrame$1 = (timestamp) => {
+const processStep = (stepId) => steps[stepId].process(frame);
+const processFrame = (timestamp) => {
     runNextFrame = false;
-    frame$1.delta = useDefaultElapsed$1
+    frame.delta = useDefaultElapsed
         ? defaultTimestep
-        : Math.max(Math.min(timestamp - frame$1.timestamp, maxElapsed$1), 1);
-    frame$1.timestamp = timestamp;
-    isProcessing$1 = true;
-    stepsOrder$1.forEach(processStep$1);
-    isProcessing$1 = false;
+        : Math.max(Math.min(timestamp - frame.timestamp, maxElapsed), 1);
+    frame.timestamp = timestamp;
+    isProcessing = true;
+    stepsOrder.forEach(processStep);
+    isProcessing = false;
     if (runNextFrame) {
-        useDefaultElapsed$1 = false;
-        onNextFrame$1(processFrame$1);
+        useDefaultElapsed = false;
+        onNextFrame(processFrame);
     }
 };
-const startLoop$1 = () => {
+const startLoop = () => {
     runNextFrame = true;
-    useDefaultElapsed$1 = true;
-    if (!isProcessing$1)
-        onNextFrame$1(processFrame$1);
+    useDefaultElapsed = true;
+    if (!isProcessing)
+        onNextFrame(processFrame);
 };
 
-const sync$2 = sync$1;
+const sync$1 = sync;
 
 function loopElapsed(elapsed, duration, delay = 0) {
     return elapsed - duration - delay;
@@ -890,7 +891,7 @@ function hasRepeatDelayElapsed(elapsed, duration, delay, isForwardPlayback) {
 const framesync = (update) => {
     const passTimestamp = ({ delta }) => update(delta);
     return {
-        start: () => sync$2.update(passTimestamp, true),
+        start: () => sync$1.update(passTimestamp, true),
         stop: () => cancelSync.update(passTimestamp),
     };
 };
@@ -1007,127 +1008,6 @@ function __rest(s, e) {
     return t;
 }
 
-var prevTime = 0;
-var onNextFrame = typeof window !== 'undefined' && window.requestAnimationFrame !== undefined ? function (callback) {
-    return window.requestAnimationFrame(callback);
-} : function (callback) {
-    var timestamp = Date.now();
-    var timeToCall = Math.max(0, 16.7 - (timestamp - prevTime));
-    prevTime = timestamp + timeToCall;
-    setTimeout(function () {
-        return callback(prevTime);
-    }, timeToCall);
-};
-
-var createStep = function (setRunNextFrame) {
-    var processToRun = [];
-    var processToRunNextFrame = [];
-    var numThisFrame = 0;
-    var isProcessing = false;
-    var i = 0;
-    var cancelled = new WeakSet();
-    var toKeepAlive = new WeakSet();
-    var renderStep = {
-        cancel: function (process) {
-            var indexOfCallback = processToRunNextFrame.indexOf(process);
-            cancelled.add(process);
-            if (indexOfCallback !== -1) {
-                processToRunNextFrame.splice(indexOfCallback, 1);
-            }
-        },
-        process: function (frame) {
-            var _a;
-            isProcessing = true;
-            _a = [processToRunNextFrame, processToRun], processToRun = _a[0], processToRunNextFrame = _a[1];
-            processToRunNextFrame.length = 0;
-            numThisFrame = processToRun.length;
-            if (numThisFrame) {
-                var process_1;
-                for (i = 0; i < numThisFrame; i++) {
-                    process_1 = processToRun[i];
-                    process_1(frame);
-                    if (toKeepAlive.has(process_1) === true && !cancelled.has(process_1)) {
-                        renderStep.schedule(process_1);
-                        setRunNextFrame(true);
-                    }
-                }
-            }
-            isProcessing = false;
-        },
-        schedule: function (process, keepAlive, immediate) {
-            if (keepAlive === void 0) {
-                keepAlive = false;
-            }
-            if (immediate === void 0) {
-                immediate = false;
-            }
-            var addToCurrentBuffer = immediate && isProcessing;
-            var buffer = addToCurrentBuffer ? processToRun : processToRunNextFrame;
-            cancelled.delete(process);
-            if (keepAlive) toKeepAlive.add(process);
-            if (buffer.indexOf(process) === -1) {
-                buffer.push(process);
-                if (addToCurrentBuffer) numThisFrame = processToRun.length;
-            }
-        }
-    };
-    return renderStep;
-};
-
-var maxElapsed = 40;
-var defaultElapsed = 1 / 60 * 1000;
-var useDefaultElapsed = true;
-var willRunNextFrame = false;
-var isProcessing = false;
-var frame = {
-    delta: 0,
-    timestamp: 0
-};
-var stepsOrder = ["read", "update", "preRender", "render", "postRender"];
-var setWillRunNextFrame = function (willRun) {
-    return willRunNextFrame = willRun;
-};
-var steps = /*#__PURE__*/stepsOrder.reduce(function (acc, key) {
-    acc[key] = createStep(setWillRunNextFrame);
-    return acc;
-}, {});
-var sync = /*#__PURE__*/stepsOrder.reduce(function (acc, key) {
-    var step = steps[key];
-    acc[key] = function (process, keepAlive, immediate) {
-        if (keepAlive === void 0) {
-            keepAlive = false;
-        }
-        if (immediate === void 0) {
-            immediate = false;
-        }
-        if (!willRunNextFrame) startLoop();
-        step.schedule(process, keepAlive, immediate);
-        return process;
-    };
-    return acc;
-}, {});
-var processStep = function (stepId) {
-    return steps[stepId].process(frame);
-};
-var processFrame = function (timestamp) {
-    willRunNextFrame = false;
-    frame.delta = useDefaultElapsed ? defaultElapsed : Math.max(Math.min(timestamp - frame.timestamp, maxElapsed), 1);
-    if (!useDefaultElapsed) defaultElapsed = frame.delta;
-    frame.timestamp = timestamp;
-    isProcessing = true;
-    stepsOrder.forEach(processStep);
-    isProcessing = false;
-    if (willRunNextFrame) {
-        useDefaultElapsed = false;
-        onNextFrame(processFrame);
-    }
-};
-var startLoop = function () {
-    willRunNextFrame = true;
-    useDefaultElapsed = true;
-    if (!isProcessing) onNextFrame(processFrame);
-};
-
 var clamp = function (min, max) { return function (v) {
     return Math.max(Math.min(v, max), min);
 }; };
@@ -1269,540 +1149,6 @@ var color = {
     }
 };
 
-var createStyler = function (_a) {
-    var onRead = _a.onRead,
-        onRender = _a.onRender,
-        _b = _a.uncachedValues,
-        uncachedValues = _b === void 0 ? new Set() : _b,
-        _c = _a.useCache,
-        useCache = _c === void 0 ? true : _c;
-    return function (_a) {
-        if (_a === void 0) {
-            _a = {};
-        }
-        var props = __rest(_a, []);
-        var state = {};
-        var changedValues = [];
-        var hasChanged = false;
-        function setValue(key, value) {
-            if (key.startsWith('--')) {
-                props.hasCSSVariable = true;
-            }
-            var currentValue = state[key];
-            state[key] = value;
-            if (state[key] === currentValue) return;
-            if (changedValues.indexOf(key) === -1) {
-                changedValues.push(key);
-            }
-            if (!hasChanged) {
-                hasChanged = true;
-                sync.render(styler.render);
-            }
-        }
-        var styler = {
-            get: function (key, forceRead) {
-                if (forceRead === void 0) {
-                    forceRead = false;
-                }
-                var useCached = !forceRead && useCache && !uncachedValues.has(key) && state[key] !== undefined;
-                return useCached ? state[key] : onRead(key, props);
-            },
-            set: function (values, value) {
-                if (typeof values === 'string') {
-                    setValue(values, value);
-                } else {
-                    for (var key in values) {
-                        setValue(key, values[key]);
-                    }
-                }
-                return this;
-            },
-            render: function (forceRender) {
-                if (forceRender === void 0) {
-                    forceRender = false;
-                }
-                if (hasChanged || forceRender === true) {
-                    onRender(state, props, changedValues);
-                    hasChanged = false;
-                    changedValues.length = 0;
-                }
-                return this;
-            }
-        };
-        return styler;
-    };
-};
-
-var CAMEL_CASE_PATTERN = /([a-z])([A-Z])/g;
-var REPLACE_TEMPLATE = '$1-$2';
-var camelToDash = function (str) {
-    return str.replace(CAMEL_CASE_PATTERN, REPLACE_TEMPLATE).toLowerCase();
-};
-
-var camelCache = /*#__PURE__*/new Map();
-var dashCache = /*#__PURE__*/new Map();
-var prefixes = ['Webkit', 'Moz', 'O', 'ms', ''];
-var numPrefixes = prefixes.length;
-var isBrowser = typeof document !== 'undefined';
-var testElement;
-var setDashPrefix = function (key, prefixed) {
-    return dashCache.set(key, camelToDash(prefixed));
-};
-var testPrefix = function (key) {
-    testElement = testElement || document.createElement('div');
-    for (var i = 0; i < numPrefixes; i++) {
-        var prefix = prefixes[i];
-        var noPrefix = prefix === '';
-        var prefixedPropertyName = noPrefix ? key : prefix + key.charAt(0).toUpperCase() + key.slice(1);
-        if (prefixedPropertyName in testElement.style || noPrefix) {
-            if (noPrefix && key === 'clipPath' && dashCache.has(key)) {
-                return;
-            }
-            camelCache.set(key, prefixedPropertyName);
-            setDashPrefix(key, "" + (noPrefix ? '' : '-') + camelToDash(prefixedPropertyName));
-        }
-    }
-};
-var setServerProperty = function (key) {
-    return setDashPrefix(key, key);
-};
-var prefixer = function (key, asDashCase) {
-    if (asDashCase === void 0) {
-        asDashCase = false;
-    }
-    var cache = asDashCase ? dashCache : camelCache;
-    if (!cache.has(key)) {
-        isBrowser ? testPrefix(key) : setServerProperty(key);
-    }
-    return cache.get(key) || key;
-};
-
-var axes = ['', 'X', 'Y', 'Z'];
-var order = ['translate', 'scale', 'rotate', 'skew', 'transformPerspective'];
-var transformProps = /*#__PURE__*/order.reduce(function (acc, key) {
-    return axes.reduce(function (axesAcc, axesKey) {
-        axesAcc.push(key + axesKey);
-        return axesAcc;
-    }, acc);
-}, ['x', 'y', 'z']);
-var transformPropDictionary = /*#__PURE__*/transformProps.reduce(function (dict, key) {
-    dict[key] = true;
-    return dict;
-}, {});
-function isTransformProp(key) {
-    return transformPropDictionary[key] === true;
-}
-function sortTransformProps(a, b) {
-    return transformProps.indexOf(a) - transformProps.indexOf(b);
-}
-var transformOriginProps = /*#__PURE__*/new Set(['originX', 'originY', 'originZ']);
-function isTransformOriginProp(key) {
-    return transformOriginProps.has(key);
-}
-
-var int = /*#__PURE__*/__assign( /*#__PURE__*/__assign({}, number), { transform: Math.round });
-var valueTypes = {
-    color: color,
-    backgroundColor: color,
-    outlineColor: color,
-    fill: color,
-    stroke: color,
-    borderColor: color,
-    borderTopColor: color,
-    borderRightColor: color,
-    borderBottomColor: color,
-    borderLeftColor: color,
-    borderWidth: px,
-    borderTopWidth: px,
-    borderRightWidth: px,
-    borderBottomWidth: px,
-    borderLeftWidth: px,
-    borderRadius: px,
-    radius: px,
-    borderTopLeftRadius: px,
-    borderTopRightRadius: px,
-    borderBottomRightRadius: px,
-    borderBottomLeftRadius: px,
-    width: px,
-    maxWidth: px,
-    height: px,
-    maxHeight: px,
-    size: px,
-    top: px,
-    right: px,
-    bottom: px,
-    left: px,
-    padding: px,
-    paddingTop: px,
-    paddingRight: px,
-    paddingBottom: px,
-    paddingLeft: px,
-    margin: px,
-    marginTop: px,
-    marginRight: px,
-    marginBottom: px,
-    marginLeft: px,
-    rotate: degrees,
-    rotateX: degrees,
-    rotateY: degrees,
-    rotateZ: degrees,
-    scale: scale,
-    scaleX: scale,
-    scaleY: scale,
-    scaleZ: scale,
-    skew: degrees,
-    skewX: degrees,
-    skewY: degrees,
-    distance: px,
-    translateX: px,
-    translateY: px,
-    translateZ: px,
-    x: px,
-    y: px,
-    z: px,
-    perspective: px,
-    opacity: alpha,
-    originX: progressPercentage,
-    originY: progressPercentage,
-    originZ: px,
-    zIndex: int,
-    fillOpacity: alpha,
-    strokeOpacity: alpha,
-    numOctaves: int
-};
-var getValueType = function (key) {
-    return valueTypes[key];
-};
-var getValueAsType = function (value, type) {
-    return type && typeof value === 'number' ? type.transform(value) : value;
-};
-
-var SCROLL_LEFT = 'scrollLeft';
-var SCROLL_TOP = 'scrollTop';
-var scrollKeys = /*#__PURE__*/new Set([SCROLL_LEFT, SCROLL_TOP]);
-
-var blacklist = /*#__PURE__*/new Set([SCROLL_LEFT, SCROLL_TOP, 'transform']);
-var translateAlias = {
-    x: 'translateX',
-    y: 'translateY',
-    z: 'translateZ'
-};
-function isCustomTemplate(v) {
-    return typeof v === 'function';
-}
-function buildTransform(state, transform, transformKeys, transformIsDefault, enableHardwareAcceleration, allowTransformNone) {
-    if (allowTransformNone === void 0) {
-        allowTransformNone = true;
-    }
-    var transformString = '';
-    var transformHasZ = false;
-    transformKeys.sort(sortTransformProps);
-    var numTransformKeys = transformKeys.length;
-    for (var i = 0; i < numTransformKeys; i++) {
-        var key = transformKeys[i];
-        transformString += (translateAlias[key] || key) + "(" + transform[key] + ") ";
-        transformHasZ = key === 'z' ? true : transformHasZ;
-    }
-    if (!transformHasZ && enableHardwareAcceleration) {
-        transformString += 'translateZ(0)';
-    } else {
-        transformString = transformString.trim();
-    }
-    if (isCustomTemplate(state.transform)) {
-        transformString = state.transform(transform, transformIsDefault ? '' : transformString);
-    } else if (allowTransformNone && transformIsDefault) {
-        transformString = 'none';
-    }
-    return transformString;
-}
-function buildStyleProperty(state, enableHardwareAcceleration, styles, transform, transformOrigin, transformKeys, isDashCase, allowTransformNone) {
-    if (enableHardwareAcceleration === void 0) {
-        enableHardwareAcceleration = true;
-    }
-    if (styles === void 0) {
-        styles = {};
-    }
-    if (transform === void 0) {
-        transform = {};
-    }
-    if (transformOrigin === void 0) {
-        transformOrigin = {};
-    }
-    if (transformKeys === void 0) {
-        transformKeys = [];
-    }
-    if (isDashCase === void 0) {
-        isDashCase = false;
-    }
-    if (allowTransformNone === void 0) {
-        allowTransformNone = true;
-    }
-    var transformIsDefault = true;
-    var hasTransform = false;
-    var hasTransformOrigin = false;
-    for (var key in state) {
-        var value = state[key];
-        var valueType = getValueType(key);
-        var valueAsType = getValueAsType(value, valueType);
-        if (isTransformProp(key)) {
-            hasTransform = true;
-            transform[key] = valueAsType;
-            transformKeys.push(key);
-            if (transformIsDefault) {
-                if (valueType.default && value !== valueType.default || !valueType.default && value !== 0) {
-                    transformIsDefault = false;
-                }
-            }
-        } else if (isTransformOriginProp(key)) {
-            transformOrigin[key] = valueAsType;
-            hasTransformOrigin = true;
-        } else if (!blacklist.has(key) || !isCustomTemplate(valueAsType)) {
-            styles[prefixer(key, isDashCase)] = valueAsType;
-        }
-    }
-    if (hasTransform || typeof state.transform === 'function') {
-        styles.transform = buildTransform(state, transform, transformKeys, transformIsDefault, enableHardwareAcceleration, allowTransformNone);
-    }
-    if (hasTransformOrigin) {
-        styles.transformOrigin = (transformOrigin.originX || '50%') + " " + (transformOrigin.originY || '50%') + " " + (transformOrigin.originZ || 0);
-    }
-    return styles;
-}
-function createStyleBuilder(_a) {
-    var _b = _a === void 0 ? {} : _a,
-        _c = _b.enableHardwareAcceleration,
-        enableHardwareAcceleration = _c === void 0 ? true : _c,
-        _d = _b.isDashCase,
-        isDashCase = _d === void 0 ? true : _d,
-        _e = _b.allowTransformNone,
-        allowTransformNone = _e === void 0 ? true : _e;
-    var styles = {};
-    var transform = {};
-    var transformOrigin = {};
-    var transformKeys = [];
-    return function (state) {
-        transformKeys.length = 0;
-        buildStyleProperty(state, enableHardwareAcceleration, styles, transform, transformOrigin, transformKeys, isDashCase, allowTransformNone);
-        return styles;
-    };
-}
-
-function onRead(key, options) {
-    var element = options.element,
-        preparseOutput = options.preparseOutput;
-    var defaultValueType = getValueType(key);
-    if (isTransformProp(key)) {
-        return defaultValueType ? defaultValueType.default || 0 : 0;
-    } else if (scrollKeys.has(key)) {
-        return element[key];
-    } else {
-        var domValue = window.getComputedStyle(element, null).getPropertyValue(prefixer(key, true)) || 0;
-        return preparseOutput && defaultValueType && defaultValueType.test(domValue) && defaultValueType.parse ? defaultValueType.parse(domValue) : domValue;
-    }
-}
-function onRender(state, _a, changedValues) {
-    var element = _a.element,
-        buildStyles = _a.buildStyles,
-        hasCSSVariable = _a.hasCSSVariable;
-    Object.assign(element.style, buildStyles(state));
-    if (hasCSSVariable) {
-        var numChangedValues = changedValues.length;
-        for (var i = 0; i < numChangedValues; i++) {
-            var key = changedValues[i];
-            if (key.startsWith('--')) {
-                element.style.setProperty(key, state[key]);
-            }
-        }
-    }
-    if (changedValues.indexOf(SCROLL_LEFT) !== -1) {
-        element[SCROLL_LEFT] = state[SCROLL_LEFT];
-    }
-    if (changedValues.indexOf(SCROLL_TOP) !== -1) {
-        element[SCROLL_TOP] = state[SCROLL_TOP];
-    }
-}
-var cssStyler = /*#__PURE__*/createStyler({
-    onRead: onRead,
-    onRender: onRender,
-    uncachedValues: scrollKeys
-});
-function createCssStyler(element, _a) {
-    if (_a === void 0) {
-        _a = {};
-    }
-    var enableHardwareAcceleration = _a.enableHardwareAcceleration,
-        allowTransformNone = _a.allowTransformNone,
-        props = __rest(_a, ["enableHardwareAcceleration", "allowTransformNone"]);
-    return cssStyler(__assign({ element: element, buildStyles: createStyleBuilder({
-            enableHardwareAcceleration: enableHardwareAcceleration,
-            allowTransformNone: allowTransformNone
-        }), preparseOutput: true }, props));
-}
-
-var camelCaseAttributes = /*#__PURE__*/new Set(['baseFrequency', 'diffuseConstant', 'kernelMatrix', 'kernelUnitLength', 'keySplines', 'keyTimes', 'limitingConeAngle', 'markerHeight', 'markerWidth', 'numOctaves', 'targetX', 'targetY', 'surfaceScale', 'specularConstant', 'specularExponent', 'stdDeviation', 'tableValues']);
-
-var defaultOrigin = 0.5;
-var svgAttrsTemplate = function () {
-    return {
-        style: {}
-    };
-};
-var progressToPixels = function (progress, length) {
-    return px.transform(progress * length);
-};
-var unmeasured = { x: 0, y: 0, width: 0, height: 0 };
-function calcOrigin(origin, offset, size) {
-    return typeof origin === 'string' ? origin : px.transform(offset + size * origin);
-}
-function calculateSVGTransformOrigin(dimensions, originX, originY) {
-    return calcOrigin(originX, dimensions.x, dimensions.width) + " " + calcOrigin(originY, dimensions.y, dimensions.height);
-}
-var svgStyleConfig = {
-    enableHardwareAcceleration: false,
-    isDashCase: false
-};
-function buildSVGAttrs(_a, dimensions, totalPathLength, cssBuilder, attrs, isDashCase) {
-    if (dimensions === void 0) {
-        dimensions = unmeasured;
-    }
-    if (cssBuilder === void 0) {
-        cssBuilder = createStyleBuilder(svgStyleConfig);
-    }
-    if (attrs === void 0) {
-        attrs = svgAttrsTemplate();
-    }
-    if (isDashCase === void 0) {
-        isDashCase = true;
-    }
-    var attrX = _a.attrX,
-        attrY = _a.attrY,
-        originX = _a.originX,
-        originY = _a.originY,
-        pathLength = _a.pathLength,
-        _b = _a.pathSpacing,
-        pathSpacing = _b === void 0 ? 1 : _b,
-        _c = _a.pathOffset,
-        pathOffset = _c === void 0 ? 0 : _c,
-        state = __rest(_a, ["attrX", "attrY", "originX", "originY", "pathLength", "pathSpacing", "pathOffset"]);
-    var style = cssBuilder(state);
-    for (var key in style) {
-        if (key === 'transform') {
-            attrs.style.transform = style[key];
-        } else {
-            var attrKey = isDashCase && !camelCaseAttributes.has(key) ? camelToDash(key) : key;
-            attrs[attrKey] = style[key];
-        }
-    }
-    if (originX !== undefined || originY !== undefined || style.transform) {
-        attrs.style.transformOrigin = calculateSVGTransformOrigin(dimensions, originX !== undefined ? originX : defaultOrigin, originY !== undefined ? originY : defaultOrigin);
-    }
-    if (attrX !== undefined) attrs.x = attrX;
-    if (attrY !== undefined) attrs.y = attrY;
-    if (totalPathLength !== undefined && pathLength !== undefined) {
-        attrs[isDashCase ? 'stroke-dashoffset' : 'strokeDashoffset'] = progressToPixels(-pathOffset, totalPathLength);
-        attrs[isDashCase ? 'stroke-dasharray' : 'strokeDasharray'] = progressToPixels(pathLength, totalPathLength) + " " + progressToPixels(pathSpacing, totalPathLength);
-    }
-    return attrs;
-}
-function createAttrBuilder(dimensions, totalPathLength, isDashCase) {
-    if (isDashCase === void 0) {
-        isDashCase = true;
-    }
-    var attrs = svgAttrsTemplate();
-    var cssBuilder = createStyleBuilder(svgStyleConfig);
-    return function (state) {
-        return buildSVGAttrs(state, dimensions, totalPathLength, cssBuilder, attrs, isDashCase);
-    };
-}
-
-var getDimensions = function (element) {
-    return typeof element.getBBox === 'function' ? element.getBBox() : element.getBoundingClientRect();
-};
-var getSVGElementDimensions = function (element) {
-    try {
-        return getDimensions(element);
-    } catch (e) {
-        return { x: 0, y: 0, width: 0, height: 0 };
-    }
-};
-
-var isPath = function (element) {
-    return element.tagName === 'path';
-};
-var svgStyler = /*#__PURE__*/createStyler({
-    onRead: function (key, _a) {
-        var element = _a.element;
-        key = !camelCaseAttributes.has(key) ? camelToDash(key) : key;
-        if (!isTransformProp(key)) {
-            return element.getAttribute(key);
-        } else {
-            var valueType = getValueType(key);
-            return valueType ? valueType.default || 0 : 0;
-        }
-    },
-    onRender: function (state, _a) {
-        var element = _a.element,
-            buildAttrs = _a.buildAttrs;
-        var attrs = buildAttrs(state);
-        for (var key in attrs) {
-            if (key === 'style') {
-                Object.assign(element.style, attrs.style);
-            } else {
-                element.setAttribute(key, attrs[key]);
-            }
-        }
-    }
-});
-var svg = function (element) {
-    var dimensions = getSVGElementDimensions(element);
-    var pathLength = isPath(element) && element.getTotalLength ? element.getTotalLength() : undefined;
-    return svgStyler({
-        element: element,
-        buildAttrs: createAttrBuilder(dimensions, pathLength)
-    });
-};
-
-var viewport = /*#__PURE__*/createStyler({
-    useCache: false,
-    onRead: function (key) {
-        return key === 'scrollTop' ? window.pageYOffset : window.pageXOffset;
-    },
-    onRender: function (_a) {
-        var _b = _a.scrollTop,
-            scrollTop = _b === void 0 ? 0 : _b,
-            _c = _a.scrollLeft,
-            scrollLeft = _c === void 0 ? 0 : _c;
-        return window.scrollTo(scrollLeft, scrollTop);
-    }
-});
-
-var cache = /*#__PURE__*/new WeakMap();
-var isHTMLElement = function (node) {
-    return node instanceof HTMLElement || typeof node.click === 'function';
-};
-var isSVGElement = function (node) {
-    return node instanceof SVGElement || 'ownerSVGElement' in node;
-};
-var createDOMStyler = function (node, props) {
-    var styler;
-    if (node === window) {
-        styler = viewport(node);
-    } else if (isHTMLElement(node)) {
-        styler = createCssStyler(node, props);
-    } else if (isSVGElement(node)) {
-        styler = svg(node);
-    }
-    cache.set(node, styler);
-    return styler;
-};
-var getStyler = function (node, props) {
-    return cache.has(node) ? cache.get(node) : createDOMStyler(node, props);
-};
-function index(nodeOrSelector, props) {
-    var node = typeof nodeOrSelector === 'string' ? document.querySelector(nodeOrSelector) : nodeOrSelector;
-    return getStyler(node, props);
-}
-
-export { animate as a, index as i };
+export { __assign as _, animate as a, __rest as b, color as c, degrees as d, alpha as e, progressPercentage as f, easeOut as g, linear as l, number as n, px as p, scale as s };
 
-//# sourceMappingURL=p-09cdd71f.js.map
+//# sourceMappingURL=p-42ea6b74.js.map