{"version":3,"file":"2088/bundle-feb8f58543a6baa4918e.js","mappings":"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","sources":["webpack://@spa/inkclub/../../node_modules/css-mediaquery/index.js","webpack://@spa/inkclub/../../node_modules/matchmediaquery/index.js","webpack://@spa/inkclub/../../node_modules/react-range/lib/Range.js","webpack://@spa/inkclub/../../node_modules/react-range/lib/index.js","webpack://@spa/inkclub/../../node_modules/react-range/lib/types.js","webpack://@spa/inkclub/../../node_modules/react-range/lib/utils.js","webpack://@spa/inkclub/../../node_modules/hyphenate-style-name/index.js","webpack://@spa/inkclub/../../node_modules/react-responsive/dist/esm/index.js","webpack://@spa/inkclub/../../node_modules/shallow-equal/dist/index.modern.mjs"],"sourcesContent":["/*\nCopyright (c) 2014, Yahoo! Inc. All rights reserved.\nCopyrights licensed under the New BSD License.\nSee the accompanying LICENSE file for terms.\n*/\n\n'use strict';\n\nexports.match = matchQuery;\nexports.parse = parseQuery;\n\n// -----------------------------------------------------------------------------\n\nvar RE_MEDIA_QUERY     = /(?:(only|not)?\\s*([^\\s\\(\\)]+)(?:\\s*and)?\\s*)?(.+)?/i,\n    RE_MQ_EXPRESSION   = /\\(\\s*([^\\s\\:\\)]+)\\s*(?:\\:\\s*([^\\s\\)]+))?\\s*\\)/,\n    RE_MQ_FEATURE      = /^(?:(min|max)-)?(.+)/,\n    RE_LENGTH_UNIT     = /(em|rem|px|cm|mm|in|pt|pc)?$/,\n    RE_RESOLUTION_UNIT = /(dpi|dpcm|dppx)?$/;\n\nfunction matchQuery(mediaQuery, values) {\n    return parseQuery(mediaQuery).some(function (query) {\n        var inverse = query.inverse;\n\n        // Either the parsed or specified `type` is \"all\", or the types must be\n        // equal for a match.\n        var typeMatch = query.type === 'all' || values.type === query.type;\n\n        // Quit early when `type` doesn't match, but take \"not\" into account.\n        if ((typeMatch && inverse) || !(typeMatch || inverse)) {\n            return false;\n        }\n\n        var expressionsMatch = query.expressions.every(function (expression) {\n            var feature  = expression.feature,\n                modifier = expression.modifier,\n                expValue = expression.value,\n                value    = values[feature];\n\n            // Missing or falsy values don't match.\n            if (!value) { return false; }\n\n            switch (feature) {\n                case 'orientation':\n                case 'scan':\n                    return value.toLowerCase() === expValue.toLowerCase();\n\n                case 'width':\n                case 'height':\n                case 'device-width':\n                case 'device-height':\n                    expValue = toPx(expValue);\n                    value    = toPx(value);\n                    break;\n\n                case 'resolution':\n                    expValue = toDpi(expValue);\n                    value    = toDpi(value);\n                    break;\n\n                case 'aspect-ratio':\n                case 'device-aspect-ratio':\n                case /* Deprecated */ 'device-pixel-ratio':\n                    expValue = toDecimal(expValue);\n                    value    = toDecimal(value);\n                    break;\n\n                case 'grid':\n                case 'color':\n                case 'color-index':\n                case 'monochrome':\n                    expValue = parseInt(expValue, 10) || 1;\n                    value    = parseInt(value, 10) || 0;\n                    break;\n            }\n\n            switch (modifier) {\n                case 'min': return value >= expValue;\n                case 'max': return value <= expValue;\n                default   : return value === expValue;\n            }\n        });\n\n        return (expressionsMatch && !inverse) || (!expressionsMatch && inverse);\n    });\n}\n\nfunction parseQuery(mediaQuery) {\n    return mediaQuery.split(',').map(function (query) {\n        query = query.trim();\n\n        var captures    = query.match(RE_MEDIA_QUERY),\n            modifier    = captures[1],\n            type        = captures[2],\n            expressions = captures[3] || '',\n            parsed      = {};\n\n        parsed.inverse = !!modifier && modifier.toLowerCase() === 'not';\n        parsed.type    = type ? type.toLowerCase() : 'all';\n\n        // Split expressions into a list.\n        expressions = expressions.match(/\\([^\\)]+\\)/g) || [];\n\n        parsed.expressions = expressions.map(function (expression) {\n            var captures = expression.match(RE_MQ_EXPRESSION),\n                feature  = captures[1].toLowerCase().match(RE_MQ_FEATURE);\n\n            return {\n                modifier: feature[1],\n                feature : feature[2],\n                value   : captures[2]\n            };\n        });\n\n        return parsed;\n    });\n}\n\n// -- Utilities ----------------------------------------------------------------\n\nfunction toDecimal(ratio) {\n    var decimal = Number(ratio),\n        numbers;\n\n    if (!decimal) {\n        numbers = ratio.match(/^(\\d+)\\s*\\/\\s*(\\d+)$/);\n        decimal = numbers[1] / numbers[2];\n    }\n\n    return decimal;\n}\n\nfunction toDpi(resolution) {\n    var value = parseFloat(resolution),\n        units = String(resolution).match(RE_RESOLUTION_UNIT)[1];\n\n    switch (units) {\n        case 'dpcm': return value / 2.54;\n        case 'dppx': return value * 96;\n        default    : return value;\n    }\n}\n\nfunction toPx(length) {\n    var value = parseFloat(length),\n        units = String(length).match(RE_LENGTH_UNIT)[1];\n\n    switch (units) {\n        case 'em' : return value * 16;\n        case 'rem': return value * 16;\n        case 'cm' : return value * 96 / 2.54;\n        case 'mm' : return value * 96 / 2.54 / 10;\n        case 'in' : return value * 96;\n        case 'pt' : return value * 72;\n        case 'pc' : return value * 72 / 12;\n        default   : return value;\n    }\n}\n","'use strict';\n\nvar staticMatch = require('css-mediaquery').match;\nvar dynamicMatch = typeof window !== 'undefined' ? window.matchMedia : null;\n\n// our fake MediaQueryList\nfunction Mql(query, values, forceStatic){\n  var self = this;\n  var mql;\n\n  // matchMedia will return null in FF when it's called in a hidden iframe\n  // ref: https://stackoverflow.com/a/12330568\n  if(dynamicMatch && !forceStatic) mql = dynamicMatch.call(window, query);\n\n  if (mql) {\n    this.matches = mql.matches;\n    this.media = mql.media;\n    // TODO: is there a time it makes sense to remove this listener?\n    mql.addListener(update);\n  } else {\n    this.matches = staticMatch(query, values);\n    this.media = query;\n  }\n\n  this.addListener = addListener;\n  this.removeListener = removeListener;\n  this.dispose = dispose;\n\n  function addListener(listener){\n    if(mql){\n      mql.addListener(listener);\n    }\n  }\n\n  function removeListener(listener){\n    if(mql){\n      mql.removeListener(listener);\n    }\n  }\n\n  // update ourselves!\n  function update(evt){\n    self.matches = evt.matches;\n    self.media = evt.media;\n  }\n\n  function dispose(){\n    if(mql){\n      mql.removeListener(update);\n    }\n  }\n}\n\nfunction matchMedia(query, values, forceStatic){\n  return new Mql(query, values, forceStatic);\n}\n\nmodule.exports = matchMedia;\n","\"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","/* eslint-disable no-var, prefer-template */\nvar uppercasePattern = /[A-Z]/g\nvar msPattern = /^ms-/\nvar cache = {}\n\nfunction toHyphenLower(match) {\n  return '-' + match.toLowerCase()\n}\n\nfunction hyphenateStyleName(name) {\n  if (cache.hasOwnProperty(name)) {\n    return cache[name]\n  }\n\n  var hName = name.replace(uppercasePattern, toHyphenLower)\n  return (cache[name] = msPattern.test(hName) ? '-' + hName : hName)\n}\n\nexport default hyphenateStyleName\n","import { createContext, useRef, useEffect, useContext, useState } from 'react';\nimport matchMedia from 'matchmediaquery';\nimport hyphenate from 'hyphenate-style-name';\nimport { shallowEqualObjects } from 'shallow-equal';\nimport PropTypes from 'prop-types';\n\nconst stringOrNumber = PropTypes.oneOfType([PropTypes.string, PropTypes.number]);\n// media types\nconst types = {\n    all: PropTypes.bool,\n    grid: PropTypes.bool,\n    aural: PropTypes.bool,\n    braille: PropTypes.bool,\n    handheld: PropTypes.bool,\n    print: PropTypes.bool,\n    projection: PropTypes.bool,\n    screen: PropTypes.bool,\n    tty: PropTypes.bool,\n    tv: PropTypes.bool,\n    embossed: PropTypes.bool\n};\n// properties that match media queries\nconst matchers = {\n    orientation: PropTypes.oneOf(['portrait', 'landscape']),\n    scan: PropTypes.oneOf(['progressive', 'interlace']),\n    aspectRatio: PropTypes.string,\n    deviceAspectRatio: PropTypes.string,\n    height: stringOrNumber,\n    deviceHeight: stringOrNumber,\n    width: stringOrNumber,\n    deviceWidth: stringOrNumber,\n    color: PropTypes.bool,\n    colorIndex: PropTypes.bool,\n    monochrome: PropTypes.bool,\n    resolution: stringOrNumber,\n    type: Object.keys(types)\n};\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nconst { type, ...featureMatchers } = matchers;\n// media features\nconst features = {\n    minAspectRatio: PropTypes.string,\n    maxAspectRatio: PropTypes.string,\n    minDeviceAspectRatio: PropTypes.string,\n    maxDeviceAspectRatio: PropTypes.string,\n    minHeight: stringOrNumber,\n    maxHeight: stringOrNumber,\n    minDeviceHeight: stringOrNumber,\n    maxDeviceHeight: stringOrNumber,\n    minWidth: stringOrNumber,\n    maxWidth: stringOrNumber,\n    minDeviceWidth: stringOrNumber,\n    maxDeviceWidth: stringOrNumber,\n    minColor: PropTypes.number,\n    maxColor: PropTypes.number,\n    minColorIndex: PropTypes.number,\n    maxColorIndex: PropTypes.number,\n    minMonochrome: PropTypes.number,\n    maxMonochrome: PropTypes.number,\n    minResolution: stringOrNumber,\n    maxResolution: stringOrNumber,\n    ...featureMatchers\n};\nconst all = { ...types, ...features };\nvar mq = {\n    all: all,\n    types: types,\n    matchers: matchers,\n    features: features\n};\n\nconst negate = (cond) => `not ${cond}`;\nconst keyVal = (k, v) => {\n    const realKey = hyphenate(k);\n    // px shorthand\n    if (typeof v === 'number') {\n        v = `${v}px`;\n    }\n    if (v === true) {\n        return realKey;\n    }\n    if (v === false) {\n        return negate(realKey);\n    }\n    return `(${realKey}: ${v})`;\n};\nconst join = (conds) => conds.join(' and ');\nconst toQuery = (obj) => {\n    const rules = [];\n    Object.keys(mq.all).forEach((k) => {\n        const v = obj[k];\n        if (v != null) {\n            rules.push(keyVal(k, v));\n        }\n    });\n    return join(rules);\n};\n\nconst Context = createContext(undefined);\n\nconst makeQuery = (settings) => settings.query || toQuery(settings);\nconst hyphenateKeys = (obj) => {\n    if (!obj)\n        return undefined;\n    const keys = Object.keys(obj);\n    return keys.reduce((result, key) => {\n        result[hyphenate(key)] = obj[key];\n        return result;\n    }, {});\n};\nconst useIsUpdate = () => {\n    const ref = useRef(false);\n    useEffect(() => {\n        ref.current = true;\n    }, []);\n    return ref.current;\n};\nconst useDevice = (deviceFromProps) => {\n    const deviceFromContext = useContext(Context);\n    const getDevice = () => hyphenateKeys(deviceFromProps) || hyphenateKeys(deviceFromContext);\n    const [device, setDevice] = useState(getDevice);\n    useEffect(() => {\n        const newDevice = getDevice();\n        if (!shallowEqualObjects(device, newDevice)) {\n            setDevice(newDevice);\n        }\n    }, [deviceFromProps, deviceFromContext]);\n    return device;\n};\nconst useQuery = (settings) => {\n    const getQuery = () => makeQuery(settings);\n    const [query, setQuery] = useState(getQuery);\n    useEffect(() => {\n        const newQuery = getQuery();\n        if (query !== newQuery) {\n            setQuery(newQuery);\n        }\n    }, [settings]);\n    return query;\n};\nconst useMatchMedia = (query, device) => {\n    const getMatchMedia = () => matchMedia(query, device || {}, !!device);\n    const [mq, setMq] = useState(getMatchMedia);\n    const isUpdate = useIsUpdate();\n    useEffect(() => {\n        if (isUpdate) {\n            // skip on mounting, it has already been set\n            const newMq = getMatchMedia();\n            setMq(newMq);\n            return () => {\n                if (newMq) {\n                    newMq.dispose();\n                }\n            };\n        }\n    }, [query, device]);\n    return mq;\n};\nconst useMatches = (mediaQuery) => {\n    const [matches, setMatches] = useState(mediaQuery.matches);\n    useEffect(() => {\n        const updateMatches = (ev) => {\n            setMatches(ev.matches);\n        };\n        mediaQuery.addListener(updateMatches);\n        setMatches(mediaQuery.matches);\n        return () => {\n            mediaQuery.removeListener(updateMatches);\n        };\n    }, [mediaQuery]);\n    return matches;\n};\nconst useMediaQuery = (settings, device, onChange) => {\n    const deviceSettings = useDevice(device);\n    const query = useQuery(settings);\n    if (!query)\n        throw new Error('Invalid or missing MediaQuery!');\n    const mq = useMatchMedia(query, deviceSettings);\n    const matches = useMatches(mq);\n    const isUpdate = useIsUpdate();\n    useEffect(() => {\n        if (isUpdate && onChange) {\n            onChange(matches);\n        }\n    }, [matches]);\n    useEffect(() => () => {\n        if (mq) {\n            mq.dispose();\n        }\n    }, []);\n    return matches;\n};\n\n// ReactNode and ReactElement typings are a little funky for functional components, so the ReactElement cast is needed on the return\nconst MediaQuery = ({ children, device, onChange, ...settings }) => {\n    const matches = useMediaQuery(settings, device, onChange);\n    if (typeof children === 'function') {\n        return children(matches);\n    }\n    return matches ? children : null;\n};\n\nexport { Context, MediaQuery as default, toQuery, useMediaQuery };\n//# sourceMappingURL=index.js.map\n","function shallowEqualArrays(arrA, arrB) {\n  if (arrA === arrB) {\n    return true;\n  }\n  if (!arrA || !arrB) {\n    return false;\n  }\n  const len = arrA.length;\n  if (arrB.length !== len) {\n    return false;\n  }\n  for (let i = 0; i < len; i++) {\n    if (arrA[i] !== arrB[i]) {\n      return false;\n    }\n  }\n  return true;\n}\n\nfunction shallowEqualObjects(objA, objB) {\n  if (objA === objB) {\n    return true;\n  }\n  if (!objA || !objB) {\n    return false;\n  }\n  const aKeys = Object.keys(objA);\n  const bKeys = Object.keys(objB);\n  const len = aKeys.length;\n  if (bKeys.length !== len) {\n    return false;\n  }\n  for (let i = 0; i < len; i++) {\n    const key = aKeys[i];\n    if (objA[key] !== objB[key] || !Object.prototype.hasOwnProperty.call(objB, key)) {\n      return false;\n    }\n  }\n  return true;\n}\n\nfunction shallowEqual(a, b) {\n  const aIsArr = Array.isArray(a);\n  const bIsArr = Array.isArray(b);\n  if (aIsArr !== bIsArr) {\n    return false;\n  }\n  if (aIsArr && bIsArr) {\n    return shallowEqualArrays(a, b);\n  }\n  return shallowEqualObjects(a, b);\n}\n\nexport { shallowEqual, shallowEqualArrays, shallowEqualObjects };\n//# sourceMappingURL=index.modern.mjs.map\n"],"names":["exports","mediaQuery","values","split","map","query","captures","trim","match","RE_MEDIA_QUERY","modifier","type","expressions","parsed","inverse","toLowerCase","expression","RE_MQ_EXPRESSION","feature","RE_MQ_FEATURE","value","parseQuery","some","typeMatch","expressionsMatch","every","expValue","toPx","toDpi","toDecimal","parseInt","RE_LENGTH_UNIT","RE_RESOLUTION_UNIT","ratio","numbers","decimal","Number","resolution","parseFloat","String","length","staticMatch","dynamicMatch","window","matchMedia","Mql","forceStatic","mql","self","this","update","evt","matches","media","call","addListener","listener","removeListener","dispose","module","extendStatics","__extends","d","b","Object","setPrototypeOf","__proto__","Array","p","prototype","hasOwnProperty","TypeError","__","constructor","create","__createBinding","o","m","k","k2","undefined","desc","getOwnPropertyDescriptor","__esModule","writable","configurable","enumerable","get","defineProperty","__setModuleDefault","v","__importStar","mod","result","__spreadArray","to","from","pack","arguments","ar","i","l","slice","concat","React","utils_1","types_1","INCREASE_KEYS","DECREASE_KEYS","Range","_super","props","_this","trackRef","createRef","thumbRefs","state","draggedTrackPos","draggedThumbIndex","thumbZIndexes","fill","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","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","getComputedStyle","trackWidth","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","event","changedTouches","roundedRes","toFixed","BIG_NUM","prev","next","remainder","floor","closestLowerNum","rounded","decimalPlaces","RangeError","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","uppercasePattern","msPattern","cache","toHyphenLower","name","hName","replace","test","stringOrNumber","types","all","grid","aural","braille","handheld","print","projection","screen","tty","tv","embossed","matchers","orientation","scan","aspectRatio","deviceAspectRatio","deviceHeight","deviceWidth","color","colorIndex","monochrome","keys","featureMatchers","features","minAspectRatio","maxAspectRatio","minDeviceAspectRatio","maxDeviceAspectRatio","minHeight","maxHeight","minDeviceHeight","maxDeviceHeight","minWidth","maxWidth","minDeviceWidth","maxDeviceWidth","minColor","maxColor","minColorIndex","maxColorIndex","minMonochrome","maxMonochrome","minResolution","maxResolution","mq","Context","createContext","hyphenateKeys","obj","useIsUpdate","useRef","useQuery","settings","getQuery","rules","realKey","keyVal","toQuery","makeQuery","setQuery","newQuery","useMediaQuery","device","deviceSettings","deviceFromProps","deviceFromContext","useContext","getDevice","setDevice","newDevice","objA","objB","aKeys","bKeys","len","shallowEqualObjects","useDevice","getMatchMedia","setMq","isUpdate","newMq","useMatchMedia","setMatches","updateMatches","ev","useMatches","MediaQuery"],"sourceRoot":""}