FileMaster

Edit File: noUISlider2.js

// https://refreshless.com/nouislider/
/*! nouislider - 8.3.0 - 2016-02-14 17:37:19 */
(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";
    // 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 isNumeric(a) {
        return typeof a === "number" && !isNaN(a) && isFinite(a);
    }
    // Rounds a number to 7 supported decimals.

function accurateNumber(number) {
        var p = Math.pow(10, 7);
        return Number((Math.round(number * p) / p).toFixed(7));
    }
    // Sets a class and removes it after [duration] ms.

function addClassFor(element, className, duration) {
        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.

function asArray(a) {
        return Array.isArray(a) ? a : [a];
    }
    // Counts decimals

function countDecimals(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) {
            el.classList.add(className);
        } else {
            el.className += " " + className;
        }
    }
    // http://youmightnotneedjquery.com/#remove_class

function removeClass(el, className) {
        if (el.classList) {
            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() {
        var supportPageOffset = window.pageXOffset !== undefined,
            isCSS1Compat = (document.compatMode || "") === "CSS1Compat",
            x = supportPageOffset ? window.pageXOffset : isCSS1Compat ? document.documentElement.scrollLeft : document.body.scrollLeft,
            y = supportPageOffset ? window.pageYOffset : isCSS1Compat ? document.documentElement.scrollTop : document.body.scrollTop;
        return {
            x: x,
            y: y
        };
    }
    // Shorthand for stopPropagation so we don't have to create a dynamic method

function stopPropagation(e) {
        e.stopPropagation();
    }
    // todo

function fromPercentage(range, value) {
        return (value * 100) / (range[1] - range[0]);
    }
    // (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]);
    }
    // (value) How much is this percentage on this range?

function isPercentage(range, value) {
        return (value * (range[1] - range[0])) / 100 + range[0];
    }
    // Range conversion

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),
            va,
            vb,
            pa,
            pb;
        va = xVal[j - 1];
        vb = xVal[j];
        pa = xPct[j - 1];
        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),
            va,
            vb,
            pa,
            pb;
        va = xVal[j - 1];
        vb = xVal[j];
        pa = xPct[j - 1];
        pb = xPct[j];
        return isPercentage([va, vb], (value - pa) * subRangeRatio(pa, pb));
    }
    // (percentage) Get the step that applies at a certain value.

function handleStepPoint(i, n, that) {
        // Ignore 'false' stepping.
        if (!n) {
            return true;
        }
        // Factor to range ratio
        that.xSteps[i] = fromPercentage([that.xVal[i], that.xVal[i + 1]], n) / subRangeRatio(that.xPct[i], that.xPct[i + 1]);
    }
    // Interface
    // The interface to Spectrum handles all direction-based
    // conversions, so the above values are unaware.

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. */
    var defaultFormatter = {
        to: function (value) {
            return value !== undefined && value.toFixed(2);
        },
        from: Number
    };

function testStep(parsed, entry) {
        if (!isNumeric(entry)) {
            throw new Error("noUiSlider: '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 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 || entry.length > 2) {
            throw new Error("noUiSlider: '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: '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: 'animate' option must be a boolean.");
        }
    }

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: 'orientation' option is invalid.");
        }
    }

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;
                parsed.connect = [0, 2, 1, 3][parsed.connect];
                break;
            default:
                throw new Error("noUiSlider: 'direction' option was not recognized.");
        }
    }

function testFormat(parsed, entry) {
        parsed.format = entry;
        // Any object with a to and from method is supported.
        if (typeof entry.to === "function" && typeof entry.from === "function") {
            return true;
        }
        throw new Error("noUiSlider: 'format' requires 'to' and 'from' methods.");
    }

function testCssPrefix(parsed, entry) {
        if (entry !== undefined && typeof entry !== "string") {
            throw new Error("noUiSlider: 'cssPrefix' must be a string.");
        }
        parsed.cssPrefix = entry;
    }
    // Test all developer settings and parse to assumption-safe values.

function addHandle(direction, index) {
            var origin = document.createElement("div"),
                handle = document.createElement("div"),
                additions = ["-lower", "-upper"];
            if (direction) {
                additions.reverse();
            }
            addClass(handle, cssClasses[3]);
            addClass(handle, cssClasses[3] + additions[index]);
            addClass(origin, cssClasses[2]);
            origin.appendChild(handle);
            return origin;
        }
        // Add the proper connection classes.

function addConnection(connect, target, handles) {
            // Apply the required connection classes to the elements
            // that need them. Some classes are made up for several
            // segments listed in the class list, to allow easy
            // renaming and provide a minor compression benefit.
            switch (connect) {
                case 1:
                    addClass(target, cssClasses[7]);
                    addClass(handles[0], cssClasses[6]);
                    break;
                case 3:
                    addClass(handles[1], cssClasses[6]);
                /* falls through */
                case 2:
                    addClass(handles[0], cssClasses[7]);
                /* falls through */
                case 0:
                    addClass(target, cssClasses[6]);
                    break;
            }
        }
        // Add handles to the slider base.

