diff --git a/public_html/noUiSlider/CHANGELOG.MD b/public_html/noUiSlider/CHANGELOG.MD new file mode 100644 index 0000000..6e4cc72 --- /dev/null +++ b/public_html/noUiSlider/CHANGELOG.MD @@ -0,0 +1,183 @@ +# Changelog + +### 14.6.3 (*2020-11-19*) +- Fixed: Fixed removing namespaced event listeners, internal listeners getting removed (#1109); + +### 14.6.2 (*2020-09-16*) +- Fixed: Ignore erroneous mouse events on taps for iOS 13.4 (#1095); +- Added: `exactInput` argument to `set` and `setHandle` methods (#436, #1094); + +### 14.6.1 (*2020-08-17*) +- Fixed: Pips in count mode ignores pip at end of range (#1088); + +### 14.6.0 (*2020-06-27*) +- Added: `keyboardPageMultiplier` and `keyboardDefaultStep` options (#1083); +- Fixed: Ignore erroneous tap events for iOS (#1057, #1079); + +### 14.5.0 (*2020-05-20*) +- Added: Support for `margin`, `padding` and `limit` on non-linear sliders (#911, #1030, #1031, #1071); + +### 14.4.0 (*2020-05-06*) +- Added: `getOrigins` and `getTooltips` methods; +- Added: Default styling to support merging overlapping tooltips (#1032); + +### 14.3.0 (*2020-05-05*) +- Added: Default `cssClasses` are now exposed and can be modified; +- Fixed: Destroying sliders with multiple classes in `cssClasses` fails (#1069); + +### 14.2.0 (*2020-03-27*) +- Added: Slider api as event parameter (#1058); +- Added: Allow multiple classes in `cssClasses` option (#1054); +- Fixed: Slider not working within shadow DOM (#1060); +- Fixed: Last pip not rendered if it is also the first and at the slider edge (#1063); + +### 14.1.1 (*2019-12-15*) +- Fixed: Text direction is not correctly determined when the slider is not in the DOM (#1038); + +### 14.1.0 (*2019-12-04*) +- Fixed: Styling requires a root `html` node, so noUiSlider can't be used in shadow dom (#1035); +- Added: Support for PageUp/PageDown and Home/End keys in keyboard support (#1036); + +### 14.0.3 (*2019-10-10*) +- Fixed: Initialising handle values near the slider edge does not always respect `margin` (#1009); + +### 14.0.2 (*2019-06-28*) +- Fixed: Keyboard interaction uses formatter when it does not need to (#1000); + +### 14.0.1 (*2019-06-21*) +- Fixed: Visual regression in Safari caused by fixing #987 (#998); + +### 14.0.0 (*2019-06-20*) +- Fixed: `change` & `slide` events should fire on keyboard control (#994); +- Fixed: `.noUi-origin` overflows document on vertical sliders (#987); +- Fixed: Clicking to right of handle doesn't move it when it's at the same point as another (#965); +- Added: Additional documentation on number formatting (#978, #985); + +### 13.1.5 (*2019-04-24*) +- Fixed: Full-range padding (#880); + +### 13.1.4 (*2019-03-20*) +- Fixed: Keyboard interaction does not work with `snap` option (#961); + +### 13.1.3 (*2019-03-15*) +- Fixed: Keyboard interaction allows handles to "push" other handles (#960); +- Fixed: Update event fires for all handles during keyboard interaction (#960); + +### 13.1.2 (*2019-03-13*) +- Fixed: Handle disappears in Safari on tap (#927); +- Fixed: Disabled slider still accepts keyboard interaction (#953); + +### 13.1.1 (*2019-02-14*) +- Fixed: Slider hang when using a zero-length range (#948); + +### 13.1.0 (*2019-02-08*) +- Fixed: Updating `pips` using `updateOptions` (#933); +- Added: Updating `tooltips` using `updateOptions` (#946); + +### 13.0.0 (*2019-02-06*) +noUiSlider 13 does not include any breaking API changes. +Keyboard support is now built-in, so any custom implementations should be removed when upgrading. +Alternatively, built-in keyboard support can be disabled using `keyboardSupport: false`. +- Added: Built-in keyboard support (#724); +- Added: `.noUi-touch-area` element (#924); +- Fixed: Dragging a range does not check for handle disabled state (#938); +- Fixed: Incorrect CSS transform in pips (#931); + +### 12.1.0 (*2018-10-25*) +- Added: `unconstrained` behaviour (#747, #815, #913); +- Added: `setHandle` API (#917); +- Changed: point to `nouislider.js` in `package.json`.`main` (#921); + +### 12.0.0 (*2018-09-14*) +- Change: License changed to MIT; +- Change: Build process is now based on NPM scripts, phasing out the Grunt task runner. +- Fixed: Aria values are now as per spec (#889); +- Change: Pips formatting are now written as HTML (#875); +- Change: The `filter` option is now called for all pips (#754); +- Added: The `filter` option can now return `-1` to hide a pip (#754); +- Added: `keyboardSupport` option (#867, #895); +- Added: `documentElement` option (#821); + +### 11.1.0 (*2018-04-02*) +- Change: `null` options are now handled consistently (#856); +- Fixed: Missing transform origin in IE9 (#870); +- Fixed: `padding` on one side of the slider could not exceed `50%` (#865); + +### 11.0.3 (*2018-01-21*) +Refactor of source code. There are no meaningful changes in the distributed files; + +### 11.0.2 (*2018-01-20*) +- Fixed: Slider ignores clicks on `.noUi-target` outside of `.noUi-base` (#842); +- Fixed: `.noUi-origin` moving out of the page causes horizontal scrolling (#852); +- Fixed: Relative `.noUi-handle` has unintended margin (#854); + +### 11.0.0 (*2018-01-12*) +noUiSlider 11 does not include any breaking API changes. +Unless major changes were made to the stylesheet or you specifically depend +on the handle/connect order in the DOM, there should be no issues upgrading. +- Change: Use CSS transforms for handle movement, resulting in a massive performance improvement (#718); +- Change: Support multitouch by default; +- Change: Handle stacking is now on `.noUi-origin` instead of `.noUi-handle`; +- Added: A `.noUi-connects` element holding all `.noUi-connect` elements; +- Added: `[data-value]` property for `.noUi-value` in pips (#733); +- Added: `padding` option can now take an array for different padding values at both sides of a slider (#822); +- Removed: `useRequestAnimationFrame` option. No longer needed with CSS transforms; +- Removed: `multitouch` option. Now enabled by default; +- Fixed: Slider could ignore end events it should handle (#704, #805, #834); +- Fixed: Stop depending on array type (#801); +- Fixed: `set` method might bypass margin option (#823); +- Fixed: Alignment of pips for RTL sliders (#795); +- Fixed: Several issues regarding pips (#812, #826, #832); + +### 10.1.0 (*2017-07-26*) +- Added: `multitouch` option (#793); + +### 10.0.0 (*2017-05-28*) +- Change: Change event listeners to be passive (#785); +- Fixed: Pips are now updated when calling `updateOptions` (#669); +- Fixed: Content Security Policy issue with pips; +- Added: `removePips` method; +- Added: aria support (#685); +- Added: `ariaFormat` option (controls `aria-valuetext`); +- Fixed: throw a better error when mistakenly trying to initialize noUiSlider with `null` (#658); +- Fixed: Made order of events consistent and documented it (#775); +- Fixed: Border radius of connect bar, white space wrapping of tooltips (#773, #774); +- Fixed: Slider now uses `ownerDocument` instead of `document` (#767); + +### 9.2.0 (*2017-01-17*) +- Added: Version number to exceptions; +- Added: `noUiSlider.version` holds current version number; +- Added: Throw exception on invalid `pips` configuration (#721); +- Added: Merged pull request that uses less preprocessor to generate CSS (#735); + +### 9.1.0 (*2016-12-10*) +- Fixed: Slider not properly handling multitouch (#700, #704); +- Fixed: Removed a querySelector for the currently active handle (#720); +- Fixed: Removed iOS/webkit flashes on tap; +- Fixed: Incorrect error when using margin/limit with a step smaller than 0 (#736); +- Fixed: Drag option using incorrect cursor arrows (#681); +- Added: New `padding` option (#711); +- Added: Re-introduced `.noUi-handle-lower` and `.noUi-handle-upper` classes removed in 9.0.0; +- Added: Compatibility for legacy `connect` options removed in 9.0.0; + +### 9.0.0 (*2016-09-26*) +- Added: Support for **more than 2 handles**; +- Added: `format` option can be updated (#641); +- Added: `reset` method the return slider to start values (#673); +- Change: `connect` option is now implemented as a separate node; +- Change: all event arguments, including the handle number, are now in slider order; +- Change: `updateOptions` now **modifies the original options** object. The reference in `slider.noUiSlider.options` remains up to date (#678); +- Change: more events fire when using various `behaviour` options (#664); +- Change: on `rtl` sliders, handles are now visually positioned from the sliders `right`/`bottom` edge; +- Change: events for `rtl` sliders now fire in the same order as for `ltr` sliders (with incremental handleNumbers); +- Change: internal `Spectrum` component is no longer `direction` aware; +- Change: `limit` and `margin` must be divisible by `step` (if set); +- Removed: `.noUi-stacking` class. Handles now stack themselves; +- ~~Removed~~ (returned in 9.1.0): `.noUi-handle-lower` and `.noUi-handle-upper` classes; +- Removed: `.noUi-background`. Use `.noUi-target` instead; +- ~~Removed~~ (backward compatibility in 9.1.0): `connect: 'lower'` and `connect: 'upper'`. These settings are replaced by `connect: [true, false]`; +- Fixed: default tooltip color (#687); +- Fixed: `margin` and `limit` calculated improperly after calling `updateOptions` with a new `range` option; +- Fixed: `range` option was required in update, even when not updating it (#682); +- Fixed: Cursor styling is now consistent for disabled handles and sliders (#644); +- Fixed: Sliders now ignore touches when the screen is touched multiple times (#649, #663, #668); diff --git a/public_html/noUiSlider/CONTRIBUTING.md b/public_html/noUiSlider/CONTRIBUTING.md new file mode 100644 index 0000000..d15d938 --- /dev/null +++ b/public_html/noUiSlider/CONTRIBUTING.md @@ -0,0 +1,25 @@ +# Issues +Please, only use the issue tracker for **problems, bugs and feature requests**. + +For help with _implementing_ noUiSlider, please ask your question on [stackoverflow](https://stackoverflow.com/questions/tagged/nouislider). I try to look at questions posted there daily, and you will get you an answer much faster. Make sure to follow the [guidelines](https://stackoverflow.com/help/how-to-ask) of the platform. + +While I'm happy to help if you can't figure something out, please note that I: +- Can't go and debug problems just based on screenshots; +- Can't help with issues that do not include **an example with code** that reproduces it; +- Won't dig through your production site or huge chunks of unrelated code; +- Won't implement your business requirements for you; + +# Tooling + +Please run the following tooling before submitting a pull request: + +```bash +npm run lint +npm run format +``` + +# Pull requests +- Detail (in the pull request comment) what your changes do. +- When applicable, include new unit tests, and make sure existing ones pass. +- If you are introducing a new feature, update the **documentation**. +- Please don't commit `/distribute/*` files, I'll do that upon release. diff --git a/public_html/noUiSlider/LICENSE.md b/public_html/noUiSlider/LICENSE.md new file mode 100644 index 0000000..98f4ca2 --- /dev/null +++ b/public_html/noUiSlider/LICENSE.md @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2019 Léon Gersen + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/public_html/noUiSlider/README.md b/public_html/noUiSlider/README.md new file mode 100644 index 0000000..50fc731 --- /dev/null +++ b/public_html/noUiSlider/README.md @@ -0,0 +1,41 @@ +# noUiSlider + +noUiSlider is a lightweight JavaScript range slider. + +- **No dependencies** +- All modern browsers and IE > 9 are supported +- Fully **responsive** +- **Multi-touch support** on Android, iOS and Windows devices +- Accessible with `aria` and keyboard support +- Tons of [examples](https://refreshless.com/nouislider/examples) and answered [Stack Overflow questions](https://stackoverflow.com/questions/tagged/nouislider) + +License +------- +noUiSlider is licensed [MIT](https://choosealicense.com/licenses/mit/). + +It can be used **for free** and **without any attribution**, in any personal or commercial project. + +[Documentation](https://refreshless.com/nouislider/) +------- +An extensive documentation, including **examples**, **options** and **configuration details**, is available here: + +[noUiSlider documentation](https://refreshless.com/nouislider/). + +Contributing +------------ + +See [Contributing](CONTRIBUTING.md). + +Sponsorship +----------- + +noUiSlider is a stable project that still receives a lot of feature requests. A lot of these are interesting, but require a good amount of effort to implement, test and document. Sponsorship of this project will allow me to spend some more of my time on these feature requests. + +Please consider sponsoring the project by clicking the "❤ Sponsor" button above. Thanks! + +Tooling +------- + +Cross-browser testing kindly provided by BrowserStack. + +[![Tested with BrowserStack](documentation/assets/browserstack-logo-380x90.png)](http://browserstack.com/) diff --git a/public_html/noUiSlider/distribute/nouislider.css b/public_html/noUiSlider/distribute/nouislider.css new file mode 100644 index 0000000..363ad9d --- /dev/null +++ b/public_html/noUiSlider/distribute/nouislider.css @@ -0,0 +1,310 @@ +/*! nouislider - 14.6.3 - 11/19/2020 */ +/* Functional styling; + * These styles are required for noUiSlider to function. + * You don't need to change these rules to apply your design. + */ +.noUi-target, +.noUi-target * { + -webkit-touch-callout: none; + -webkit-tap-highlight-color: rgba(0, 0, 0, 0); + -webkit-user-select: none; + -ms-touch-action: none; + touch-action: none; + -ms-user-select: none; + -moz-user-select: none; + user-select: none; + -moz-box-sizing: border-box; + box-sizing: border-box; +} +.noUi-target { + position: relative; +} +.noUi-base, +.noUi-connects { + width: 100%; + height: 100%; + position: relative; + z-index: 1; +} +/* Wrapper for all connect elements. + */ +.noUi-connects { + overflow: hidden; + z-index: 0; +} +.noUi-connect, +.noUi-origin { + will-change: transform; + position: absolute; + z-index: 1; + top: 0; + right: 0; + -ms-transform-origin: 0 0; + -webkit-transform-origin: 0 0; + -webkit-transform-style: preserve-3d; + transform-origin: 0 0; + transform-style: flat; +} +.noUi-connect { + height: 100%; + width: 100%; +} +.noUi-origin { + height: 10%; + width: 10%; +} +/* Offset direction + */ +.noUi-txt-dir-rtl.noUi-horizontal .noUi-origin { + left: 0; + right: auto; +} +/* Give origins 0 height/width so they don't interfere with clicking the + * connect elements. + */ +.noUi-vertical .noUi-origin { + width: 0; +} +.noUi-horizontal .noUi-origin { + height: 0; +} +.noUi-handle { + -webkit-backface-visibility: hidden; + backface-visibility: hidden; + position: absolute; +} +.noUi-touch-area { + height: 100%; + width: 100%; +} +.noUi-state-tap .noUi-connect, +.noUi-state-tap .noUi-origin { + -webkit-transition: transform 0.3s; + transition: transform 0.3s; +} +.noUi-state-drag * { + cursor: inherit !important; +} +/* Slider size and handle placement; + */ +.noUi-horizontal { + height: 18px; +} +.noUi-horizontal .noUi-handle { + width: 34px; + height: 28px; + right: -17px; + top: -6px; +} +.noUi-vertical { + width: 18px; +} +.noUi-vertical .noUi-handle { + width: 28px; + height: 34px; + right: -6px; + top: -17px; +} +.noUi-txt-dir-rtl.noUi-horizontal .noUi-handle { + left: -17px; + right: auto; +} +/* Styling; + * Giving the connect element a border radius causes issues with using transform: scale + */ +.noUi-target { + background: #FAFAFA; + border-radius: 4px; + border: 1px solid #D3D3D3; + box-shadow: inset 0 1px 1px #F0F0F0, 0 3px 6px -5px #BBB; +} +.noUi-connects { + border-radius: 3px; +} +.noUi-connect { + background: #3FB8AF; +} +/* Handles and cursors; + */ +.noUi-draggable { + cursor: ew-resize; +} +.noUi-vertical .noUi-draggable { + cursor: ns-resize; +} +.noUi-handle { + border: 1px solid #D9D9D9; + border-radius: 3px; + background: #FFF; + cursor: default; + box-shadow: inset 0 0 1px #FFF, inset 0 1px 7px #EBEBEB, 0 3px 6px -3px #BBB; +} +.noUi-active { + box-shadow: inset 0 0 1px #FFF, inset 0 1px 7px #DDD, 0 3px 6px -3px #BBB; +} +/* Handle stripes; + */ +.noUi-handle:before, +.noUi-handle:after { + content: ""; + display: block; + position: absolute; + height: 14px; + width: 1px; + background: #E8E7E6; + left: 14px; + top: 6px; +} +.noUi-handle:after { + left: 17px; +} +.noUi-vertical .noUi-handle:before, +.noUi-vertical .noUi-handle:after { + width: 14px; + height: 1px; + left: 6px; + top: 14px; +} +.noUi-vertical .noUi-handle:after { + top: 17px; +} +/* Disabled state; + */ +[disabled] .noUi-connect { + background: #B8B8B8; +} +[disabled].noUi-target, +[disabled].noUi-handle, +[disabled] .noUi-handle { + cursor: not-allowed; +} +/* Base; + * + */ +.noUi-pips, +.noUi-pips * { + -moz-box-sizing: border-box; + box-sizing: border-box; +} +.noUi-pips { + position: absolute; + color: #999; +} +/* Values; + * + */ +.noUi-value { + position: absolute; + white-space: nowrap; + text-align: center; +} +.noUi-value-sub { + color: #ccc; + font-size: 10px; +} +/* Markings; + * + */ +.noUi-marker { + position: absolute; + background: #CCC; +} +.noUi-marker-sub { + background: #AAA; +} +.noUi-marker-large { + background: #AAA; +} +/* Horizontal layout; + * + */ +.noUi-pips-horizontal { + padding: 10px 0; + height: 80px; + top: 100%; + left: 0; + width: 100%; +} +.noUi-value-horizontal { + -webkit-transform: translate(-50%, 50%); + transform: translate(-50%, 50%); +} +.noUi-rtl .noUi-value-horizontal { + -webkit-transform: translate(50%, 50%); + transform: translate(50%, 50%); +} +.noUi-marker-horizontal.noUi-marker { + margin-left: -1px; + width: 2px; + height: 5px; +} +.noUi-marker-horizontal.noUi-marker-sub { + height: 10px; +} +.noUi-marker-horizontal.noUi-marker-large { + height: 15px; +} +/* Vertical layout; + * + */ +.noUi-pips-vertical { + padding: 0 10px; + height: 100%; + top: 0; + left: 100%; +} +.noUi-value-vertical { + -webkit-transform: translate(0, -50%); + transform: translate(0, -50%); + padding-left: 25px; +} +.noUi-rtl .noUi-value-vertical { + -webkit-transform: translate(0, 50%); + transform: translate(0, 50%); +} +.noUi-marker-vertical.noUi-marker { + width: 5px; + height: 2px; + margin-top: -1px; +} +.noUi-marker-vertical.noUi-marker-sub { + width: 10px; +} +.noUi-marker-vertical.noUi-marker-large { + width: 15px; +} +.noUi-tooltip { + display: block; + position: absolute; + border: 1px solid #D9D9D9; + border-radius: 3px; + background: #fff; + color: #000; + padding: 5px; + text-align: center; + white-space: nowrap; +} +.noUi-horizontal .noUi-tooltip { + -webkit-transform: translate(-50%, 0); + transform: translate(-50%, 0); + left: 50%; + bottom: 120%; +} +.noUi-vertical .noUi-tooltip { + -webkit-transform: translate(0, -50%); + transform: translate(0, -50%); + top: 50%; + right: 120%; +} +.noUi-horizontal .noUi-origin > .noUi-tooltip { + -webkit-transform: translate(50%, 0); + transform: translate(50%, 0); + left: auto; + bottom: 10px; +} +.noUi-vertical .noUi-origin > .noUi-tooltip { + -webkit-transform: translate(0, -18px); + transform: translate(0, -18px); + top: auto; + right: 28px; +} diff --git a/public_html/noUiSlider/distribute/nouislider.js b/public_html/noUiSlider/distribute/nouislider.js new file mode 100644 index 0000000..4247067 --- /dev/null +++ b/public_html/noUiSlider/distribute/nouislider.js @@ -0,0 +1,2693 @@ +/*! nouislider - 14.6.3 - 11/19/2020 */ +(function(factory) { + if (typeof define === "function" && define.amd) { + // AMD. Register as an anonymous module. + define([], factory); + } else if (typeof exports === "object") { + // Node/CommonJS + module.exports = factory(); + } else { + // Browser globals + window.noUiSlider = factory(); + } +})(function() { + "use strict"; + + var VERSION = "14.6.3"; + + //region Helper Methods + + function isValidFormatter(entry) { + return typeof entry === "object" && typeof entry.to === "function" && typeof entry.from === "function"; + } + + function removeElement(el) { + el.parentElement.removeChild(el); + } + + function isSet(value) { + return value !== null && value !== undefined; + } + + // Bindable version + function preventDefault(e) { + e.preventDefault(); + } + + // Removes duplicates from an array. + function unique(array) { + return array.filter(function(a) { + return !this[a] ? (this[a] = true) : false; + }, {}); + } + + // Round a value to the closest 'to'. + function closest(value, to) { + return Math.round(value / to) * to; + } + + // Current position of an element relative to the document. + function offset(elem, orientation) { + var rect = elem.getBoundingClientRect(); + var doc = elem.ownerDocument; + var docElem = doc.documentElement; + var pageOffset = getPageOffset(doc); + + // getBoundingClientRect contains left scroll in Chrome on Android. + // I haven't found a feature detection that proves this. Worst case + // scenario on mis-match: the 'tap' feature on horizontal sliders breaks. + if (/webkit.*Chrome.*Mobile/i.test(navigator.userAgent)) { + pageOffset.x = 0; + } + + return orientation + ? rect.top + pageOffset.y - docElem.clientTop + : rect.left + pageOffset.x - docElem.clientLeft; + } + + // Checks whether a value is numerical. + function isNumeric(a) { + return typeof a === "number" && !isNaN(a) && isFinite(a); + } + + // Sets a class and removes it after [duration] ms. + function addClassFor(element, className, duration) { + if (duration > 0) { + addClass(element, className); + setTimeout(function() { + removeClass(element, className); + }, duration); + } + } + + // Limits a value to 0 - 100 + function limit(a) { + return Math.max(Math.min(a, 100), 0); + } + + // Wraps a variable as an array, if it isn't one yet. + // Note that an input array is returned by reference! + function asArray(a) { + return Array.isArray(a) ? a : [a]; + } + + // Counts decimals + function countDecimals(numStr) { + numStr = String(numStr); + var pieces = numStr.split("."); + return pieces.length > 1 ? pieces[1].length : 0; + } + + // http://youmightnotneedjquery.com/#add_class + function addClass(el, className) { + if (el.classList && !/\s/.test(className)) { + el.classList.add(className); + } else { + el.className += " " + className; + } + } + + // http://youmightnotneedjquery.com/#remove_class + function removeClass(el, className) { + if (el.classList && !/\s/.test(className)) { + el.classList.remove(className); + } else { + el.className = el.className.replace( + new RegExp("(^|\\b)" + className.split(" ").join("|") + "(\\b|$)", "gi"), + " " + ); + } + } + + // https://plainjs.com/javascript/attributes/adding-removing-and-testing-for-classes-9/ + function hasClass(el, className) { + return el.classList + ? el.classList.contains(className) + : new RegExp("\\b" + className + "\\b").test(el.className); + } + + // https://developer.mozilla.org/en-US/docs/Web/API/Window/scrollY#Notes + function getPageOffset(doc) { + var supportPageOffset = window.pageXOffset !== undefined; + var isCSS1Compat = (doc.compatMode || "") === "CSS1Compat"; + var x = supportPageOffset + ? window.pageXOffset + : isCSS1Compat + ? doc.documentElement.scrollLeft + : doc.body.scrollLeft; + var y = supportPageOffset + ? window.pageYOffset + : isCSS1Compat + ? doc.documentElement.scrollTop + : doc.body.scrollTop; + + return { + x: x, + y: y + }; + } + + // we provide a function to compute constants instead + // of accessing window.* as soon as the module needs it + // so that we do not compute anything if not needed + function getActions() { + // Determine the events to bind. IE11 implements pointerEvents without + // a prefix, which breaks compatibility with the IE10 implementation. + return window.navigator.pointerEnabled + ? { + start: "pointerdown", + move: "pointermove", + end: "pointerup" + } + : window.navigator.msPointerEnabled + ? { + start: "MSPointerDown", + move: "MSPointerMove", + end: "MSPointerUp" + } + : { + start: "mousedown touchstart", + move: "mousemove touchmove", + end: "mouseup touchend" + }; + } + + // https://github.com/WICG/EventListenerOptions/blob/gh-pages/explainer.md + // Issue #785 + function getSupportsPassive() { + var supportsPassive = false; + + /* eslint-disable */ + try { + var opts = Object.defineProperty({}, "passive", { + get: function() { + supportsPassive = true; + } + }); + + window.addEventListener("test", null, opts); + } catch (e) {} + /* eslint-enable */ + + return supportsPassive; + } + + function getSupportsTouchActionNone() { + return window.CSS && CSS.supports && CSS.supports("touch-action", "none"); + } + + //endregion + + //region Range Calculation + + // Determine the size of a sub-range in relation to a full range. + function subRangeRatio(pa, pb) { + return 100 / (pb - pa); + } + + // (percentage) How many percent is this value of this range? + function fromPercentage(range, value, startRange) { + return (value * 100) / (range[startRange + 1] - range[startRange]); + } + + // (percentage) Where is this value on this range? + function toPercentage(range, value) { + return fromPercentage(range, range[0] < 0 ? value + Math.abs(range[0]) : value - range[0], 0); + } + + // (value) How much is this percentage on this range? + function isPercentage(range, value) { + return (value * (range[1] - range[0])) / 100 + range[0]; + } + + function getJ(value, arr) { + var j = 1; + + while (value >= arr[j]) { + j += 1; + } + + return j; + } + + // (percentage) Input a value, find where, on a scale of 0-100, it applies. + function toStepping(xVal, xPct, value) { + if (value >= xVal.slice(-1)[0]) { + return 100; + } + + var j = getJ(value, xVal); + var va = xVal[j - 1]; + var vb = xVal[j]; + var pa = xPct[j - 1]; + var pb = xPct[j]; + + return pa + toPercentage([va, vb], value) / subRangeRatio(pa, pb); + } + + // (value) Input a percentage, find where it is on the specified range. + function fromStepping(xVal, xPct, value) { + // There is no range group that fits 100 + if (value >= 100) { + return xVal.slice(-1)[0]; + } + + var j = getJ(value, xPct); + var va = xVal[j - 1]; + var vb = xVal[j]; + var pa = xPct[j - 1]; + var pb = xPct[j]; + + return isPercentage([va, vb], (value - pa) * subRangeRatio(pa, pb)); + } + + // (percentage) Get the step that applies at a certain value. + function getStep(xPct, xSteps, snap, value) { + if (value === 100) { + return value; + } + + var j = getJ(value, xPct); + var a = xPct[j - 1]; + var b = xPct[j]; + + // If 'snap' is set, steps are used as fixed points on the slider. + if (snap) { + // Find the closest position, a or b. + if (value - a > (b - a) / 2) { + return b; + } + + return a; + } + + if (!xSteps[j - 1]) { + return value; + } + + return xPct[j - 1] + closest(value - xPct[j - 1], xSteps[j - 1]); + } + + function handleEntryPoint(index, value, that) { + var percentage; + + // Wrap numerical input in an array. + if (typeof value === "number") { + value = [value]; + } + + // Reject any invalid input, by testing whether value is an array. + if (!Array.isArray(value)) { + throw new Error("noUiSlider (" + VERSION + "): 'range' contains invalid value."); + } + + // Covert min/max syntax to 0 and 100. + if (index === "min") { + percentage = 0; + } else if (index === "max") { + percentage = 100; + } else { + percentage = parseFloat(index); + } + + // Check for correct input. + if (!isNumeric(percentage) || !isNumeric(value[0])) { + throw new Error("noUiSlider (" + VERSION + "): 'range' value isn't numeric."); + } + + // Store values. + that.xPct.push(percentage); + that.xVal.push(value[0]); + + // NaN will evaluate to false too, but to keep + // logging clear, set step explicitly. Make sure + // not to override the 'step' setting with false. + if (!percentage) { + if (!isNaN(value[1])) { + that.xSteps[0] = value[1]; + } + } else { + that.xSteps.push(isNaN(value[1]) ? false : value[1]); + } + + that.xHighestCompleteStep.push(0); + } + + function handleStepPoint(i, n, that) { + // Ignore 'false' stepping. + if (!n) { + return; + } + + // Step over zero-length ranges (#948); + if (that.xVal[i] === that.xVal[i + 1]) { + that.xSteps[i] = that.xHighestCompleteStep[i] = that.xVal[i]; + + return; + } + + // Factor to range ratio + that.xSteps[i] = + fromPercentage([that.xVal[i], that.xVal[i + 1]], n, 0) / subRangeRatio(that.xPct[i], that.xPct[i + 1]); + + var totalSteps = (that.xVal[i + 1] - that.xVal[i]) / that.xNumSteps[i]; + var highestStep = Math.ceil(Number(totalSteps.toFixed(3)) - 1); + var step = that.xVal[i] + that.xNumSteps[i] * highestStep; + + that.xHighestCompleteStep[i] = step; + } + + //endregion + + //region Spectrum + + function Spectrum(entry, snap, singleStep) { + this.xPct = []; + this.xVal = []; + this.xSteps = [singleStep || false]; + this.xNumSteps = [false]; + this.xHighestCompleteStep = []; + + this.snap = snap; + + var index; + var ordered = []; // [0, 'min'], [1, '50%'], [2, 'max'] + + // Map the object keys to an array. + for (index in entry) { + if (entry.hasOwnProperty(index)) { + ordered.push([entry[index], index]); + } + } + + // Sort all entries by value (numeric sort). + if (ordered.length && typeof ordered[0][0] === "object") { + ordered.sort(function(a, b) { + return a[0][0] - b[0][0]; + }); + } else { + ordered.sort(function(a, b) { + return a[0] - b[0]; + }); + } + + // Convert all entries to subranges. + for (index = 0; index < ordered.length; index++) { + handleEntryPoint(ordered[index][1], ordered[index][0], this); + } + + // Store the actual step values. + // xSteps is sorted in the same order as xPct and xVal. + this.xNumSteps = this.xSteps.slice(0); + + // Convert all numeric steps to the percentage of the subrange they represent. + for (index = 0; index < this.xNumSteps.length; index++) { + handleStepPoint(index, this.xNumSteps[index], this); + } + } + + Spectrum.prototype.getDistance = function(value) { + var index; + var distances = []; + + for (index = 0; index < this.xNumSteps.length - 1; index++) { + // last "range" can't contain step size as it is purely an endpoint. + var step = this.xNumSteps[index]; + + if (step && (value / step) % 1 !== 0) { + throw new Error( + "noUiSlider (" + + VERSION + + "): 'limit', 'margin' and 'padding' of " + + this.xPct[index] + + "% range must be divisible by step." + ); + } + + // Calculate percentual distance in current range of limit, margin or padding + distances[index] = fromPercentage(this.xVal, value, index); + } + + return distances; + }; + + // Calculate the percentual distance over the whole scale of ranges. + // direction: 0 = backwards / 1 = forwards + Spectrum.prototype.getAbsoluteDistance = function(value, distances, direction) { + var xPct_index = 0; + + // Calculate range where to start calculation + if (value < this.xPct[this.xPct.length - 1]) { + while (value > this.xPct[xPct_index + 1]) { + xPct_index++; + } + } else if (value === this.xPct[this.xPct.length - 1]) { + xPct_index = this.xPct.length - 2; + } + + // If looking backwards and the value is exactly at a range separator then look one range further + if (!direction && value === this.xPct[xPct_index + 1]) { + xPct_index++; + } + + var start_factor; + var rest_factor = 1; + + var rest_rel_distance = distances[xPct_index]; + + var range_pct = 0; + + var rel_range_distance = 0; + var abs_distance_counter = 0; + var range_counter = 0; + + // Calculate what part of the start range the value is + if (direction) { + start_factor = (value - this.xPct[xPct_index]) / (this.xPct[xPct_index + 1] - this.xPct[xPct_index]); + } else { + start_factor = (this.xPct[xPct_index + 1] - value) / (this.xPct[xPct_index + 1] - this.xPct[xPct_index]); + } + + // Do until the complete distance across ranges is calculated + while (rest_rel_distance > 0) { + // Calculate the percentage of total range + range_pct = this.xPct[xPct_index + 1 + range_counter] - this.xPct[xPct_index + range_counter]; + + // Detect if the margin, padding or limit is larger then the current range and calculate + if (distances[xPct_index + range_counter] * rest_factor + 100 - start_factor * 100 > 100) { + // If larger then take the percentual distance of the whole range + rel_range_distance = range_pct * start_factor; + // Rest factor of relative percentual distance still to be calculated + rest_factor = (rest_rel_distance - 100 * start_factor) / distances[xPct_index + range_counter]; + // Set start factor to 1 as for next range it does not apply. + start_factor = 1; + } else { + // If smaller or equal then take the percentual distance of the calculate percentual part of that range + rel_range_distance = ((distances[xPct_index + range_counter] * range_pct) / 100) * rest_factor; + // No rest left as the rest fits in current range + rest_factor = 0; + } + + if (direction) { + abs_distance_counter = abs_distance_counter - rel_range_distance; + // Limit range to first range when distance becomes outside of minimum range + if (this.xPct.length + range_counter >= 1) { + range_counter--; + } + } else { + abs_distance_counter = abs_distance_counter + rel_range_distance; + // Limit range to last range when distance becomes outside of maximum range + if (this.xPct.length - range_counter >= 1) { + range_counter++; + } + } + + // Rest of relative percentual distance still to be calculated + rest_rel_distance = distances[xPct_index + range_counter] * rest_factor; + } + + return value + abs_distance_counter; + }; + + Spectrum.prototype.toStepping = function(value) { + value = toStepping(this.xVal, this.xPct, value); + + return value; + }; + + Spectrum.prototype.fromStepping = function(value) { + return fromStepping(this.xVal, this.xPct, value); + }; + + Spectrum.prototype.getStep = function(value) { + value = getStep(this.xPct, this.xSteps, this.snap, value); + + return value; + }; + + Spectrum.prototype.getDefaultStep = function(value, isDown, size) { + var j = getJ(value, this.xPct); + + // When at the top or stepping down, look at the previous sub-range + if (value === 100 || (isDown && value === this.xPct[j - 1])) { + j = Math.max(j - 1, 1); + } + + return (this.xVal[j] - this.xVal[j - 1]) / size; + }; + + Spectrum.prototype.getNearbySteps = function(value) { + var j = getJ(value, this.xPct); + + return { + stepBefore: { + startValue: this.xVal[j - 2], + step: this.xNumSteps[j - 2], + highestStep: this.xHighestCompleteStep[j - 2] + }, + thisStep: { + startValue: this.xVal[j - 1], + step: this.xNumSteps[j - 1], + highestStep: this.xHighestCompleteStep[j - 1] + }, + stepAfter: { + startValue: this.xVal[j], + step: this.xNumSteps[j], + highestStep: this.xHighestCompleteStep[j] + } + }; + }; + + Spectrum.prototype.countStepDecimals = function() { + var stepDecimals = this.xNumSteps.map(countDecimals); + return Math.max.apply(null, stepDecimals); + }; + + // Outside testing + Spectrum.prototype.convert = function(value) { + return this.getStep(this.toStepping(value)); + }; + + //endregion + + //region Options + + /* Every input option is tested and parsed. This'll prevent + endless validation in internal methods. These tests are + structured with an item for every option available. An + option can be marked as required by setting the 'r' flag. + The testing function is provided with three arguments: + - The provided value for the option; + - A reference to the options object; + - The name for the option; + + The testing function returns false when an error is detected, + or true when everything is OK. It can also modify the option + object, to make sure all values can be correctly looped elsewhere. */ + + //region Defaults + + var defaultFormatter = { + to: function(value) { + return value !== undefined && value.toFixed(2); + }, + from: Number + }; + + var cssClasses = { + target: "target", + base: "base", + origin: "origin", + handle: "handle", + handleLower: "handle-lower", + handleUpper: "handle-upper", + touchArea: "touch-area", + horizontal: "horizontal", + vertical: "vertical", + background: "background", + connect: "connect", + connects: "connects", + ltr: "ltr", + rtl: "rtl", + textDirectionLtr: "txt-dir-ltr", + textDirectionRtl: "txt-dir-rtl", + draggable: "draggable", + drag: "state-drag", + tap: "state-tap", + active: "active", + tooltip: "tooltip", + pips: "pips", + pipsHorizontal: "pips-horizontal", + pipsVertical: "pips-vertical", + marker: "marker", + markerHorizontal: "marker-horizontal", + markerVertical: "marker-vertical", + markerNormal: "marker-normal", + markerLarge: "marker-large", + markerSub: "marker-sub", + value: "value", + valueHorizontal: "value-horizontal", + valueVertical: "value-vertical", + valueNormal: "value-normal", + valueLarge: "value-large", + valueSub: "value-sub" + }; + + // Namespaces of internal event listeners + var INTERNAL_EVENT_NS = { + tooltips: ".__tooltips", + aria: ".__aria" + }; + + //endregion + + function validateFormat(entry) { + // Any object with a to and from method is supported. + if (isValidFormatter(entry)) { + return true; + } + + throw new Error("noUiSlider (" + VERSION + "): 'format' requires 'to' and 'from' methods."); + } + + function testStep(parsed, entry) { + if (!isNumeric(entry)) { + throw new Error("noUiSlider (" + VERSION + "): 'step' is not numeric."); + } + + // The step option can still be used to set stepping + // for linear sliders. Overwritten if set in 'range'. + parsed.singleStep = entry; + } + + function testKeyboardPageMultiplier(parsed, entry) { + if (!isNumeric(entry)) { + throw new Error("noUiSlider (" + VERSION + "): 'keyboardPageMultiplier' is not numeric."); + } + + parsed.keyboardPageMultiplier = entry; + } + + function testKeyboardDefaultStep(parsed, entry) { + if (!isNumeric(entry)) { + throw new Error("noUiSlider (" + VERSION + "): 'keyboardDefaultStep' is not numeric."); + } + + parsed.keyboardDefaultStep = entry; + } + + function testRange(parsed, entry) { + // Filter incorrect input. + if (typeof entry !== "object" || Array.isArray(entry)) { + throw new Error("noUiSlider (" + VERSION + "): 'range' is not an object."); + } + + // Catch missing start or end. + if (entry.min === undefined || entry.max === undefined) { + throw new Error("noUiSlider (" + VERSION + "): Missing 'min' or 'max' in 'range'."); + } + + // Catch equal start or end. + if (entry.min === entry.max) { + throw new Error("noUiSlider (" + VERSION + "): 'range' 'min' and 'max' cannot be equal."); + } + + parsed.spectrum = new Spectrum(entry, parsed.snap, parsed.singleStep); + } + + function testStart(parsed, entry) { + entry = asArray(entry); + + // Validate input. Values aren't tested, as the public .val method + // will always provide a valid location. + if (!Array.isArray(entry) || !entry.length) { + throw new Error("noUiSlider (" + VERSION + "): 'start' option is incorrect."); + } + + // Store the number of handles. + parsed.handles = entry.length; + + // When the slider is initialized, the .val method will + // be called with the start options. + parsed.start = entry; + } + + function testSnap(parsed, entry) { + // Enforce 100% stepping within subranges. + parsed.snap = entry; + + if (typeof entry !== "boolean") { + throw new Error("noUiSlider (" + VERSION + "): 'snap' option must be a boolean."); + } + } + + function testAnimate(parsed, entry) { + // Enforce 100% stepping within subranges. + parsed.animate = entry; + + if (typeof entry !== "boolean") { + throw new Error("noUiSlider (" + VERSION + "): 'animate' option must be a boolean."); + } + } + + function testAnimationDuration(parsed, entry) { + parsed.animationDuration = entry; + + if (typeof entry !== "number") { + throw new Error("noUiSlider (" + VERSION + "): 'animationDuration' option must be a number."); + } + } + + function testConnect(parsed, entry) { + var connect = [false]; + var i; + + // Map legacy options + if (entry === "lower") { + entry = [true, false]; + } else if (entry === "upper") { + entry = [false, true]; + } + + // Handle boolean options + if (entry === true || entry === false) { + for (i = 1; i < parsed.handles; i++) { + connect.push(entry); + } + + connect.push(false); + } + + // Reject invalid input + else if (!Array.isArray(entry) || !entry.length || entry.length !== parsed.handles + 1) { + throw new Error("noUiSlider (" + VERSION + "): 'connect' option doesn't match handle count."); + } else { + connect = entry; + } + + parsed.connect = connect; + } + + function testOrientation(parsed, entry) { + // Set orientation to an a numerical value for easy + // array selection. + switch (entry) { + case "horizontal": + parsed.ort = 0; + break; + case "vertical": + parsed.ort = 1; + break; + default: + throw new Error("noUiSlider (" + VERSION + "): 'orientation' option is invalid."); + } + } + + function testMargin(parsed, entry) { + if (!isNumeric(entry)) { + throw new Error("noUiSlider (" + VERSION + "): 'margin' option must be numeric."); + } + + // Issue #582 + if (entry === 0) { + return; + } + + parsed.margin = parsed.spectrum.getDistance(entry); + } + + function testLimit(parsed, entry) { + if (!isNumeric(entry)) { + throw new Error("noUiSlider (" + VERSION + "): 'limit' option must be numeric."); + } + + parsed.limit = parsed.spectrum.getDistance(entry); + + if (!parsed.limit || parsed.handles < 2) { + throw new Error( + "noUiSlider (" + + VERSION + + "): 'limit' option is only supported on linear sliders with 2 or more handles." + ); + } + } + + function testPadding(parsed, entry) { + var index; + + if (!isNumeric(entry) && !Array.isArray(entry)) { + throw new Error( + "noUiSlider (" + VERSION + "): 'padding' option must be numeric or array of exactly 2 numbers." + ); + } + + if (Array.isArray(entry) && !(entry.length === 2 || isNumeric(entry[0]) || isNumeric(entry[1]))) { + throw new Error( + "noUiSlider (" + VERSION + "): 'padding' option must be numeric or array of exactly 2 numbers." + ); + } + + if (entry === 0) { + return; + } + + if (!Array.isArray(entry)) { + entry = [entry, entry]; + } + + // 'getDistance' returns false for invalid values. + parsed.padding = [parsed.spectrum.getDistance(entry[0]), parsed.spectrum.getDistance(entry[1])]; + + for (index = 0; index < parsed.spectrum.xNumSteps.length - 1; index++) { + // last "range" can't contain step size as it is purely an endpoint. + if (parsed.padding[0][index] < 0 || parsed.padding[1][index] < 0) { + throw new Error("noUiSlider (" + VERSION + "): 'padding' option must be a positive number(s)."); + } + } + + var totalPadding = entry[0] + entry[1]; + var firstValue = parsed.spectrum.xVal[0]; + var lastValue = parsed.spectrum.xVal[parsed.spectrum.xVal.length - 1]; + + if (totalPadding / (lastValue - firstValue) > 1) { + throw new Error("noUiSlider (" + VERSION + "): 'padding' option must not exceed 100% of the range."); + } + } + + function testDirection(parsed, entry) { + // Set direction as a numerical value for easy parsing. + // Invert connection for RTL sliders, so that the proper + // handles get the connect/background classes. + switch (entry) { + case "ltr": + parsed.dir = 0; + break; + case "rtl": + parsed.dir = 1; + break; + default: + throw new Error("noUiSlider (" + VERSION + "): 'direction' option was not recognized."); + } + } + + function testBehaviour(parsed, entry) { + // Make sure the input is a string. + if (typeof entry !== "string") { + throw new Error("noUiSlider (" + VERSION + "): 'behaviour' must be a string containing options."); + } + + // Check if the string contains any keywords. + // None are required. + var tap = entry.indexOf("tap") >= 0; + var drag = entry.indexOf("drag") >= 0; + var fixed = entry.indexOf("fixed") >= 0; + var snap = entry.indexOf("snap") >= 0; + var hover = entry.indexOf("hover") >= 0; + var unconstrained = entry.indexOf("unconstrained") >= 0; + + if (fixed) { + if (parsed.handles !== 2) { + throw new Error("noUiSlider (" + VERSION + "): 'fixed' behaviour must be used with 2 handles"); + } + + // Use margin to enforce fixed state + testMargin(parsed, parsed.start[1] - parsed.start[0]); + } + + if (unconstrained && (parsed.margin || parsed.limit)) { + throw new Error( + "noUiSlider (" + VERSION + "): 'unconstrained' behaviour cannot be used with margin or limit" + ); + } + + parsed.events = { + tap: tap || snap, + drag: drag, + fixed: fixed, + snap: snap, + hover: hover, + unconstrained: unconstrained + }; + } + + function testTooltips(parsed, entry) { + if (entry === false) { + return; + } + + if (entry === true) { + parsed.tooltips = []; + + for (var i = 0; i < parsed.handles; i++) { + parsed.tooltips.push(true); + } + } else { + parsed.tooltips = asArray(entry); + + if (parsed.tooltips.length !== parsed.handles) { + throw new Error("noUiSlider (" + VERSION + "): must pass a formatter for all handles."); + } + + parsed.tooltips.forEach(function(formatter) { + if ( + typeof formatter !== "boolean" && + (typeof formatter !== "object" || typeof formatter.to !== "function") + ) { + throw new Error("noUiSlider (" + VERSION + "): 'tooltips' must be passed a formatter or 'false'."); + } + }); + } + } + + function testAriaFormat(parsed, entry) { + parsed.ariaFormat = entry; + validateFormat(entry); + } + + function testFormat(parsed, entry) { + parsed.format = entry; + validateFormat(entry); + } + + function testKeyboardSupport(parsed, entry) { + parsed.keyboardSupport = entry; + + if (typeof entry !== "boolean") { + throw new Error("noUiSlider (" + VERSION + "): 'keyboardSupport' option must be a boolean."); + } + } + + function testDocumentElement(parsed, entry) { + // This is an advanced option. Passed values are used without validation. + parsed.documentElement = entry; + } + + function testCssPrefix(parsed, entry) { + if (typeof entry !== "string" && entry !== false) { + throw new Error("noUiSlider (" + VERSION + "): 'cssPrefix' must be a string or `false`."); + } + + parsed.cssPrefix = entry; + } + + function testCssClasses(parsed, entry) { + if (typeof entry !== "object") { + throw new Error("noUiSlider (" + VERSION + "): 'cssClasses' must be an object."); + } + + if (typeof parsed.cssPrefix === "string") { + parsed.cssClasses = {}; + + for (var key in entry) { + if (!entry.hasOwnProperty(key)) { + continue; + } + + parsed.cssClasses[key] = parsed.cssPrefix + entry[key]; + } + } else { + parsed.cssClasses = entry; + } + } + + // Test all developer settings and parse to assumption-safe values. + function testOptions(options) { + // To prove a fix for #537, freeze options here. + // If the object is modified, an error will be thrown. + // Object.freeze(options); + + var parsed = { + margin: 0, + limit: 0, + padding: 0, + animate: true, + animationDuration: 300, + ariaFormat: defaultFormatter, + format: defaultFormatter + }; + + // Tests are executed in the order they are presented here. + var tests = { + step: { r: false, t: testStep }, + keyboardPageMultiplier: { r: false, t: testKeyboardPageMultiplier }, + keyboardDefaultStep: { r: false, t: testKeyboardDefaultStep }, + start: { r: true, t: testStart }, + connect: { r: true, t: testConnect }, + direction: { r: true, t: testDirection }, + snap: { r: false, t: testSnap }, + animate: { r: false, t: testAnimate }, + animationDuration: { r: false, t: testAnimationDuration }, + range: { r: true, t: testRange }, + orientation: { r: false, t: testOrientation }, + margin: { r: false, t: testMargin }, + limit: { r: false, t: testLimit }, + padding: { r: false, t: testPadding }, + behaviour: { r: true, t: testBehaviour }, + ariaFormat: { r: false, t: testAriaFormat }, + format: { r: false, t: testFormat }, + tooltips: { r: false, t: testTooltips }, + keyboardSupport: { r: true, t: testKeyboardSupport }, + documentElement: { r: false, t: testDocumentElement }, + cssPrefix: { r: true, t: testCssPrefix }, + cssClasses: { r: true, t: testCssClasses } + }; + + var defaults = { + connect: false, + direction: "ltr", + behaviour: "tap", + orientation: "horizontal", + keyboardSupport: true, + cssPrefix: "noUi-", + cssClasses: cssClasses, + keyboardPageMultiplier: 5, + keyboardDefaultStep: 10 + }; + + // AriaFormat defaults to regular format, if any. + if (options.format && !options.ariaFormat) { + options.ariaFormat = options.format; + } + + // Run all options through a testing mechanism to ensure correct + // input. It should be noted that options might get modified to + // be handled properly. E.g. wrapping integers in arrays. + Object.keys(tests).forEach(function(name) { + // If the option isn't set, but it is required, throw an error. + if (!isSet(options[name]) && defaults[name] === undefined) { + if (tests[name].r) { + throw new Error("noUiSlider (" + VERSION + "): '" + name + "' is required."); + } + + return true; + } + + tests[name].t(parsed, !isSet(options[name]) ? defaults[name] : options[name]); + }); + + // Forward pips options + parsed.pips = options.pips; + + // All recent browsers accept unprefixed transform. + // We need -ms- for IE9 and -webkit- for older Android; + // Assume use of -webkit- if unprefixed and -ms- are not supported. + // https://caniuse.com/#feat=transforms2d + var d = document.createElement("div"); + var msPrefix = d.style.msTransform !== undefined; + var noPrefix = d.style.transform !== undefined; + + parsed.transformRule = noPrefix ? "transform" : msPrefix ? "msTransform" : "webkitTransform"; + + // Pips don't move, so we can place them using left/top. + var styles = [["left", "top"], ["right", "bottom"]]; + + parsed.style = styles[parsed.dir][parsed.ort]; + + return parsed; + } + + //endregion + + function scope(target, options, originalOptions) { + var actions = getActions(); + var supportsTouchActionNone = getSupportsTouchActionNone(); + var supportsPassive = supportsTouchActionNone && getSupportsPassive(); + + // All variables local to 'scope' are prefixed with 'scope_' + + // Slider DOM Nodes + var scope_Target = target; + var scope_Base; + var scope_Handles; + var scope_Connects; + var scope_Pips; + var scope_Tooltips; + + // Slider state values + var scope_Spectrum = options.spectrum; + var scope_Values = []; + var scope_Locations = []; + var scope_HandleNumbers = []; + var scope_ActiveHandlesCount = 0; + var scope_Events = {}; + + // Exposed API + var scope_Self; + + // Document Nodes + var scope_Document = target.ownerDocument; + var scope_DocumentElement = options.documentElement || scope_Document.documentElement; + var scope_Body = scope_Document.body; + + // Pips constants + var PIPS_NONE = -1; + var PIPS_NO_VALUE = 0; + var PIPS_LARGE_VALUE = 1; + var PIPS_SMALL_VALUE = 2; + + // For horizontal sliders in standard ltr documents, + // make .noUi-origin overflow to the left so the document doesn't scroll. + var scope_DirOffset = scope_Document.dir === "rtl" || options.ort === 1 ? 0 : 100; + + // Creates a node, adds it to target, returns the new node. + function addNodeTo(addTarget, className) { + var div = scope_Document.createElement("div"); + + if (className) { + addClass(div, className); + } + + addTarget.appendChild(div); + + return div; + } + + // Append a origin to the base + function addOrigin(base, handleNumber) { + var origin = addNodeTo(base, options.cssClasses.origin); + var handle = addNodeTo(origin, options.cssClasses.handle); + + addNodeTo(handle, options.cssClasses.touchArea); + + handle.setAttribute("data-handle", handleNumber); + + if (options.keyboardSupport) { + // https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/tabindex + // 0 = focusable and reachable + handle.setAttribute("tabindex", "0"); + handle.addEventListener("keydown", function(event) { + return eventKeydown(event, handleNumber); + }); + } + + handle.setAttribute("role", "slider"); + handle.setAttribute("aria-orientation", options.ort ? "vertical" : "horizontal"); + + if (handleNumber === 0) { + addClass(handle, options.cssClasses.handleLower); + } else if (handleNumber === options.handles - 1) { + addClass(handle, options.cssClasses.handleUpper); + } + + return origin; + } + + // Insert nodes for connect elements + function addConnect(base, add) { + if (!add) { + return false; + } + + return addNodeTo(base, options.cssClasses.connect); + } + + // Add handles to the slider base. + function addElements(connectOptions, base) { + var connectBase = addNodeTo(base, options.cssClasses.connects); + + scope_Handles = []; + scope_Connects = []; + + scope_Connects.push(addConnect(connectBase, connectOptions[0])); + + // [::::O====O====O====] + // connectOptions = [0, 1, 1, 1] + + for (var i = 0; i < options.handles; i++) { + // Keep a list of all added handles. + scope_Handles.push(addOrigin(base, i)); + scope_HandleNumbers[i] = i; + scope_Connects.push(addConnect(connectBase, connectOptions[i + 1])); + } + } + + // Initialize a single slider. + function addSlider(addTarget) { + // Apply classes and data to the target. + addClass(addTarget, options.cssClasses.target); + + if (options.dir === 0) { + addClass(addTarget, options.cssClasses.ltr); + } else { + addClass(addTarget, options.cssClasses.rtl); + } + + if (options.ort === 0) { + addClass(addTarget, options.cssClasses.horizontal); + } else { + addClass(addTarget, options.cssClasses.vertical); + } + + var textDirection = getComputedStyle(addTarget).direction; + + if (textDirection === "rtl") { + addClass(addTarget, options.cssClasses.textDirectionRtl); + } else { + addClass(addTarget, options.cssClasses.textDirectionLtr); + } + + return addNodeTo(addTarget, options.cssClasses.base); + } + + function addTooltip(handle, handleNumber) { + if (!options.tooltips[handleNumber]) { + return false; + } + + return addNodeTo(handle.firstChild, options.cssClasses.tooltip); + } + + function isSliderDisabled() { + return scope_Target.hasAttribute("disabled"); + } + + // Disable the slider dragging if any handle is disabled + function isHandleDisabled(handleNumber) { + var handleOrigin = scope_Handles[handleNumber]; + return handleOrigin.hasAttribute("disabled"); + } + + function removeTooltips() { + if (scope_Tooltips) { + removeEvent("update" + INTERNAL_EVENT_NS.tooltips); + scope_Tooltips.forEach(function(tooltip) { + if (tooltip) { + removeElement(tooltip); + } + }); + scope_Tooltips = null; + } + } + + // The tooltips option is a shorthand for using the 'update' event. + function tooltips() { + removeTooltips(); + + // Tooltips are added with options.tooltips in original order. + scope_Tooltips = scope_Handles.map(addTooltip); + + bindEvent("update" + INTERNAL_EVENT_NS.tooltips, function(values, handleNumber, unencoded) { + if (!scope_Tooltips[handleNumber]) { + return; + } + + var formattedValue = values[handleNumber]; + + if (options.tooltips[handleNumber] !== true) { + formattedValue = options.tooltips[handleNumber].to(unencoded[handleNumber]); + } + + scope_Tooltips[handleNumber].innerHTML = formattedValue; + }); + } + + function aria() { + removeEvent("update" + INTERNAL_EVENT_NS.aria); + bindEvent("update" + INTERNAL_EVENT_NS.aria, function(values, handleNumber, unencoded, tap, positions) { + // Update Aria Values for all handles, as a change in one changes min and max values for the next. + scope_HandleNumbers.forEach(function(index) { + var handle = scope_Handles[index]; + + var min = checkHandlePosition(scope_Locations, index, 0, true, true, true); + var max = checkHandlePosition(scope_Locations, index, 100, true, true, true); + + var now = positions[index]; + + // Formatted value for display + var text = options.ariaFormat.to(unencoded[index]); + + // Map to slider range values + min = scope_Spectrum.fromStepping(min).toFixed(1); + max = scope_Spectrum.fromStepping(max).toFixed(1); + now = scope_Spectrum.fromStepping(now).toFixed(1); + + handle.children[0].setAttribute("aria-valuemin", min); + handle.children[0].setAttribute("aria-valuemax", max); + handle.children[0].setAttribute("aria-valuenow", now); + handle.children[0].setAttribute("aria-valuetext", text); + }); + }); + } + + function getGroup(mode, values, stepped) { + // Use the range. + if (mode === "range" || mode === "steps") { + return scope_Spectrum.xVal; + } + + if (mode === "count") { + if (values < 2) { + throw new Error("noUiSlider (" + VERSION + "): 'values' (>= 2) required for mode 'count'."); + } + + // Divide 0 - 100 in 'count' parts. + var interval = values - 1; + var spread = 100 / interval; + + values = []; + + // List these parts and have them handled as 'positions'. + while (interval--) { + values[interval] = interval * spread; + } + + values.push(100); + + mode = "positions"; + } + + if (mode === "positions") { + // Map all percentages to on-range values. + return values.map(function(value) { + return scope_Spectrum.fromStepping(stepped ? scope_Spectrum.getStep(value) : value); + }); + } + + if (mode === "values") { + // If the value must be stepped, it needs to be converted to a percentage first. + if (stepped) { + return values.map(function(value) { + // Convert to percentage, apply step, return to value. + return scope_Spectrum.fromStepping(scope_Spectrum.getStep(scope_Spectrum.toStepping(value))); + }); + } + + // Otherwise, we can simply use the values. + return values; + } + } + + function generateSpread(density, mode, group) { + function safeIncrement(value, increment) { + // Avoid floating point variance by dropping the smallest decimal places. + return (value + increment).toFixed(7) / 1; + } + + var indexes = {}; + var firstInRange = scope_Spectrum.xVal[0]; + var lastInRange = scope_Spectrum.xVal[scope_Spectrum.xVal.length - 1]; + var ignoreFirst = false; + var ignoreLast = false; + var prevPct = 0; + + // Create a copy of the group, sort it and filter away all duplicates. + group = unique( + group.slice().sort(function(a, b) { + return a - b; + }) + ); + + // Make sure the range starts with the first element. + if (group[0] !== firstInRange) { + group.unshift(firstInRange); + ignoreFirst = true; + } + + // Likewise for the last one. + if (group[group.length - 1] !== lastInRange) { + group.push(lastInRange); + ignoreLast = true; + } + + group.forEach(function(current, index) { + // Get the current step and the lower + upper positions. + var step; + var i; + var q; + var low = current; + var high = group[index + 1]; + var newPct; + var pctDifference; + var pctPos; + var type; + var steps; + var realSteps; + var stepSize; + var isSteps = mode === "steps"; + + // When using 'steps' mode, use the provided steps. + // Otherwise, we'll step on to the next subrange. + if (isSteps) { + step = scope_Spectrum.xNumSteps[index]; + } + + // Default to a 'full' step. + if (!step) { + step = high - low; + } + + // Low can be 0, so test for false. Index 0 is already handled. + if (low === false) { + return; + } + + // If high is undefined we are at the last subrange. Make sure it iterates once (#1088) + if (high === undefined) { + high = low; + } + + // Make sure step isn't 0, which would cause an infinite loop (#654) + step = Math.max(step, 0.0000001); + + // Find all steps in the subrange. + for (i = low; i <= high; i = safeIncrement(i, step)) { + // Get the percentage value for the current step, + // calculate the size for the subrange. + newPct = scope_Spectrum.toStepping(i); + pctDifference = newPct - prevPct; + + steps = pctDifference / density; + realSteps = Math.round(steps); + + // This ratio represents the amount of percentage-space a point indicates. + // For a density 1 the points/percentage = 1. For density 2, that percentage needs to be re-divided. + // Round the percentage offset to an even number, then divide by two + // to spread the offset on both sides of the range. + stepSize = pctDifference / realSteps; + + // Divide all points evenly, adding the correct number to this subrange. + // Run up to <= so that 100% gets a point, event if ignoreLast is set. + for (q = 1; q <= realSteps; q += 1) { + // The ratio between the rounded value and the actual size might be ~1% off. + // Correct the percentage offset by the number of points + // per subrange. density = 1 will result in 100 points on the + // full range, 2 for 50, 4 for 25, etc. + pctPos = prevPct + q * stepSize; + indexes[pctPos.toFixed(5)] = [scope_Spectrum.fromStepping(pctPos), 0]; + } + + // Determine the point type. + type = group.indexOf(i) > -1 ? PIPS_LARGE_VALUE : isSteps ? PIPS_SMALL_VALUE : PIPS_NO_VALUE; + + // Enforce the 'ignoreFirst' option by overwriting the type for 0. + if (!index && ignoreFirst && i !== high) { + type = 0; + } + + if (!(i === high && ignoreLast)) { + // Mark the 'type' of this point. 0 = plain, 1 = real value, 2 = step value. + indexes[newPct.toFixed(5)] = [i, type]; + } + + // Update the percentage count. + prevPct = newPct; + } + }); + + return indexes; + } + + function addMarking(spread, filterFunc, formatter) { + var element = scope_Document.createElement("div"); + + var valueSizeClasses = []; + valueSizeClasses[PIPS_NO_VALUE] = options.cssClasses.valueNormal; + valueSizeClasses[PIPS_LARGE_VALUE] = options.cssClasses.valueLarge; + valueSizeClasses[PIPS_SMALL_VALUE] = options.cssClasses.valueSub; + + var markerSizeClasses = []; + markerSizeClasses[PIPS_NO_VALUE] = options.cssClasses.markerNormal; + markerSizeClasses[PIPS_LARGE_VALUE] = options.cssClasses.markerLarge; + markerSizeClasses[PIPS_SMALL_VALUE] = options.cssClasses.markerSub; + + var valueOrientationClasses = [options.cssClasses.valueHorizontal, options.cssClasses.valueVertical]; + var markerOrientationClasses = [options.cssClasses.markerHorizontal, options.cssClasses.markerVertical]; + + addClass(element, options.cssClasses.pips); + addClass(element, options.ort === 0 ? options.cssClasses.pipsHorizontal : options.cssClasses.pipsVertical); + + function getClasses(type, source) { + var a = source === options.cssClasses.value; + var orientationClasses = a ? valueOrientationClasses : markerOrientationClasses; + var sizeClasses = a ? valueSizeClasses : markerSizeClasses; + + return source + " " + orientationClasses[options.ort] + " " + sizeClasses[type]; + } + + function addSpread(offset, value, type) { + // Apply the filter function, if it is set. + type = filterFunc ? filterFunc(value, type) : type; + + if (type === PIPS_NONE) { + return; + } + + // Add a marker for every point + var node = addNodeTo(element, false); + node.className = getClasses(type, options.cssClasses.marker); + node.style[options.style] = offset + "%"; + + // Values are only appended for points marked '1' or '2'. + if (type > PIPS_NO_VALUE) { + node = addNodeTo(element, false); + node.className = getClasses(type, options.cssClasses.value); + node.setAttribute("data-value", value); + node.style[options.style] = offset + "%"; + node.innerHTML = formatter.to(value); + } + } + + // Append all points. + Object.keys(spread).forEach(function(offset) { + addSpread(offset, spread[offset][0], spread[offset][1]); + }); + + return element; + } + + function removePips() { + if (scope_Pips) { + removeElement(scope_Pips); + scope_Pips = null; + } + } + + function pips(grid) { + // Fix #669 + removePips(); + + var mode = grid.mode; + var density = grid.density || 1; + var filter = grid.filter || false; + var values = grid.values || false; + var stepped = grid.stepped || false; + var group = getGroup(mode, values, stepped); + var spread = generateSpread(density, mode, group); + var format = grid.format || { + to: Math.round + }; + + scope_Pips = scope_Target.appendChild(addMarking(spread, filter, format)); + + return scope_Pips; + } + + // Shorthand for base dimensions. + function baseSize() { + var rect = scope_Base.getBoundingClientRect(); + var alt = "offset" + ["Width", "Height"][options.ort]; + return options.ort === 0 ? rect.width || scope_Base[alt] : rect.height || scope_Base[alt]; + } + + // Handler for attaching events trough a proxy. + function attachEvent(events, element, callback, data) { + // This function can be used to 'filter' events to the slider. + // element is a node, not a nodeList + + var method = function(e) { + e = fixEvent(e, data.pageOffset, data.target || element); + + // fixEvent returns false if this event has a different target + // when handling (multi-) touch events; + if (!e) { + return false; + } + + // doNotReject is passed by all end events to make sure released touches + // are not rejected, leaving the slider "stuck" to the cursor; + if (isSliderDisabled() && !data.doNotReject) { + return false; + } + + // Stop if an active 'tap' transition is taking place. + if (hasClass(scope_Target, options.cssClasses.tap) && !data.doNotReject) { + return false; + } + + // Ignore right or middle clicks on start #454 + if (events === actions.start && e.buttons !== undefined && e.buttons > 1) { + return false; + } + + // Ignore right or middle clicks on start #454 + if (data.hover && e.buttons) { + return false; + } + + // 'supportsPassive' is only true if a browser also supports touch-action: none in CSS. + // iOS safari does not, so it doesn't get to benefit from passive scrolling. iOS does support + // touch-action: manipulation, but that allows panning, which breaks + // sliders after zooming/on non-responsive pages. + // See: https://bugs.webkit.org/show_bug.cgi?id=133112 + if (!supportsPassive) { + e.preventDefault(); + } + + e.calcPoint = e.points[options.ort]; + + // Call the event handler with the event [ and additional data ]. + callback(e, data); + }; + + var methods = []; + + // Bind a closure on the target for every event type. + events.split(" ").forEach(function(eventName) { + element.addEventListener(eventName, method, supportsPassive ? { passive: true } : false); + methods.push([eventName, method]); + }); + + return methods; + } + + // Provide a clean event with standardized offset values. + function fixEvent(e, pageOffset, eventTarget) { + // Filter the event to register the type, which can be + // touch, mouse or pointer. Offset changes need to be + // made on an event specific basis. + var touch = e.type.indexOf("touch") === 0; + var mouse = e.type.indexOf("mouse") === 0; + var pointer = e.type.indexOf("pointer") === 0; + + var x; + var y; + + // IE10 implemented pointer events with a prefix; + if (e.type.indexOf("MSPointer") === 0) { + pointer = true; + } + + // Erroneous events seem to be passed in occasionally on iOS/iPadOS after user finishes interacting with + // the slider. They appear to be of type MouseEvent, yet they don't have usual properties set. Ignore + // events that have no touches or buttons associated with them. (#1057, #1079, #1095) + if (e.type === "mousedown" && !e.buttons && !e.touches) { + return false; + } + + // The only thing one handle should be concerned about is the touches that originated on top of it. + if (touch) { + // Returns true if a touch originated on the target. + var isTouchOnTarget = function(checkTouch) { + return ( + checkTouch.target === eventTarget || + eventTarget.contains(checkTouch.target) || + (checkTouch.target.shadowRoot && checkTouch.target.shadowRoot.contains(eventTarget)) + ); + }; + + // In the case of touchstart events, we need to make sure there is still no more than one + // touch on the target so we look amongst all touches. + if (e.type === "touchstart") { + var targetTouches = Array.prototype.filter.call(e.touches, isTouchOnTarget); + + // Do not support more than one touch per handle. + if (targetTouches.length > 1) { + return false; + } + + x = targetTouches[0].pageX; + y = targetTouches[0].pageY; + } else { + // In the other cases, find on changedTouches is enough. + var targetTouch = Array.prototype.find.call(e.changedTouches, isTouchOnTarget); + + // Cancel if the target touch has not moved. + if (!targetTouch) { + return false; + } + + x = targetTouch.pageX; + y = targetTouch.pageY; + } + } + + pageOffset = pageOffset || getPageOffset(scope_Document); + + if (mouse || pointer) { + x = e.clientX + pageOffset.x; + y = e.clientY + pageOffset.y; + } + + e.pageOffset = pageOffset; + e.points = [x, y]; + e.cursor = mouse || pointer; // Fix #435 + + return e; + } + + // Translate a coordinate in the document to a percentage on the slider + function calcPointToPercentage(calcPoint) { + var location = calcPoint - offset(scope_Base, options.ort); + var proposal = (location * 100) / baseSize(); + + // Clamp proposal between 0% and 100% + // Out-of-bound coordinates may occur when .noUi-base pseudo-elements + // are used (e.g. contained handles feature) + proposal = limit(proposal); + + return options.dir ? 100 - proposal : proposal; + } + + // Find handle closest to a certain percentage on the slider + function getClosestHandle(clickedPosition) { + var smallestDifference = 100; + var handleNumber = false; + + scope_Handles.forEach(function(handle, index) { + // Disabled handles are ignored + if (isHandleDisabled(index)) { + return; + } + + var handlePosition = scope_Locations[index]; + var differenceWithThisHandle = Math.abs(handlePosition - clickedPosition); + + // Initial state + var clickAtEdge = differenceWithThisHandle === 100 && smallestDifference === 100; + + // Difference with this handle is smaller than the previously checked handle + var isCloser = differenceWithThisHandle < smallestDifference; + var isCloserAfter = differenceWithThisHandle <= smallestDifference && clickedPosition > handlePosition; + + if (isCloser || isCloserAfter || clickAtEdge) { + handleNumber = index; + smallestDifference = differenceWithThisHandle; + } + }); + + return handleNumber; + } + + // Fire 'end' when a mouse or pen leaves the document. + function documentLeave(event, data) { + if (event.type === "mouseout" && event.target.nodeName === "HTML" && event.relatedTarget === null) { + eventEnd(event, data); + } + } + + // Handle movement on document for handle and range drag. + function eventMove(event, data) { + // Fix #498 + // Check value of .buttons in 'start' to work around a bug in IE10 mobile (data.buttonsProperty). + // https://connect.microsoft.com/IE/feedback/details/927005/mobile-ie10-windows-phone-buttons-property-of-pointermove-event-always-zero + // IE9 has .buttons and .which zero on mousemove. + // Firefox breaks the spec MDN defines. + if (navigator.appVersion.indexOf("MSIE 9") === -1 && event.buttons === 0 && data.buttonsProperty !== 0) { + return eventEnd(event, data); + } + + // Check if we are moving up or down + var movement = (options.dir ? -1 : 1) * (event.calcPoint - data.startCalcPoint); + + // Convert the movement into a percentage of the slider width/height + var proposal = (movement * 100) / data.baseSize; + + moveHandles(movement > 0, proposal, data.locations, data.handleNumbers); + } + + // Unbind move events on document, call callbacks. + function eventEnd(event, data) { + // The handle is no longer active, so remove the class. + if (data.handle) { + removeClass(data.handle, options.cssClasses.active); + scope_ActiveHandlesCount -= 1; + } + + // Unbind the move and end events, which are added on 'start'. + data.listeners.forEach(function(c) { + scope_DocumentElement.removeEventListener(c[0], c[1]); + }); + + if (scope_ActiveHandlesCount === 0) { + // Remove dragging class. + removeClass(scope_Target, options.cssClasses.drag); + setZindex(); + + // Remove cursor styles and text-selection events bound to the body. + if (event.cursor) { + scope_Body.style.cursor = ""; + scope_Body.removeEventListener("selectstart", preventDefault); + } + } + + data.handleNumbers.forEach(function(handleNumber) { + fireEvent("change", handleNumber); + fireEvent("set", handleNumber); + fireEvent("end", handleNumber); + }); + } + + // Bind move events on document. + function eventStart(event, data) { + // Ignore event if any handle is disabled + if (data.handleNumbers.some(isHandleDisabled)) { + return false; + } + + var handle; + + if (data.handleNumbers.length === 1) { + var handleOrigin = scope_Handles[data.handleNumbers[0]]; + + handle = handleOrigin.children[0]; + scope_ActiveHandlesCount += 1; + + // Mark the handle as 'active' so it can be styled. + addClass(handle, options.cssClasses.active); + } + + // A drag should never propagate up to the 'tap' event. + event.stopPropagation(); + + // Record the event listeners. + var listeners = []; + + // Attach the move and end events. + var moveEvent = attachEvent(actions.move, scope_DocumentElement, eventMove, { + // The event target has changed so we need to propagate the original one so that we keep + // relying on it to extract target touches. + target: event.target, + handle: handle, + listeners: listeners, + startCalcPoint: event.calcPoint, + baseSize: baseSize(), + pageOffset: event.pageOffset, + handleNumbers: data.handleNumbers, + buttonsProperty: event.buttons, + locations: scope_Locations.slice() + }); + + var endEvent = attachEvent(actions.end, scope_DocumentElement, eventEnd, { + target: event.target, + handle: handle, + listeners: listeners, + doNotReject: true, + handleNumbers: data.handleNumbers + }); + + var outEvent = attachEvent("mouseout", scope_DocumentElement, documentLeave, { + target: event.target, + handle: handle, + listeners: listeners, + doNotReject: true, + handleNumbers: data.handleNumbers + }); + + // We want to make sure we pushed the listeners in the listener list rather than creating + // a new one as it has already been passed to the event handlers. + listeners.push.apply(listeners, moveEvent.concat(endEvent, outEvent)); + + // Text selection isn't an issue on touch devices, + // so adding cursor styles can be skipped. + if (event.cursor) { + // Prevent the 'I' cursor and extend the range-drag cursor. + scope_Body.style.cursor = getComputedStyle(event.target).cursor; + + // Mark the target with a dragging state. + if (scope_Handles.length > 1) { + addClass(scope_Target, options.cssClasses.drag); + } + + // Prevent text selection when dragging the handles. + // In noUiSlider <= 9.2.0, this was handled by calling preventDefault on mouse/touch start/move, + // which is scroll blocking. The selectstart event is supported by FireFox starting from version 52, + // meaning the only holdout is iOS Safari. This doesn't matter: text selection isn't triggered there. + // The 'cursor' flag is false. + // See: http://caniuse.com/#search=selectstart + scope_Body.addEventListener("selectstart", preventDefault, false); + } + + data.handleNumbers.forEach(function(handleNumber) { + fireEvent("start", handleNumber); + }); + } + + // Move closest handle to tapped location. + function eventTap(event) { + // The tap event shouldn't propagate up + event.stopPropagation(); + + var proposal = calcPointToPercentage(event.calcPoint); + var handleNumber = getClosestHandle(proposal); + + // Tackle the case that all handles are 'disabled'. + if (handleNumber === false) { + return false; + } + + // Flag the slider as it is now in a transitional state. + // Transition takes a configurable amount of ms (default 300). Re-enable the slider after that. + if (!options.events.snap) { + addClassFor(scope_Target, options.cssClasses.tap, options.animationDuration); + } + + setHandle(handleNumber, proposal, true, true); + + setZindex(); + + fireEvent("slide", handleNumber, true); + fireEvent("update", handleNumber, true); + fireEvent("change", handleNumber, true); + fireEvent("set", handleNumber, true); + + if (options.events.snap) { + eventStart(event, { handleNumbers: [handleNumber] }); + } + } + + // Fires a 'hover' event for a hovered mouse/pen position. + function eventHover(event) { + var proposal = calcPointToPercentage(event.calcPoint); + + var to = scope_Spectrum.getStep(proposal); + var value = scope_Spectrum.fromStepping(to); + + Object.keys(scope_Events).forEach(function(targetEvent) { + if ("hover" === targetEvent.split(".")[0]) { + scope_Events[targetEvent].forEach(function(callback) { + callback.call(scope_Self, value); + }); + } + }); + } + + // Handles keydown on focused handles + // Don't move the document when pressing arrow keys on focused handles + function eventKeydown(event, handleNumber) { + if (isSliderDisabled() || isHandleDisabled(handleNumber)) { + return false; + } + + var horizontalKeys = ["Left", "Right"]; + var verticalKeys = ["Down", "Up"]; + var largeStepKeys = ["PageDown", "PageUp"]; + var edgeKeys = ["Home", "End"]; + + if (options.dir && !options.ort) { + // On an right-to-left slider, the left and right keys act inverted + horizontalKeys.reverse(); + } else if (options.ort && !options.dir) { + // On a top-to-bottom slider, the up and down keys act inverted + verticalKeys.reverse(); + largeStepKeys.reverse(); + } + + // Strip "Arrow" for IE compatibility. https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key + var key = event.key.replace("Arrow", ""); + + var isLargeDown = key === largeStepKeys[0]; + var isLargeUp = key === largeStepKeys[1]; + var isDown = key === verticalKeys[0] || key === horizontalKeys[0] || isLargeDown; + var isUp = key === verticalKeys[1] || key === horizontalKeys[1] || isLargeUp; + var isMin = key === edgeKeys[0]; + var isMax = key === edgeKeys[1]; + + if (!isDown && !isUp && !isMin && !isMax) { + return true; + } + + event.preventDefault(); + + var to; + + if (isUp || isDown) { + var multiplier = options.keyboardPageMultiplier; + var direction = isDown ? 0 : 1; + var steps = getNextStepsForHandle(handleNumber); + var step = steps[direction]; + + // At the edge of a slider, do nothing + if (step === null) { + return false; + } + + // No step set, use the default of 10% of the sub-range + if (step === false) { + step = scope_Spectrum.getDefaultStep( + scope_Locations[handleNumber], + isDown, + options.keyboardDefaultStep + ); + } + + if (isLargeUp || isLargeDown) { + step *= multiplier; + } + + // Step over zero-length ranges (#948); + step = Math.max(step, 0.0000001); + + // Decrement for down steps + step = (isDown ? -1 : 1) * step; + + to = scope_Values[handleNumber] + step; + } else if (isMax) { + // End key + to = options.spectrum.xVal[options.spectrum.xVal.length - 1]; + } else { + // Home key + to = options.spectrum.xVal[0]; + } + + setHandle(handleNumber, scope_Spectrum.toStepping(to), true, true); + + fireEvent("slide", handleNumber); + fireEvent("update", handleNumber); + fireEvent("change", handleNumber); + fireEvent("set", handleNumber); + + return false; + } + + // Attach events to several slider parts. + function bindSliderEvents(behaviour) { + // Attach the standard drag event to the handles. + if (!behaviour.fixed) { + scope_Handles.forEach(function(handle, index) { + // These events are only bound to the visual handle + // element, not the 'real' origin element. + attachEvent(actions.start, handle.children[0], eventStart, { + handleNumbers: [index] + }); + }); + } + + // Attach the tap event to the slider base. + if (behaviour.tap) { + attachEvent(actions.start, scope_Base, eventTap, {}); + } + + // Fire hover events + if (behaviour.hover) { + attachEvent(actions.move, scope_Base, eventHover, { + hover: true + }); + } + + // Make the range draggable. + if (behaviour.drag) { + scope_Connects.forEach(function(connect, index) { + if (connect === false || index === 0 || index === scope_Connects.length - 1) { + return; + } + + var handleBefore = scope_Handles[index - 1]; + var handleAfter = scope_Handles[index]; + var eventHolders = [connect]; + + addClass(connect, options.cssClasses.draggable); + + // When the range is fixed, the entire range can + // be dragged by the handles. The handle in the first + // origin will propagate the start event upward, + // but it needs to be bound manually on the other. + if (behaviour.fixed) { + eventHolders.push(handleBefore.children[0]); + eventHolders.push(handleAfter.children[0]); + } + + eventHolders.forEach(function(eventHolder) { + attachEvent(actions.start, eventHolder, eventStart, { + handles: [handleBefore, handleAfter], + handleNumbers: [index - 1, index] + }); + }); + }); + } + } + + // Attach an event to this slider, possibly including a namespace + function bindEvent(namespacedEvent, callback) { + scope_Events[namespacedEvent] = scope_Events[namespacedEvent] || []; + scope_Events[namespacedEvent].push(callback); + + // If the event bound is 'update,' fire it immediately for all handles. + if (namespacedEvent.split(".")[0] === "update") { + scope_Handles.forEach(function(a, index) { + fireEvent("update", index); + }); + } + } + + function isInternalNamespace(namespace) { + return namespace === INTERNAL_EVENT_NS.aria || namespace === INTERNAL_EVENT_NS.tooltips; + } + + // Undo attachment of event + function removeEvent(namespacedEvent) { + var event = namespacedEvent && namespacedEvent.split(".")[0]; + var namespace = event ? namespacedEvent.substring(event.length) : namespacedEvent; + + Object.keys(scope_Events).forEach(function(bind) { + var tEvent = bind.split(".")[0]; + var tNamespace = bind.substring(tEvent.length); + if ((!event || event === tEvent) && (!namespace || namespace === tNamespace)) { + // only delete protected internal event if intentional + if (!isInternalNamespace(tNamespace) || namespace === tNamespace) { + delete scope_Events[bind]; + } + } + }); + } + + // External event handling + function fireEvent(eventName, handleNumber, tap) { + Object.keys(scope_Events).forEach(function(targetEvent) { + var eventType = targetEvent.split(".")[0]; + + if (eventName === eventType) { + scope_Events[targetEvent].forEach(function(callback) { + callback.call( + // Use the slider public API as the scope ('this') + scope_Self, + // Return values as array, so arg_1[arg_2] is always valid. + scope_Values.map(options.format.to), + // Handle index, 0 or 1 + handleNumber, + // Un-formatted slider values + scope_Values.slice(), + // Event is fired by tap, true or false + tap || false, + // Left offset of the handle, in relation to the slider + scope_Locations.slice(), + // add the slider public API to an accessible parameter when this is unavailable + scope_Self + ); + }); + } + }); + } + + // Split out the handle positioning logic so the Move event can use it, too + function checkHandlePosition(reference, handleNumber, to, lookBackward, lookForward, getValue) { + var distance; + + // For sliders with multiple handles, limit movement to the other handle. + // Apply the margin option by adding it to the handle positions. + if (scope_Handles.length > 1 && !options.events.unconstrained) { + if (lookBackward && handleNumber > 0) { + distance = scope_Spectrum.getAbsoluteDistance(reference[handleNumber - 1], options.margin, 0); + to = Math.max(to, distance); + } + + if (lookForward && handleNumber < scope_Handles.length - 1) { + distance = scope_Spectrum.getAbsoluteDistance(reference[handleNumber + 1], options.margin, 1); + to = Math.min(to, distance); + } + } + + // The limit option has the opposite effect, limiting handles to a + // maximum distance from another. Limit must be > 0, as otherwise + // handles would be unmovable. + if (scope_Handles.length > 1 && options.limit) { + if (lookBackward && handleNumber > 0) { + distance = scope_Spectrum.getAbsoluteDistance(reference[handleNumber - 1], options.limit, 0); + to = Math.min(to, distance); + } + + if (lookForward && handleNumber < scope_Handles.length - 1) { + distance = scope_Spectrum.getAbsoluteDistance(reference[handleNumber + 1], options.limit, 1); + to = Math.max(to, distance); + } + } + + // The padding option keeps the handles a certain distance from the + // edges of the slider. Padding must be > 0. + if (options.padding) { + if (handleNumber === 0) { + distance = scope_Spectrum.getAbsoluteDistance(0, options.padding[0], 0); + to = Math.max(to, distance); + } + + if (handleNumber === scope_Handles.length - 1) { + distance = scope_Spectrum.getAbsoluteDistance(100, options.padding[1], 1); + to = Math.min(to, distance); + } + } + + to = scope_Spectrum.getStep(to); + + // Limit percentage to the 0 - 100 range + to = limit(to); + + // Return false if handle can't move + if (to === reference[handleNumber] && !getValue) { + return false; + } + + return to; + } + + // Uses slider orientation to create CSS rules. a = base value; + function inRuleOrder(v, a) { + var o = options.ort; + return (o ? a : v) + ", " + (o ? v : a); + } + + // Moves handle(s) by a percentage + // (bool, % to move, [% where handle started, ...], [index in scope_Handles, ...]) + function moveHandles(upward, proposal, locations, handleNumbers) { + var proposals = locations.slice(); + + var b = [!upward, upward]; + var f = [upward, !upward]; + + // Copy handleNumbers so we don't change the dataset + handleNumbers = handleNumbers.slice(); + + // Check to see which handle is 'leading'. + // If that one can't move the second can't either. + if (upward) { + handleNumbers.reverse(); + } + + // Step 1: get the maximum percentage that any of the handles can move + if (handleNumbers.length > 1) { + handleNumbers.forEach(function(handleNumber, o) { + var to = checkHandlePosition( + proposals, + handleNumber, + proposals[handleNumber] + proposal, + b[o], + f[o], + false + ); + + // Stop if one of the handles can't move. + if (to === false) { + proposal = 0; + } else { + proposal = to - proposals[handleNumber]; + proposals[handleNumber] = to; + } + }); + } + + // If using one handle, check backward AND forward + else { + b = f = [true]; + } + + var state = false; + + // Step 2: Try to set the handles with the found percentage + handleNumbers.forEach(function(handleNumber, o) { + state = setHandle(handleNumber, locations[handleNumber] + proposal, b[o], f[o]) || state; + }); + + // Step 3: If a handle moved, fire events + if (state) { + handleNumbers.forEach(function(handleNumber) { + fireEvent("update", handleNumber); + fireEvent("slide", handleNumber); + }); + } + } + + // Takes a base value and an offset. This offset is used for the connect bar size. + // In the initial design for this feature, the origin element was 1% wide. + // Unfortunately, a rounding bug in Chrome makes it impossible to implement this feature + // in this manner: https://bugs.chromium.org/p/chromium/issues/detail?id=798223 + function transformDirection(a, b) { + return options.dir ? 100 - a - b : a; + } + + // Updates scope_Locations and scope_Values, updates visual state + function updateHandlePosition(handleNumber, to) { + // Update locations. + scope_Locations[handleNumber] = to; + + // Convert the value to the slider stepping/range. + scope_Values[handleNumber] = scope_Spectrum.fromStepping(to); + + var translation = 10 * (transformDirection(to, 0) - scope_DirOffset); + var translateRule = "translate(" + inRuleOrder(translation + "%", "0") + ")"; + + scope_Handles[handleNumber].style[options.transformRule] = translateRule; + + updateConnect(handleNumber); + updateConnect(handleNumber + 1); + } + + // Handles before the slider middle are stacked later = higher, + // Handles after the middle later is lower + // [[7] [8] .......... | .......... [5] [4] + function setZindex() { + scope_HandleNumbers.forEach(function(handleNumber) { + var dir = scope_Locations[handleNumber] > 50 ? -1 : 1; + var zIndex = 3 + (scope_Handles.length + dir * handleNumber); + scope_Handles[handleNumber].style.zIndex = zIndex; + }); + } + + // Test suggested values and apply margin, step. + // if exactInput is true, don't run checkHandlePosition, then the handle can be placed in between steps (#436) + function setHandle(handleNumber, to, lookBackward, lookForward, exactInput) { + if (!exactInput) { + to = checkHandlePosition(scope_Locations, handleNumber, to, lookBackward, lookForward, false); + } + + if (to === false) { + return false; + } + + updateHandlePosition(handleNumber, to); + + return true; + } + + // Updates style attribute for connect nodes + function updateConnect(index) { + // Skip connects set to false + if (!scope_Connects[index]) { + return; + } + + var l = 0; + var h = 100; + + if (index !== 0) { + l = scope_Locations[index - 1]; + } + + if (index !== scope_Connects.length - 1) { + h = scope_Locations[index]; + } + + // We use two rules: + // 'translate' to change the left/top offset; + // 'scale' to change the width of the element; + // As the element has a width of 100%, a translation of 100% is equal to 100% of the parent (.noUi-base) + var connectWidth = h - l; + var translateRule = "translate(" + inRuleOrder(transformDirection(l, connectWidth) + "%", "0") + ")"; + var scaleRule = "scale(" + inRuleOrder(connectWidth / 100, "1") + ")"; + + scope_Connects[index].style[options.transformRule] = translateRule + " " + scaleRule; + } + + // Parses value passed to .set method. Returns current value if not parse-able. + function resolveToValue(to, handleNumber) { + // Setting with null indicates an 'ignore'. + // Inputting 'false' is invalid. + if (to === null || to === false || to === undefined) { + return scope_Locations[handleNumber]; + } + + // If a formatted number was passed, attempt to decode it. + if (typeof to === "number") { + to = String(to); + } + + to = options.format.from(to); + to = scope_Spectrum.toStepping(to); + + // If parsing the number failed, use the current value. + if (to === false || isNaN(to)) { + return scope_Locations[handleNumber]; + } + + return to; + } + + // Set the slider value. + function valueSet(input, fireSetEvent, exactInput) { + var values = asArray(input); + var isInit = scope_Locations[0] === undefined; + + // Event fires by default + fireSetEvent = fireSetEvent === undefined ? true : !!fireSetEvent; + + // Animation is optional. + // Make sure the initial values were set before using animated placement. + if (options.animate && !isInit) { + addClassFor(scope_Target, options.cssClasses.tap, options.animationDuration); + } + + // First pass, without lookAhead but with lookBackward. Values are set from left to right. + scope_HandleNumbers.forEach(function(handleNumber) { + setHandle(handleNumber, resolveToValue(values[handleNumber], handleNumber), true, false, exactInput); + }); + + var i = scope_HandleNumbers.length === 1 ? 0 : 1; + + // Secondary passes. Now that all base values are set, apply constraints. + // Iterate all handles to ensure constraints are applied for the entire slider (Issue #1009) + for (; i < scope_HandleNumbers.length; ++i) { + scope_HandleNumbers.forEach(function(handleNumber) { + setHandle(handleNumber, scope_Locations[handleNumber], true, true, exactInput); + }); + } + + setZindex(); + + scope_HandleNumbers.forEach(function(handleNumber) { + fireEvent("update", handleNumber); + + // Fire the event only for handles that received a new value, as per #579 + if (values[handleNumber] !== null && fireSetEvent) { + fireEvent("set", handleNumber); + } + }); + } + + // Reset slider to initial values + function valueReset(fireSetEvent) { + valueSet(options.start, fireSetEvent); + } + + // Set value for a single handle + function valueSetHandle(handleNumber, value, fireSetEvent, exactInput) { + // Ensure numeric input + handleNumber = Number(handleNumber); + + if (!(handleNumber >= 0 && handleNumber < scope_HandleNumbers.length)) { + throw new Error("noUiSlider (" + VERSION + "): invalid handle number, got: " + handleNumber); + } + + // Look both backward and forward, since we don't want this handle to "push" other handles (#960); + // The exactInput argument can be used to ignore slider stepping (#436) + setHandle(handleNumber, resolveToValue(value, handleNumber), true, true, exactInput); + + fireEvent("update", handleNumber); + + if (fireSetEvent) { + fireEvent("set", handleNumber); + } + } + + // Get the slider value. + function valueGet() { + var values = scope_Values.map(options.format.to); + + // If only one handle is used, return a single value. + if (values.length === 1) { + return values[0]; + } + + return values; + } + + // Removes classes from the root and empties it. + function destroy() { + // remove protected internal listeners + removeEvent(INTERNAL_EVENT_NS.aria); + removeEvent(INTERNAL_EVENT_NS.tooltips); + + for (var key in options.cssClasses) { + if (!options.cssClasses.hasOwnProperty(key)) { + continue; + } + removeClass(scope_Target, options.cssClasses[key]); + } + + while (scope_Target.firstChild) { + scope_Target.removeChild(scope_Target.firstChild); + } + + delete scope_Target.noUiSlider; + } + + function getNextStepsForHandle(handleNumber) { + var location = scope_Locations[handleNumber]; + var nearbySteps = scope_Spectrum.getNearbySteps(location); + var value = scope_Values[handleNumber]; + var increment = nearbySteps.thisStep.step; + var decrement = null; + + // If snapped, directly use defined step value + if (options.snap) { + return [ + value - nearbySteps.stepBefore.startValue || null, + nearbySteps.stepAfter.startValue - value || null + ]; + } + + // If the next value in this step moves into the next step, + // the increment is the start of the next step - the current value + if (increment !== false) { + if (value + increment > nearbySteps.stepAfter.startValue) { + increment = nearbySteps.stepAfter.startValue - value; + } + } + + // If the value is beyond the starting point + if (value > nearbySteps.thisStep.startValue) { + decrement = nearbySteps.thisStep.step; + } else if (nearbySteps.stepBefore.step === false) { + decrement = false; + } + + // If a handle is at the start of a step, it always steps back into the previous step first + else { + decrement = value - nearbySteps.stepBefore.highestStep; + } + + // Now, if at the slider edges, there is no in/decrement + if (location === 100) { + increment = null; + } else if (location === 0) { + decrement = null; + } + + // As per #391, the comparison for the decrement step can have some rounding issues. + var stepDecimals = scope_Spectrum.countStepDecimals(); + + // Round per #391 + if (increment !== null && increment !== false) { + increment = Number(increment.toFixed(stepDecimals)); + } + + if (decrement !== null && decrement !== false) { + decrement = Number(decrement.toFixed(stepDecimals)); + } + + return [decrement, increment]; + } + + // Get the current step size for the slider. + function getNextSteps() { + return scope_HandleNumbers.map(getNextStepsForHandle); + } + + // Updateable: margin, limit, padding, step, range, animate, snap + function updateOptions(optionsToUpdate, fireSetEvent) { + // Spectrum is created using the range, snap, direction and step options. + // 'snap' and 'step' can be updated. + // If 'snap' and 'step' are not passed, they should remain unchanged. + var v = valueGet(); + + var updateAble = [ + "margin", + "limit", + "padding", + "range", + "animate", + "snap", + "step", + "format", + "pips", + "tooltips" + ]; + + // Only change options that we're actually passed to update. + updateAble.forEach(function(name) { + // Check for undefined. null removes the value. + if (optionsToUpdate[name] !== undefined) { + originalOptions[name] = optionsToUpdate[name]; + } + }); + + var newOptions = testOptions(originalOptions); + + // Load new options into the slider state + updateAble.forEach(function(name) { + if (optionsToUpdate[name] !== undefined) { + options[name] = newOptions[name]; + } + }); + + scope_Spectrum = newOptions.spectrum; + + // Limit, margin and padding depend on the spectrum but are stored outside of it. (#677) + options.margin = newOptions.margin; + options.limit = newOptions.limit; + options.padding = newOptions.padding; + + // Update pips, removes existing. + if (options.pips) { + pips(options.pips); + } else { + removePips(); + } + + // Update tooltips, removes existing. + if (options.tooltips) { + tooltips(); + } else { + removeTooltips(); + } + + // Invalidate the current positioning so valueSet forces an update. + scope_Locations = []; + valueSet(optionsToUpdate.start || v, fireSetEvent); + } + + // Initialization steps + function setupSlider() { + // Create the base element, initialize HTML and set classes. + // Add handles and connect elements. + scope_Base = addSlider(scope_Target); + + addElements(options.connect, scope_Base); + + // Attach user events. + bindSliderEvents(options.events); + + // Use the public value method to set the start values. + valueSet(options.start); + + if (options.pips) { + pips(options.pips); + } + + if (options.tooltips) { + tooltips(); + } + + aria(); + } + + setupSlider(); + + // noinspection JSUnusedGlobalSymbols + scope_Self = { + destroy: destroy, + steps: getNextSteps, + on: bindEvent, + off: removeEvent, + get: valueGet, + set: valueSet, + setHandle: valueSetHandle, + reset: valueReset, + // Exposed for unit testing, don't use this in your application. + __moveHandles: function(a, b, c) { + moveHandles(a, b, scope_Locations, c); + }, + options: originalOptions, // Issue #600, #678 + updateOptions: updateOptions, + target: scope_Target, // Issue #597 + removePips: removePips, + removeTooltips: removeTooltips, + getTooltips: function() { + return scope_Tooltips; + }, + getOrigins: function() { + return scope_Handles; + }, + pips: pips // Issue #594 + }; + + return scope_Self; + } + + // Run the standard initializer + function initialize(target, originalOptions) { + if (!target || !target.nodeName) { + throw new Error("noUiSlider (" + VERSION + "): create requires a single element, got: " + target); + } + + // Throw an error if the slider was already initialized. + if (target.noUiSlider) { + throw new Error("noUiSlider (" + VERSION + "): Slider was already initialized."); + } + + // Test the options and create the slider environment; + var options = testOptions(originalOptions, target); + var api = scope(target, options, originalOptions); + + target.noUiSlider = api; + + return api; + } + + // Use an object instead of a function for future expandability; + return { + // Exposed for unit testing, don't use this in your application. + __spectrum: Spectrum, + version: VERSION, + // A reference to the default classes, allows global changes. + // Use the cssClasses option for changes to one slider. + cssClasses: cssClasses, + create: initialize + }; +}); diff --git a/public_html/noUiSlider/distribute/nouislider.min.css b/public_html/noUiSlider/distribute/nouislider.min.css new file mode 100644 index 0000000..8181ce3 --- /dev/null +++ b/public_html/noUiSlider/distribute/nouislider.min.css @@ -0,0 +1,2 @@ +/*! nouislider - 14.6.3 - 11/19/2020 */ +.noUi-target,.noUi-target *{-webkit-touch-callout:none;-webkit-tap-highlight-color:transparent;-webkit-user-select:none;-ms-touch-action:none;touch-action:none;-ms-user-select:none;-moz-user-select:none;user-select:none;-moz-box-sizing:border-box;box-sizing:border-box}.noUi-target{position:relative}.noUi-base,.noUi-connects{width:100%;height:100%;position:relative;z-index:1}.noUi-connects{overflow:hidden;z-index:0}.noUi-connect,.noUi-origin{will-change:transform;position:absolute;z-index:1;top:0;right:0;-ms-transform-origin:0 0;-webkit-transform-origin:0 0;-webkit-transform-style:preserve-3d;transform-origin:0 0;transform-style:flat}.noUi-connect{height:100%;width:100%}.noUi-origin{height:10%;width:10%}.noUi-txt-dir-rtl.noUi-horizontal .noUi-origin{left:0;right:auto}.noUi-vertical .noUi-origin{width:0}.noUi-horizontal .noUi-origin{height:0}.noUi-handle{-webkit-backface-visibility:hidden;backface-visibility:hidden;position:absolute}.noUi-touch-area{height:100%;width:100%}.noUi-state-tap .noUi-connect,.noUi-state-tap .noUi-origin{-webkit-transition:transform .3s;transition:transform .3s}.noUi-state-drag *{cursor:inherit!important}.noUi-horizontal{height:18px}.noUi-horizontal .noUi-handle{width:34px;height:28px;right:-17px;top:-6px}.noUi-vertical{width:18px}.noUi-vertical .noUi-handle{width:28px;height:34px;right:-6px;top:-17px}.noUi-txt-dir-rtl.noUi-horizontal .noUi-handle{left:-17px;right:auto}.noUi-target{background:#FAFAFA;border-radius:4px;border:1px solid #D3D3D3;box-shadow:inset 0 1px 1px #F0F0F0,0 3px 6px -5px #BBB}.noUi-connects{border-radius:3px}.noUi-connect{background:#3FB8AF}.noUi-draggable{cursor:ew-resize}.noUi-vertical .noUi-draggable{cursor:ns-resize}.noUi-handle{border:1px solid #D9D9D9;border-radius:3px;background:#FFF;cursor:default;box-shadow:inset 0 0 1px #FFF,inset 0 1px 7px #EBEBEB,0 3px 6px -3px #BBB}.noUi-active{box-shadow:inset 0 0 1px #FFF,inset 0 1px 7px #DDD,0 3px 6px -3px #BBB}.noUi-handle:after,.noUi-handle:before{content:"";display:block;position:absolute;height:14px;width:1px;background:#E8E7E6;left:14px;top:6px}.noUi-handle:after{left:17px}.noUi-vertical .noUi-handle:after,.noUi-vertical .noUi-handle:before{width:14px;height:1px;left:6px;top:14px}.noUi-vertical .noUi-handle:after{top:17px}[disabled] .noUi-connect{background:#B8B8B8}[disabled] .noUi-handle,[disabled].noUi-handle,[disabled].noUi-target{cursor:not-allowed}.noUi-pips,.noUi-pips *{-moz-box-sizing:border-box;box-sizing:border-box}.noUi-pips{position:absolute;color:#999}.noUi-value{position:absolute;white-space:nowrap;text-align:center}.noUi-value-sub{color:#ccc;font-size:10px}.noUi-marker{position:absolute;background:#CCC}.noUi-marker-sub{background:#AAA}.noUi-marker-large{background:#AAA}.noUi-pips-horizontal{padding:10px 0;height:80px;top:100%;left:0;width:100%}.noUi-value-horizontal{-webkit-transform:translate(-50%,50%);transform:translate(-50%,50%)}.noUi-rtl .noUi-value-horizontal{-webkit-transform:translate(50%,50%);transform:translate(50%,50%)}.noUi-marker-horizontal.noUi-marker{margin-left:-1px;width:2px;height:5px}.noUi-marker-horizontal.noUi-marker-sub{height:10px}.noUi-marker-horizontal.noUi-marker-large{height:15px}.noUi-pips-vertical{padding:0 10px;height:100%;top:0;left:100%}.noUi-value-vertical{-webkit-transform:translate(0,-50%);transform:translate(0,-50%);padding-left:25px}.noUi-rtl .noUi-value-vertical{-webkit-transform:translate(0,50%);transform:translate(0,50%)}.noUi-marker-vertical.noUi-marker{width:5px;height:2px;margin-top:-1px}.noUi-marker-vertical.noUi-marker-sub{width:10px}.noUi-marker-vertical.noUi-marker-large{width:15px}.noUi-tooltip{display:block;position:absolute;border:1px solid #D9D9D9;border-radius:3px;background:#fff;color:#000;padding:5px;text-align:center;white-space:nowrap}.noUi-horizontal .noUi-tooltip{-webkit-transform:translate(-50%,0);transform:translate(-50%,0);left:50%;bottom:120%}.noUi-vertical .noUi-tooltip{-webkit-transform:translate(0,-50%);transform:translate(0,-50%);top:50%;right:120%}.noUi-horizontal .noUi-origin>.noUi-tooltip{-webkit-transform:translate(50%,0);transform:translate(50%,0);left:auto;bottom:10px}.noUi-vertical .noUi-origin>.noUi-tooltip{-webkit-transform:translate(0,-18px);transform:translate(0,-18px);top:auto;right:28px} \ No newline at end of file diff --git a/public_html/noUiSlider/distribute/nouislider.min.js b/public_html/noUiSlider/distribute/nouislider.min.js new file mode 100644 index 0000000..0f04919 --- /dev/null +++ b/public_html/noUiSlider/distribute/nouislider.min.js @@ -0,0 +1,2 @@ +/*! nouislider - 14.6.3 - 11/19/2020 */ +!function(t){"function"==typeof define&&define.amd?define([],t):"object"==typeof exports?module.exports=t():window.noUiSlider=t()}(function(){"use strict";var lt="14.6.3";function ut(t){t.parentElement.removeChild(t)}function a(t){return null!=t}function ct(t){t.preventDefault()}function o(t){return"number"==typeof t&&!isNaN(t)&&isFinite(t)}function pt(t,e,r){0=e[r];)r+=1;return r}function r(t,e,r){if(r>=t.slice(-1)[0])return 100;var n,i,o=f(r,t),s=t[o-1],a=t[o],l=e[o-1],u=e[o];return l+(i=r,p(n=[s,a],n[0]<0?i+Math.abs(n[0]):i-n[0],0)/c(l,u))}function n(t,e,r,n){if(100===n)return n;var i,o,s=f(n,t),a=t[s-1],l=t[s];return r?(l-a)/2this.xPct[i+1];)i++;else t===this.xPct[this.xPct.length-1]&&(i=this.xPct.length-2);r||t!==this.xPct[i+1]||i++;var o=1,s=e[i],a=0,l=0,u=0,c=0;for(n=r?(t-this.xPct[i])/(this.xPct[i+1]-this.xPct[i]):(this.xPct[i+1]-t)/(this.xPct[i+1]-this.xPct[i]);0= 2) required for mode 'count'.");var n=e-1,i=100/n;for(e=[];n--;)e[n]=n*i;e.push(100),t="positions"}return"positions"===t?e.map(function(t){return y.fromStepping(r?y.getStep(t):t)}):"values"===t?r?e.map(function(t){return y.fromStepping(y.getStep(y.toStepping(t)))}):e:void 0}(n,t.values||!1,t.stepped||!1),a=(m=i,g=n,v=s,b={},e=y.xVal[0],r=y.xVal[y.xVal.length-1],S=x=!1,w=0,(v=v.slice().sort(function(t,e){return t-e}).filter(function(t){return!this[t]&&(this[t]=!0)},{}))[0]!==e&&(v.unshift(e),x=!0),v[v.length-1]!==r&&(v.push(r),S=!0),v.forEach(function(t,e){var r,n,i,o,s,a,l,u,c,p,f=t,d=v[e+1],h="steps"===g;if(h&&(r=y.xNumSteps[e]),r||(r=d-f),!1!==f)for(void 0===d&&(d=f),r=Math.max(r,1e-7),n=f;n<=d;n=(n+r).toFixed(7)/1){for(u=(s=(o=y.toStepping(n))-w)/m,p=s/(c=Math.round(u)),i=1;i<=c;i+=1)b[(a=w+i*p).toFixed(5)]=[y.fromStepping(a),0];l=-1r.stepAfter.startValue&&(i=r.stepAfter.startValue-n),o=n>r.thisStep.startValue?r.thisStep.step:!1!==r.stepBefore.step&&n-r.stepBefore.highestStep,100===e?i=null:0===e&&(o=null);var s=y.countStepDecimals();return null!==i&&!1!==i&&(i=Number(i.toFixed(s))),null!==o&&!1!==o&&(o=Number(o.toFixed(s))),[o,i]}return ht(e=h,b.cssClasses.target),0===b.dir?ht(e,b.cssClasses.ltr):ht(e,b.cssClasses.rtl),0===b.ort?ht(e,b.cssClasses.horizontal):ht(e,b.cssClasses.vertical),ht(e,"rtl"===getComputedStyle(e).direction?b.cssClasses.textDirectionRtl:b.cssClasses.textDirectionLtr),l=V(e,b.cssClasses.base),function(t,e){var r=V(e,b.cssClasses.connects);u=[],(s=[]).push(M(r,t[0]));for(var n=0;n