{"version":3,"file":"8458-894a283cb597216df503.js","mappings":"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","sources":["webpack://ess-mep/./node_modules/react-range/lib/Range.js","webpack://ess-mep/./node_modules/react-range/lib/index.js","webpack://ess-mep/./node_modules/react-range/lib/types.js","webpack://ess-mep/./node_modules/react-range/lib/utils.js","webpack://ess-mep/./node_modules/react-spinners/esm/helpers/unitConverter.js","webpack://ess-mep/./node_modules/react-spinners/esm/helpers/animation.js","webpack://ess-mep/./node_modules/react-spinners/esm/PuffLoader.js","webpack://ess-mep/./node_modules/react-use/esm/useFirstMountState.js"],"sourcesContent":["\"use strict\";\nvar __extends = (this && this.__extends) || (function () {\n    var extendStatics = function (d, b) {\n        extendStatics = Object.setPrototypeOf ||\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        if (typeof b !== \"function\" && b !== null)\n            throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\n}) : function(o, v) {\n    o[\"default\"] = v;\n});\nvar __importStar = (this && this.__importStar) || function (mod) {\n    if (mod && mod.__esModule) return mod;\n    var result = {};\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\n    __setModuleDefault(result, mod);\n    return result;\n};\nvar __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {\n    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\n        if (ar || !(i in from)) {\n            if (!ar) ar = Array.prototype.slice.call(from, 0, i);\n            ar[i] = from[i];\n        }\n    }\n    return to.concat(ar || Array.prototype.slice.call(from));\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar React = __importStar(require(\"react\"));\nvar utils_1 = require(\"./utils\");\nvar types_1 = require(\"./types\");\nvar INCREASE_KEYS = [\"ArrowRight\", \"ArrowUp\", \"k\", \"PageUp\"];\nvar DECREASE_KEYS = [\"ArrowLeft\", \"ArrowDown\", \"j\", \"PageDown\"];\nvar Range = /** @class */ (function (_super) {\n    __extends(Range, _super);\n    function Range(props) {\n        var _this = _super.call(this, props) || this;\n        _this.trackRef = React.createRef();\n        _this.thumbRefs = [];\n        _this.state = {\n            draggedTrackPos: [-1, -1],\n            draggedThumbIndex: -1,\n            thumbZIndexes: new Array(_this.props.values.length).fill(0).map(function (t, i) { return i; }),\n            isChanged: false,\n            markOffsets: [],\n        };\n        _this.getOffsets = function () {\n            var _a = _this.props, direction = _a.direction, values = _a.values, min = _a.min, max = _a.max;\n            var trackElement = _this.trackRef.current;\n            if (!trackElement) {\n                console.warn(\"No track element found.\");\n                return [];\n            }\n            var trackRect = trackElement.getBoundingClientRect();\n            var trackPadding = (0, utils_1.getPaddingAndBorder)(trackElement);\n            return _this.getThumbs().map(function (thumb, index) {\n                var thumbOffsets = { x: 0, y: 0 };\n                var thumbRect = thumb.getBoundingClientRect();\n                var thumbMargins = (0, utils_1.getMargin)(thumb);\n                switch (direction) {\n                    case types_1.Direction.Right:\n                        thumbOffsets.x = (thumbMargins.left + trackPadding.left) * -1;\n                        thumbOffsets.y =\n                            ((thumbRect.height - trackRect.height) / 2 + trackPadding.top) * -1;\n                        thumbOffsets.x +=\n                            trackRect.width * (0, utils_1.relativeValue)(values[index], min, max) -\n                                thumbRect.width / 2;\n                        return thumbOffsets;\n                    case types_1.Direction.Left:\n                        thumbOffsets.x = (thumbMargins.right + trackPadding.right) * -1;\n                        thumbOffsets.y =\n                            ((thumbRect.height - trackRect.height) / 2 + trackPadding.top) * -1;\n                        thumbOffsets.x +=\n                            trackRect.width -\n                                trackRect.width * (0, utils_1.relativeValue)(values[index], min, max) -\n                                thumbRect.width / 2;\n                        return thumbOffsets;\n                    case types_1.Direction.Up:\n                        thumbOffsets.x =\n                            ((thumbRect.width - trackRect.width) / 2 +\n                                thumbMargins.left +\n                                trackPadding.left) *\n                                -1;\n                        thumbOffsets.y = -trackPadding.left;\n                        thumbOffsets.y +=\n                            trackRect.height -\n                                trackRect.height * (0, utils_1.relativeValue)(values[index], min, max) -\n                                thumbRect.height / 2;\n                        return thumbOffsets;\n                    case types_1.Direction.Down:\n                        thumbOffsets.x =\n                            ((thumbRect.width - trackRect.width) / 2 +\n                                thumbMargins.left +\n                                trackPadding.left) *\n                                -1;\n                        thumbOffsets.y = -trackPadding.left;\n                        thumbOffsets.y +=\n                            trackRect.height * (0, utils_1.relativeValue)(values[index], min, max) -\n                                thumbRect.height / 2;\n                        return thumbOffsets;\n                    default:\n                        return (0, utils_1.assertUnreachable)(direction);\n                }\n            });\n        };\n        _this.getThumbs = function () {\n            if (_this.trackRef && _this.trackRef.current) {\n                return Array.from(_this.trackRef.current.children).filter(function (el) {\n                    return el.hasAttribute(\"aria-valuenow\");\n                });\n            }\n            console.warn(\"No thumbs found in the track container. Did you forget to pass & spread the `props` param in renderTrack?\");\n            return [];\n        };\n        _this.getTargetIndex = function (e) {\n            return _this.getThumbs().findIndex(function (child) { return child === e.target || child.contains(e.target); });\n        };\n        _this.addTouchEvents = function (e) {\n            document.addEventListener(\"touchmove\", _this.schdOnTouchMove, {\n                passive: false,\n            });\n            document.addEventListener(\"touchend\", _this.schdOnEnd, {\n                passive: false,\n            });\n            document.addEventListener(\"touchcancel\", _this.schdOnEnd, {\n                passive: false,\n            });\n        };\n        _this.addMouseEvents = function (e) {\n            document.addEventListener(\"mousemove\", _this.schdOnMouseMove);\n            document.addEventListener(\"mouseup\", _this.schdOnEnd);\n        };\n        _this.onMouseDownTrack = function (e) {\n            var _a;\n            if (e.button !== 0 || (0, utils_1.isIOS)())\n                return;\n            e.persist();\n            e.preventDefault();\n            _this.addMouseEvents(e.nativeEvent);\n            if (_this.props.values.length > 1 && _this.props.draggableTrack) {\n                if (_this.thumbRefs.some(function (thumbRef) { var _a; return (_a = thumbRef.current) === null || _a === void 0 ? void 0 : _a.contains(e.target); }))\n                    return;\n                // handle dragging the whole track\n                _this.setState({\n                    draggedTrackPos: [e.clientX, e.clientY],\n                }, function () { return _this.onMove(e.clientX, e.clientY); });\n            }\n            else {\n                // get the index of the thumb that is closest to the place where the track is clicked\n                var draggedThumbIndex = (0, utils_1.getClosestThumbIndex)(_this.thumbRefs.map(function (t) { return t.current; }), e.clientX, e.clientY, _this.props.direction);\n                // move the thumb which is closest to the place where the track is clicked\n                (_a = _this.thumbRefs[draggedThumbIndex].current) === null || _a === void 0 ? void 0 : _a.focus();\n                _this.setState({\n                    draggedThumbIndex: draggedThumbIndex,\n                }, function () { return _this.onMove(e.clientX, e.clientY); });\n            }\n        };\n        _this.onResize = function () {\n            (0, utils_1.translateThumbs)(_this.getThumbs(), _this.getOffsets(), _this.props.rtl);\n            _this.calculateMarkOffsets();\n        };\n        _this.onTouchStartTrack = function (e) {\n            var _a;\n            e.persist();\n            _this.addTouchEvents(e.nativeEvent);\n            if (_this.props.values.length > 1 && _this.props.draggableTrack) {\n                if (_this.thumbRefs.some(function (thumbRef) { var _a; return (_a = thumbRef.current) === null || _a === void 0 ? void 0 : _a.contains(e.target); }))\n                    return;\n                // handle dragging the whole track\n                _this.setState({\n                    draggedTrackPos: [e.touches[0].clientX, e.touches[0].clientY],\n                }, function () { return _this.onMove(e.touches[0].clientX, e.touches[0].clientY); });\n            }\n            else {\n                // get the index of the thumb that is closest to the place where the track is clicked\n                var draggedThumbIndex = (0, utils_1.getClosestThumbIndex)(_this.thumbRefs.map(function (t) { return t.current; }), e.touches[0].clientX, e.touches[0].clientY, _this.props.direction);\n                // move the thumb which is closest to the place where the track is clicked\n                (_a = _this.thumbRefs[draggedThumbIndex].current) === null || _a === void 0 ? void 0 : _a.focus();\n                _this.setState({\n                    draggedThumbIndex: draggedThumbIndex,\n                }, function () { return _this.onMove(e.touches[0].clientX, e.touches[0].clientY); });\n            }\n        };\n        _this.onMouseOrTouchStart = function (e) {\n            if (_this.props.disabled)\n                return;\n            var isTouch = (0, utils_1.isTouchEvent)(e);\n            if (!isTouch && e.button !== 0)\n                return;\n            var index = _this.getTargetIndex(e);\n            if (index === -1)\n                return;\n            if (isTouch) {\n                _this.addTouchEvents(e);\n            }\n            else {\n                _this.addMouseEvents(e);\n            }\n            _this.setState({\n                draggedThumbIndex: index,\n                thumbZIndexes: _this.state.thumbZIndexes.map(function (t, i) {\n                    if (i === index) {\n                        return Math.max.apply(Math, _this.state.thumbZIndexes);\n                    }\n                    return t <= _this.state.thumbZIndexes[index] ? t : t - 1;\n                }),\n            });\n        };\n        _this.onMouseMove = function (e) {\n            e.preventDefault();\n            _this.onMove(e.clientX, e.clientY);\n        };\n        _this.onTouchMove = function (e) {\n            e.preventDefault();\n            _this.onMove(e.touches[0].clientX, e.touches[0].clientY);\n        };\n        _this.onKeyDown = function (e) {\n            var _a = _this.props, values = _a.values, onChange = _a.onChange, step = _a.step, rtl = _a.rtl, direction = _a.direction;\n            var isChanged = _this.state.isChanged;\n            var index = _this.getTargetIndex(e.nativeEvent);\n            var inverter = rtl || direction === types_1.Direction.Left || direction === types_1.Direction.Down\n                ? -1\n                : 1;\n            if (index === -1)\n                return;\n            if (INCREASE_KEYS.includes(e.key)) {\n                e.preventDefault();\n                _this.setState({\n                    draggedThumbIndex: index,\n                    isChanged: true,\n                });\n                onChange((0, utils_1.replaceAt)(values, index, _this.normalizeValue(values[index] + inverter * (e.key === \"PageUp\" ? step * 10 : step), index)));\n            }\n            else if (DECREASE_KEYS.includes(e.key)) {\n                e.preventDefault();\n                _this.setState({\n                    draggedThumbIndex: index,\n                    isChanged: true,\n                });\n                onChange((0, utils_1.replaceAt)(values, index, _this.normalizeValue(values[index] -\n                    inverter * (e.key === \"PageDown\" ? step * 10 : step), index)));\n            }\n            else if (e.key === \"Tab\") {\n                _this.setState({ draggedThumbIndex: -1 }, function () {\n                    // If key pressed when thumb was moving, fire onFinalChange\n                    if (isChanged) {\n                        _this.fireOnFinalChange();\n                    }\n                });\n            }\n            else {\n                if (isChanged) {\n                    _this.fireOnFinalChange();\n                }\n            }\n        };\n        _this.onKeyUp = function (e) {\n            var isChanged = _this.state.isChanged;\n            _this.setState({\n                draggedThumbIndex: -1,\n            }, function () {\n                if (isChanged) {\n                    _this.fireOnFinalChange();\n                }\n            });\n        };\n        _this.onMove = function (clientX, clientY) {\n            var _a = _this.state, draggedThumbIndex = _a.draggedThumbIndex, draggedTrackPos = _a.draggedTrackPos;\n            var _b = _this.props, direction = _b.direction, min = _b.min, max = _b.max, onChange = _b.onChange, values = _b.values, step = _b.step, rtl = _b.rtl;\n            if (draggedThumbIndex === -1 &&\n                draggedTrackPos[0] === -1 &&\n                draggedTrackPos[1] === -1)\n                return null;\n            var trackElement = _this.trackRef.current;\n            // If component was closed down prematurely, A last onMove could be triggered based on requestAnimationFrame()\n            if (!trackElement)\n                return null;\n            var trackRect = trackElement.getBoundingClientRect();\n            var trackLength = (0, utils_1.isVertical)(direction)\n                ? trackRect.height\n                : trackRect.width;\n            if (draggedTrackPos[0] !== -1 && draggedTrackPos[1] !== -1) {\n                // calculate how much it moved since the last update\n                var dX = clientX - draggedTrackPos[0];\n                var dY = clientY - draggedTrackPos[1];\n                // calculate the delta of the value\n                var deltaValue = 0;\n                switch (direction) {\n                    case types_1.Direction.Right:\n                    case types_1.Direction.Left:\n                        deltaValue = (dX / trackLength) * (max - min);\n                        break;\n                    case types_1.Direction.Down:\n                    case types_1.Direction.Up:\n                        deltaValue = (dY / trackLength) * (max - min);\n                        break;\n                    default:\n                        (0, utils_1.assertUnreachable)(direction);\n                }\n                // invert for RTL\n                if (rtl) {\n                    deltaValue *= -1;\n                }\n                if (Math.abs(deltaValue) >= step / 2) {\n                    // adjust delta so it fits into the range\n                    for (var i = 0; i < _this.thumbRefs.length; i++) {\n                        if ((values[i] === max && Math.sign(deltaValue) === 1) ||\n                            (values[i] === min && Math.sign(deltaValue) === -1))\n                            return;\n                        var thumbValue = values[i] + deltaValue;\n                        if (thumbValue > max)\n                            deltaValue = max - values[i];\n                        else if (thumbValue < min)\n                            deltaValue = min - values[i];\n                    }\n                    // add the delta to each thumb\n                    var newValues = values.slice(0);\n                    for (var i = 0; i < _this.thumbRefs.length; i++) {\n                        newValues = (0, utils_1.replaceAt)(newValues, i, _this.normalizeValue(values[i] + deltaValue, i));\n                    }\n                    _this.setState({\n                        draggedTrackPos: [clientX, clientY],\n                    });\n                    onChange(newValues);\n                }\n            }\n            else {\n                var newValue = 0;\n                switch (direction) {\n                    case types_1.Direction.Right:\n                        newValue =\n                            ((clientX - trackRect.left) / trackLength) * (max - min) + min;\n                        break;\n                    case types_1.Direction.Left:\n                        newValue =\n                            ((trackLength - (clientX - trackRect.left)) / trackLength) *\n                                (max - min) +\n                                min;\n                        break;\n                    case types_1.Direction.Down:\n                        newValue =\n                            ((clientY - trackRect.top) / trackLength) * (max - min) + min;\n                        break;\n                    case types_1.Direction.Up:\n                        newValue =\n                            ((trackLength - (clientY - trackRect.top)) / trackLength) *\n                                (max - min) +\n                                min;\n                        break;\n                    default:\n                        (0, utils_1.assertUnreachable)(direction);\n                }\n                // invert for RTL\n                if (rtl) {\n                    newValue = max + min - newValue;\n                }\n                if (Math.abs(values[draggedThumbIndex] - newValue) >= step / 2) {\n                    onChange((0, utils_1.replaceAt)(values, draggedThumbIndex, _this.normalizeValue(newValue, draggedThumbIndex)));\n                }\n            }\n        };\n        _this.normalizeValue = function (value, index) {\n            var _a = _this.props, min = _a.min, max = _a.max, step = _a.step, allowOverlap = _a.allowOverlap, values = _a.values;\n            return (0, utils_1.normalizeValue)(value, index, min, max, step, allowOverlap, values);\n        };\n        _this.onEnd = function (e) {\n            e.preventDefault();\n            document.removeEventListener(\"mousemove\", _this.schdOnMouseMove);\n            document.removeEventListener(\"touchmove\", _this.schdOnTouchMove);\n            document.removeEventListener(\"mouseup\", _this.schdOnEnd);\n            document.removeEventListener(\"touchend\", _this.schdOnEnd);\n            document.removeEventListener(\"touchcancel\", _this.schdOnEnd);\n            if (_this.state.draggedThumbIndex === -1 &&\n                _this.state.draggedTrackPos[0] === -1 &&\n                _this.state.draggedTrackPos[1] === -1)\n                return null;\n            _this.setState({ draggedThumbIndex: -1, draggedTrackPos: [-1, -1] }, function () {\n                _this.fireOnFinalChange();\n            });\n        };\n        _this.fireOnFinalChange = function () {\n            _this.setState({ isChanged: false });\n            var _a = _this.props, onFinalChange = _a.onFinalChange, values = _a.values;\n            if (onFinalChange) {\n                onFinalChange(values);\n            }\n        };\n        _this.updateMarkRefs = function (props) {\n            if (!props.renderMark) {\n                // don't create mark refs unless we are rendering marks\n                _this.numOfMarks = undefined;\n                _this.markRefs = undefined;\n                return;\n            }\n            _this.numOfMarks = (props.max - props.min) / _this.props.step;\n            _this.markRefs = [];\n            for (var i = 0; i < _this.numOfMarks + 1; i++) {\n                _this.markRefs[i] = React.createRef();\n            }\n        };\n        _this.calculateMarkOffsets = function () {\n            if (!_this.props.renderMark ||\n                !_this.trackRef ||\n                !_this.numOfMarks ||\n                !_this.markRefs ||\n                _this.trackRef.current === null)\n                return;\n            var elStyles = window.getComputedStyle(_this.trackRef.current);\n            var trackWidth = parseInt(elStyles.width, 10);\n            var trackHeight = parseInt(elStyles.height, 10);\n            var paddingLeft = parseInt(elStyles.paddingLeft, 10);\n            var paddingTop = parseInt(elStyles.paddingTop, 10);\n            var res = [];\n            for (var i = 0; i < _this.numOfMarks + 1; i++) {\n                var markHeight = 9999;\n                var markWidth = 9999;\n                if (_this.markRefs[i].current) {\n                    var markRect = _this.markRefs[i].current.getBoundingClientRect();\n                    markHeight = markRect.height;\n                    markWidth = markRect.width;\n                }\n                if (_this.props.direction === types_1.Direction.Left ||\n                    _this.props.direction === types_1.Direction.Right) {\n                    res.push([\n                        Math.round((trackWidth / _this.numOfMarks) * i + paddingLeft - markWidth / 2),\n                        -Math.round((markHeight - trackHeight) / 2),\n                    ]);\n                }\n                else {\n                    res.push([\n                        Math.round((trackHeight / _this.numOfMarks) * i + paddingTop - markHeight / 2),\n                        -Math.round((markWidth - trackWidth) / 2),\n                    ]);\n                }\n            }\n            _this.setState({ markOffsets: res });\n        };\n        if (props.step === 0) {\n            throw new Error('\"step\" property should be a positive number');\n        }\n        _this.schdOnMouseMove = (0, utils_1.schd)(_this.onMouseMove);\n        _this.schdOnTouchMove = (0, utils_1.schd)(_this.onTouchMove);\n        _this.schdOnEnd = (0, utils_1.schd)(_this.onEnd);\n        _this.thumbRefs = props.values.map(function () { return React.createRef(); });\n        _this.updateMarkRefs(props);\n        return _this;\n    }\n    Range.prototype.componentDidMount = function () {\n        var _this = this;\n        var _a = this.props, values = _a.values, min = _a.min, step = _a.step;\n        this.resizeObserver = window.ResizeObserver\n            ? new window.ResizeObserver(this.onResize)\n            : {\n                observe: function () { return window.addEventListener(\"resize\", _this.onResize); },\n                unobserve: function () { return window.removeEventListener(\"resize\", _this.onResize); },\n            };\n        document.addEventListener(\"touchstart\", this.onMouseOrTouchStart, {\n            passive: false,\n        });\n        document.addEventListener(\"mousedown\", this.onMouseOrTouchStart, {\n            passive: false,\n        });\n        !this.props.allowOverlap && (0, utils_1.checkInitialOverlap)(this.props.values);\n        this.props.values.forEach(function (value) {\n            return (0, utils_1.checkBoundaries)(value, _this.props.min, _this.props.max);\n        });\n        this.resizeObserver.observe(this.trackRef.current);\n        (0, utils_1.translateThumbs)(this.getThumbs(), this.getOffsets(), this.props.rtl);\n        this.calculateMarkOffsets();\n        values.forEach(function (value) {\n            if (!(0, utils_1.isStepDivisible)(min, value, step)) {\n                console.warn(\"The `values` property is in conflict with the current `step`, `min`, and `max` properties. Please provide values that are accessible using the min, max, and step values.\");\n            }\n        });\n    };\n    Range.prototype.componentDidUpdate = function (prevProps, prevState) {\n        var _a = this.props, max = _a.max, min = _a.min, step = _a.step, values = _a.values, rtl = _a.rtl;\n        if (prevProps.max !== max ||\n            prevProps.min !== min ||\n            prevProps.step !== step) {\n            this.updateMarkRefs(this.props);\n        }\n        (0, utils_1.translateThumbs)(this.getThumbs(), this.getOffsets(), rtl);\n        // ensure offsets are calculated when the refs for the marks have been created\n        // and those refs have been mounted to the dom\n        // on the state update in calculateOffsets with new markOffsets are calculated\n        if (prevProps.max !== max ||\n            prevProps.min !== min ||\n            prevProps.step !== step ||\n            prevState.markOffsets.length !== this.state.markOffsets.length) {\n            this.calculateMarkOffsets();\n            values.forEach(function (value) {\n                if (!(0, utils_1.isStepDivisible)(min, value, step)) {\n                    console.warn(\"The `values` property is in conflict with the current `step`, `min`, and `max` properties. Please provide values that are accessible using the min, max, and step values.\");\n                }\n            });\n        }\n    };\n    Range.prototype.componentWillUnmount = function () {\n        var options = {\n            passive: false,\n        };\n        document.removeEventListener(\"mousedown\", this.onMouseOrTouchStart, options);\n        // These need to be removed!!\n        document.removeEventListener(\"mousemove\", this.schdOnMouseMove);\n        document.removeEventListener(\"touchmove\", this.schdOnTouchMove);\n        document.removeEventListener(\"touchstart\", this.onMouseOrTouchStart);\n        document.removeEventListener(\"mouseup\", this.schdOnEnd);\n        document.removeEventListener(\"touchend\", this.schdOnEnd);\n        this.resizeObserver.unobserve(this.trackRef.current);\n    };\n    Range.prototype.render = function () {\n        var _this = this;\n        var _a = this.props, label = _a.label, labelledBy = _a.labelledBy, renderTrack = _a.renderTrack, renderThumb = _a.renderThumb, _b = _a.renderMark, renderMark = _b === void 0 ? function () { return null; } : _b, values = _a.values, min = _a.min, max = _a.max, allowOverlap = _a.allowOverlap, disabled = _a.disabled;\n        var _c = this.state, draggedThumbIndex = _c.draggedThumbIndex, thumbZIndexes = _c.thumbZIndexes, markOffsets = _c.markOffsets;\n        return renderTrack({\n            props: {\n                style: {\n                    // creates stacking context that prevents z-index applied to thumbs\n                    // interfere with other elements\n                    transform: \"scale(1)\",\n                    cursor: draggedThumbIndex > -1\n                        ? \"grabbing\"\n                        : this.props.draggableTrack\n                            ? (0, utils_1.isVertical)(this.props.direction)\n                                ? \"ns-resize\"\n                                : \"ew-resize\"\n                            : values.length === 1 && !disabled\n                                ? \"pointer\"\n                                : \"inherit\",\n                },\n                onMouseDown: disabled ? utils_1.voidFn : this.onMouseDownTrack,\n                onTouchStart: disabled ? utils_1.voidFn : this.onTouchStartTrack,\n                ref: this.trackRef,\n            },\n            isDragged: this.state.draggedThumbIndex > -1,\n            disabled: disabled,\n            children: __spreadArray(__spreadArray([], markOffsets.map(function (offset, index, arr) {\n                return renderMark({\n                    props: {\n                        style: _this.props.direction === types_1.Direction.Left ||\n                            _this.props.direction === types_1.Direction.Right\n                            ? {\n                                position: \"absolute\",\n                                left: \"\".concat(offset[0], \"px\"),\n                                marginTop: \"\".concat(offset[1], \"px\"),\n                            }\n                            : {\n                                position: \"absolute\",\n                                top: \"\".concat(offset[0], \"px\"),\n                                marginLeft: \"\".concat(offset[1], \"px\"),\n                            },\n                        key: \"mark\".concat(index),\n                        ref: _this.markRefs[index],\n                    },\n                    index: index,\n                });\n            }), true), values.map(function (value, index) {\n                var isDragged = _this.state.draggedThumbIndex === index;\n                return renderThumb({\n                    index: index,\n                    value: value,\n                    isDragged: isDragged,\n                    props: {\n                        style: {\n                            position: \"absolute\",\n                            zIndex: thumbZIndexes[index],\n                            cursor: disabled ? \"inherit\" : isDragged ? \"grabbing\" : \"grab\",\n                            userSelect: \"none\",\n                            touchAction: \"none\",\n                            WebkitUserSelect: \"none\",\n                            MozUserSelect: \"none\",\n                            msUserSelect: \"none\",\n                        },\n                        key: index,\n                        tabIndex: disabled ? undefined : 0,\n                        \"aria-valuemax\": allowOverlap ? max : values[index + 1] || max,\n                        \"aria-valuemin\": allowOverlap ? min : values[index - 1] || min,\n                        \"aria-valuenow\": value,\n                        draggable: false,\n                        ref: _this.thumbRefs[index],\n                        \"aria-label\": label,\n                        \"aria-labelledby\": labelledBy,\n                        role: \"slider\",\n                        onKeyDown: disabled ? utils_1.voidFn : _this.onKeyDown,\n                        onKeyUp: disabled ? utils_1.voidFn : _this.onKeyUp,\n                    },\n                });\n            }), true),\n        });\n    };\n    Range.defaultProps = {\n        label: \"Accessibility label\",\n        labelledBy: null,\n        step: 1,\n        direction: types_1.Direction.Right,\n        rtl: false,\n        disabled: false,\n        allowOverlap: false,\n        draggableTrack: false,\n        min: 0,\n        max: 100,\n    };\n    return Range;\n}(React.Component));\nexports.default = Range;\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.checkValuesAgainstBoundaries = exports.relativeValue = exports.useThumbOverlap = exports.Direction = exports.getTrackBackground = exports.Range = void 0;\nvar Range_1 = __importDefault(require(\"./Range\"));\nexports.Range = Range_1.default;\nvar utils_1 = require(\"./utils\");\nObject.defineProperty(exports, \"getTrackBackground\", { enumerable: true, get: function () { return utils_1.getTrackBackground; } });\nObject.defineProperty(exports, \"useThumbOverlap\", { enumerable: true, get: function () { return utils_1.useThumbOverlap; } });\nObject.defineProperty(exports, \"relativeValue\", { enumerable: true, get: function () { return utils_1.relativeValue; } });\nObject.defineProperty(exports, \"checkValuesAgainstBoundaries\", { enumerable: true, get: function () { return utils_1.checkValuesAgainstBoundaries; } });\nvar types_1 = require(\"./types\");\nObject.defineProperty(exports, \"Direction\", { enumerable: true, get: function () { return types_1.Direction; } });\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.Direction = void 0;\nvar Direction;\n(function (Direction) {\n    Direction[\"Right\"] = \"to right\";\n    Direction[\"Left\"] = \"to left\";\n    Direction[\"Down\"] = \"to bottom\";\n    Direction[\"Up\"] = \"to top\";\n})(Direction || (exports.Direction = Direction = {}));\n","\"use strict\";\nvar __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {\n    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\n        if (ar || !(i in from)) {\n            if (!ar) ar = Array.prototype.slice.call(from, 0, i);\n            ar[i] = from[i];\n        }\n    }\n    return to.concat(ar || Array.prototype.slice.call(from));\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.isIOS = exports.useThumbOverlap = exports.assertUnreachable = exports.voidFn = exports.getTrackBackground = exports.replaceAt = exports.schd = exports.translate = exports.getClosestThumbIndex = exports.translateThumbs = exports.getPaddingAndBorder = exports.getMargin = exports.checkInitialOverlap = exports.checkValuesAgainstBoundaries = exports.checkBoundaries = exports.isVertical = exports.relativeValue = exports.normalizeValue = exports.isStepDivisible = exports.isTouchEvent = exports.getStepDecimals = void 0;\nvar react_1 = require(\"react\");\nvar types_1 = require(\"./types\");\nvar getStepDecimals = function (step) {\n    var decimals = step.toString().split(\".\")[1];\n    return decimals ? decimals.length : 0;\n};\nexports.getStepDecimals = getStepDecimals;\nfunction isTouchEvent(event) {\n    return ((event.touches && event.touches.length) ||\n        (event.changedTouches && event.changedTouches.length));\n}\nexports.isTouchEvent = isTouchEvent;\nfunction isStepDivisible(min, max, step) {\n    var res = (max - min) / step;\n    var precision = 8;\n    var roundedRes = Number(res.toFixed(precision));\n    return parseInt(roundedRes.toString(), 10) === roundedRes;\n}\nexports.isStepDivisible = isStepDivisible;\nfunction normalizeValue(value, index, min, max, step, allowOverlap, values) {\n    var BIG_NUM = 10e10;\n    value = Math.round(value * BIG_NUM) / BIG_NUM;\n    if (!allowOverlap) {\n        var prev = values[index - 1];\n        var next = values[index + 1];\n        if (prev && prev > value)\n            return prev;\n        if (next && next < value)\n            return next;\n    }\n    if (value > max)\n        return max;\n    if (value < min)\n        return min;\n    // `remainder` is a difference between the given value and a full step value\n    // that is closest lower to the given value and is in the range between the min value\n    // and the given value\n    var remainder = Math.floor(value * BIG_NUM - min * BIG_NUM) % Math.floor(step * BIG_NUM);\n    var closestLowerNum = Math.floor(value * BIG_NUM - Math.abs(remainder));\n    var rounded = remainder === 0 ? value : closestLowerNum / BIG_NUM;\n    // Values with a remainder `< step/2` are rounded to the closest lower value\n    // while values with a remainder `= > step/2` are rounded to the closest bigger value\n    var res = Math.abs(remainder / BIG_NUM) < step / 2 ? rounded : rounded + step;\n    var decimalPlaces = (0, exports.getStepDecimals)(step);\n    return parseFloat(res.toFixed(decimalPlaces));\n}\nexports.normalizeValue = normalizeValue;\nfunction relativeValue(value, min, max) {\n    return (value - min) / (max - min);\n}\nexports.relativeValue = relativeValue;\nfunction isVertical(direction) {\n    return direction === types_1.Direction.Up || direction === types_1.Direction.Down;\n}\nexports.isVertical = isVertical;\nfunction checkBoundaries(value, min, max) {\n    if (min >= max) {\n        throw new RangeError(\"min (\".concat(min, \") is equal/bigger than max (\").concat(max, \")\"));\n    }\n    if (value < min) {\n        throw new RangeError(\"value (\".concat(value, \") is smaller than min (\").concat(min, \")\"));\n    }\n    if (value > max) {\n        throw new RangeError(\"value (\".concat(value, \") is bigger than max (\").concat(max, \")\"));\n    }\n}\nexports.checkBoundaries = checkBoundaries;\nfunction checkValuesAgainstBoundaries(value, min, max) {\n    if (value < min) {\n        // set selectedValue to min\n        return min;\n    }\n    if (value > max) {\n        // set selectedValue to max\n        return max;\n    }\n    else {\n        return value;\n    }\n}\nexports.checkValuesAgainstBoundaries = checkValuesAgainstBoundaries;\nfunction checkInitialOverlap(values) {\n    if (values.length < 2)\n        return;\n    if (!values.slice(1).every(function (item, i) { return values[i] <= item; })) {\n        throw new RangeError(\"values={[\".concat(values, \"]} needs to be sorted when allowOverlap={false}\"));\n    }\n}\nexports.checkInitialOverlap = checkInitialOverlap;\nfunction getMargin(element) {\n    var style = window.getComputedStyle(element);\n    return {\n        top: parseInt(style[\"margin-top\"], 10),\n        bottom: parseInt(style[\"margin-bottom\"], 10),\n        left: parseInt(style[\"margin-left\"], 10),\n        right: parseInt(style[\"margin-right\"], 10),\n    };\n}\nexports.getMargin = getMargin;\nfunction getPaddingAndBorder(element) {\n    var style = window.getComputedStyle(element);\n    return {\n        top: parseInt(style[\"padding-top\"], 10) +\n            parseInt(style[\"border-top-width\"], 10),\n        bottom: parseInt(style[\"padding-bottom\"], 10) +\n            parseInt(style[\"border-bottom-width\"], 10),\n        left: parseInt(style[\"padding-left\"], 10) +\n            parseInt(style[\"border-left-width\"], 10),\n        right: parseInt(style[\"padding-right\"], 10) +\n            parseInt(style[\"border-right-width\"], 10),\n    };\n}\nexports.getPaddingAndBorder = getPaddingAndBorder;\nfunction translateThumbs(elements, offsets, rtl) {\n    var inverter = rtl ? -1 : 1;\n    elements.forEach(function (element, index) {\n        return translate(element, inverter * offsets[index].x, offsets[index].y);\n    });\n}\nexports.translateThumbs = translateThumbs;\n/**\n * Util function for calculating the index of the thumb that is closes to a given position\n * @param thumbs - array of Thumb element to calculate the distance from\n * @param clientX - target x position (mouse/touch)\n * @param clientY - target y position (mouse/touch)\n * @param direction - the direction of the track\n */\nfunction getClosestThumbIndex(thumbs, clientX, clientY, direction) {\n    var thumbIndex = 0;\n    var minThumbDistance = getThumbDistance(thumbs[0], clientX, clientY, direction);\n    for (var i = 1; i < thumbs.length; i++) {\n        var thumbDistance = getThumbDistance(thumbs[i], clientX, clientY, direction);\n        if (thumbDistance < minThumbDistance) {\n            minThumbDistance = thumbDistance;\n            thumbIndex = i;\n        }\n    }\n    return thumbIndex;\n}\nexports.getClosestThumbIndex = getClosestThumbIndex;\nfunction translate(element, x, y) {\n    element.style.transform = \"translate(\".concat(x, \"px, \").concat(y, \"px)\");\n}\nexports.translate = translate;\n// adapted from https://github.com/alexreardon/raf-schd\nvar schd = function (fn) {\n    var lastArgs = [];\n    var frameId = null;\n    var wrapperFn = function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        lastArgs = args;\n        if (frameId) {\n            return;\n        }\n        frameId = requestAnimationFrame(function () {\n            frameId = null;\n            fn.apply(void 0, lastArgs);\n        });\n    };\n    return wrapperFn;\n};\nexports.schd = schd;\nfunction replaceAt(values, index, value) {\n    var ret = values.slice(0);\n    ret[index] = value;\n    return ret;\n}\nexports.replaceAt = replaceAt;\nfunction getTrackBackground(_a) {\n    var values = _a.values, colors = _a.colors, min = _a.min, max = _a.max, _b = _a.direction, direction = _b === void 0 ? types_1.Direction.Right : _b, _c = _a.rtl, rtl = _c === void 0 ? false : _c;\n    if (rtl && direction === types_1.Direction.Right) {\n        direction = types_1.Direction.Left;\n    }\n    else if (rtl && types_1.Direction.Left) {\n        direction = types_1.Direction.Right;\n    }\n    // sort values ascending\n    var progress = values\n        .slice(0)\n        .sort(function (a, b) { return a - b; })\n        .map(function (value) { return ((value - min) / (max - min)) * 100; });\n    var middle = progress.reduce(function (acc, point, index) {\n        return \"\".concat(acc, \", \").concat(colors[index], \" \").concat(point, \"%, \").concat(colors[index + 1], \" \").concat(point, \"%\");\n    }, \"\");\n    return \"linear-gradient(\".concat(direction, \", \").concat(colors[0], \" 0%\").concat(middle, \", \").concat(colors[colors.length - 1], \" 100%)\");\n}\nexports.getTrackBackground = getTrackBackground;\nfunction voidFn() { }\nexports.voidFn = voidFn;\nfunction assertUnreachable(x) {\n    throw new Error(\"Didn't expect to get here\");\n}\nexports.assertUnreachable = assertUnreachable;\n/**\n * Util function for grabbing the true largest width of a thumb\n * including the label\n * @param thumbEl - Thumb element to grab the largest width from\n * @param value - Thumb value, not label value\n * @param separator - Label separator value\n */\nvar getThumbWidth = function (thumbEl, value, separator, decimalPlaces, valueToLabel) {\n    if (valueToLabel === void 0) { valueToLabel = function (value) { return value; }; }\n    var width = Math.ceil(__spreadArray([thumbEl], Array.from(thumbEl.children), true).reduce(function (width, el) {\n        var elWidth = Math.ceil(el.getBoundingClientRect().width);\n        /**\n         * If a label contains a merged label value, it won't return the true\n         * label width for that Thumb. Clone the label and change the value\n         * to that individual Thumb value in order to grab the true width.\n         */\n        if (el.innerText &&\n            el.innerText.includes(separator) &&\n            el.childElementCount === 0) {\n            var elClone = el.cloneNode(true);\n            elClone.innerHTML = valueToLabel(value.toFixed(decimalPlaces));\n            elClone.style.visibility = \"hidden\";\n            document.body.appendChild(elClone);\n            elWidth = Math.ceil(elClone.getBoundingClientRect().width);\n            document.body.removeChild(elClone);\n        }\n        return elWidth > width ? elWidth : width;\n    }, thumbEl.getBoundingClientRect().width));\n    return width;\n};\n/**\n * Bulk of logic for thumb overlaps\n * Consider a scenario with 5 thumbs;\n * Thumb 1 overlaps with thumb 0 and thumb 2\n * Thumb 2 overlaps with thumb 3\n * We need an array that contains [0, 1, 2, 3]\n * The function needs to return the directly overlapping thumbs\n * and all thumbs overlapping linked to those and so on\n * @param index - Thumb index calculating overlaps for\n * @param offsets - Current Array of Thumb offsets for Range\n * @param thumbs - Array of Thumb elements\n * @param values - Array of Thumb values\n * @param separator - String separator for merged label values\n * @returns overlaps - Array of all overlapping thumbs from the index\n */\nvar getOverlaps = function (index, offsets, thumbs, values, separator, decimalPlaces, valueToLabel) {\n    if (valueToLabel === void 0) { valueToLabel = function (value) { return value; }; }\n    var overlaps = [];\n    /**\n     * Recursive function for building the overlaps Array\n     * If an overlap is found, find the overlaps for that overlap\n     * @param thumbIndex current Thumb index to find overlaps from\n     */\n    var buildOverlaps = function (thumbIndex) {\n        var thumbXWidth = getThumbWidth(thumbs[thumbIndex], values[thumbIndex], separator, decimalPlaces, valueToLabel);\n        var thumbX = offsets[thumbIndex].x;\n        /**\n         * Iterate through the Thumb offsets, if there is a match\n         * add the thumbIndex and siblingIndex to the overlaps Array\n         *\n         * Then build overlaps from the overlapping siblingIndex\n         */\n        offsets.forEach(function (_a, siblingIndex) {\n            var siblingX = _a.x;\n            var siblingWidth = getThumbWidth(thumbs[siblingIndex], values[siblingIndex], separator, decimalPlaces, valueToLabel);\n            if (thumbIndex !== siblingIndex &&\n                ((thumbX >= siblingX && thumbX <= siblingX + siblingWidth) ||\n                    (thumbX + thumbXWidth >= siblingX &&\n                        thumbX + thumbXWidth <= siblingX + siblingWidth))) {\n                if (!overlaps.includes(siblingIndex)) {\n                    overlaps.push(thumbIndex);\n                    overlaps.push(siblingIndex);\n                    overlaps = __spreadArray(__spreadArray([], overlaps, true), [thumbIndex, siblingIndex], false);\n                    buildOverlaps(siblingIndex);\n                }\n            }\n        });\n    };\n    buildOverlaps(index);\n    // Sort and remove duplicates from the built overlaps\n    return Array.from(new Set(overlaps.sort()));\n};\n/**\n * A custom React Hook for calculating whether a thumb overlaps\n * another and whether labels could/should merge.\n * @param rangeRef - React ref value of Range component\n * @param values - current Range values Array\n * @param index - thumb index\n * @param step - step value, used to calculate the number of decimal places\n * @param separator - string to separate thumb values\n * @returns label value + styling for thumb label\n */\nvar useThumbOverlap = function (rangeRef, values, index, step, separator, valueToLabel) {\n    if (step === void 0) { step = 0.1; }\n    if (separator === void 0) { separator = \" - \"; }\n    if (valueToLabel === void 0) { valueToLabel = function (value) { return value; }; }\n    var decimalPlaces = (0, exports.getStepDecimals)(step);\n    // Create initial label style and value. Label value defaults to thumb value\n    var _a = (0, react_1.useState)({}), labelStyle = _a[0], setLabelStyle = _a[1];\n    var _b = (0, react_1.useState)(valueToLabel(values[index].toFixed(decimalPlaces))), labelValue = _b[0], setLabelValue = _b[1];\n    // When the rangeRef or values change, update the Thumb label values and styling\n    (0, react_1.useEffect)(function () {\n        if (rangeRef) {\n            var thumbs = rangeRef.getThumbs();\n            if (thumbs.length < 1)\n                return;\n            var newStyle = {};\n            var offsets_1 = rangeRef.getOffsets();\n            /**\n             * Get any overlaps for the given Thumb index. This must return all linked\n             * Thumbs. So if there are 4 Thumbs and Thumbs 2, 3 and 4 overlap. If we are\n             * getting the overlaps for Thumb 1 and it overlaps only Thumb 2, we must get\n             * 2, 3 and 4 also.\n             */\n            var overlaps = getOverlaps(index, offsets_1, thumbs, values, separator, decimalPlaces, valueToLabel);\n            // Set a default label value of the Thumb value\n            var labelValue_1 = valueToLabel(values[index].toFixed(decimalPlaces));\n            /**\n             * If there are overlaps for the Thumb, we need to calculate the correct\n             * Label value along with the relevant styling. We only want to show a Label\n             * for the left most Thumb in an overlapping set.\n             * All other Thumbs will be set to display: none.\n             */\n            if (overlaps.length) {\n                /**\n                 * Get an Array of the offsets for the overlapping Thumbs\n                 * This is so we can determine if the Thumb we are looking at\n                 * is the left most thumb in an overlapping set\n                 */\n                var offsetsX = overlaps.reduce(function (a, c, i, s) {\n                    return a.length ? __spreadArray(__spreadArray([], a, true), [offsets_1[s[i]].x], false) : [offsets_1[s[i]].x];\n                }, []);\n                /**\n                 * If our Thumb is the left most Thumb, we can build a Label value\n                 * and set the style for that Label\n                 */\n                if (Math.min.apply(Math, offsetsX) === offsets_1[index].x) {\n                    /**\n                     * First calculate the Label value. To do this,\n                     * grab all the values for the Thumbs in our overlaps.\n                     * Then convert that to a Set and sort it whilst removing duplicates.\n                     */\n                    var labelValues_1 = [];\n                    overlaps.forEach(function (thumb) {\n                        labelValues_1.push(values[thumb].toFixed(decimalPlaces));\n                    });\n                    /**\n                     *  Update the labelValue with the resulting Array\n                     *  joined by our defined separator\n                     */\n                    labelValue_1 = Array.from(new Set(labelValues_1.sort(function (a, b) { return parseFloat(a) - parseFloat(b); })))\n                        .map(valueToLabel)\n                        .join(separator);\n                    /**\n                     * Lastly, build the label styling. The label styling will\n                     * position the label and apply a transform so that it's centered.\n                     * We want the center point between the left edge of the left most Thumb\n                     * and the right edge of the right most Thumb.\n                     */\n                    var first = Math.min.apply(Math, offsetsX);\n                    var last = Math.max.apply(Math, offsetsX);\n                    var lastWidth = thumbs[overlaps[offsetsX.indexOf(last)]].getBoundingClientRect()\n                        .width;\n                    newStyle.left = \"\".concat(Math.abs(first - (last + lastWidth)) / 2, \"px\");\n                    newStyle.transform = \"translate(-50%, 0)\";\n                }\n                else {\n                    // If the Thumb isn't the left most Thumb, hide the Label!\n                    newStyle.visibility = \"hidden\";\n                }\n            }\n            // Update the label value and style\n            setLabelValue(labelValue_1);\n            setLabelStyle(newStyle);\n        }\n    }, [rangeRef, values]);\n    return [labelValue, labelStyle];\n};\nexports.useThumbOverlap = useThumbOverlap;\n/**\n * Util function for calculating the distance of the center of a thumb\n * form a given mouse/touch target's position\n * @param thumbEl - Thumb element to calculate the distance from\n * @param clientX - target x position (mouse/touch)\n * @param clientY - target y position (mouse/touch)\n * @param direction - the direction of the track\n */\nfunction getThumbDistance(thumbEl, clientX, clientY, direction) {\n    var _a = thumbEl.getBoundingClientRect(), left = _a.left, top = _a.top, width = _a.width, height = _a.height;\n    return isVertical(direction)\n        ? Math.abs(clientY - (top + height / 2))\n        : Math.abs(clientX - (left + width / 2));\n}\nvar isIOS = function () {\n    var _a;\n    // @ts-ignore\n    var platform = ((_a = navigator.userAgentData) === null || _a === void 0 ? void 0 : _a.platform) || navigator.platform;\n    return ([\n        \"iPad Simulator\",\n        \"iPhone Simulator\",\n        \"iPod Simulator\",\n        \"iPad\",\n        \"iPhone\",\n        \"iPod\",\n    ].includes(platform) ||\n        // iPad on iOS 13 detection\n        (navigator.userAgent.includes(\"Mac\") && \"ontouchend\" in document));\n};\nexports.isIOS = isIOS;\n","var cssUnit = {\n    cm: true,\n    mm: true,\n    in: true,\n    px: true,\n    pt: true,\n    pc: true,\n    em: true,\n    ex: true,\n    ch: true,\n    rem: true,\n    vw: true,\n    vh: true,\n    vmin: true,\n    vmax: true,\n    \"%\": true,\n};\n/**\n * If size is a number, append px to the value as default unit.\n * If size is a string, validate against list of valid units.\n * If unit is valid, return size as is.\n * If unit is invalid, console warn issue, replace with px as the unit.\n *\n * @param {(number | string)} size\n * @return {LengthObject} LengthObject\n */\nexport function parseLengthAndUnit(size) {\n    if (typeof size === \"number\") {\n        return {\n            value: size,\n            unit: \"px\",\n        };\n    }\n    var value;\n    var valueString = (size.match(/^[0-9.]*/) || \"\").toString();\n    if (valueString.includes(\".\")) {\n        value = parseFloat(valueString);\n    }\n    else {\n        value = parseInt(valueString, 10);\n    }\n    var unit = (size.match(/[^0-9]*$/) || \"\").toString();\n    if (cssUnit[unit]) {\n        return {\n            value: value,\n            unit: unit,\n        };\n    }\n    console.warn(\"React Spinners: \".concat(size, \" is not a valid css value. Defaulting to \").concat(value, \"px.\"));\n    return {\n        value: value,\n        unit: \"px\",\n    };\n}\n/**\n * Take value as an input and return valid css value\n *\n * @param {(number | string)} value\n * @return {string} valid css value\n */\nexport function cssValue(value) {\n    var lengthWithunit = parseLengthAndUnit(value);\n    return \"\".concat(lengthWithunit.value).concat(lengthWithunit.unit);\n}\n","export var createAnimation = function (loaderName, frames, suffix) {\n    var animationName = \"react-spinners-\".concat(loaderName, \"-\").concat(suffix);\n    if (typeof window == \"undefined\" || !window.document) {\n        return animationName;\n    }\n    var styleEl = document.createElement(\"style\");\n    document.head.appendChild(styleEl);\n    var styleSheet = styleEl.sheet;\n    var keyFrames = \"\\n    @keyframes \".concat(animationName, \" {\\n      \").concat(frames, \"\\n    }\\n  \");\n    if (styleSheet) {\n        styleSheet.insertRule(keyFrames, 0);\n    }\n    return animationName;\n};\n","var __assign = (this && this.__assign) || function () {\n    __assign = Object.assign || function(t) {\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\n            s = arguments[i];\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n                t[p] = s[p];\n        }\n        return t;\n    };\n    return __assign.apply(this, arguments);\n};\nvar __rest = (this && this.__rest) || function (s, e) {\n    var t = {};\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\n        t[p] = s[p];\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\n                t[p[i]] = s[p[i]];\n        }\n    return t;\n};\nimport * as React from \"react\";\nimport { cssValue } from \"./helpers/unitConverter\";\nimport { createAnimation } from \"./helpers/animation\";\nvar puff = [\n    createAnimation(\"PuffLoader\", \"0% {transform: scale(0)} 100% {transform: scale(1.0)}\", \"puff-1\"),\n    createAnimation(\"PuffLoader\", \"0% {opacity: 1} 100% {opacity: 0}\", \"puff-2\"),\n];\nfunction PuffLoader(_a) {\n    var _b = _a.loading, loading = _b === void 0 ? true : _b, _c = _a.color, color = _c === void 0 ? \"#000000\" : _c, _d = _a.speedMultiplier, speedMultiplier = _d === void 0 ? 1 : _d, _e = _a.cssOverride, cssOverride = _e === void 0 ? {} : _e, _f = _a.size, size = _f === void 0 ? 60 : _f, additionalprops = __rest(_a, [\"loading\", \"color\", \"speedMultiplier\", \"cssOverride\", \"size\"]);\n    var wrapper = __assign({ display: \"inherit\", position: \"relative\", width: cssValue(size), height: cssValue(size) }, cssOverride);\n    var style = function (i) {\n        return {\n            position: \"absolute\",\n            height: cssValue(size),\n            width: cssValue(size),\n            border: \"thick solid \".concat(color),\n            borderRadius: \"50%\",\n            opacity: \"1\",\n            top: \"0\",\n            left: \"0\",\n            animationFillMode: \"both\",\n            animation: \"\".concat(puff[0], \", \").concat(puff[1]),\n            animationDuration: \"\".concat(2 / speedMultiplier, \"s\"),\n            animationIterationCount: \"infinite\",\n            animationTimingFunction: \"cubic-bezier(0.165, 0.84, 0.44, 1), cubic-bezier(0.3, 0.61, 0.355, 1)\",\n            animationDelay: i === 1 ? \"-1s\" : \"0s\",\n        };\n    };\n    if (!loading) {\n        return null;\n    }\n    return (React.createElement(\"span\", __assign({ style: wrapper }, additionalprops),\n        React.createElement(\"span\", { style: style(1) }),\n        React.createElement(\"span\", { style: style(2) })));\n}\nexport default PuffLoader;\n","import { useRef } from 'react';\nexport function useFirstMountState() {\n    var isFirst = useRef(true);\n    if (isFirst.current) {\n        isFirst.current = false;\n        return true;\n    }\n    return isFirst.current;\n}\n"],"names":["extendStatics","__extends","this","d","b","Object","setPrototypeOf","__proto__","Array","p","prototype","hasOwnProperty","call","TypeError","String","__","constructor","create","__createBinding","o","m","k","k2","undefined","desc","getOwnPropertyDescriptor","__esModule","writable","configurable","enumerable","get","defineProperty","__setModuleDefault","v","value","__importStar","mod","result","__spreadArray","to","from","pack","arguments","length","ar","i","l","slice","concat","exports","React","utils_1","types_1","INCREASE_KEYS","DECREASE_KEYS","Range","_super","props","_this","trackRef","createRef","thumbRefs","state","draggedTrackPos","draggedThumbIndex","thumbZIndexes","values","fill","map","t","isChanged","markOffsets","getOffsets","_a","direction","min","max","trackElement","current","console","warn","trackRect","getBoundingClientRect","trackPadding","getPaddingAndBorder","getThumbs","thumb","index","thumbOffsets","x","y","thumbRect","thumbMargins","getMargin","Direction","Right","left","height","top","width","relativeValue","Left","right","Up","Down","assertUnreachable","children","filter","el","hasAttribute","getTargetIndex","e","findIndex","child","target","contains","addTouchEvents","document","addEventListener","schdOnTouchMove","passive","schdOnEnd","addMouseEvents","schdOnMouseMove","onMouseDownTrack","button","isIOS","persist","preventDefault","nativeEvent","draggableTrack","some","thumbRef","setState","clientX","clientY","onMove","getClosestThumbIndex","focus","onResize","translateThumbs","rtl","calculateMarkOffsets","onTouchStartTrack","touches","onMouseOrTouchStart","disabled","isTouch","isTouchEvent","Math","apply","onMouseMove","onTouchMove","onKeyDown","onChange","step","inverter","includes","key","replaceAt","normalizeValue","fireOnFinalChange","onKeyUp","_b","trackLength","isVertical","dX","dY","deltaValue","abs","sign","thumbValue","newValues","newValue","allowOverlap","onEnd","removeEventListener","onFinalChange","updateMarkRefs","renderMark","numOfMarks","markRefs","elStyles","window","getComputedStyle","trackWidth","parseInt","trackHeight","paddingLeft","paddingTop","res","markHeight","markWidth","markRect","push","round","Error","schd","componentDidMount","resizeObserver","ResizeObserver","observe","unobserve","checkInitialOverlap","forEach","checkBoundaries","isStepDivisible","componentDidUpdate","prevProps","prevState","componentWillUnmount","render","label","labelledBy","renderTrack","renderThumb","_c","style","transform","cursor","onMouseDown","voidFn","onTouchStart","ref","isDragged","offset","arr","position","marginTop","marginLeft","zIndex","userSelect","touchAction","WebkitUserSelect","MozUserSelect","msUserSelect","tabIndex","draggable","role","defaultProps","Component","__importDefault","checkValuesAgainstBoundaries","useThumbOverlap","getTrackBackground","Range_1","default","translate","getStepDecimals","react_1","element","decimals","toString","split","event","changedTouches","roundedRes","Number","toFixed","BIG_NUM","prev","next","remainder","floor","closestLowerNum","rounded","decimalPlaces","parseFloat","RangeError","every","item","bottom","elements","offsets","thumbs","thumbIndex","minThumbDistance","getThumbDistance","thumbDistance","fn","lastArgs","frameId","args","_i","requestAnimationFrame","ret","colors","middle","sort","a","reduce","acc","point","getThumbWidth","thumbEl","separator","valueToLabel","ceil","elWidth","innerText","childElementCount","elClone","cloneNode","innerHTML","visibility","body","appendChild","removeChild","rangeRef","useState","labelStyle","setLabelStyle","labelValue","setLabelValue","useEffect","newStyle","offsets_1","overlaps","buildOverlaps","thumbXWidth","thumbX","siblingIndex","siblingX","siblingWidth","Set","getOverlaps","labelValue_1","offsetsX","c","s","labelValues_1","join","first","last","lastWidth","indexOf","platform","navigator","userAgentData","userAgent","cssUnit","cm","mm","in","px","pt","pc","em","ex","ch","rem","vw","vh","vmin","vmax","cssValue","lengthWithunit","size","unit","valueString","match","parseLengthAndUnit","createAnimation","loaderName","frames","suffix","animationName","styleEl","createElement","head","styleSheet","sheet","keyFrames","insertRule","__assign","assign","n","puff","loading","color","_d","speedMultiplier","_e","cssOverride","_f","additionalprops","getOwnPropertySymbols","propertyIsEnumerable","__rest","wrapper","display","border","borderRadius","opacity","animationFillMode","animation","animationDuration","animationIterationCount","animationTimingFunction","animationDelay","useFirstMountState","isFirst","useRef"],"sourceRoot":""}