芝麻web文件管理V1.00

编辑当前文件:/var/www/italafricacentrale.com/wp-content/plugins/mapsvg/dist/mapsvg-front.umd.js

(function (global, factory) {
    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('Handlebars'), require('Bloodhound'), require('CodeMirror')) :
    typeof define === 'function' && define.amd ? define(['exports', 'Handlebars', 'Bloodhound', 'CodeMirror'], factory) :
    (global = global || self, factory(global.mapsvg = {}, global.Handlebars, global.Bloodhound, global.CodeMirror));
}(this, (function (exports, Handlebars, Bloodhound, CodeMirror) { 'use strict';

Handlebars = Handlebars && Handlebars.hasOwnProperty('default') ? Handlebars['default'] : Handlebars;
    Bloodhound = Bloodhound && Bloodhound.hasOwnProperty('default') ? Bloodhound['default'] : Bloodhound;

/**
     * Global MapSVG class. It contains all other MapSVG classes and some static methods.
     * @constructor
     * @example
     * var mapsvg = MapSVG.get(0); // get first map instance
     * var mapsvg2 = MapSVG.get(1); // get second map instance
     * var mapsvg3 = MapSVG.getById(123); // get map by ID
     *
     * var mapsvg = new MapSVG.Map("my-container",{
     *   source: "/path/to/map.svg"
     * });
     *
     * var marker = new MapSVG.Marker({
     *   location: location,
     *   mapsvg: mapsvg
     * });
     *
     * if(MapSVG.isPhone){
     *  // do something special for mobile devices
     * }
     *
     *
     */
    var MapSVG = function () {};
    const $ = jQuery;

MapSVG.formBuilder = {};
    MapSVG.mediaUploader = {};

if (typeof wp !== "undefined" && typeof wp.media !== "undefined") {
        MapSVG.mediaUploader = wp.media({
            title: "Choose images",
            button: {
                text: "Choose images",
            },
            multiple: true,
        });
    }

/**
     * Keeps loaded HBS templates
     * @type {Array}
     * @private
     * @static
     * @property
     */
    MapSVG.templatesLoaded = {};

/**
     * Keeps URLs
     * @type {Array}
     * @private
     * @static
     * @property
     */
    if (typeof mapsvg_paths !== "undefined") {
        MapSVG.urls = mapsvg_paths;
    } else {
        MapSVG.urls = {};
    }
    if (typeof ajaxurl !== "undefined") {
        MapSVG.urls.ajaxurl = ajaxurl;
    }

/**
     * Keeps map instances
     * @type {Array}
     * @private
     * @static
     * @property
     */
    MapSVG.instances = [];

MapSVG.userAgent = navigator.userAgent.toLowerCase();

/**
     * Determines if current device is touch-device
     * @type {boolean}
     * @static
     * @property
     */
    MapSVG.touchDevice =
        "ontouchstart" in window || navigator.MaxTouchPoints > 0 || navigator.msMaxTouchPoints > 0;
    // (MapSVG.userAgent.indexOf("ipad") > -1) ||
    // (MapSVG.userAgent.indexOf("iphone") > -1) ||
    // (MapSVG.userAgent.indexOf("ipod") > -1) ||
    // (MapSVG.userAgent.indexOf("android") > -1);

/**
     * Determines if current device is iOS-device
     * @type {boolean}
     * @static
     * @property
     */
    MapSVG.ios =
        MapSVG.userAgent.indexOf("ipad") > -1 ||
        MapSVG.userAgent.indexOf("iphone") > -1 ||
        MapSVG.userAgent.indexOf("ipod") > -1;

/**
     * Determines if current device is Android-device
     * @type {boolean}
     * @static
     * @property
     */
    MapSVG.android = MapSVG.userAgent.indexOf("android");

/**
     * Determines if current device is mobile-device
     * @type {boolean}
     * @static
     * @property
     */
    MapSVG.isPhone = window.matchMedia("only screen and (max-width: 812px)").matches;

/**
     * Keeps browser information
     * @type {object}
     * @static
     * @property
     */
    MapSVG.browser = {};
    MapSVG.browser.ie =
        MapSVG.userAgent.indexOf("msie") > -1 ||
        MapSVG.userAgent.indexOf("trident") > -1 ||
        MapSVG.userAgent.indexOf("edge") > -1
            ? {}
            : false;
    MapSVG.browser.firefox = MapSVG.userAgent.indexOf("firefox") > -1;

/**
     * Contains device information
     * @type {object}
     * @static
     * @property
     */
    var ua = window.navigator.userAgent;
    MapSVG.device = {};
    MapSVG.device.ios = !!ua.match(/iPad/i) || !!ua.match(/iPhone/i);
    MapSVG.device.android = !!ua.match(/Android/i);

if (!String.prototype.trim) {
        String.prototype.trim = function () {
            return this.replace(/^\s+|\s+$/g, "");
        };
    }

/**
     * Converts mouse event object to x/y coordinates
     * @param e
     * @returns {{x: *, y: *}}
     */
    MapSVG.mouseCoords = function (e) {
        if (e.clientX) {
            return { x: e.clientX + $(document).scrollLeft(), y: e.clientY + $(document).scrollTop() };
        }
        if (e.pageX) {
            return { x: e.pageX, y: e.pageY };
        } else if (MapSVG.touchDevice) {
            e = e.originalEvent || e;
            return e.touches && e.touches[0]
                ? { x: e.touches[0].pageX, y: e.touches[0].pageY }
                : { x: e.changedTouches[0].pageX, y: e.changedTouches[0].pageY };
        }
    };

/**
     * Adds new instance of the map
     * @param {MapSVG.Map} mapsvg
     */
    MapSVG.addInstance = function (mapsvg) {
        MapSVG.instances.push(mapsvg);
    };

MapSVG.get = function (index) {
        return MapSVG.instances[index];
    };

MapSVG.getById = function (id) {
        var instance = MapSVG.instances.filter(function (i) {
            return i.id == id;
        });
        if (instance.length > 0) {
            return instance[0];
        }
    };

MapSVG.getByContainerId = function (id) {
        var instance = MapSVG.instances.filter(function (i) {
            return i.$map.attr("id") == id;
        });
        if (instance.length > 0) {
            return instance[0];
        }
    };

MapSVG.extend = function (sub, base) {
        sub.prototype = Object.create(base.prototype);
        sub.prototype.constructor = sub;
    };

MapSVG.ucfirst = function (string) {
        return string.charAt(0).toUpperCase() + string.slice(1);
    };
    MapSVG.parseBoolean = function (string) {
        switch (String(string).toLowerCase()) {
            case "on":
            case "true":
            case "1":
            case "yes":
            case "y":
                return true;
            case "off":
            case "false":
            case "0":
            case "no":
            case "n":
                return false;
            default:
                return undefined;
        }
    };
    MapSVG.isNumber = function (n) {
        return !isNaN(parseFloat(n)) && isFinite(n);
    };

MapSVG.safeURL = function (url) {
        if (url.indexOf("http://") == 0 || url.indexOf("https://") == 0)
            url = "//" + url.split("://").pop();
        return url.replace(/^.*\/\/[^\/]+/, "");
    };

MapSVG.convertToText = function (obj) {
        //create an array that will later be joined into a string.
        var string = [];

//is object
        //    Both arrays and objects seem to return "object"
        //    when typeof(obj) is applied to them. So instead
        //    I am checking to see if they have the property
        //    join, which normal objects don't have but
        //    arrays do.
        if (obj === null) {
            return null;
        }
        if (obj === undefined) {
            return '""';
        } else if (typeof obj == "object" && obj.join == undefined) {
            var prop;
            for (prop in obj) {
                if (obj.hasOwnProperty(prop)) {
                    var key = '"' + prop.replace(/\"/g, '\\"') + '"'; //prop.search(/[^a-zA-Z]+/) === -1 ?  prop : ...
                    string.push(key + ": " + MapSVG.convertToText(obj[prop]));
                }
            }
            return "{" + string.join(",") + "}";

//is array
        } else if (typeof obj == "object" && !(obj.join == undefined)) {
            var prop;
            for (prop in obj) {
                string.push(MapSVG.convertToText(obj[prop]));
            }
            return "[" + string.join(",") + "]";

//is function
        } else if (typeof obj == "function") {
            return obj.toString().replace("function anonymous", "function");
            // string.push(obj.toString().replace('function anonymous','function'));

//all other values can be done with JSON.stringify
        } else {
            return JSON.stringify(obj);
            // var s = JSON.stringify(obj);
            // string.push(s);
        }
    };

// Create Element.remove() function if not exists
    if (!("remove" in Element.prototype)) {
        Element.prototype.remove = function () {
            if (this.parentNode) {
                this.parentNode.removeChild(this);
            }
        };
    }

Math.hypot =
        Math.hypot ||
        function () {
            var y = 0;
            var length = arguments.length;

for (var i = 0; i < length; i++) {
                if (arguments[i] === Infinity || arguments[i] === -Infinity) {
                    return Infinity;
                }
                y += arguments[i] * arguments[i];
            }
            return Math.sqrt(y);
        };
    SVGElement.prototype.getTransformToElement =
        SVGElement.prototype.getTransformToElement ||
        function (toElement) {
            let value;
            try {
                value = toElement.getScreenCTM().inverse().multiply(this.getScreenCTM());
            } catch (e) {
                return;
            }
            return value;
        };

Map.prototype.toArray = function () {
        return Array.from(this, ([name, value]) => value);
    };

MapSVG.ResizeSensor = class ResizeSensor {
        constructor(element, callback) {
            var _this = this;
            _this.element = element;
            _this.callback = callback;
            var style = getComputedStyle(element);
            var zIndex = parseInt(style.zIndex);
            if (isNaN(zIndex)) {
                zIndex = 0;
            }
            zIndex--;
            _this.expand = document.createElement("div");
            _this.expand.style.position = "absolute";
            _this.expand.style.left = "0px";
            _this.expand.style.top = "0px";
            _this.expand.style.right = "0px";
            _this.expand.style.bottom = "0px";
            _this.expand.style.overflow = "hidden";
            _this.expand.style.zIndex = zIndex.toString();
            _this.expand.style.visibility = "hidden";
            var expandChild = document.createElement("div");
            expandChild.style.position = "absolute";
            expandChild.style.left = "0px";
            expandChild.style.top = "0px";
            expandChild.style.width = "10000000px";
            expandChild.style.height = "10000000px";
            _this.expand.appendChild(expandChild);
            _this.shrink = document.createElement("div");
            _this.shrink.style.position = "absolute";
            _this.shrink.style.left = "0px";
            _this.shrink.style.top = "0px";
            _this.shrink.style.right = "0px";
            _this.shrink.style.bottom = "0px";
            _this.shrink.style.overflow = "hidden";
            _this.shrink.style.zIndex = zIndex.toString();
            _this.shrink.style.visibility = "hidden";
            var shrinkChild = document.createElement("div");
            shrinkChild.style.position = "absolute";
            shrinkChild.style.left = "0px";
            shrinkChild.style.top = "0px";
            shrinkChild.style.width = "200%";
            shrinkChild.style.height = "200%";
            _this.shrink.appendChild(shrinkChild);
            _this.element.appendChild(_this.expand);
            _this.element.appendChild(_this.shrink);
            var size = element.getBoundingClientRect();
            _this.currentWidth = size.width;
            _this.currentHeight = size.height;
            _this.setScroll();
            _this.expand.addEventListener("scroll", function () {
                _this.onScroll();
            });
            _this.shrink.addEventListener("scroll", function () {
                _this.onScroll();
            });
        }
        onScroll() {
            var _this = this;
            var size = _this.element.getBoundingClientRect();
            var newWidth = size.width;
            var newHeight = size.height;
            if (newWidth != _this.currentWidth || newHeight != _this.currentHeight) {
                _this.currentWidth = newWidth;
                _this.currentHeight = newHeight;
                _this.callback();
            }
            this.setScroll();
        }
        setScroll() {
            this.expand.scrollLeft = 10000000;
            this.expand.scrollTop = 10000000;
            this.shrink.scrollLeft = 10000000;
            this.shrink.scrollTop = 10000000;
        }
        destroy() {
            this.expand.remove();
            this.shrink.remove();
        }
    };

MapSVG.nonce = function () {
        return mapsvg_runtime_vars.nonce;
    };

/**
     * Adds # hash at the beginning of HEX color value
     * @param {String} color
     * @returns {String}
     * @private
     */
    MapSVG.fixColorHash = (color) => {
        const hexColorNoHash = new RegExp(/^([0-9a-f]{3}|[0-9a-f]{6})$/i);
        if (color && color.match(hexColorNoHash) !== null) {
            color = "#" + color;
        }
        return color;
    };

/**
     * Delays method execution.
     * For example, it can be used in search input fields to prevent sending
     * an ajax request on each key press.
     * @param {Function} method
     * @param {number} delay
     * @param {object} scope
     * @param {array} params
     * @private
     */
    MapSVG.throttle = (method, delay, scope, params) => {
        clearTimeout(method._tId);
        method._tId = setTimeout(function () {
            method.apply(scope, params);
        }, delay);
    };
    MapSVG.geocode = (query, callback) => {
        if (!window.google) {
            console.error("MapSVG: can't do Geocoding - Google Maps API is not loaded.");
            jQuery.growl.error({
                title: "Error",
                message: "Google Maps API files are not loaded",
            });
            return false;
        }
        // if (!MapSVG.options.google_api_key) {
        //     jQuery.growl.error({
        //         title: "Error",
        //         message: "Google Maps API key is not provided",
        //     });
        //     return false;
        // }
        if (!MapSVG.geocoder) {
            MapSVG.geocoder = new google.maps.Geocoder();
        }

MapSVG.throttle(MapSVG.geocoder.geocode, 500, MapSVG.geocoder, [
            query,
            function (results, status) {
                if (status === "OK") {
                    callback(results);
                } else {
                    jQuery.growl.error({
                        title: "Error: " + status,
                        message:
                            "There is some problem with Google API keys. See browser's console for more details",
                    });
                }
            },
        ]);
    };

MapSVG.handleFailedRequest = (response) => {
        var message = "";

if (response.status === 403) {
            if (response.responseText.indexOf("Wordfence") !== -1) {
                message +=
                    "The request has been blocked by Wordfence. " +
                    'Switch Wordfence to "Learning mode", and save the map settings again. ' +
                    "If the settings are saved successfully, you can switch Wordfence back to normal mode.";
            } else {
                message +=
                    "The request has been blocked by your server. " +
                    "Do you have mod_sec Apache's module enabled? If that's the case you need to change its settings.";
            }
        } else {
            if (response && response.responseText) {
                try {
                    var _response = JSON.parse(response.responseText);
                    if (_response && _response.data && _response.data.error) {
                        message = _response.data.error;
                    }
                } catch (e) {
                }
            }
        }

$.growl.error({
            title: "Error: " + response.status + " " + response.statusText,
            message: message,
            duration: 30000,
        });
    };

if (!Object.values) {
        Object.values = function (object) {
            return Object.keys(object).map(function (k) {
                return object[k];
            });
        };
    }

window.MapSVG = MapSVG;

// TinyColor v1.4.1
    // https://github.com/bgrins/TinyColor
    // Brian Grinstead, MIT License

//(function(Math) {

var trimLeft = /^\s+/,
        trimRight = /\s+$/,
        tinyCounter = 0,
        mathRound = Math.round,
        mathMin = Math.min,
        mathMax = Math.max,
        mathRandom = Math.random;

function tinycolor(color, opts) {
        color = color ? color : "";
        opts = opts || {};

// If input is already a tinycolor, return itself
        if (color instanceof tinycolor) {
            return color;
        }
        // If we are called as a function, call using new instead
        if (!(this instanceof tinycolor)) {
            return new tinycolor(color, opts);
        }

var rgb = inputToRGB(color);
        (this._originalInput = color),
            (this._r = rgb.r),
            (this._g = rgb.g),
            (this._b = rgb.b),
            (this._a = rgb.a),
            (this._roundA = mathRound(100 * this._a) / 100),
            (this._format = opts.format || rgb.format);
        this._gradientType = opts.gradientType;

// Don't let the range of [0,255] come back in [0,1].
        // Potentially lose a little bit of precision here, but will fix issues where
        // .5 gets interpreted as half of the total, instead of half of 1
        // If it was supposed to be 128, this was already taken care of by `inputToRgb`
        if (this._r < 1) {
            this._r = mathRound(this._r);
        }
        if (this._g < 1) {
            this._g = mathRound(this._g);
        }
        if (this._b < 1) {
            this._b = mathRound(this._b);
        }

this._ok = rgb.ok;
        this._tc_id = tinyCounter++;
    }

tinycolor.prototype = {
        isDark: function () {
            return this.getBrightness() < 128;
        },
        isLight: function () {
            return !this.isDark();
        },
        isValid: function () {
            return this._ok;
        },
        getOriginalInput: function () {
            return this._originalInput;
        },
        getFormat: function () {
            return this._format;
        },
        getAlpha: function () {
            return this._a;
        },
        getBrightness: function () {
            //http://www.w3.org/TR/AERT#color-contrast
            var rgb = this.toRgb();
            return (rgb.r * 299 + rgb.g * 587 + rgb.b * 114) / 1000;
        },
        getLuminance: function () {
            //http://www.w3.org/TR/2008/REC-WCAG20-20081211/#relativeluminancedef
            var rgb = this.toRgb();
            var RsRGB, GsRGB, BsRGB, R, G, B;
            RsRGB = rgb.r / 255;
            GsRGB = rgb.g / 255;
            BsRGB = rgb.b / 255;

if (RsRGB <= 0.03928) {
                R = RsRGB / 12.92;
            } else {
                R = Math.pow((RsRGB + 0.055) / 1.055, 2.4);
            }
            if (GsRGB <= 0.03928) {
                G = GsRGB / 12.92;
            } else {
                G = Math.pow((GsRGB + 0.055) / 1.055, 2.4);
            }
            if (BsRGB <= 0.03928) {
                B = BsRGB / 12.92;
            } else {
                B = Math.pow((BsRGB + 0.055) / 1.055, 2.4);
            }
            return 0.2126 * R + 0.7152 * G + 0.0722 * B;
        },
        setAlpha: function (value) {
            this._a = boundAlpha(value);
            this._roundA = mathRound(100 * this._a) / 100;
            return this;
        },
        toHsv: function () {
            var hsv = rgbToHsv(this._r, this._g, this._b);
            return { h: hsv.h * 360, s: hsv.s, v: hsv.v, a: this._a };
        },
        toHsvString: function () {
            var hsv = rgbToHsv(this._r, this._g, this._b);
            var h = mathRound(hsv.h * 360),
                s = mathRound(hsv.s * 100),
                v = mathRound(hsv.v * 100);
            return this._a == 1
                ? "hsv(" + h + ", " + s + "%, " + v + "%)"
                : "hsva(" + h + ", " + s + "%, " + v + "%, " + this._roundA + ")";
        },
        toHsl: function () {
            var hsl = rgbToHsl(this._r, this._g, this._b);
            return { h: hsl.h * 360, s: hsl.s, l: hsl.l, a: this._a };
        },
        toHslString: function () {
            var hsl = rgbToHsl(this._r, this._g, this._b);
            var h = mathRound(hsl.h * 360),
                s = mathRound(hsl.s * 100),
                l = mathRound(hsl.l * 100);
            return this._a == 1
                ? "hsl(" + h + ", " + s + "%, " + l + "%)"
                : "hsla(" + h + ", " + s + "%, " + l + "%, " + this._roundA + ")";
        },
        toHex: function (allow3Char) {
            return rgbToHex(this._r, this._g, this._b, allow3Char);
        },
        toHexString: function (allow3Char) {
            return "#" + this.toHex(allow3Char);
        },
        toHex8: function (allow4Char) {
            return rgbaToHex(this._r, this._g, this._b, this._a, allow4Char);
        },
        toHex8String: function (allow4Char) {
            return "#" + this.toHex8(allow4Char);
        },
        toRgb: function () {
            return { r: mathRound(this._r), g: mathRound(this._g), b: mathRound(this._b), a: this._a };
        },
        toRgbString: function () {
            return this._a == 1
                ? "rgb(" +
                      mathRound(this._r) +
                      ", " +
                      mathRound(this._g) +
                      ", " +
                      mathRound(this._b) +
                      ")"
                : "rgba(" +
                      mathRound(this._r) +
                      ", " +
                      mathRound(this._g) +
                      ", " +
                      mathRound(this._b) +
                      ", " +
                      this._roundA +
                      ")";
        },
        toPercentageRgb: function () {
            return {
                r: mathRound(bound01(this._r, 255) * 100) + "%",
                g: mathRound(bound01(this._g, 255) * 100) + "%",
                b: mathRound(bound01(this._b, 255) * 100) + "%",
                a: this._a,
            };
        },
        toPercentageRgbString: function () {
            return this._a == 1
                ? "rgb(" +
                      mathRound(bound01(this._r, 255) * 100) +
                      "%, " +
                      mathRound(bound01(this._g, 255) * 100) +
                      "%, " +
                      mathRound(bound01(this._b, 255) * 100) +
                      "%)"
                : "rgba(" +
                      mathRound(bound01(this._r, 255) * 100) +
                      "%, " +
                      mathRound(bound01(this._g, 255) * 100) +
                      "%, " +
                      mathRound(bound01(this._b, 255) * 100) +
                      "%, " +
                      this._roundA +
                      ")";
        },
        toName: function () {
            if (this._a === 0) {
                return "transparent";
            }

if (this._a < 1) {
                return false;
            }

return hexNames[rgbToHex(this._r, this._g, this._b, true)] || false;
        },
        toFilter: function (secondColor) {
            var hex8String = "#" + rgbaToArgbHex(this._r, this._g, this._b, this._a);
            var secondHex8String = hex8String;
            var gradientType = this._gradientType ? "GradientType = 1, " : "";

if (secondColor) {
                var s = tinycolor(secondColor);
                secondHex8String = "#" + rgbaToArgbHex(s._r, s._g, s._b, s._a);
            }

return (
                "progid:DXImageTransform.Microsoft.gradient(" +
                gradientType +
                "startColorstr=" +
                hex8String +
                ",endColorstr=" +
                secondHex8String +
                ")"
            );
        },
        toString: function (format) {
            var formatSet = !!format;
            format = format || this._format;

var formattedString = false;
            var hasAlpha = this._a < 1 && this._a >= 0;
            var needsAlphaFormat =
                !formatSet &&
                hasAlpha &&
                (format === "hex" ||
                    format === "hex6" ||
                    format === "hex3" ||
                    format === "hex4" ||
                    format === "hex8" ||
                    format === "name");

if (needsAlphaFormat) {
                // Special case for "transparent", all other non-alpha formats
                // will return rgba when there is transparency.
                if (format === "name" && this._a === 0) {
                    return this.toName();
                }
                return this.toRgbString();
            }
            if (format === "rgb") {
                formattedString = this.toRgbString();
            }
            if (format === "prgb") {
                formattedString = this.toPercentageRgbString();
            }
            if (format === "hex" || format === "hex6") {
                formattedString = this.toHexString();
            }
            if (format === "hex3") {
                formattedString = this.toHexString(true);
            }
            if (format === "hex4") {
                formattedString = this.toHex8String(true);
            }
            if (format === "hex8") {
                formattedString = this.toHex8String();
            }
            if (format === "name") {
                formattedString = this.toName();
            }
            if (format === "hsl") {
                formattedString = this.toHslString();
            }
            if (format === "hsv") {
                formattedString = this.toHsvString();
            }

return formattedString || this.toHexString();
        },
        clone: function () {
            return tinycolor(this.toString());
        },

_applyModification: function (fn, args) {
            var color = fn.apply(null, [this].concat([].slice.call(args)));
            this._r = color._r;
            this._g = color._g;
            this._b = color._b;
            this.setAlpha(color._a);
            return this;
        },
        lighten: function () {
            return this._applyModification(lighten, arguments);
        },
        brighten: function () {
            return this._applyModification(brighten, arguments);
        },
        darken: function () {
            return this._applyModification(darken, arguments);
        },
        desaturate: function () {
            return this._applyModification(desaturate, arguments);
        },
        saturate: function () {
            return this._applyModification(saturate, arguments);
        },
        greyscale: function () {
            return this._applyModification(greyscale, arguments);
        },
        spin: function () {
            return this._applyModification(spin, arguments);
        },

_applyCombination: function (fn, args) {
            return fn.apply(null, [this].concat([].slice.call(args)));
        },
        analogous: function () {
            return this._applyCombination(analogous, arguments);
        },
        complement: function () {
            return this._applyCombination(complement, arguments);
        },
        monochromatic: function () {
            return this._applyCombination(monochromatic, arguments);
        },
        splitcomplement: function () {
            return this._applyCombination(splitcomplement, arguments);
        },
        triad: function () {
            return this._applyCombination(triad, arguments);
        },
        tetrad: function () {
            return this._applyCombination(tetrad, arguments);
        },
    };

// If input is an object, force 1 into "1.0" to handle ratios properly
    // String input requires "1.0" as input, so 1 will be treated as 1
    tinycolor.fromRatio = function (color, opts) {
        if (typeof color == "object") {
            var newColor = {};
            for (var i in color) {
                if (color.hasOwnProperty(i)) {
                    if (i === "a") {
                        newColor[i] = color[i];
                    } else {
                        newColor[i] = convertToPercentage(color[i]);
                    }
                }
            }
            color = newColor;
        }

return tinycolor(color, opts);
    };

// Given a string or object, convert that input to RGB
    // Possible string inputs:
    //
    //     "red"
    //     "#f00" or "f00"
    //     "#ff0000" or "ff0000"
    //     "#ff000000" or "ff000000"
    //     "rgb 255 0 0" or "rgb (255, 0, 0)"
    //     "rgb 1.0 0 0" or "rgb (1, 0, 0)"
    //     "rgba (255, 0, 0, 1)" or "rgba 255, 0, 0, 1"
    //     "rgba (1.0, 0, 0, 1)" or "rgba 1.0, 0, 0, 1"
    //     "hsl(0, 100%, 50%)" or "hsl 0 100% 50%"
    //     "hsla(0, 100%, 50%, 1)" or "hsla 0 100% 50%, 1"
    //     "hsv(0, 100%, 100%)" or "hsv 0 100% 100%"
    //
    function inputToRGB(color) {
        var rgb = { r: 0, g: 0, b: 0 };
        var a = 1;
        var s = null;
        var v = null;
        var l = null;
        var ok = false;
        var format = false;

if (typeof color == "string") {
            color = stringInputToObject(color);
        }

if (typeof color == "object") {
            if (isValidCSSUnit(color.r) && isValidCSSUnit(color.g) && isValidCSSUnit(color.b)) {
                rgb = rgbToRgb(color.r, color.g, color.b);
                ok = true;
                format = String(color.r).substr(-1) === "%" ? "prgb" : "rgb";
            } else if (isValidCSSUnit(color.h) && isValidCSSUnit(color.s) && isValidCSSUnit(color.v)) {
                s = convertToPercentage(color.s);
                v = convertToPercentage(color.v);
                rgb = hsvToRgb(color.h, s, v);
                ok = true;
                format = "hsv";
            } else if (isValidCSSUnit(color.h) && isValidCSSUnit(color.s) && isValidCSSUnit(color.l)) {
                s = convertToPercentage(color.s);
                l = convertToPercentage(color.l);
                rgb = hslToRgb(color.h, s, l);
                ok = true;
                format = "hsl";
            }

if (color.hasOwnProperty("a")) {
                a = color.a;
            }
        }

a = boundAlpha(a);

return {
            ok: ok,
            format: color.format || format,
            r: mathMin(255, mathMax(rgb.r, 0)),
            g: mathMin(255, mathMax(rgb.g, 0)),
            b: mathMin(255, mathMax(rgb.b, 0)),
            a: a,
        };
    }

// Conversion Functions
    // --------------------

// `rgbToHsl`, `rgbToHsv`, `hslToRgb`, `hsvToRgb` modified from:
    // <http://mjijackson.com/2008/02/rgb-to-hsl-and-rgb-to-hsv-color-model-conversion-algorithms-in-javascript>

// `rgbToRgb`
    // Handle bounds / percentage checking to conform to CSS color spec
    // <http://www.w3.org/TR/css3-color/>
    // *Assumes:* r, g, b in [0, 255] or [0, 1]
    // *Returns:* { r, g, b } in [0, 255]
    function rgbToRgb(r, g, b) {
        return {
            r: bound01(r, 255) * 255,
            g: bound01(g, 255) * 255,
            b: bound01(b, 255) * 255,
        };
    }

// `rgbToHsl`
    // Converts an RGB color value to HSL.
    // *Assumes:* r, g, and b are contained in [0, 255] or [0, 1]
    // *Returns:* { h, s, l } in [0,1]
    function rgbToHsl(r, g, b) {
        r = bound01(r, 255);
        g = bound01(g, 255);
        b = bound01(b, 255);

var max = mathMax(r, g, b),
            min = mathMin(r, g, b);
        var h,
            s,
            l = (max + min) / 2;

if (max == min) {
            h = s = 0; // achromatic
        } else {
            var d = max - min;
            s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
            switch (max) {
                case r:
                    h = (g - b) / d + (g < b ? 6 : 0);
                    break;
                case g:
                    h = (b - r) / d + 2;
                    break;
                case b:
                    h = (r - g) / d + 4;
                    break;
            }

h /= 6;
        }

return { h: h, s: s, l: l };
    }

// `hslToRgb`
    // Converts an HSL color value to RGB.
    // *Assumes:* h is contained in [0, 1] or [0, 360] and s and l are contained [0, 1] or [0, 100]
    // *Returns:* { r, g, b } in the set [0, 255]
    function hslToRgb(h, s, l) {
        var r, g, b;

h = bound01(h, 360);
        s = bound01(s, 100);
        l = bound01(l, 100);

function hue2rgb(p, q, t) {
            if (t < 0) t += 1;
            if (t > 1) t -= 1;
            if (t < 1 / 6) return p + (q - p) * 6 * t;
            if (t < 1 / 2) return q;
            if (t < 2 / 3) return p + (q - p) * (2 / 3 - t) * 6;
            return p;
        }

if (s === 0) {
            r = g = b = l; // achromatic
        } else {
            var q = l < 0.5 ? l * (1 + s) : l + s - l * s;
            var p = 2 * l - q;
            r = hue2rgb(p, q, h + 1 / 3);
            g = hue2rgb(p, q, h);
            b = hue2rgb(p, q, h - 1 / 3);
        }

return { r: r * 255, g: g * 255, b: b * 255 };
    }

// `rgbToHsv`
    // Converts an RGB color value to HSV
    // *Assumes:* r, g, and b are contained in the set [0, 255] or [0, 1]
    // *Returns:* { h, s, v } in [0,1]
    function rgbToHsv(r, g, b) {
        r = bound01(r, 255);
        g = bound01(g, 255);
        b = bound01(b, 255);

var max = mathMax(r, g, b),
            min = mathMin(r, g, b);
        var h,
            s,
            v = max;

var d = max - min;
        s = max === 0 ? 0 : d / max;

if (max == min) {
            h = 0; // achromatic
        } else {
            switch (max) {
                case r:
                    h = (g - b) / d + (g < b ? 6 : 0);
                    break;
                case g:
                    h = (b - r) / d + 2;
                    break;
                case b:
                    h = (r - g) / d + 4;
                    break;
            }
            h /= 6;
        }
        return { h: h, s: s, v: v };
    }

// `hsvToRgb`
    // Converts an HSV color value to RGB.
    // *Assumes:* h is contained in [0, 1] or [0, 360] and s and v are contained in [0, 1] or [0, 100]
    // *Returns:* { r, g, b } in the set [0, 255]
    function hsvToRgb(h, s, v) {
        h = bound01(h, 360) * 6;
        s = bound01(s, 100);
        v = bound01(v, 100);

var i = Math.floor(h),
            f = h - i,
            p = v * (1 - s),
            q = v * (1 - f * s),
            t = v * (1 - (1 - f) * s),
            mod = i % 6,
            r = [v, q, p, p, t, v][mod],
            g = [t, v, v, q, p, p][mod],
            b = [p, p, t, v, v, q][mod];

return { r: r * 255, g: g * 255, b: b * 255 };
    }

// `rgbToHex`
    // Converts an RGB color to hex
    // Assumes r, g, and b are contained in the set [0, 255]
    // Returns a 3 or 6 character hex
    function rgbToHex(r, g, b, allow3Char) {
        var hex = [
            pad2(mathRound(r).toString(16)),
            pad2(mathRound(g).toString(16)),
            pad2(mathRound(b).toString(16)),
        ];

// Return a 3 character hex if possible
        if (
            allow3Char &&
            hex[0].charAt(0) == hex[0].charAt(1) &&
            hex[1].charAt(0) == hex[1].charAt(1) &&
            hex[2].charAt(0) == hex[2].charAt(1)
        ) {
            return hex[0].charAt(0) + hex[1].charAt(0) + hex[2].charAt(0);
        }

return hex.join("");
    }

// `rgbaToHex`
    // Converts an RGBA color plus alpha transparency to hex
    // Assumes r, g, b are contained in the set [0, 255] and
    // a in [0, 1]. Returns a 4 or 8 character rgba hex
    function rgbaToHex(r, g, b, a, allow4Char) {
        var hex = [
            pad2(mathRound(r).toString(16)),
            pad2(mathRound(g).toString(16)),
            pad2(mathRound(b).toString(16)),
            pad2(convertDecimalToHex(a)),
        ];

// Return a 4 character hex if possible
        if (
            allow4Char &&
            hex[0].charAt(0) == hex[0].charAt(1) &&
            hex[1].charAt(0) == hex[1].charAt(1) &&
            hex[2].charAt(0) == hex[2].charAt(1) &&
            hex[3].charAt(0) == hex[3].charAt(1)
        ) {
            return hex[0].charAt(0) + hex[1].charAt(0) + hex[2].charAt(0) + hex[3].charAt(0);
        }

return hex.join("");
    }

// `rgbaToArgbHex`
    // Converts an RGBA color to an ARGB Hex8 string
    // Rarely used, but required for "toFilter()"
    function rgbaToArgbHex(r, g, b, a) {
        var hex = [
            pad2(convertDecimalToHex(a)),
            pad2(mathRound(r).toString(16)),
            pad2(mathRound(g).toString(16)),
            pad2(mathRound(b).toString(16)),
        ];

return hex.join("");
    }

// `equals`
    // Can be called with any tinycolor input
    tinycolor.equals = function (color1, color2) {
        if (!color1 || !color2) {
            return false;
        }
        return tinycolor(color1).toRgbString() == tinycolor(color2).toRgbString();
    };

tinycolor.random = function () {
        return tinycolor.fromRatio({
            r: mathRandom(),
            g: mathRandom(),
            b: mathRandom(),
        });
    };

// Modification Functions
    // ----------------------
    // Thanks to less.js for some of the basics here
    // <https://github.com/cloudhead/less.js/blob/master/lib/less/functions.js>

function desaturate(color, amount) {
        amount = amount === 0 ? 0 : amount || 10;
        var hsl = tinycolor(color).toHsl();
        hsl.s -= amount / 100;
        hsl.s = clamp01(hsl.s);
        return tinycolor(hsl);
    }

function saturate(color, amount) {
        amount = amount === 0 ? 0 : amount || 10;
        var hsl = tinycolor(color).toHsl();
        hsl.s += amount / 100;
        hsl.s = clamp01(hsl.s);
        return tinycolor(hsl);
    }

function greyscale(color) {
        return tinycolor(color).desaturate(100);
    }

function lighten(color, amount) {
        amount = amount === 0 ? 0 : amount || 10;
        var hsl = tinycolor(color).toHsl();
        hsl.l += amount / 100;
        hsl.l = clamp01(hsl.l);
        return tinycolor(hsl);
    }

function brighten(color, amount) {
        amount = amount === 0 ? 0 : amount || 10;
        var rgb = tinycolor(color).toRgb();
        rgb.r = mathMax(0, mathMin(255, rgb.r - mathRound(255 * -(amount / 100))));
        rgb.g = mathMax(0, mathMin(255, rgb.g - mathRound(255 * -(amount / 100))));
        rgb.b = mathMax(0, mathMin(255, rgb.b - mathRound(255 * -(amount / 100))));
        return tinycolor(rgb);
    }

function darken(color, amount) {
        amount = amount === 0 ? 0 : amount || 10;
        var hsl = tinycolor(color).toHsl();
        hsl.l -= amount / 100;
        hsl.l = clamp01(hsl.l);
        return tinycolor(hsl);
    }

// Spin takes a positive or negative amount within [-360, 360] indicating the change of hue.
    // Values outside of this range will be wrapped into this range.
    function spin(color, amount) {
        var hsl = tinycolor(color).toHsl();
        var hue = (hsl.h + amount) % 360;
        hsl.h = hue < 0 ? 360 + hue : hue;
        return tinycolor(hsl);
    }

// Combination Functions
    // ---------------------
    // Thanks to jQuery xColor for some of the ideas behind these
    // <https://github.com/infusion/jQuery-xcolor/blob/master/jquery.xcolor.js>

function complement(color) {
        var hsl = tinycolor(color).toHsl();
        hsl.h = (hsl.h + 180) % 360;
        return tinycolor(hsl);
    }

function analogous(color, results, slices) {
        results = results || 6;
        slices = slices || 30;

var hsl = tinycolor(color).toHsl();
        var part = 360 / slices;
        var ret = [tinycolor(color)];

for (hsl.h = (hsl.h - ((part * results) >> 1) + 720) % 360; --results; ) {
            hsl.h = (hsl.h + part) % 360;
            ret.push(tinycolor(hsl));
        }
        return ret;
    }

function monochromatic(color, results) {
        results = results || 6;
        var hsv = tinycolor(color).toHsv();
        var h = hsv.h,
            s = hsv.s,
            v = hsv.v;
        var ret = [];
        var modification = 1 / results;

while (results--) {
            ret.push(tinycolor({ h: h, s: s, v: v }));
            v = (v + modification) % 1;
        }

return ret;
    }

// Utility Functions
    // ---------------------

tinycolor.mix = function (color1, color2, amount) {
        amount = amount === 0 ? 0 : amount || 50;

var rgb1 = tinycolor(color1).toRgb();
        var rgb2 = tinycolor(color2).toRgb();

var p = amount / 100;

var rgba = {
            r: (rgb2.r - rgb1.r) * p + rgb1.r,
            g: (rgb2.g - rgb1.g) * p + rgb1.g,
            b: (rgb2.b - rgb1.b) * p + rgb1.b,
            a: (rgb2.a - rgb1.a) * p + rgb1.a,
        };

return tinycolor(rgba);
    };

// Readability Functions
    // ---------------------
    // <http://www.w3.org/TR/2008/REC-WCAG20-20081211/#contrast-ratiodef (WCAG Version 2)

// `contrast`
    // Analyze the 2 colors and returns the color contrast defined by (WCAG Version 2)
    tinycolor.readability = function (color1, color2) {
        var c1 = tinycolor(color1);
        var c2 = tinycolor(color2);
        return (
            (Math.max(c1.getLuminance(), c2.getLuminance()) + 0.05) /
            (Math.min(c1.getLuminance(), c2.getLuminance()) + 0.05)
        );
    };

// `isReadable`
    // Ensure that foreground and background color combinations meet WCAG2 guidelines.
    // The third argument is an optional Object.
    //      the 'level' property states 'AA' or 'AAA' - if missing or invalid, it defaults to 'AA';
    //      the 'size' property states 'large' or 'small' - if missing or invalid, it defaults to 'small'.
    // If the entire object is absent, isReadable defaults to {level:"AA",size:"small"}.

// *Example*
    //    tinycolor.isReadable("#000", "#111") => false
    //    tinycolor.isReadable("#000", "#111",{level:"AA",size:"large"}) => false
    tinycolor.isReadable = function (color1, color2, wcag2) {
        var readability = tinycolor.readability(color1, color2);
        var wcag2Parms, out;

out = false;

wcag2Parms = validateWCAG2Parms(wcag2);
        switch (wcag2Parms.level + wcag2Parms.size) {
            case "AAsmall":
            case "AAAlarge":
                out = readability >= 4.5;
                break;
            case "AAlarge":
                out = readability >= 3;
                break;
            case "AAAsmall":
                out = readability >= 7;
                break;
        }
        return out;
    };

// `mostReadable`
    // Given a base color and a list of possible foreground or background
    // colors for that base, returns the most readable color.
    // Optionally returns Black or White if the most readable color is unreadable.
    // *Example*
    //    tinycolor.mostReadable(tinycolor.mostReadable("#123", ["#124", "#125"],{includeFallbackColors:false}).toHexString(); // "#112255"
    //    tinycolor.mostReadable(tinycolor.mostReadable("#123", ["#124", "#125"],{includeFallbackColors:true}).toHexString();  // "#ffffff"
    //    tinycolor.mostReadable("#a8015a", ["#faf3f3"],{includeFallbackColors:true,level:"AAA",size:"large"}).toHexString(); // "#faf3f3"
    //    tinycolor.mostReadable("#a8015a", ["#faf3f3"],{includeFallbackColors:true,level:"AAA",size:"small"}).toHexString(); // "#ffffff"
    tinycolor.mostReadable = function (baseColor, colorList, args) {
        var bestColor = null;
        var bestScore = 0;
        var readability;
        var includeFallbackColors, level, size;
        args = args || {};
        includeFallbackColors = args.includeFallbackColors;
        level = args.level;
        size = args.size;

for (var i = 0; i < colorList.length; i++) {
            readability = tinycolor.readability(baseColor, colorList[i]);
            if (readability > bestScore) {
                bestScore = readability;
                bestColor = tinycolor(colorList[i]);
            }
        }

if (
            tinycolor.isReadable(baseColor, bestColor, { level: level, size: size }) ||
            !includeFallbackColors
        ) {
            return bestColor;
        } else {
            args.includeFallbackColors = false;
            return tinycolor.mostReadable(baseColor, ["#fff", "#000"], args);
        }
    };

// Big List of Colors
    // ------------------
    // <http://www.w3.org/TR/css3-color/#svg-color>
    var names = (tinycolor.names = {
        aliceblue: "f0f8ff",
        antiquewhite: "faebd7",
        aqua: "0ff",
        aquamarine: "7fffd4",
        azure: "f0ffff",
        beige: "f5f5dc",
        bisque: "ffe4c4",
        black: "000",
        blanchedalmond: "ffebcd",
        blue: "00f",
        blueviolet: "8a2be2",
        brown: "a52a2a",
        burlywood: "deb887",
        burntsienna: "ea7e5d",
        cadetblue: "5f9ea0",
        chartreuse: "7fff00",
        chocolate: "d2691e",
        coral: "ff7f50",
        cornflowerblue: "6495ed",
        cornsilk: "fff8dc",
        crimson: "dc143c",
        cyan: "0ff",
        darkblue: "00008b",
        darkcyan: "008b8b",
        darkgoldenrod: "b8860b",
        darkgray: "a9a9a9",
        darkgreen: "006400",
        darkgrey: "a9a9a9",
        darkkhaki: "bdb76b",
        darkmagenta: "8b008b",
        darkolivegreen: "556b2f",
        darkorange: "ff8c00",
        darkorchid: "9932cc",
        darkred: "8b0000",
        darksalmon: "e9967a",
        darkseagreen: "8fbc8f",
        darkslateblue: "483d8b",
        darkslategray: "2f4f4f",
        darkslategrey: "2f4f4f",
        darkturquoise: "00ced1",
        darkviolet: "9400d3",
        deeppink: "ff1493",
        deepskyblue: "00bfff",
        dimgray: "696969",
        dimgrey: "696969",
        dodgerblue: "1e90ff",
        firebrick: "b22222",
        floralwhite: "fffaf0",
        forestgreen: "228b22",
        fuchsia: "f0f",
        gainsboro: "dcdcdc",
        ghostwhite: "f8f8ff",
        gold: "ffd700",
        goldenrod: "daa520",
        gray: "808080",
        green: "008000",
        greenyellow: "adff2f",
        grey: "808080",
        honeydew: "f0fff0",
        hotpink: "ff69b4",
        indianred: "cd5c5c",
        indigo: "4b0082",
        ivory: "fffff0",
        khaki: "f0e68c",
        lavender: "e6e6fa",
        lavenderblush: "fff0f5",
        lawngreen: "7cfc00",
        lemonchiffon: "fffacd",
        lightblue: "add8e6",
        lightcoral: "f08080",
        lightcyan: "e0ffff",
        lightgoldenrodyellow: "fafad2",
        lightgray: "d3d3d3",
        lightgreen: "90ee90",
        lightgrey: "d3d3d3",
        lightpink: "ffb6c1",
        lightsalmon: "ffa07a",
        lightseagreen: "20b2aa",
        lightskyblue: "87cefa",
        lightslategray: "789",
        lightslategrey: "789",
        lightsteelblue: "b0c4de",
        lightyellow: "ffffe0",
        lime: "0f0",
        limegreen: "32cd32",
        linen: "faf0e6",
        magenta: "f0f",
        maroon: "800000",
        mediumaquamarine: "66cdaa",
        mediumblue: "0000cd",
        mediumorchid: "ba55d3",
        mediumpurple: "9370db",
        mediumseagreen: "3cb371",
        mediumslateblue: "7b68ee",
        mediumspringgreen: "00fa9a",
        mediumturquoise: "48d1cc",
        mediumvioletred: "c71585",
        midnightblue: "191970",
        mintcream: "f5fffa",
        mistyrose: "ffe4e1",
        moccasin: "ffe4b5",
        navajowhite: "ffdead",
        navy: "000080",
        oldlace: "fdf5e6",
        olive: "808000",
        olivedrab: "6b8e23",
        orange: "ffa500",
        orangered: "ff4500",
        orchid: "da70d6",
        palegoldenrod: "eee8aa",
        palegreen: "98fb98",
        paleturquoise: "afeeee",
        palevioletred: "db7093",
        papayawhip: "ffefd5",
        peachpuff: "ffdab9",
        peru: "cd853f",
        pink: "ffc0cb",
        plum: "dda0dd",
        powderblue: "b0e0e6",
        purple: "800080",
        rebeccapurple: "663399",
        red: "f00",
        rosybrown: "bc8f8f",
        royalblue: "4169e1",
        saddlebrown: "8b4513",
        salmon: "fa8072",
        sandybrown: "f4a460",
        seagreen: "2e8b57",
        seashell: "fff5ee",
        sienna: "a0522d",
        silver: "c0c0c0",
        skyblue: "87ceeb",
        slateblue: "6a5acd",
        slategray: "708090",
        slategrey: "708090",
        snow: "fffafa",
        springgreen: "00ff7f",
        steelblue: "4682b4",
        tan: "d2b48c",
        teal: "008080",
        thistle: "d8bfd8",
        tomato: "ff6347",
        turquoise: "40e0d0",
        violet: "ee82ee",
        wheat: "f5deb3",
        white: "fff",
        whitesmoke: "f5f5f5",
        yellow: "ff0",
        yellowgreen: "9acd32",
    });

// Make it easy to access colors via `hexNames[hex]`
    var hexNames = (tinycolor.hexNames = flip(names));

// Utilities
    // ---------

// `{ 'name1': 'val1' }` becomes `{ 'val1': 'name1' }`
    function flip(o) {
        var flipped = {};
        for (var i in o) {
            if (o.hasOwnProperty(i)) {
                flipped[o[i]] = i;
            }
        }
        return flipped;
    }

// Return a valid alpha value [0,1] with all invalid values being set to 1
    function boundAlpha(a) {
        a = parseFloat(a);

if (isNaN(a) || a < 0 || a > 1) {
            a = 1;
        }

return a;
    }

// Take input from [0, n] and return it as [0, 1]
    function bound01(n, max) {
        if (isOnePointZero(n)) {
            n = "100%";
        }

var processPercent = isPercentage(n);
        n = mathMin(max, mathMax(0, parseFloat(n)));

// Automatically convert percentage into number
        if (processPercent) {
            n = parseInt(n * max, 10) / 100;
        }

// Handle floating point rounding errors
        if (Math.abs(n - max) < 0.000001) {
            return 1;
        }

// Convert into [0, 1] range if it isn't already
        return (n % max) / parseFloat(max);
    }

// Force a number between 0 and 1
    function clamp01(val) {
        return mathMin(1, mathMax(0, val));
    }

// Parse a base-16 hex value into a base-10 integer
    function parseIntFromHex(val) {
        return parseInt(val, 16);
    }

// Need to handle 1.0 as 100%, since once it is a number, there is no difference between it and 1
    // <http://stackoverflow.com/questions/7422072/javascript-how-to-detect-number-as-a-decimal-including-1-0>
    function isOnePointZero(n) {
        return typeof n == "string" && n.indexOf(".") != -1 && parseFloat(n) === 1;
    }

// Check to see if string passed in is a percentage
    function isPercentage(n) {
        return typeof n === "string" && n.indexOf("%") != -1;
    }

// Force a hex value to have 2 characters
    function pad2(c) {
        return c.length == 1 ? "0" + c : "" + c;
    }

// Replace a decimal with it's percentage value
    function convertToPercentage(n) {
        if (n <= 1) {
            n = n * 100 + "%";
        }

return n;
    }

// Converts a decimal to a hex value
    function convertDecimalToHex(d) {
        return Math.round(parseFloat(d) * 255).toString(16);
    }
    // Converts a hex value to a decimal
    function convertHexToDecimal(h) {
        return parseIntFromHex(h) / 255;
    }

var matchers = (function () {
        // <http://www.w3.org/TR/css3-values/#integers>
        var CSS_INTEGER = "[-\\+]?\\d+%?";

// <http://www.w3.org/TR/css3-values/#number-value>
        var CSS_NUMBER = "[-\\+]?\\d*\\.\\d+%?";

// Allow positive/negative integer/number.  Don't capture the either/or, just the entire outcome.
        var CSS_UNIT = "(?:" + CSS_NUMBER + ")|(?:" + CSS_INTEGER + ")";

// Actual matching.
        // Parentheses and commas are optional, but not required.
        // Whitespace can take the place of commas or opening paren
        var PERMISSIVE_MATCH3 =
            "[\\s|\$]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")\\s*\$?";
        var PERMISSIVE_MATCH4 =
            "[\\s|\$]+(" +
            CSS_UNIT +
            ")[,|\\s]+(" +
            CSS_UNIT +
            ")[,|\\s]+(" +
            CSS_UNIT +
            ")[,|\\s]+(" +
            CSS_UNIT +
            ")\\s*\$?";

return {
            CSS_UNIT: new RegExp(CSS_UNIT),
            rgb: new RegExp("rgb" + PERMISSIVE_MATCH3),
            rgba: new RegExp("rgba" + PERMISSIVE_MATCH4),
            hsl: new RegExp("hsl" + PERMISSIVE_MATCH3),
            hsla: new RegExp("hsla" + PERMISSIVE_MATCH4),
            hsv: new RegExp("hsv" + PERMISSIVE_MATCH3),
            hsva: new RegExp("hsva" + PERMISSIVE_MATCH4),
            hex3: /^#?([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,
            hex6: /^#?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/,
            hex4: /^#?([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,
            hex8: /^#?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/,
        };
    })();

// `isValidCSSUnit`
    // Take in a single string / number and check to see if it looks like a CSS unit
    // (see `matchers` above for definition).
    function isValidCSSUnit(color) {
        return !!matchers.CSS_UNIT.exec(color);
    }

// `stringInputToObject`
    // Permissive string parsing.  Take in a number of formats, and output an object
    // based on detected format.  Returns `{ r, g, b }` or `{ h, s, l }` or `{ h, s, v}`
    function stringInputToObject(color) {
        color = color.replace(trimLeft, "").replace(trimRight, "").toLowerCase();
        var named = false;
        if (names[color]) {
            color = names[color];
            named = true;
        } else if (color == "transparent") {
            return { r: 0, g: 0, b: 0, a: 0, format: "name" };
        }

// Try to match string input using regular expressions.
        // Keep most of the number bounding out of this function - don't worry about [0,1] or [0,100] or [0,360]
        // Just return an object and let the conversion functions handle that.
        // This way the result will be the same whether the tinycolor is initialized with string or object.
        var match;
        if ((match = matchers.rgb.exec(color))) {
            return { r: match[1], g: match[2], b: match[3] };
        }
        if ((match = matchers.rgba.exec(color))) {
            return { r: match[1], g: match[2], b: match[3], a: match[4] };
        }
        if ((match = matchers.hsl.exec(color))) {
            return { h: match[1], s: match[2], l: match[3] };
        }
        if ((match = matchers.hsla.exec(color))) {
            return { h: match[1], s: match[2], l: match[3], a: match[4] };
        }
        if ((match = matchers.hsv.exec(color))) {
            return { h: match[1], s: match[2], v: match[3] };
        }
        if ((match = matchers.hsva.exec(color))) {
            return { h: match[1], s: match[2], v: match[3], a: match[4] };
        }
        if ((match = matchers.hex8.exec(color))) {
            return {
                r: parseIntFromHex(match[1]),
                g: parseIntFromHex(match[2]),
                b: parseIntFromHex(match[3]),
                a: convertHexToDecimal(match[4]),
                format: named ? "name" : "hex8",
            };
        }
        if ((match = matchers.hex6.exec(color))) {
            return {
                r: parseIntFromHex(match[1]),
                g: parseIntFromHex(match[2]),
                b: parseIntFromHex(match[3]),
                format: named ? "name" : "hex",
            };
        }
        if ((match = matchers.hex4.exec(color))) {
            return {
                r: parseIntFromHex(match[1] + "" + match[1]),
                g: parseIntFromHex(match[2] + "" + match[2]),
                b: parseIntFromHex(match[3] + "" + match[3]),
                a: convertHexToDecimal(match[4] + "" + match[4]),
                format: named ? "name" : "hex8",
            };
        }
        if ((match = matchers.hex3.exec(color))) {
            return {
                r: parseIntFromHex(match[1] + "" + match[1]),
                g: parseIntFromHex(match[2] + "" + match[2]),
                b: parseIntFromHex(match[3] + "" + match[3]),
                format: named ? "name" : "hex",
            };
        }

return false;
    }

class Events {
        constructor(context) {
            this.events = {};
            this.context = context;
        }
        on(event, callbackOrObjectType, callback) {
            if (!this.events[event])
                this.events[event] = [];
            let callbackFunction;
            if (typeof callbackOrObjectType === "string") {
                callbackFunction = callback;
            }
            else {
                callbackFunction = callbackOrObjectType;
            }
            this.events[event].push(callbackFunction);
            return this;
        }
        off(event, callback) {
            const _this = this;
            if (this.events[event] && this.events[event].length) {
                this.events[event].forEach(function (_callback, index) {
                    if (typeof callback === "undefined") {
                        _this.events[event].splice(index, 1);
                    }
                    else if (_callback === callback) {
                        _this.events[event].splice(index, 1);
                    }
                });
            }
            return this;
        }
        trigger(event, thisArg, args) {
            if (this.events[event] && this.events[event].length)
                this.events[event].forEach((callback) => {
                    try {
                        callback && callback.apply(thisArg || this.context, args || [this.context]);
                    }
                    catch (err) {
                        console.error(err);
                    }
                });
            return this;
        }
    }

class ArrayIndexed extends Array {
        constructor(indexKey, items, options) {
            if (items) {
                super(...items);
            }
            else {
                super();
            }
            this.key = indexKey;
            this.dict = {};
            this.nextId = 1;
            if (options) {
                this.options = options;
            }
            else {
                this.options = { autoId: false, unique: false };
            }
            if (this.length > 0) {
                let i = 0;
                const _this = this;
                if (this.options.autoId) {
                    let maxId = 0;
                    let missingIds = false;
                    this.forEach(function (item) {
                        if (item[_this.key] != null) {
                            if (item[_this.key] > maxId) {
                                maxId = item[_this.key];
                            }
                        }
                        else {
                            missingIds = true;
                        }
                    });
                    this.nextId = ++maxId;
                    if (missingIds) {
                        this.forEach(function (item) {
                            if (item[_this.key] == null) {
                                item[_this.key] = _this.nextId;
                                _this.nextId++;
                            }
                        });
                    }
                }
                this.forEach(function (item) {
                    _this.dict[item[_this.key]] = i;
                    i++;
                });
            }
        }
        push(item) {
            const length = super.push(item);
            if (this.options.autoId === true) {
                item[this.key] = this.nextId;
                this.nextId++;
            }
            this.dict[item[this.key]] = length - 1;
            return length;
        }
        pop() {
            const item = this[this.length - 1];
            const id = item[this.key];
            const length = super.pop();
            delete this.dict[id];
            this.reindex();
            return super.pop();
        }
        update(data) {
            if (data[this.key] != null) {
                const obj = this.get(data[this.key]);
                for (const i in data) {
                    obj[i] = data[i];
                }
                return obj;
            }
            return false;
        }
        get(id) {
            return this.findById(id);
        }
        findById(id) {
            return this[this.dict[id]];
        }
        deleteById(id) {
            const index = this.dict[id];
            if (typeof index !== "undefined") {
                delete this.dict[id];
                this.splice(index, 1);
            }
        }
        delete(id) {
            this.deleteById(id);
        }
        clear() {
            this.length = 0;
            this.reindex();
        }
        reindex() {
            const _this = this;
            this.dict = {};
            this.forEach(function (item, index) {
                _this.dict[item[_this.key]] = index;
            });
        }
        sort(compareFn) {
            super.sort(compareFn);
            this.reindex();
            return this;
        }
        splice(start, deleteCount) {
            const res = super.splice(start, deleteCount);
            this.reindex();
            return res;
        }
    }

class SchemaField {
        constructor(field) {
            const booleans = ["visible", "searchable", "readonly", "protected"];
            for (const key in field) {
                this[key] = field[key];
            }
            booleans.forEach((paramName) => {
                if (typeof this[paramName] !== "undefined") {
                    this[paramName] = MapSVG.parseBoolean(this[paramName]);
                }
                else {
                    this[paramName] = false;
                }
            });
            if (typeof this.options !== "undefined") {
                if (!(this.options instanceof ArrayIndexed)) {
                    this.options = new ArrayIndexed("value", this.options);
                }
            }
        }
    }

class Schema {
        constructor(options) {
            this.fields = new ArrayIndexed("name");
            this.build(options);
            this.lastChangeTime = Date.now();
            this.events = new Events(this);
        }
        build(options) {
            const allowedParams = ["id", "title", "type", "name", "fields"];
            allowedParams.forEach((paramName) => {
                const setter = "set" + MapSVG.ucfirst(paramName);
                if (typeof options[paramName] !== "undefined" && typeof this[setter] == "function") {
                    this[setter](options[paramName]);
                }
            });
        }
        update(options) {
            this.build(options);
        }
        setId(id) {
            this.id = id;
        }
        setTitle(title) {
            this.title = title;
        }
        setName(name) {
            this.name = name;
        }
        loaded() {
            return this.fields.length !== 0;
        }
        setFields(fields) {
            if (fields) {
                this.fields.clear();
                fields.forEach((fieldParams) => {
                    this.fields.push(new SchemaField(fieldParams));
                });
            }
        }
        getFields() {
            return this.fields;
        }
        getFieldsAsArray() {
            return this.fields;
        }
        getFieldNames() {
            return this.fields.map((f) => f.name);
        }
        getField(field) {
            return this.fields.findById(field);
        }
        getFieldByType(type) {
            let f = null;
            this.fields.forEach(function (field) {
                if (field.type === type)
                    f = field;
            });
            return f;
        }
        getColumns(filters) {
            filters = filters || {};
            const columns = this.fields;
            const needfilters = Object.keys(filters).length !== 0;
            let results = [];
            if (needfilters) {
                let filterpass;
                columns.forEach(function (obj) {
                    filterpass = true;
                    for (const param in filters) {
                        filterpass = obj[param] == filters[param];
                    }
                    filterpass && results.push(obj);
                });
            }
            else {
                results = columns;
            }
            return results;
        }
        getData() {
            const data = {
                id: this.id,
                title: this.title,
                name: this.name,
                fields: this.fields,
                type: this.type,
            };
            return data;
        }
    }

class Query {
        constructor(options) {
            this.filters = {};
            this.filterout = {};
            this.page = 1;
            if (options) {
                for (const i in options) {
                    if (typeof options[i] !== "undefined") {
                        this[i] = options[i];
                    }
                }
            }
        }
        setFields(fields) {
            const _this = this;
            for (const key in fields) {
                if (key == "filters") {
                    _this.setFilters(fields[key]);
                }
                else {
                    _this[key] = fields[key];
                }
            }
        }
        update(query) {
            for (const i in query) {
                if (typeof query[i] !== "undefined") {
                    if (i === "filters") {
                        this.setFilters(query[i]);
                    }
                    else {
                        this[i] = query[i];
                    }
                }
            }
        }
        get() {
            return {
                search: this.search,
                searchField: this.searchField,
                searchFallback: this.searchFallback,
                filters: this.filters,
                filterout: this.filterout,
                page: this.page,
                sort: this.sort,
                perpage: this.perpage,
                lastpage: this.lastpage,
            };
        }
        clearFilters() {
            this.resetFilters();
        }
        setFilters(fields) {
            const _this = this;
            for (const key in fields) {
                if (fields[key] === null || fields[key] === "" || fields[key] === undefined) {
                    if (_this.filters[key]) {
                        delete _this.filters[key];
                    }
                }
                else {
                    _this.filters[key] = fields[key];
                }
            }
        }
        setSearch(search) {
            this.search = search;
        }
        setFilterOut(fields) {
            if (fields === null) {
                delete this.filterout;
            }
            else {
                this.filterout = fields;
            }
        }
        resetFilters(fields) {
            this.filters = {};
            this.setSearch("");
        }
        setFilterField(field, value) {
            this.filters[field] = value;
        }
        hasFilters() {
            return Object.keys(this.filters).length > 0 || this.search.length > 0;
        }
        removeFilter(fieldName) {
            this.filters[fieldName] = null;
            delete this.filters[fieldName];
        }
        requestSchema(requestSchema) {
            this.withSchema = requestSchema ? requestSchema : true;
        }
    }

class LocationAddress {
        constructor(fields) {
            for (const i in fields) {
                this[i] = fields[i];
            }
        }
        getData() {
            const copy = {};
            [
                "route",
                "address_formatted",
                "administrative_area_level_1",
                "administrative_area_level_1_short",
                "administrative_area_level_2",
                "administrative_area_level_2_short",
                "country",
                "country_short",
                "postal_code",
            ].forEach((field) => {
                if (this[field]) {
                    copy[field] = this[field];
                }
            });
            return copy;
        }
        get state() {
            return this.country_short === "US" ? this.administrative_area_level_1 : null;
        }
        get state_short() {
            return this.country_short === "US" ? this.administrative_area_level_1_short : null;
        }
        get county() {
            return this.country_short === "US" ? this.administrative_area_level_2 : null;
        }
        get zip() {
            return this.postal_code;
        }
    }

class ScreenPoint {
        constructor(x, y) {
            this.x = x;
            this.y = y;
        }
    }
    class SVGPoint {
        constructor(x, y) {
            let _x, _y;
            if (typeof x === "object") {
                if (x.x && x.y) {
                    _x = parseFloat(x.x + "");
                    _y = parseFloat(x.y + "");
                }
                else {
                    console.error("MapSVG: incorrect format of {x, y} object for SVGPoint.");
                    _x = 0;
                    _y = 0;
                }
            }
            else {
                _x = parseFloat(x + "");
                _y = parseFloat(y + "");
            }
            this.x = _x;
            this.y = _y;
        }
        toString() {
            return this.x + "," + this.y;
        }
    }
    class GeoPoint {
        constructor(lat, lng) {
            let _lat, _lng;
            if (typeof lat === "object") {
                if (lat.lat && lat.lng) {
                    _lat = parseFloat(lat.lat + "");
                    _lng = parseFloat(lat.lng + "");
                }
                else {
                    console.error("MapSVG: incorrect format of {lat, lng} object for GeoPoint.");
                    _lat = 0;
                    _lng = 0;
                }
            }
            else {
                _lat = parseFloat(lat + "");
                _lng = parseFloat(lng + "");
            }
            this.lat = _lat;
            this.lng = _lng;
        }
        toString() {
            return this.lat + "," + this.lng;
        }
    }
    class Location {
        constructor(options) {
            this.update(options);
        }
        update(options) {
            if (options.object) {
                this.setObject(options.object);
            }
            if (options.img) {
                this.setImage(options.img);
            }
            if (options.address) {
                this.setAddress(options.address);
            }
            if (options.svgPoint) {
                this.setSvgPoint(options.svgPoint);
            }
            if (options.geoPoint) {
                this.setGeoPoint(options.geoPoint);
            }
        }
        setObject(object) {
            this.object = object;
        }
        setImage(imgUrl) {
            if (typeof imgUrl !== "string") {
                return;
            }
            let src = imgUrl.split("/").pop();
            if (imgUrl.indexOf("uploads") !== -1) {
                src = "uploads/" + src;
            }
            this.img = src;
            this.imagePath = this.getImageUrl();
            this.marker && this.marker && this.marker.setImage(this.imagePath);
        }
        getImageUrl() {
            if (this.img && this.img.indexOf("uploads/") === 0) {
                return MapSVG.urls.uploads + "markers/" + this.img.replace("uploads/", "");
            }
            else {
                return MapSVG.urls.root + "markers/" + (this.img || "_pin_default.png");
            }
        }
        setAddress(address) {
            this.address = new LocationAddress(address);
        }
        setSvgPoint(svgPoint) {
            this.svgPoint = svgPoint instanceof SVGPoint ? svgPoint : new SVGPoint(svgPoint);
            if (this.marker) {
                this.marker.setSvgPointFromLocation();
            }
        }
        setGeoPoint(geoPoint) {
            this.geoPoint = geoPoint instanceof GeoPoint ? geoPoint : new GeoPoint(geoPoint);
            if (this.marker) {
                this.marker.setSvgPointFromLocation();
            }
        }
        getMarkerImage() {
            if (this.img && this.img.indexOf("uploads/") === 0) {
                return MapSVG.urls.uploads + "markers/" + this.img.replace("uploads/", "");
            }
            else {
                return MapSVG.urls.root + "markers/" + (this.img || "_pin_default.png");
            }
        }
        getData() {
            const data = {
                img: this.img,
                imagePath: this.imagePath,
                markerImagePath: this.marker && this.marker.object
                    ? this.marker.object.getMarkerImage()
                    : this.imagePath,
                address: this.address,
            };
            if (this.geoPoint) {
                data.geoPoint = { lat: this.geoPoint.lat, lng: this.geoPoint.lng };
            }
            if (this.svgPoint) {
                data.svgPoint = { x: this.svgPoint.x, y: this.svgPoint.y };
            }
            return data;
        }
    }

class CustomObject {
        constructor(params, schema) {
            this.initialLoad = true;
            this.setSchema(schema);
            this.dirtyFields = [];
            this.regions = [];
            this._regions = {};
            if (params.id !== undefined) {
                this.id = params.id;
            }
            this.initialLoad = true;
            this.build(params);
            this.initialLoad = false;
            if (this.id) {
                this.clearDirtyFields();
            }
        }
        setSchema(schema) {
            this.schema = schema;
            this.schema.events.on("changed", () => this.setLocationField());
            this.fields = schema.getFieldNames();
            this.setLocationField();
        }
        build(params) {
            for (const fieldName in params) {
                const field = this.schema.getField(fieldName);
                if (field) {
                    if (!this.initialLoad) {
                        this.dirtyFields.push(fieldName);
                    }
                    switch (field.type) {
                        case "region":
                            this.regions = params[fieldName];
                            break;
                        case "location":
                            if (params[fieldName] != null &&
                                params[fieldName] != "" &&
                                Object.keys(params[fieldName]).length !== 0) {
                                const data = {
                                    img: this.isMarkersByFieldEnabled()
                                        ? this.getMarkerImage()
                                        : params[fieldName].img,
                                    address: new LocationAddress(params[fieldName].address),
                                };
                                if (params[fieldName].geoPoint &&
                                    params[fieldName].geoPoint.lat &&
                                    params[fieldName].geoPoint.lng) {
                                    data.geoPoint = new GeoPoint(params[fieldName].geoPoint);
                                }
                                else if (params[fieldName].svgPoint &&
                                    params[fieldName].svgPoint.x &&
                                    params[fieldName].svgPoint.y) {
                                    data.svgPoint = new SVGPoint(params[fieldName].svgPoint);
                                }
                                if (this.location != null) {
                                    this.location.update(data);
                                }
                                else {
                                    this.location = new Location(data);
                                }
                            }
                            else {
                                this.location = null;
                            }
                            break;
                        case "post":
                            if (params.post) {
                                this.post = params.post;
                            }
                            break;
                        case "select":
                            this[fieldName] = params[fieldName];
                            if (!field.multiselect) {
                                this[fieldName + "_text"] = this.getEnumLabel(field, params, fieldName);
                            }
                            break;
                        case "radio":
                            this[fieldName] = params[fieldName];
                            this[fieldName + "_text"] = this.getEnumLabel(field, params, fieldName);
                            break;
                        default:
                            this[fieldName] = params[fieldName];
                            break;
                    }
                }
            }
            const locationField = this.getLocationField();
            if (locationField && this.isMarkersByFieldEnabled() && this.isMarkerFieldChanged(params)) {
                this.reloadMarkerImage();
            }
        }
        isMarkerFieldChanged(params) {
            return Object.keys(params).indexOf(this.getLocationField().markerField) !== -1;
        }
        setLocationField() {
        }
        getLocationField() {
            return this.schema.getFieldByType("location");
        }
        reloadMarkerImage() {
            this.location && this.location.setImage(this.getMarkerImage());
        }
        getMarkerImage() {
            let fieldValue;
            if (this.isMarkersByFieldEnabled()) {
                const locationField = this.getLocationField();
                fieldValue = this[locationField.markerField];
                if (!fieldValue) {
                    return locationField.defaultMarkerPath || MapSVG.defaultMarkerImage;
                }
                else {
                    if (locationField.markerField === "regions") {
                        fieldValue = fieldValue[0] && fieldValue[0].id;
                    }
                    else if (typeof fieldValue === "object" && fieldValue.length) {
                        fieldValue = fieldValue[0].value;
                    }
                    return (locationField.markersByField[fieldValue] ||
                        locationField.defaultMarkerPath ||
                        MapSVG.defaultMarkerImage);
                }
            }
            else {
                return this.location.imagePath;
            }
        }
        isMarkersByFieldEnabled() {
            const locationField = this.getLocationField();
            if (!locationField) {
                return false;
            }
            if (locationField.markersByFieldEnabled &&
                locationField.markerField &&
                Object.values(locationField.markersByField).length > 0) {
                return true;
            }
            else {
                return false;
            }
        }
        clone() {
            const data = this.getData();
            return new CustomObject(data, this.schema);
        }
        getEnumLabel(field, params, fieldName) {
            const value = field.options.get(params[fieldName]);
            if (typeof value !== "undefined") {
                return value.label;
            }
            else {
                return "";
            }
        }
        update(params) {
            this.build(params);
        }
        getDirtyFields() {
            const data = {};
            this.dirtyFields.forEach((field) => {
                data[field] = this[field];
            });
            data.id = this.id;
            if (data.location != null) {
                data.location = data.location.getData();
            }
            if (this.schema.getFieldByType("region")) {
                data.regions = this.regions;
            }
            return data;
        }
        clearDirtyFields() {
            this.dirtyFields = [];
        }
        getData() {
            const data = {};
            const fields = this.schema.getFields();
            fields.forEach((field) => {
                switch (field.type) {
                    case "region":
                        data[field.name] = this[field.name];
                        break;
                    case "select":
                        data[field.name] = this[field.name];
                        if (!field.multiselect) {
                            data[field.name + "_text"] = this[field.name + "_text"];
                        }
                        break;
                    case "post":
                        data[field.name] = this[field.name];
                        data["post"] = this.post;
                        break;
                    case "status":
                    case "radio":
                        data[field.name] = this[field.name];
                        data[field.name + "_text"] = this[field.name + "_text"];
                        break;
                    case "location":
                        data[field.name] = this[field.name] ? this[field.name].getData() : null;
                        break;
                    default:
                        data[field.name] = this[field.name];
                        break;
                }
            });
            return data;
        }
        getRegions(regionsTableName) {
            return this.regions;
        }
        getRegionsForTable(regionsTableName) {
            return this.regions
                ? this.regions.filter((region) => !region.tableName || region.tableName === regionsTableName)
                : [];
        }
    }

class MapsRepository extends Repository {
        constructor() {
            super("map", "maps");
            this.path = "maps/";
        }
        encodeData(params) {
            const data = {};
            if (typeof params.options !== "undefined") {
                data.options = JSON.stringify(params.options);
                data.options = data.options.replace(/select/g, "!mapsvg-encoded-slct");
                data.options = data.options.replace(/table/g, "!mapsvg-encoded-tbl");
                data.options = data.options.replace(/database/g, "!mapsvg-encoded-db");
                data.options = data.options.replace(/varchar/g, "!mapsvg-encoded-vc");
                data.options = data.options.replace(/int$11$/g, "!mapsvg-encoded-int");
            }
            if (typeof params.title !== "undefined") {
                data.title = params.title;
            }
            if (typeof params.id !== "undefined") {
                data.id = params.id;
            }
            if (typeof params.status !== "undefined") {
                data.status = params.status;
            }
            return data;
        }
        decodeData(dataJSON) {
            let data;
            if (typeof dataJSON === "string") {
                data = JSON.parse(dataJSON);
            }
            else {
                data = dataJSON;
            }
            return data;
        }
        copy(id, title) {
            const defer = jQuery.Deferred();
            defer.promise();
            const data = { options: { title: title } };
            this.server
                .post(this.path + id + "/copy", this.encodeData(data))
                .done((response) => {
                const data = this.decodeData(response);
                this.objects.clear();
                this.events.trigger("loaded");
                this.events.trigger("cleared");
                defer.resolve(data.map);
            })
                .fail(() => {
                defer.reject();
            });
            return defer;
        }
        createFromV2(object) {
            const defer = jQuery.Deferred();
            defer.promise();
            const data = {};
            data[this.objectNameSingle] = this.encodeData(object);
            this.server
                .post(this.path + "/createFromV2", data)
                .done((response) => {
                const data = this.decodeData(response);
                const object = data[this.objectNameSingle];
                this.objects.push(object);
                defer.resolve(object);
                this.events.trigger("created", this, [object]);
            })
                .fail(() => {
                defer.reject();
            });
            return defer;
        }
        delete(id) {
            const defer = jQuery.Deferred();
            defer.promise();
            this.server
                .delete(this.path + id)
                .done((response) => {
                this.objects.delete(id.toString());
                this.events.trigger("deleted");
                defer.resolve();
            })
                .fail(() => {
                defer.reject();
            });
            return defer;
        }
    }

class MapsV2Repository extends Repository {
        constructor() {
            super("map", "maps");
            this.path = "maps-v2/";
        }
        encodeData(params) {
            const data = {};
            data.options = JSON.stringify(params.options);
            data.options = data.options.replace(/select/g, "!mapsvg-encoded-slct");
            data.options = data.options.replace(/table/g, "!mapsvg-encoded-tbl");
            data.options = data.options.replace(/database/g, "!mapsvg-encoded-db");
            data.options = data.options.replace(/varchar/g, "!mapsvg-encoded-vc");
            data.id = params.id;
            data.title = params.title;
            return data;
        }
        decodeData(dataJSON) {
            let data;
            if (typeof dataJSON === "string") {
                data = JSON.parse(dataJSON);
            }
            else {
                data = dataJSON;
            }
            return data;
        }
    }

class Converter {
        constructor(mapElement, defViewBox, viewBox, geoViewBox) {
            this.mapElement = mapElement;
            this.defViewBox = defViewBox;
            this.viewBox = viewBox;
            this.yShift = 0;
            if (geoViewBox) {
                this.setGeoViewBox(geoViewBox);
            }
        }
        setYShift() {
            if (this.defViewBox.width === 20426) {
                this.yShift = 0;
                return;
            }
            if (this.geoViewBox) {
                const topLeftPoint = this.convertGeoToSVG(this.geoViewBox.ne);
                this.yShift = topLeftPoint.y - this.defViewBox.y;
            }
        }
        setGeoViewBox(geoViewBox) {
            this.geoViewBox = geoViewBox;
            this.mapLonDelta = this.geoViewBox.ne.lng - this.geoViewBox.sw.lng;
            this.mapLatBottomDegree = (this.geoViewBox.sw.lat * Math.PI) / 180;
            this.worldMapWidth = (this.defViewBox.width / this.mapLonDelta) * 360;
            this.worldMapRadius = ((this.defViewBox.width / this.mapLonDelta) * 360) / (2 * Math.PI);
            this.setYShift();
        }
        setWorldShift(on) {
            this.worldShift = on;
        }
        getScale() {
            return this.mapElement.clientWidth / this.viewBox.width;
        }
        convertSVGToPixel(svgPoint) {
            const scale = this.getScale();
            let shiftXByGM = 0;
            const shiftYByGM = 0;
            if (this.worldShift) {
                if (this.viewBox.x - this.defViewBox.x > this.defViewBox.width) {
                    shiftXByGM =
                        this.worldMapWidth *
                            Math.floor((this.viewBox.x - this.defViewBox.x) / this.defViewBox.width);
                }
            }
            return new ScreenPoint((svgPoint.x - this.viewBox.x + shiftXByGM) * scale, (svgPoint.y - this.viewBox.y + shiftYByGM) * scale);
        }
        convertPixelToSVG(screenPoint) {
            const scale = this.getScale();
            return new SVGPoint(screenPoint.x / scale + this.viewBox.x, screenPoint.y / scale + this.viewBox.y);
        }
        convertGeoToSVG(geoPoint) {
            if (!this.geoViewBox) {
                throw new Error("Can't do convertGeoToSVG() - geoViewBox is not provided.");
            }
            let x = (geoPoint.lng - this.geoViewBox.sw.lng) * (this.defViewBox.width / this.mapLonDelta);
            const lat = (geoPoint.lat * Math.PI) / 180;
            const mapOffsetY = (this.worldMapRadius / 2) *
                Math.log((1 + Math.sin(this.mapLatBottomDegree)) / (1 - Math.sin(this.mapLatBottomDegree)));
            let y = this.defViewBox.height -
                ((this.worldMapRadius / 2) * Math.log((1 + Math.sin(lat)) / (1 - Math.sin(lat))) -
                    mapOffsetY);
            x += this.defViewBox.x;
            y += this.defViewBox.y;
            y -= this.yShift;
            return new SVGPoint(x, y);
        }
        convertSVGToGeo(svgPoint) {
            if (!this.geoViewBox) {
                throw new Error("Can't do convertSVGToGeo() - geoViewBox is not provided.");
            }
            const tx = svgPoint.x - this.defViewBox.x;
            const ty = svgPoint.y - this.defViewBox.y;
            const mapOffsetY = (this.worldMapRadius / 2) *
                Math.log((1 + Math.sin(this.mapLatBottomDegree)) / (1 - Math.sin(this.mapLatBottomDegree)));
            const equatorY = this.defViewBox.height + mapOffsetY;
            const a = (equatorY - ty) / this.worldMapRadius;
            let lat = (180 / Math.PI) * (2 * Math.atan(Math.exp(a)) - Math.PI / 2);
            let lng = this.geoViewBox.sw.lng + (tx / this.defViewBox.width) * this.mapLonDelta;
            lat = parseFloat(lat.toFixed(6));
            lng = parseFloat(lng.toFixed(6));
            return new GeoPoint(lat, lng);
        }
    }

class ViewBox {
        constructor(x, y, width, height) {
            if (typeof x === "object") {
                if (x.hasOwnProperty("x") &&
                    x.hasOwnProperty("y") &&
                    x.hasOwnProperty("width") &&
                    x.hasOwnProperty("height")) {
                    this.x = typeof x.x === "string" ? parseFloat(x.x) : x.x;
                    this.y = typeof x.y === "string" ? parseFloat(x.y) : x.y;
                    this.width = typeof x.width === "string" ? parseFloat(x.width) : x.width;
                    this.height = typeof x.height === "string" ? parseFloat(x.height) : x.height;
                }
                else if (typeof x === "object" && x.length && x.length === 4) {
                    this.x = typeof x[0] === "string" ? parseFloat(x[0]) : x[0];
                    this.y = typeof x[1] === "string" ? parseFloat(x[1]) : x[1];
                    this.width = typeof x[2] === "string" ? parseFloat(x[2]) : x[2];
                    this.height = typeof x[3] === "string" ? parseFloat(x[3]) : x[3];
                }
            }
            else {
                this.x = typeof x === "string" ? parseFloat(x) : x;
                this.y = typeof y === "string" ? parseFloat(y) : y;
                this.width = typeof width === "string" ? parseFloat(width) : width;
                this.height = typeof height === "string" ? parseFloat(height) : height;
            }
        }
        update(newViewBox) {
            this.x = newViewBox.x;
            this.y = newViewBox.y;
            this.width = newViewBox.width;
            this.height = newViewBox.height;
        }
        toString() {
            return this.x + " " + this.y + " " + this.width + " " + this.height;
        }
        toArray() {
            return [this.x, this.y, this.width, this.height];
        }
        clone() {
            return new ViewBox({ x: this.x, y: this.y, width: this.width, height: this.height });
        }
        fitsInViewBox(viewBox, atLeastByOneDimension) {
            if (atLeastByOneDimension === true) {
                return viewBox.width > this.width || viewBox.height > this.height;
            }
            else {
                return viewBox.width > this.width && viewBox.height > this.height;
            }
        }
        addPadding(padding) {
            if (padding.top) {
                this.y -= padding.top;
                this.height += padding.top;
            }
            if (padding.right) {
                this.width += padding.right;
            }
            if (padding.bottom) {
                this.height += padding.bottom;
            }
            if (padding.left) {
                this.x -= padding.left;
                this.width += padding.left;
            }
        }
    }
    class GeoViewBox {
        constructor(sw, ne) {
            this.sw = sw;
            this.ne = ne;
        }
    }

class SchemaRepository extends Repository {
        constructor() {
            const objectName = "schema";
            super(objectName, +objectName + "s");
            this.className = "Schema";
            this.objectNameSingle = objectName;
            this.objectNameMany = objectName + "s";
            this.path = objectName + "s/";
            this.events = new Events(this);
        }
        create(schema) {
            const defer = jQuery.Deferred();
            defer.promise();
            const data = {};
            data[this.objectNameSingle] = this.encodeData(schema);
            this.server
                .post(this.path, data)
                .done((response) => {
                const data = this.decodeData(response);
                schema.id = data[this.objectNameSingle].id;
                this.objects.push(schema);
                this.events.trigger("created");
                schema.events.trigger("created");
                defer.resolve(schema);
            })
                .fail(() => {
                defer.reject();
            });
            return defer;
        }
        update(schema) {
            const defer = jQuery.Deferred();
            defer.promise();
            const data = {};
            data[this.objectNameSingle] = this.encodeData(schema);
            this.server
                .put(this.path + schema.id, data)
                .done((response) => {
                const data = this.decodeData(response);
                this.objects.push(schema);
                defer.resolve(schema);
                this.events.trigger("changed");
                schema.events.trigger("changed");
            })
                .fail(() => {
                defer.reject();
            });
            return defer;
        }
        encodeData(schema) {
            const _schema = schema.getData();
            let fieldsJsonString = JSON.stringify(_schema);
            fieldsJsonString = fieldsJsonString.replace(/select/g, "!mapsvg-encoded-slct");
            fieldsJsonString = fieldsJsonString.replace(/table/g, "!mapsvg-encoded-tbl");
            fieldsJsonString = fieldsJsonString.replace(/database/g, "!mapsvg-encoded-db");
            fieldsJsonString = fieldsJsonString.replace(/varchar/g, "!mapsvg-encoded-vc");
            fieldsJsonString = fieldsJsonString.replace(/int$11$/g, "!mapsvg-encoded-int");
            const back = JSON.parse(fieldsJsonString);
            back.fields = JSON.stringify(_schema.fields);
            return back;
        }
    }

const $$g = jQuery;
    class EmptyFormElement extends FormElement {
        constructor(options, formBuilder, external) {
            super(options, formBuilder, external);
            this.readonly = true;
        }
    }

class IdFormElement extends FormElement {
        constructor(options, formBuilder, external) {
            super(options, formBuilder, external);
        }
        getData() {
            return { name: "id", value: this.value };
        }
    }

function createCommonjsModule(fn, module) {
    	return module = { exports: {} }, fn(module, module.exports), module.exports;
    }

var sortable_min = createCommonjsModule(function (module) {
    /**!
     * Sortable
     * @author	RubaXa   <trash@rubaxa.org>
     * @license MIT
     */

(function sortableModule(factory) {

{
            module.exports = factory();
        }
    })(function sortableFactory() {

if (typeof window == "undefined" || !window.document) {
            return function sortableError() {
                throw new Error("Sortable.js requires a window with a document");
            };
        }

var dragEl,
            parentEl,
            ghostEl,
            cloneEl,
            rootEl,
            nextEl,
            scrollEl,
            scrollParentEl,
            scrollCustomFn,
            lastEl,
            lastCSS,
            lastParentCSS,
            oldIndex,
            newIndex,
            activeGroup,
            putSortable,
            autoScroll = {},
            tapEvt,
            touchEvt,
            moved,
            /** @const */
            RSPACE = /\s+/g,
            expando = "Sortable" + new Date().getTime(),
            win = window,
            document = win.document,
            parseInt = win.parseInt,
            $ = win.jQuery || win.Zepto,
            Polymer = win.Polymer,
            supportDraggable = !!("draggable" in document.createElement("div")),
            supportCssPointerEvents = (function (el) {
                // false when IE11
                if (navigator.userAgent.match(/Trident.*rv[ :]?11\./)) {
                    return false;
                }
                el = document.createElement("x");
                el.style.cssText = "pointer-events:auto";
                return el.style.pointerEvents === "auto";
            })(),
            _silent = false,
            abs = Math.abs,
            min = Math.min,
            touchDragOverListeners = [],
            _autoScroll = _throttle(function (
                /**Event*/ evt,
                /**Object*/ options,
                /**HTMLElement*/ rootEl
            ) {
                // Bug: https://bugzilla.mozilla.org/show_bug.cgi?id=505521
                if (rootEl && options.scroll) {
                    var el,
                        rect,
                        sens = options.scrollSensitivity,
                        speed = options.scrollSpeed,
                        x = evt.clientX,
                        y = evt.clientY,
                        winWidth = window.innerWidth,
                        winHeight = window.innerHeight,
                        vx,
                        vy,
                        scrollOffsetX,
                        scrollOffsetY;

// Delect scrollEl
                    if (scrollParentEl !== rootEl) {
                        scrollEl = options.scroll;
                        scrollParentEl = rootEl;
                        scrollCustomFn = options.scrollFn;

if (scrollEl === true) {
                            scrollEl = rootEl;

do {
                                if (
                                    scrollEl.offsetWidth < scrollEl.scrollWidth ||
                                    scrollEl.offsetHeight < scrollEl.scrollHeight
                                ) {
                                    break;
                                }
                                /* jshint boss:true */
                            } while ((scrollEl = scrollEl.parentNode));
                        }
                    }

if (scrollEl) {
                        el = scrollEl;
                        rect = scrollEl.getBoundingClientRect();
                        vx = (abs(rect.right - x) <= sens) - (abs(rect.left - x) <= sens);
                        vy = (abs(rect.bottom - y) <= sens) - (abs(rect.top - y) <= sens);
                    }

if (!(vx || vy)) {
                        vx = (winWidth - x <= sens) - (x <= sens);
                        vy = (winHeight - y <= sens) - (y <= sens);

/* jshint expr:true */
                        (vx || vy) && (el = win);
                    }

if (autoScroll.vx !== vx || autoScroll.vy !== vy || autoScroll.el !== el) {
                        autoScroll.el = el;
                        autoScroll.vx = vx;
                        autoScroll.vy = vy;

clearInterval(autoScroll.pid);

if (el) {
                            autoScroll.pid = setInterval(function () {
                                scrollOffsetY = vy ? vy * speed : 0;
                                scrollOffsetX = vx ? vx * speed : 0;

if ("function" === typeof scrollCustomFn) {
                                    return scrollCustomFn.call(
                                        _this,
                                        scrollOffsetX,
                                        scrollOffsetY,
                                        evt
                                    );
                                }

if (el === win) {
                                    win.scrollTo(
                                        win.pageXOffset + scrollOffsetX,
                                        win.pageYOffset + scrollOffsetY
                                    );
                                } else {
                                    el.scrollTop += scrollOffsetY;
                                    el.scrollLeft += scrollOffsetX;
                                }
                            }, 24);
                        }
                    }
                }
            },
            30),
            _prepareGroup = function (options) {
                function toFn(value, pull) {
                    if (value === void 0 || value === true) {
                        value = group.name;
                    }

if (typeof value === "function") {
                        return value;
                    } else {
                        return function (to, from) {
                            var fromGroup = from.options.group.name;

return pull
                                ? value
                                : value &&
                                      (value.join ? value.indexOf(fromGroup) > -1 : fromGroup == value);
                        };
                    }
                }

var group = {};
                var originalGroup = options.group;

if (!originalGroup || typeof originalGroup != "object") {
                    originalGroup = { name: originalGroup };
                }

group.name = originalGroup.name;
                group.checkPull = toFn(originalGroup.pull, true);
                group.checkPut = toFn(originalGroup.put);

options.group = group;
            };
        /**
         * @class  Sortable
         * @param  {HTMLElement}  el
         * @param  {Object}       [options]
         */
        function Sortable(el, options) {
            if (!(el && el.nodeType && el.nodeType === 1)) {
                throw "Sortable: `el` must be HTMLElement, and not " + {}.toString.call(el);
            }

this.el = el; // root element
            this.options = options = _extend({}, options);

// Export instance
            el[expando] = this;

// Default options
            var defaults = {
                group: Math.random(),
                sort: true,
                disabled: false,
                store: null,
                handle: null,
                scroll: true,
                scrollSensitivity: 30,
                scrollSpeed: 10,
                draggable: /[uo]l/i.test(el.nodeName) ? "li" : ">*",
                ghostClass: "sortable-ghost",
                chosenClass: "sortable-chosen",
                dragClass: "sortable-drag",
                ignore: "a, img",
                filter: null,
                animation: 0,
                setData: function (dataTransfer, dragEl) {
                    dataTransfer.setData("Text", dragEl.textContent);
                },
                dropBubble: false,
                dragoverBubble: false,
                dataIdAttr: "data-id",
                delay: 0,
                forceFallback: false,
                fallbackClass: "sortable-fallback",
                fallbackOnBody: false,
                fallbackTolerance: 0,
                fallbackOffset: { x: 0, y: 0 },
            };

// Set default options
            for (var name in defaults) {
                !(name in options) && (options[name] = defaults[name]);
            }

_prepareGroup(options);

// Bind all private methods
            for (var fn in this) {
                if (fn.charAt(0) === "_" && typeof this[fn] === "function") {
                    this[fn] = this[fn].bind(this);
                }
            }

// Setup drag mode
            this.nativeDraggable = options.forceFallback ? false : supportDraggable;

// Bind events
            _on(el, "mousedown", this._onTapStart);
            _on(el, "touchstart", this._onTapStart);

if (this.nativeDraggable) {
                _on(el, "dragover", this);
                _on(el, "dragenter", this);
            }

touchDragOverListeners.push(this._onDragOver);

// Restore sorting
            options.store && this.sort(options.store.get(this));
        }

Sortable.prototype = /** @lends Sortable.prototype */ {
            constructor: Sortable,

_onTapStart: function (/** Event|TouchEvent */ evt) {
                if (evt.target.tagName == "i" || evt.target.tagName == "I") {
                    evt.target.click();
                    return;
                }
                var _this = this,
                    el = this.el,
                    options = this.options,
                    type = evt.type,
                    touch = evt.touches && evt.touches[0],
                    target = (touch || evt).target,
                    originalTarget = (evt.target.shadowRoot && evt.path[0]) || target,
                    filter = options.filter,
                    startIndex;

// Don't trigger start event when an element is been dragged, otherwise the evt.oldindex always wrong when set option.group.
                if (dragEl) {
                    return;
                }

if ((type === "mousedown" && evt.button !== 0) || options.disabled) {
                    return; // only left button or enabled
                }

if (options.handle && !_closest(originalTarget, options.handle, el)) {
                    return;
                }

target = _closest(target, options.draggable, el);

if (!target) {
                    return;
                }

// Get the index of the dragged element within its parent
                startIndex = _index(target, options.draggable);

// Check filter
                if (typeof filter === "function") {
                    if (filter.call(this, evt, target, this)) {
                        _dispatchEvent(_this, originalTarget, "filter", target, el, startIndex);
                        evt.preventDefault();
                        return; // cancel dnd
                    }
                } else if (filter) {
                    filter = filter.split(",").some(function (criteria) {
                        criteria = _closest(originalTarget, criteria.trim(), el);

if (criteria) {
                            _dispatchEvent(_this, criteria, "filter", target, el, startIndex);
                            return true;
                        }
                    });

if (filter) {
                        evt.preventDefault();
                        return; // cancel dnd
                    }
                }

// Prepare `dragstart`
                this._prepareDragStart(evt, touch, target, startIndex);
            },

_prepareDragStart: function (
                /** Event */ evt,
                /** Touch */ touch,
                /** HTMLElement */ target,
                /** Number */ startIndex
            ) {
                var _this = this,
                    el = _this.el,
                    options = _this.options,
                    ownerDocument = el.ownerDocument,
                    dragStartFn;

if (target && !dragEl && target.parentNode === el) {
                    tapEvt = evt;

rootEl = el;
                    dragEl = target;
                    parentEl = dragEl.parentNode;
                    nextEl = dragEl.nextSibling;
                    activeGroup = options.group;
                    oldIndex = startIndex;

this._lastX = (touch || evt).clientX;
                    this._lastY = (touch || evt).clientY;

dragEl.style["will-change"] = "transform";

dragStartFn = function () {
                        // Delayed drag has been triggered
                        // we can re-enable the events: touchmove/mousemove
                        _this._disableDelayedDrag();

// Make the element draggable
                        dragEl.draggable = _this.nativeDraggable;

// Chosen item
                        _toggleClass(dragEl, options.chosenClass, true);

// Bind the events: dragstart/dragend
                        _this._triggerDragStart(touch);

// Drag start event
                        _dispatchEvent(_this, rootEl, "choose", dragEl, rootEl, oldIndex);
                    };

// Disable "draggable"
                    options.ignore.split(",").forEach(function (criteria) {
                        _find(dragEl, criteria.trim(), _disableDraggable);
                    });

_on(ownerDocument, "mouseup", _this._onDrop);
                    _on(ownerDocument, "touchend", _this._onDrop);
                    _on(ownerDocument, "touchcancel", _this._onDrop);

if (options.delay) {
                        // If the user moves the pointer or let go the click or touch
                        // before the delay has been reached:
                        // disable the delayed drag
                        _on(ownerDocument, "mouseup", _this._disableDelayedDrag);
                        _on(ownerDocument, "touchend", _this._disableDelayedDrag);
                        _on(ownerDocument, "touchcancel", _this._disableDelayedDrag);
                        _on(ownerDocument, "mousemove", _this._disableDelayedDrag);
                        _on(ownerDocument, "touchmove", _this._disableDelayedDrag);

_this._dragStartTimer = setTimeout(dragStartFn, options.delay);
                    } else {
                        dragStartFn();
                    }
                }
            },

_disableDelayedDrag: function () {
                var ownerDocument = this.el.ownerDocument;

clearTimeout(this._dragStartTimer);
                _off(ownerDocument, "mouseup", this._disableDelayedDrag);
                _off(ownerDocument, "touchend", this._disableDelayedDrag);
                _off(ownerDocument, "touchcancel", this._disableDelayedDrag);
                _off(ownerDocument, "mousemove", this._disableDelayedDrag);
                _off(ownerDocument, "touchmove", this._disableDelayedDrag);
            },

_triggerDragStart: function (/** Touch */ touch) {
                if (touch) {
                    // Touch device support
                    tapEvt = {
                        target: dragEl,
                        clientX: touch.clientX,
                        clientY: touch.clientY,
                    };

this._onDragStart(tapEvt, "touch");
                } else if (!this.nativeDraggable) {
                    this._onDragStart(tapEvt, true);
                } else {
                    _on(dragEl, "dragend", this);
                    _on(rootEl, "dragstart", this._onDragStart);
                }

try {
                    if (document.selection) {
                        // Timeout neccessary for IE9
                        setTimeout(function () {
                            document.selection.empty();
                        });
                    } else {
                        window.getSelection().removeAllRanges();
                    }
                } catch (err) {}
            },

_dragStarted: function () {
                if (rootEl && dragEl) {
                    var options = this.options;

// Apply effect
                    _toggleClass(dragEl, options.ghostClass, true);
                    _toggleClass(dragEl, options.dragClass, false);

Sortable.active = this;

// Drag start event
                    _dispatchEvent(this, rootEl, "start", dragEl, rootEl, oldIndex);
                }
            },

_emulateDragOver: function () {
                if (touchEvt) {
                    if (this._lastX === touchEvt.clientX && this._lastY === touchEvt.clientY) {
                        return;
                    }

this._lastX = touchEvt.clientX;
                    this._lastY = touchEvt.clientY;

if (!supportCssPointerEvents) {
                        _css(ghostEl, "display", "none");
                    }

var target = document.elementFromPoint(touchEvt.clientX, touchEvt.clientY),
                        parent = target,
                        i = touchDragOverListeners.length;

if (parent) {
                        do {
                            if (parent[expando]) {
                                while (i--) {
                                    touchDragOverListeners[i]({
                                        clientX: touchEvt.clientX,
                                        clientY: touchEvt.clientY,
                                        target: target,
                                        rootEl: parent,
                                    });
                                }

break;
                            }

target = parent; // store last element
                        } while (
                            /* jshint boss:true */
                            (parent = parent.parentNode)
                        );
                    }

if (!supportCssPointerEvents) {
                        _css(ghostEl, "display", "");
                    }
                }
            },

_onTouchMove: function (/**TouchEvent*/ evt) {
                if (tapEvt) {
                    var options = this.options,
                        fallbackTolerance = options.fallbackTolerance,
                        fallbackOffset = options.fallbackOffset,
                        touch = evt.touches ? evt.touches[0] : evt,
                        dx = touch.clientX - tapEvt.clientX + fallbackOffset.x,
                        dy = touch.clientY - tapEvt.clientY + fallbackOffset.y,
                        translate3d = evt.touches
                            ? "translate3d(" + dx + "px," + dy + "px,0)"
                            : "translate(" + dx + "px," + dy + "px)";

// only set the status to dragging, when we are actually dragging
                    if (!Sortable.active) {
                        if (
                            fallbackTolerance &&
                            min(abs(touch.clientX - this._lastX), abs(touch.clientY - this._lastY)) <
                                fallbackTolerance
                        ) {
                            return;
                        }

this._dragStarted();
                    }

// as well as creating the ghost element on the document body
                    this._appendGhost();

moved = true;
                    touchEvt = touch;

_css(ghostEl, "webkitTransform", translate3d);
                    _css(ghostEl, "mozTransform", translate3d);
                    _css(ghostEl, "msTransform", translate3d);
                    _css(ghostEl, "transform", translate3d);

evt.preventDefault();
                }
            },

_appendGhost: function () {
                if (!ghostEl) {
                    var rect = dragEl.getBoundingClientRect(),
                        css = _css(dragEl),
                        options = this.options,
                        ghostRect;

ghostEl = dragEl.cloneNode(true);

_toggleClass(ghostEl, options.ghostClass, false);
                    _toggleClass(ghostEl, options.fallbackClass, true);
                    _toggleClass(ghostEl, options.dragClass, true);

_css(ghostEl, "top", rect.top - parseInt(css.marginTop, 10));
                    _css(ghostEl, "left", rect.left - parseInt(css.marginLeft, 10));
                    _css(ghostEl, "width", rect.width);
                    _css(ghostEl, "height", rect.height);
                    _css(ghostEl, "opacity", "0.8");
                    _css(ghostEl, "position", "fixed");
                    _css(ghostEl, "zIndex", "100000");
                    _css(ghostEl, "pointerEvents", "none");

(options.fallbackOnBody && document.body.appendChild(ghostEl)) ||
                        rootEl.appendChild(ghostEl);

// Fixing dimensions.
                    ghostRect = ghostEl.getBoundingClientRect();
                    _css(ghostEl, "width", rect.width * 2 - ghostRect.width);
                    _css(ghostEl, "height", rect.height * 2 - ghostRect.height);
                }
            },

_onDragStart: function (/**Event*/ evt, /**boolean*/ useFallback) {
                var dataTransfer = evt.dataTransfer,
                    options = this.options;

this._offUpEvents();

if (activeGroup.checkPull(this, this, dragEl, evt) == "clone") {
                    cloneEl = _clone(dragEl);
                    _css(cloneEl, "display", "none");
                    rootEl.insertBefore(cloneEl, dragEl);
                    _dispatchEvent(this, rootEl, "clone", dragEl);
                }

_toggleClass(dragEl, options.dragClass, true);

if (useFallback) {
                    if (useFallback === "touch") {
                        // Bind touch events
                        _on(document, "touchmove", this._onTouchMove);
                        _on(document, "touchend", this._onDrop);
                        _on(document, "touchcancel", this._onDrop);
                    } else {
                        // Old brwoser
                        _on(document, "mousemove", this._onTouchMove);
                        _on(document, "mouseup", this._onDrop);
                    }

this._loopId = setInterval(this._emulateDragOver, 50);
                } else {
                    if (dataTransfer) {
                        dataTransfer.effectAllowed = "move";
                        options.setData && options.setData.call(this, dataTransfer, dragEl);
                    }

_on(document, "drop", this);
                    setTimeout(this._dragStarted, 0);
                }
            },

_onDragOver: function (/**Event*/ evt) {
                var el = this.el,
                    target,
                    dragRect,
                    targetRect,
                    revert,
                    options = this.options,
                    group = options.group,
                    activeSortable = Sortable.active,
                    isOwner = activeGroup === group,
                    canSort = options.sort;

if (evt.preventDefault !== void 0) {
                    evt.preventDefault();
                    !options.dragoverBubble && evt.stopPropagation();
                }

moved = true;

if (
                    activeGroup &&
                    !options.disabled &&
                    (isOwner
                        ? canSort || (revert = !rootEl.contains(dragEl)) // Reverting item into the original list
                        : putSortable === this ||
                          (activeGroup.checkPull(this, activeSortable, dragEl, evt) &&
                              group.checkPut(this, activeSortable, dragEl, evt))) &&
                    (evt.rootEl === void 0 || evt.rootEl === this.el) // touch fallback
                ) {
                    // Smart auto-scrolling
                    _autoScroll(evt, options, this.el);

if (_silent) {
                        return;
                    }

target = _closest(evt.target, options.draggable, el);
                    dragRect = dragEl.getBoundingClientRect();
                    putSortable = this;

if (revert) {
                        _cloneHide(true);
                        parentEl = rootEl; // actualization

if (cloneEl || nextEl) {
                            rootEl.insertBefore(dragEl, cloneEl || nextEl);
                        } else if (!canSort) {
                            rootEl.appendChild(dragEl);
                        }

return;
                    }

if (
                        el.children.length === 0 ||
                        el.children[0] === ghostEl ||
                        (el === evt.target && (target = _ghostIsLast(el, evt)))
                    ) {
                        if (target) {
                            if (target.animated) {
                                return;
                            }

targetRect = target.getBoundingClientRect();
                        }

_cloneHide(isOwner);

if (_onMove(rootEl, el, dragEl, dragRect, target, targetRect, evt) !== false) {
                            if (!dragEl.contains(el)) {
                                el.appendChild(dragEl);
                                parentEl = el; // actualization
                            }

this._animate(dragRect, dragEl);
                            target && this._animate(targetRect, target);
                        }
                    } else if (
                        target &&
                        !target.animated &&
                        target !== dragEl &&
                        target.parentNode[expando] !== void 0
                    ) {
                        if (lastEl !== target) {
                            lastEl = target;
                            lastCSS = _css(target);
                            lastParentCSS = _css(target.parentNode);
                        }

targetRect = target.getBoundingClientRect();

var width = targetRect.right - targetRect.left,
                            height = targetRect.bottom - targetRect.top,
                            floating =
                                /left|right|inline/.test(lastCSS.cssFloat + lastCSS.display) ||
                                (lastParentCSS.display == "flex" &&
                                    lastParentCSS["flex-direction"].indexOf("row") === 0),
                            isWide = target.offsetWidth > dragEl.offsetWidth,
                            isLong = target.offsetHeight > dragEl.offsetHeight,
                            halfway =
                                (floating
                                    ? (evt.clientX - targetRect.left) / width
                                    : (evt.clientY - targetRect.top) / height) > 0.5,
                            nextSibling = target.nextElementSibling,
                            moveVector = _onMove(rootEl, el, dragEl, dragRect, target, targetRect, evt),
                            after;

if (moveVector !== false) {
                            _silent = true;
                            setTimeout(_unsilent, 30);

_cloneHide(isOwner);

if (moveVector === 1 || moveVector === -1) {
                                after = moveVector === 1;
                            } else if (floating) {
                                var elTop = dragEl.offsetTop,
                                    tgTop = target.offsetTop;

if (elTop === tgTop) {
                                    after =
                                        (target.previousElementSibling === dragEl && !isWide) ||
                                        (halfway && isWide);
                                } else if (
                                    target.previousElementSibling === dragEl ||
                                    dragEl.previousElementSibling === target
                                ) {
                                    after = (evt.clientY - targetRect.top) / height > 0.5;
                                } else {
                                    after = tgTop > elTop;
                                }
                            } else {
                                after = (nextSibling !== dragEl && !isLong) || (halfway && isLong);
                            }

if (!dragEl.contains(el)) {
                                if (after && !nextSibling) {
                                    el.appendChild(dragEl);
                                } else {
                                    target.parentNode.insertBefore(
                                        dragEl,
                                        after ? nextSibling : target
                                    );
                                }
                            }

parentEl = dragEl.parentNode; // actualization

this._animate(dragRect, dragEl);
                            this._animate(targetRect, target);
                        }
                    }
                }
            },

_animate: function (prevRect, target) {
                var ms = this.options.animation;

if (ms) {
                    var currentRect = target.getBoundingClientRect();

_css(target, "transition", "none");
                    _css(
                        target,
                        "transform",
                        "translate3d(" +
                            (prevRect.left - currentRect.left) +
                            "px," +
                            (prevRect.top - currentRect.top) +
                            "px,0)"
                    );

target.offsetWidth; // repaint

_css(target, "transition", "all " + ms + "ms");
                    _css(target, "transform", "translate3d(0,0,0)");

clearTimeout(target.animated);
                    target.animated = setTimeout(function () {
                        _css(target, "transition", "");
                        _css(target, "transform", "");
                        target.animated = false;
                    }, ms);
                }
            },

_offUpEvents: function () {
                var ownerDocument = this.el.ownerDocument;

_off(document, "touchmove", this._onTouchMove);
                _off(ownerDocument, "mouseup", this._onDrop);
                _off(ownerDocument, "touchend", this._onDrop);
                _off(ownerDocument, "touchcancel", this._onDrop);
            },

_onDrop: function (/**Event*/ evt) {
                var el = this.el,
                    options = this.options;

clearInterval(this._loopId);
                clearInterval(autoScroll.pid);
                clearTimeout(this._dragStartTimer);

// Unbind events
                _off(document, "mousemove", this._onTouchMove);

if (this.nativeDraggable) {
                    _off(document, "drop", this);
                    _off(el, "dragstart", this._onDragStart);
                }

this._offUpEvents();

if (evt) {
                    if (moved) {
                        evt.preventDefault();
                        !options.dropBubble && evt.stopPropagation();
                    }

ghostEl && ghostEl.parentNode.removeChild(ghostEl);

if (dragEl) {
                        if (this.nativeDraggable) {
                            _off(dragEl, "dragend", this);
                        }

_disableDraggable(dragEl);
                        dragEl.style["will-change"] = "";

// Remove class's
                        _toggleClass(dragEl, this.options.ghostClass, false);
                        _toggleClass(dragEl, this.options.chosenClass, false);

if (rootEl !== parentEl) {
                            newIndex = _index(dragEl, options.draggable);

if (newIndex >= 0) {
                                // Add event
                                _dispatchEvent(
                                    null,
                                    parentEl,
                                    "add",
                                    dragEl,
                                    rootEl,
                                    oldIndex,
                                    newIndex
                                );

// Remove event
                                _dispatchEvent(
                                    this,
                                    rootEl,
                                    "remove",
                                    dragEl,
                                    rootEl,
                                    oldIndex,
                                    newIndex
                                );

// drag from one list and drop into another
                                _dispatchEvent(
                                    null,
                                    parentEl,
                                    "sort",
                                    dragEl,
                                    rootEl,
                                    oldIndex,
                                    newIndex
                                );
                                _dispatchEvent(
                                    this,
                                    rootEl,
                                    "sort",
                                    dragEl,
                                    rootEl,
                                    oldIndex,
                                    newIndex
                                );
                            }
                        } else {
                            // Remove clone
                            cloneEl && cloneEl.parentNode.removeChild(cloneEl);

if (dragEl.nextSibling !== nextEl) {
                                // Get the index of the dragged element within its parent
                                newIndex = _index(dragEl, options.draggable);

if (newIndex >= 0) {
                                    // drag & drop within the same list
                                    _dispatchEvent(
                                        this,
                                        rootEl,
                                        "update",
                                        dragEl,
                                        rootEl,
                                        oldIndex,
                                        newIndex
                                    );
                                    _dispatchEvent(
                                        this,
                                        rootEl,
                                        "sort",
                                        dragEl,
                                        rootEl,
                                        oldIndex,
                                        newIndex
                                    );
                                }
                            }
                        }

if (Sortable.active) {
                            /* jshint eqnull:true */
                            if (newIndex == null || newIndex === -1) {
                                newIndex = oldIndex;
                            }

_dispatchEvent(this, rootEl, "end", dragEl, rootEl, oldIndex, newIndex);

// Save sorting
                            this.save();
                        }
                    }
                }

this._nulling();
            },

_nulling: function () {
                rootEl = dragEl = parentEl = ghostEl = nextEl = cloneEl = scrollEl = scrollParentEl = tapEvt = touchEvt = moved = newIndex = lastEl = lastCSS = putSortable = activeGroup = Sortable.active = null;
            },

handleEvent: function (/**Event*/ evt) {
                var type = evt.type;

if (type === "dragover" || type === "dragenter") {
                    if (dragEl) {
                        this._onDragOver(evt);
                        _globalDragOver(evt);
                    }
                } else if (type === "drop" || type === "dragend") {
                    this._onDrop(evt);
                }
            },

/**
             * Serializes the item into an array of string.
             * @returns {String[]}
             */
            toArray: function () {
                var order = [],
                    el,
                    children = this.el.children,
                    i = 0,
                    n = children.length,
                    options = this.options;

for (; i < n; i++) {
                    el = children[i];
                    if (_closest(el, options.draggable, this.el)) {
                        order.push(el.getAttribute(options.dataIdAttr) || _generateId(el));
                    }
                }

return order;
            },

/**
             * Sorts the elements according to the array.
             * @param  {String[]}  order  order of the items
             */
            sort: function (order) {
                var items = {},
                    rootEl = this.el;

this.toArray().forEach(function (id, i) {
                    var el = rootEl.children[i];

if (_closest(el, this.options.draggable, rootEl)) {
                        items[id] = el;
                    }
                }, this);

order.forEach(function (id) {
                    if (items[id]) {
                        rootEl.removeChild(items[id]);
                        rootEl.appendChild(items[id]);
                    }
                });
            },

/**
             * Save the current sorting
             */
            save: function () {
                var store = this.options.store;
                store && store.set(this);
            },

/**
             * For each element in the set, get the first element that matches the selector by testing the element itself and traversing up through its ancestors in the DOM tree.
             * @param   {HTMLElement}  el
             * @param   {String}       [selector]  default: `options.draggable`
             * @returns {HTMLElement|null}
             */
            closest: function (el, selector) {
                return _closest(el, selector || this.options.draggable, this.el);
            },

/**
             * Set/get option
             * @param   {string} name
             * @param   {*}      [value]
             * @returns {*}
             */
            option: function (name, value) {
                var options = this.options;

if (value === void 0) {
                    return options[name];
                } else {
                    options[name] = value;

if (name === "group") {
                        _prepareGroup(options);
                    }
                }
            },

/**
             * Destroy
             */
            destroy: function () {
                var el = this.el;

el[expando] = null;

_off(el, "mousedown", this._onTapStart);
                _off(el, "touchstart", this._onTapStart);

if (this.nativeDraggable) {
                    _off(el, "dragover", this);
                    _off(el, "dragenter", this);
                }

// Remove draggable attributes
                Array.prototype.forEach.call(el.querySelectorAll("[draggable]"), function (el) {
                    el.removeAttribute("draggable");
                });

touchDragOverListeners.splice(touchDragOverListeners.indexOf(this._onDragOver), 1);

this._onDrop();

this.el = el = null;
            },
        };

function _cloneHide(state) {
            if (cloneEl && cloneEl.state !== state) {
                _css(cloneEl, "display", state ? "none" : "");
                !state && cloneEl.state && rootEl.insertBefore(cloneEl, dragEl);
                cloneEl.state = state;
            }
        }

function _closest(/**HTMLElement*/ el, /**String*/ selector, /**HTMLElement*/ ctx) {
            if (el) {
                ctx = ctx || document;

do {
                    if ((selector === ">*" && el.parentNode === ctx) || _matches(el, selector)) {
                        return el;
                    }
                    /* jshint boss:true */
                } while ((el = _getParentOrHost(el)));
            }

return null;
        }

function _getParentOrHost(el) {
            var parent = el.host;

return parent && parent.nodeType ? parent : el.parentNode;
        }

function _globalDragOver(/**Event*/ evt) {
            if (evt.dataTransfer) {
                evt.dataTransfer.dropEffect = "move";
            }
            evt.preventDefault();
        }

function _on(el, event, fn) {
            el.addEventListener(event, fn, false);
        }

function _off(el, event, fn) {
            el.removeEventListener(event, fn, false);
        }

function _css(el, prop, val) {
            var style = el && el.style;

if (style) {
                if (val === void 0) {
                    if (document.defaultView && document.defaultView.getComputedStyle) {
                        val = document.defaultView.getComputedStyle(el, "");
                    } else if (el.currentStyle) {
                        val = el.currentStyle;
                    }

return prop === void 0 ? val : val[prop];
                } else {
                    if (!(prop in style)) {
                        prop = "-webkit-" + prop;
                    }

style[prop] = val + (typeof val === "string" ? "" : "px");
                }
            }
        }

function _find(ctx, tagName, iterator) {
            if (ctx) {
                var list = ctx.getElementsByTagName(tagName),
                    i = 0,
                    n = list.length;

if (iterator) {
                    for (; i < n; i++) {
                        iterator(list[i], i);
                    }
                }

return list;
            }

return [];
        }

function _dispatchEvent(sortable, rootEl, name, targetEl, fromEl, startIndex, newIndex) {
            sortable = sortable || rootEl[expando];

var evt = document.createEvent("Event"),
                options = sortable.options,
                onName = "on" + name.charAt(0).toUpperCase() + name.substr(1);

evt.initEvent(name, true, true);

evt.to = rootEl;
            evt.from = fromEl || rootEl;
            evt.item = targetEl || rootEl;
            evt.clone = cloneEl;

evt.oldIndex = startIndex;
            evt.newIndex = newIndex;

rootEl.dispatchEvent(evt);

if (options[onName]) {
                options[onName].call(sortable, evt);
            }
        }

function _onMove(fromEl, toEl, dragEl, dragRect, targetEl, targetRect, originalEvt) {
            var evt,
                sortable = fromEl[expando],
                onMoveFn = sortable.options.onMove,
                retVal;

evt = document.createEvent("Event");
            evt.initEvent("move", true, true);

evt.to = toEl;
            evt.from = fromEl;
            evt.dragged = dragEl;
            evt.draggedRect = dragRect;
            evt.related = targetEl || toEl;
            evt.relatedRect = targetRect || toEl.getBoundingClientRect();

fromEl.dispatchEvent(evt);

if (onMoveFn) {
                retVal = onMoveFn.call(sortable, evt, originalEvt);
            }

return retVal;
        }

function _disableDraggable(el) {
            el.draggable = false;
        }

function _unsilent() {
            _silent = false;
        }

/** @returns {HTMLElement|false} */
        function _ghostIsLast(el, evt) {
            var lastEl = el.lastElementChild,
                rect = lastEl.getBoundingClientRect();

// 5 — min delta
            // abs — нельзя добавлять, а то глюки при наведении сверху
            return (
                (evt.clientY - (rect.top + rect.height) > 5 ||
                    evt.clientX - (rect.right + rect.width) > 5) &&
                lastEl
            );
        }

/**
         * Generate id
         * @param   {HTMLElement} el
         * @returns {String}
         * @private
         */
        function _generateId(el) {
            var str = el.tagName + el.className + el.src + el.href + el.textContent,
                i = str.length,
                sum = 0;

while (i--) {
                sum += str.charCodeAt(i);
            }

return sum.toString(36);
        }

/**
         * Returns the index of an element within its parent for a selected set of
         * elements
         * @param  {HTMLElement} el
         * @param  {selector} selector
         * @return {number}
         */
        function _index(el, selector) {
            var index = 0;

if (!el || !el.parentNode) {
                return -1;
            }

while (el && (el = el.previousElementSibling)) {
                if (
                    el.nodeName.toUpperCase() !== "TEMPLATE" &&
                    (selector === ">*" || _matches(el, selector))
                ) {
                    index++;
                }
            }

return index;
        }

function _matches(/**HTMLElement*/ el, /**String*/ selector) {
            if (el) {
                selector = selector.split(".");

var tag = selector.shift().toUpperCase(),
                    re = new RegExp("\\s(" + selector.join("|") + ")(?=\\s)", "g");

return (
                    (tag === "" || el.nodeName.toUpperCase() == tag) &&
                    (!selector.length ||
                        ((" " + el.className + " ").match(re) || []).length == selector.length)
                );
            }

return false;
        }

function _throttle(callback, ms) {
            var args, _this;

return function () {
                if (args === void 0) {
                    args = arguments;
                    _this = this;

setTimeout(function () {
                        if (args.length === 1) {
                            callback.call(_this, args[0]);
                        } else {
                            callback.apply(_this, args);
                        }

args = void 0;
                    }, ms);
                }
            };
        }

function _extend(dst, src) {
            if (dst && src) {
                for (var key in src) {
                    if (src.hasOwnProperty(key)) {
                        dst[key] = src[key];
                    }
                }
            }

return dst;
        }

function _clone(el) {
            return $
                ? $(el).clone(true)[0]
                : Polymer && Polymer.dom
                ? Polymer.dom(el).cloneNode(true)
                : el.cloneNode(true);
        }

// Export utils
        Sortable.utils = {
            on: _on,
            off: _off,
            css: _css,
            find: _find,
            is: function (el, selector) {
                return !!_closest(el, selector, el);
            },
            extend: _extend,
            throttle: _throttle,
            closest: _closest,
            toggleClass: _toggleClass,
            clone: _clone,
            index: _index,
        };

/**
         * Create sortable instance
         * @param {HTMLElement}  el
         * @param {Object}      [options]
         */
        Sortable.create = function (el, options) {
            return new Sortable(el, options);
        };

// Export
        Sortable.version = "1.4.2";
        return Sortable;
    });
    });

exports.MapSVGMap = MapSVGMap;
    exports.arrayIndexed = ArrayIndexed;
    exports.customObject = CustomObject;
    exports.formBuilder = FormBuilder;
    exports.geoPoint = GeoPoint;
    exports.globals = MapSVG;
    exports.location = Location;
    exports.map = MapSVGMap;
    exports.mapsRepository = MapsRepository;
    exports.mapsV2Repository = MapsV2Repository;
    exports.marker = Marker;
    exports.query = Query;
    exports.repository = Repository;
    exports.schema = Schema;
    exports.schemaRepository = SchemaRepository;
    exports.screenPoint = ScreenPoint;
    exports.server = Server;
    exports.svgPoint = SVGPoint;

Object.defineProperty(exports, '__esModule', { value: true });

})));
//# sourceMappingURL=mapsvg-front.umd.js.map