{"version":3,"sources":["webpack:///./node_modules/react-range/lib/index.js","webpack:///./node_modules/react-range/lib/types.js","webpack:///./node_modules/react-range/lib/utils.js","webpack:///./node_modules/react-range/lib/Range.js"],"names":["__importDefault","this","mod","__esModule","Object","defineProperty","exports","value","checkValuesAgainstBoundaries","relativeValue","useThumbOverlap","Direction","getTrackBackground","Range","Range_1","default","utils_1","enumerable","get","types_1","__spreadArrays","s","i","il","arguments","length","r","Array","k","a","j","jl","assertUnreachable","voidFn","replaceAt","schd","translate","getClosestThumbIndex","translateThumbs","getPaddingAndBorder","getMargin","checkInitialOverlap","checkBoundaries","isVertical","normalizeValue","isStepDivisible","isTouchEvent","getStepDecimals","react_1","direction","Up","Down","element","x","y","style","transform","step","decimals","toString","split","event","touches","changedTouches","min","max","roundedRes","Number","toFixed","parseInt","index","allowOverlap","values","BIG_NUM","Math","round","prev","next","remainder","floor","closestLowerNum","abs","rounded","res","decimalPlaces","parseFloat","RangeError","slice","every","item","window","getComputedStyle","top","bottom","left","right","elements","offsets","rtl","inverter","forEach","thumbs","clientX","clientY","thumbIndex","minThumbDistance","getThumbDistance","thumbDistance","fn","lastArgs","frameId","args","_i","requestAnimationFrame","apply","ret","_a","colors","_b","Right","_c","Left","middle","sort","b","map","reduce","acc","point","Error","getThumbWidth","thumbEl","separator","valueToLabel","ceil","from","children","width","el","elWidth","getBoundingClientRect","innerText","includes","childElementCount","elClone","cloneNode","innerHTML","visibility","document","body","appendChild","removeChild","height","rangeRef","useState","labelStyle","setLabelStyle","labelValue","setLabelValue","useEffect","getThumbs","newStyle","offsets_1","getOffsets","overlaps","buildOverlaps","thumbXWidth","thumbX","siblingIndex","siblingX","siblingWidth","push","Set","getOverlaps","labelValue_1","offsetsX","c","labelValues_1","thumb","join","first","last","lastWidth","indexOf","extendStatics","__extends","d","setPrototypeOf","__proto__","p","prototype","hasOwnProperty","call","__","constructor","create","__createBinding","o","m","k2","undefined","__setModuleDefault","v","__importStar","result","React","INCREASE_KEYS","DECREASE_KEYS","_super","props","_this","trackRef","createRef","thumbRefs","markRefs","state","draggedTrackPos","draggedThumbIndex","thumbZIndexes","fill","t","isChanged","markOffsets","trackElement","current","trackRect","trackPadding","thumbOffsets","thumbRect","thumbMargins","filter","hasAttribute","console","warn","getTargetIndex","e","findIndex","child","target","contains","addTouchEvents","addEventListener","schdOnTouchMove","passive","schdOnEnd","addMouseEvents","schdOnMouseMove","onMouseDownTrack","button","persist","preventDefault","nativeEvent","draggableTrack","some","thumbRef","setState","onMove","focus","onResize","calculateMarkOffsets","onTouchStartTrack","onMouseOrTouchStart","disabled","isTouch","onMouseMove","onTouchMove","onKeyDown","onChange","key","fireOnFinalChange","onKeyUp","trackLength","dX","dY","deltaValue","sign","thumbValue","newValues","newValue","onEnd","removeEventListener","onFinalChange","renderMark","elStyles","trackWidth","trackHeight","paddingLeft","paddingTop","numOfMarks","markHeight","markWidth","markRect","componentDidMount","resizeObserver","ResizeObserver","observe","unobserve","componentDidUpdate","prevProps","prevState","componentWillUnmount","render","renderTrack","renderThumb","cursor","onMouseDown","onTouchStart","ref","isDragged","offset","arr","position","marginTop","marginLeft","zIndex","userSelect","touchAction","WebkitUserSelect","MozUserSelect","msUserSelect","tabIndex","draggable","role","defaultProps","Component"],"mappings":"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","file":"defaultVendors~FinanceCalculator~HomeHeroBanner~ProductListing~SearchByBudget~SellYourVehicleQuestionnaire-c7f4429084bf988cde82.js","sourcesContent":["\"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 || (exports.Direction = {}));\n","\"use strict\";\nvar __spreadArrays = (this && this.__spreadArrays) || function () {\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\n            r[k] = a[j];\n    return r;\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.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) %\n        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\n        ? rounded\n        : rounded + step;\n    var decimalPlaces = 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 (\" + min + \") is equal/bigger than max (\" + max + \")\");\n    }\n    if (value < min) {\n        throw new RangeError(\"value (\" + value + \") is smaller than min (\" + min + \")\");\n    }\n    if (value > max) {\n        throw new RangeError(\"value (\" + value + \") is bigger than max (\" + 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={[\" + 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) + parseInt(style['border-top-width'], 10),\n        bottom: parseInt(style['padding-bottom'], 10) + parseInt(style['border-bottom-width'], 10),\n        left: parseInt(style['padding-left'], 10) + parseInt(style['border-left-width'], 10),\n        right: parseInt(style['padding-right'], 10) + 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(\" + x + \"px, \" + 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.slice(0).sort(function (a, b) { return a - b; }).map(function (value) { return ((value - min) / (max - min)) * 100; });\n    var middle = progress.reduce(function (acc, point, index) {\n        return acc + \", \" + colors[index] + \" \" + point + \"%, \" + colors[index + 1] + \" \" + point + \"%\";\n    }, '');\n    return \"linear-gradient(\" + direction + \", \" + colors[0] + \" 0%\" + middle + \", \" + 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(__spreadArrays([thumbEl], Array.from(thumbEl.children)).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 = __spreadArrays(overlaps, [thumbIndex, siblingIndex]);\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 = exports.getStepDecimals(step);\n    // Create initial label style and value. Label value defaults to thumb value\n    var _a = react_1.useState({}), labelStyle = _a[0], setLabelStyle = _a[1];\n    var _b = 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    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 ? __spreadArrays(a, [offsets_1[s[i]].x]) : [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().width;\n                    newStyle.left = 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) ? Math.abs(clientY - (top + height / 2)) : Math.abs(clientX - (left + width / 2));\n}\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        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    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });\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 __spreadArrays = (this && this.__spreadArrays) || function () {\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\n            r[k] = a[j];\n    return r;\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.markRefs = [];\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            var trackRect = trackElement.getBoundingClientRect();\n            var trackPadding = 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 = 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 * 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 * 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 * 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 * utils_1.relativeValue(values[index], min, max) -\n                                thumbRect.height / 2;\n                        return thumbOffsets;\n                    default:\n                        return 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)\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 = 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            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 = 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 = 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;\n            var isChanged = _this.state.isChanged;\n            var index = _this.getTargetIndex(e.nativeEvent);\n            var inverter = rtl ? -1 : 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(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(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 = 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                        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 = 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                        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(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 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.calculateMarkOffsets = function () {\n            if (!_this.props.renderMark ||\n                !_this.trackRef ||\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.numOfMarks = (props.max - props.min) / _this.props.step;\n        _this.schdOnMouseMove = utils_1.schd(_this.onMouseMove);\n        _this.schdOnTouchMove = utils_1.schd(_this.onTouchMove);\n        _this.schdOnEnd = utils_1.schd(_this.onEnd);\n        _this.thumbRefs = props.values.map(function () { return React.createRef(); });\n        for (var i = 0; i < _this.numOfMarks + 1; i++) {\n            _this.markRefs[i] = React.createRef();\n        }\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 && utils_1.checkInitialOverlap(this.props.values);\n        this.props.values.forEach(function (value) {\n            return utils_1.checkBoundaries(value, _this.props.min, _this.props.max);\n        });\n        this.resizeObserver.observe(this.trackRef.current);\n        utils_1.translateThumbs(this.getThumbs(), this.getOffsets(), this.props.rtl);\n        this.calculateMarkOffsets();\n        values.forEach(function (value) {\n            if (!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.markRefs = [];\n            this.numOfMarks = (max - min) / step;\n            for (var i = 0; i < this.numOfMarks + 1; i++) {\n                this.markRefs[i] = React.createRef();\n            }\n        }\n        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 (!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, 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                            ? 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: __spreadArrays(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: offset[0] + \"px\",\n                                marginTop: offset[1] + \"px\"\n                            }\n                            : {\n                                position: 'absolute',\n                                top: offset[0] + \"px\",\n                                marginLeft: offset[1] + \"px\"\n                            },\n                        key: \"mark\" + index,\n                        ref: _this.markRefs[index]\n                    },\n                    index: index\n                });\n            }), 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                        role: 'slider',\n                        onKeyDown: disabled ? utils_1.voidFn : _this.onKeyDown,\n                        onKeyUp: disabled ? utils_1.voidFn : _this.onKeyUp\n                    }\n                });\n            }))\n        });\n    };\n    Range.defaultProps = {\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"],"sourceRoot":""}