function addHandles(nrHandles, direction, base) {
            var index,
                handles = [];
            // Append handles.
            for (index = 0; index < nrHandles; index += 1) {
                // Keep a list of all added handles.
                handles.push(base.appendChild(addHandle(direction, index)));
            }
            return handles;
        }
        // Initialize a single slider.

function addSlider(direction, orientation, target) {
            // Apply classes and data to the target.
            addClass(target, cssClasses[0]);
            addClass(target, cssClasses[8 + direction]);
            addClass(target, cssClasses[4 + orientation]);
            var div = document.createElement("div");
            addClass(div, cssClasses[1]);
            target.appendChild(div);
            return div;
        }

function addTooltip(handle, index) {
            if (!options.tooltips[index]) {
                return false;
            }
            var element = document.createElement("div");
            element.className = cssClasses[18];
            return handle.firstChild.appendChild(element);
        }
        // The tooltips option is a shorthand for using the 'update' event.

function addMarking(spread, filterFunc, formatter) {
            var style = ["horizontal", "vertical"][options.ort],
                element = document.createElement("div"),
                out = "";
            addClass(element, cssClasses[20]);
            addClass(element, cssClasses[20] + "-" + style);

function getSize(type) {
                return ["-normal", "-large", "-sub"][type];
            }

function getTags(offset, source, values) {
                return 'class="' + source + " " + source + "-" + style + " " + source + getSize(values[1]) + '" style="' + options.style + ": " + offset + '%"';
            }

function pips(grid) {
            var mode = grid.mode,
                density = grid.density || 1,
                filter = grid.filter || false,
                values = grid.values || false,
                stepped = grid.stepped || false,
                group = getGroup(mode, values, stepped),
                spread = generateSpread(density, mode, group),
                format = grid.format || {
                    to: Math.round
                };
            return scope_Target.appendChild(addMarking(spread, filter, format));
        }
        // Shorthand for base dimensions.

function baseSize() {
            var rect = scope_Base.getBoundingClientRect(),
                alt = "offset" + ["Width", "Height"][options.ort];
            return options.ort === 0 ? rect.width || scope_Base[alt] : rect.height || scope_Base[alt];
        }
        // External event handling

function documentLeave(event, data) {
            if (event.type === "mouseout" && event.target.nodeName === "HTML" && event.relatedTarget === null) {
                end(event, data);
            }
        }
        // Bind move events on document.

function valueGet() {
            var i,
                retour = [];
            // Get the value from all handles.
            for (i = 0; i < options.handles; i += 1) {
                retour[i] = options.format.to(scope_Values[i]);
            }
            return inSliderOrder(retour);
        }
        // Removes classes from the root and empties it.

function getCurrentStep() {
            // Check all locations, map them to their stepping point.
            // Get the step point, then find it in the input list.
            var retour = scope_Locations.map(function (location, index) {
                var step = scope_Spectrum.getApplicableStep(location),
                    // As per #391, the comparison for the decrement step can have some rounding issues.
                    // Round the value to the precision used in the step.
                    stepDecimals = countDecimals(String(step[2])),
                    // Get the current numeric value
                    value = scope_Values[index],
                    // To move the slider 'one step up', the current step value needs to be added.
                    // Use null if we are at the maximum slider value.
                    increment = location === 100 ? null : step[2],
                    // Going 'one step down' might put the slider in a different sub-range, so we
                    // need to switch between the current or the previous step.
                    prev = Number((value - step[2]).toFixed(stepDecimals)),
                    // If the value fits the step, return the current step value. Otherwise, use the
                    // previous step. Return null if the slider is at its minimum value.
                    decrement = location === 0 ? null : prev >= step[1] ? step[2] : step[0] || false;
                return [decrement, increment];
            });
            // Return values in the proper order.
            return inSliderOrder(retour);
        }
        // Attach an event to this slider, possibly including a namespace

function strStartsWith(input, match) {
        return input.substring(0, match.length) === match;
    }
    // Check is a string ends in a specified postfix.

function strEndsWith(input, match) {
        return input.slice(-1 * match.length) === match;
    }
    // Throw an error if formatting options are incompatible.

function throwEqualError(F, a, b) {
        if ((F[a] || F[b]) && F[a] === F[b]) {
            throw new Error(a);
        }
    }
    // Check if a number is finite and not NaN

function isValidNumber(input) {
        return typeof input === "number" && isFinite(input);
    }
    // Provide rounding-accurate toFixed method.

function toFixed(value, decimals) {
        var scale = Math.pow(10, decimals);
        return (Math.round(value * scale) / scale).toFixed(decimals);
    }
    // Formatting
    // Accept a number as input, output formatted string.

function passAll(options, method, input) {
        var i,
            args = [];
        // Add all options in order of FormatOptions
        for (i = 0; i < FormatOptions.length; i += 1) {
            args.push(options[FormatOptions[i]]);
        }
        // Append the input, then call the method, presenting all
        // options as arguments.
        args.push(input);
        return method.apply("", args);
    }
    /** @constructor */

Back