https://club-ihtiolog.ru/bitrix/cache/js/s1/main/page_9abc38bfd014…92cee139d10fa8390fe6_v1.js?1791183762275304

387        })
388    });
389}
390
391document.addEventListener("DOMContentLoaded", ready);
392
393/* End */
394;
395; /* Start:"a:4:{s:4:"full";s:64:"/o-klube/shema-territorii/assets/svg-pan-zoom.js?160241708291090";s:6:"source";s:48:"/o-klube/shema-territorii/assets/svg-pan-zoom.js";s:3:"min";s:0:"";s:3:"map";s:0:"";}"*/
396// svg-pan-zoom v3.6.1
397// https://github.com/ariutta/svg-pan-zoom
398(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){
399        var SvgUtils = require("./svg-utilities");
400
401        module.exports = {
402            enable: function(instance) {
403                // Select (and create if necessary) defs
404                var defs = instance.svg.querySelector("defs");
405                if (!defs) {
406                    defs = document.createElementNS(SvgUtils.svgNS, "defs");
407                    instance.svg.appendChild(defs);
408                }
409
410                // Check for style element, and create it if it doesn't exist
411                var styleEl = defs.querySelector("style#svg-pan-zoom-controls-styles");
412                if (!styleEl) {
413                    var style = document.createElementNS(SvgUtils.svgNS, "style");
414                    style.setAttribute("id", "svg-pan-zoom-controls-styles");
415                    style.setAttribute("type", "text/css");
416                    style.textContent =
417                        ".svg-pan-zoom-control { cursor: pointer; fill: black; fill-opacity: 0.333; } .svg-pan-zoom-control:hover { fill-opacity: 0.8; } .svg-pan-zoom-control-background { fill: white; fill-opacity: 0.5; } .svg-pan-zoom-control-background { fill-opacity: 0.8; }";
418                    defs.appendChild(style);
419                }
420
421                // Zoom Group
422                var zoomGroup = document.createElementNS(SvgUtils.svgNS, "g");
423                zoomGroup.setAttribute("id", "svg-pan-zoom-controls");
424                zoomGroup.setAttribute(
425                    "transform",
426                    "translate(" +
427                    (instance.width - 70) +
428                    " " +
429                    (instance.height - 76) +
430                    ") scale(0.75)"
431                );
432                zoomGroup.setAttribute("class", "svg-pan-zoom-control");
433
434                // Control elements
435                zoomGroup.appendChild(this._createZoomIn(instance));
436                zoomGroup.appendChild(this._createZoomReset(instance));
437                zoomGroup.appendChild(this._createZoomOut(instance));
438
439                // Finally append created element
440                instance.svg.appendChild(zoomGroup);
441
442                // Cache control instance
443                instance.controlIcons = zoomGroup;
444            },
445
446            _createZoomIn: function(instance) {
447                var zoomIn = document.createElementNS(SvgUtils.svgNS, "g");
448                zoomIn.setAttribute("id", "svg-pan-zoom-zoom-in");
449                zoomIn.setAttribute("transform", "translate(30.5 5) scale(0.015)");
450                zoomIn.setAttribute("class", "svg-pan-zoom-control");
451                zoomIn.addEventListener(
452                    "click",
453                    function() {
454                        instance.getPublicInstance().zoomIn();
455                    },
456                    false
457                );
458                zoomIn.addEventListener(
459                    "touchstart",
460                    function() {
461                        instance.getPublicInstance().zoomIn();
462                    },
463                    false
464                );
465
466                var zoomInBackground = document.createElementNS(SvgUtils.svgNS, "rect"); // TODO change these background space fillers to rounded rectangles s

572                var zoomOutBackground = document.createElementNS(SvgUtils.svgNS, "rect"); // TODO change these background space fillers to rounded rectangles so they look prettier
573                zoomOutBackground.setAttribute("x", "0");
574                zoomOutBackground.setAttribute("y", "0");
575                zoomOutBackground.setAttribute("width", "1500"); // larger than expected because the whole group is transformed to scale down
576                zoomOutBackground.setAttribute("height", "1400");
577                zoomOutBackground.setAttribute("class", "svg-pan-zoom-control-background");
578                zoomOut.appendChild(zoomOutBackground);
579
580                var zoomOutShape = document.createElementNS(SvgUtils.svgNS, "path");
581                zoomOutShape.setAttribute(
582                    "d",
583                    "M1280 576v128q0 26 -19 45t-45 19h-896q-26 0 -45 -19t-19 -45v-128q0 -26 19 -45t45 -19h896q26 0 45 19t19 45zM1536 1120v-960q0 -119 -84.5 -203.5t-203.5 -84.5h-960q-119 0 -203.5 84.5t-84.5 203.5v960q0 119 84.5 203.5t203.5 84.5h960q119 0 203.5 -84.5 t84.5 -203.5z"
584                );
585                zoomOutShape.setAttribute("class", "svg-pan-zoom-control-element");
586                zoomOut.appendChild(zoomOutShape);
587
588                return zoomOut;
589            },
590
591            disable: function(instance) {
592                if (instance.controlIcons) {
593                    instance.controlIcons.parentNode.removeChild(instance.controlIcons);
594                    instance.controlIcons = null;
595                }
596            }
597        };
598
599    },{"./svg-utilities":5}],2:[function(require,module,exports){
600        var SvgUtils = require("./svg-utilities"),
601            Utils = require("./utilities");
602
603        var ShadowViewport = function(viewport, options) {
604            this.init(viewport, options);
605        };
606
607        /**
608         * Initialization
609         *
610         * @param  {SVGElement} viewport
611         * @param  {Object} options
612         */
613        ShadowViewport.prototype.init = function(viewport, options) {
614            // DOM Elements
615            this.viewport = viewport;
616            this.options = options;
617
618            // State cache
619            this.originalState = { zoom: 1, x: 0, y: 0 };
620            this.activeState = { zoom: 1, x: 0, y: 0 };
621
622            this.updateCTMCached = Utils.proxy(this.updateCTM, this);
623
624            // Create a custom requestAnimationFrame taking in account refreshRate
625            this.requestAnimationFrame = Utils.createRequestAnimationFrame(
626                this.options.refreshRate
627            );
628
629            // ViewBox
630            this.viewBox = { x: 0, y: 0, width: 0, height: 0 };
631            this.cacheViewBox();
632
633            // Process CTM
634            var newCTM = this.processCTM();
635
636            // Update viewport CTM and cache zoom and pan
637            this.setCTM(newCTM);
638
639            // Update CTM in this frame
640            this.updateCTM();
641        };
642
643        /**
644         * Cache initial viewBox value
645         * If no viewBox is defined, then use viewport size/position instead for viewBox values
646         */
647        ShadowViewport.prototype.cacheViewBox = function() {
648            var svgViewBox = this.options.svg.getAttribute("viewBox");
649
650            if (svgViewBox) {
651                var viewBoxValues = svgViewBox
652                    .split(/[\s\,]/)
653                    .filter(function(v) {
654                        return v;
655                    })
656                    .map(parseFloat);
657
658                // Cache viewbox x and y offset
659                this.viewBox.x = viewBoxValues[0];
660                this.viewBox.y = viewBoxValues[1];
661                this.viewBox.width = viewBoxValues[2];
662                this.viewBox.height = viewBoxValues[3];
663
664                var zoom = Math.min(
665                    this.options.width / this.viewBox.width,
666                    this.options.height / this.viewBox.height
667                );
668
669                // Update active state
670                this.activeState.zoom = zoom;
671                this.activeState.x = (this.options.width - this.viewBox.width * zoom) / 2;
672                this.activeState.y = (this.options.height - this.viewBox.height * zoom) / 2;
673
674                // Force updating CTM
675                this.updateCTMOnNextFrame();
676
677                this.options.svg.removeAttribute("viewBox");
678            } else {
679                this.simpleViewBoxCache();
680            }
681        };
682
683        /**
684         * Recalculate viewport sizes and update viewBox cache
685         */
686        ShadowViewport.prototype.simpleViewBoxCache = function() {
687            var bBox = this.viewport.getBBox();
688
689            this.viewBox.x = bBox.x;
690            this.viewBox.y = bBox.y;
691            this.viewBox.width = bBox.width;
692            this.viewBox.height = bBox.height;
693        };
694
695        /**
696         * Returns a viewbox object. Safe to alter
697         *
698         * @return {Object} viewbox object
699         */
700        ShadowViewport.prototype.getViewBox = function() {
701            return Utils.extend({}, this.viewBox);
702        };
703
704        /**
705         * Get initial zoom and pan values. Save them into originalState
706         * Parses viewBox attribute to alter initial sizes
707         *
708         * @return {CTM} CTM object based on options
709         */
710        ShadowViewport.prototype.processCTM = function() {
711            var newCTM = this.getCTM();
712
713            if (this.options.fit || this.options.contain) {
714                var newScale;
715                if (this.options.fit) {
716                    newScale = Math.min(
717                        this.options.width / this.viewBox.width,
718                        this.options.height / this.viewBox.height
719                    );
720                } else {
721                    newScale = Math.max(
722                        this.options.width / this.viewBox.width,
723                        this.options.height / this.viewBox.height
724                    );
725                }
726
727                newCTM.a = newScale; //x-scale
728                newCTM.d = newScale; //y-scale
729                newCTM.e = -this.viewBox.x * newScale; //x-transform
730                newCTM.f = -this.viewBox.y * newScale; //y-transform
731            }
732
733            if (this.options.center) {
734                var offsetX =
735                    (this.options.width -
736                        (this.viewBox.width + this.viewBox.x * 2) * newCTM.a) *
737                    0.5,
738                    offsetY =
739                        (this.options.height -
740                            (this.viewBox.height + this.viewBox.y * 2) * newCTM.a) *
741                        0.5;
742
743                newCTM.e = offsetX;
744                newCTM.f = offsetY;
745            }
746
747            // Cache initial values. Based on activeState and fix+center opitons
748            this.originalState.zoom = newCTM.a;
749            this.originalState.x = newCTM.e;
750            this.originalState.y = newCTM.f;
751
752            return newCTM;
753        };
754
755        /**
756         * Return originalState object. Safe to alter
757         *
758         * @return {Object}
759         */
760        ShadowViewport.prototype.getOriginalState = function() {
761            return Utils.extend({}, this.originalState);
762        };
763
764        /**
765         * Return actualState object. Safe to alter
766         *
767         * @return {Object}
768         */
769        ShadowViewport.prototype.getState = function() {
770            return Utils.extend({}, this.activeState);
771        };
772
773        /**
774         * Get zoom scale
775         *
776         * @return {Float} zoom scale
777         */
778        ShadowViewport.prototype.getZoom = function() {
779            return this.activeState.zoom;
780        };
781
782        /**
783         * Get zoom scale for pubilc usage
784         *
785         * @return {Float} zoom scale
786         */
787        ShadowViewport.prototype.getRelativeZoom = function() {
788            return this.activeState.zoom / this.originalState.zoom;
789        };
790
791        /**
792         * Compute zoom scale for pubilc usage
793         *
794         * @return {Float} zoom scale
795         */
796        ShadowViewport.prototype.computeRelativeZoom = function(scale) {
797            return scale / this.originalState.zoom;
798        };
799
800        /**
801         * Get pan
802         *
803         * @return {Object}
804         */
805        ShadowViewport.prototype.getPan = function() {
806            return { x: this.activeState.x, y: this.activeState.y };
807        };
808
809        /**
810         * Return cached viewport CTM value that can be safely modified
811         *
812         * @return {SVGMatrix}
813         */
814        ShadowViewport.prototype.getCTM = function() {
815            var safeCTM = this.options.svg.createSVGMatrix();
816
817            // Copy values manually as in FF they are not itterable
818            safeCTM.a = this.activeState.zoom;
819            safeCTM.b = 0;
820            safeCTM.c = 0;
821            safeCTM.d = this.activeState.zoom;
822            safeCTM.e = this.activeState.x;
823            safeCTM.f = this.activeState.y;
824
825            return safeCTM;
826        };
827
828        /**
829         * Set a new CTM
830         *
831         * @param {SVGMatrix} newCTM
832         */
833        ShadowViewport.prototype.setCTM = function(newCTM) {
834            var willZoom = this.isZoomDifferent(newCTM),
835                willPan = this.isPanDifferent(newCTM);
836
837            if (willZoom || willPan) {
838                // Before zoom
839                if (willZoom) {
840                    // If returns false then cancel zooming
841                    if (
842                        this.options.beforeZoom(
843                            this.getRelativeZoom(),
844                            this.computeRelativeZoom(newCTM.a)
845                        ) === false
846                    ) {
847                        newCTM.a = newCTM.d = this.activeState.zoom;
848                        willZoom = false;
849                    } else {
850                        this.updateCache(newCTM);
851                        this.options.onZoom(this.getRelativeZoom());
852                    }
853                }
854
855                // Before pan
856                if (willPan) {
857                    var preventPan = this.options.beforePan(this.getPan(), {
858                            x: newCTM.e,
859                            y: newCTM.f
860                        }),
861                        // If prevent pan is an object
862                        preventPanX = false,
863                        preventPanY = false;
864
865                    // If prevent pan is Boolean false
866                    if (preventPan === false) {
867                        // Set x and y same as before
868                        newCTM.e = this.getPan().x;
869                        newCTM.f = this.getPan().y;
870
871                        preventPanX = preventPanY = true;
872                    } else if (Utils.isObject(preventPan)) {
873                        // Check for X axes attribute
874                        if (preventPan.x === false) {
875                            // Prevent panning on x axes
876                            newCTM.e = this.getPan().x;
877                            preventPanX = true;
878                        } else if (Utils.isNumber(preventPan.x)) {
879                            // Set a custom pan value
880                            newCTM.e = preventPan.x;
881                        }
882
883                        // Check for Y axes attribute
884                        if (preventPan.y === false) {
885                            // Prevent panning on x axes
886                            newCTM.f = this.getPan().y;
887                            preventPanY = true;
888                        } else if (Utils.isNumber(preventPan.y)) {
889                            // Set a custom pan value
890                            newCTM.f = preventPan.y;
891                        }
892                    }
893
894                    // Update willPan flag
895                    // Check if newCTM is still different
896                    if ((preventPanX && preventPanY) || !this.isPanDifferent(newCTM)) {
897                        willPan = false;
898                    } else {
899                        this.updateCache(newCTM);
900                        this.options.onPan(this.getPan());
901                    }
902                }
903
904                // Check again if should zoom or pan
905                if (willZoom || willPan) {
906                    this.updateCTMOnNextFrame();
907                }
908            }
909        };
910
911        ShadowViewport.prototype.isZoomDifferent = function(newCTM) {
912            return this.activeState.zoom !== newCTM.a;
913        };
914
915        ShadowViewport.prototype.isPanDifferent = function(newCTM) {
916            return this.activeState.x !== newCTM.e || this.activeState.y !== newCTM.f;
917        };
918
919        /**
920         * Update cached CTM and active state
921         *
922         * @param {SVGMatrix} newCTM
923         */
924        ShadowViewport.prototype.updateCache = function(newCTM) {
925            this.activeState.zoom = newCTM.a;
926            this.activeState.x = newCTM.e;
927            this.activeState.y = newCTM.f;
928        };
929
930        ShadowViewport.prototype.pendingUpdate = false;
931
932        /**
933         * Place a request to update CTM on next Frame
934         */
935        ShadowViewport.prototype.updateCTMOnNextFrame = function() {
936            if (!this.pendingUpdate) {
937                // Lock
938                this.pendingUpdate = true;
939
940                // Throttle next update
941                this.requestAnimationFrame.call(window, this.updateCTMCached);
942            }
943        };
944
945        /**
946         * Update viewport CTM with cached CTM
947         */
948        ShadowViewport.prototype.updateCTM = function() {
949            var ctm = this.getCTM();
950
951            // Updates SVG element
952            SvgUtils.setCTM(this.viewport, ctm, this.defs);
953
954            // Free the lock
955            this.pendingUpdate = false;
956
957            // Notify about the update
958            if (this.options.onUpdatedCTM) {
959                this.options.onUpdatedCTM(ctm);
960            }
961        };
962
963        module.exports = function(viewport, options) {
964            return new ShadowViewport(viewport, options);
965        };
966
967    },{"./svg-utilities":5,"./utilities":7}],3:[function(require,module,exports){
968        var svgPanZoom = require("./svg-pan-zoom.js");
969
970// UMD module definition
971        (function(window, document) {
972            // AMD
973            if (typeof define === "function" && define.amd) {
974                define("svg-pan-zoom", function() {
975                    return svgPanZoom;
976                });
977                // CMD
978            } else if (typeof module !== "undefined" && module.exports) {
979                module.exports = svgPanZoom;
980
981                // Browser
982                // Keep exporting globally as module.exports is available because of browserify
983                window.svgPanZoom = svgPanZoom;
984            }
985        })(window, document);
986
987    },{"./svg-pan-zoom.js":4}],4:[function(require,module,exports){
988        var Wheel = require("./uniwheel"),
989            ControlIcons = require("./control-icons"),
990            Utils = require("./utilities"),
991            SvgUtils = require("./svg-utilities"),
992            ShadowViewport = require("./shadow-viewport");
993
994        var SvgPanZoom = function(svg, options) {
995            this.init(svg, options);
996        };
997
998        var optionsDefaults = {
999            viewportSelector: ".svg-pan-zoom_viewport", // Viewport selector. Can be querySelector string or SVGElement
1000            panEnabled: true, // enable or disable panning (default enabled)
1001            controlIconsEnabled: false, // insert icons to give user an option in addition to mouse events to control pan/zoom (default disabled)
1002            zoomEnabled: true, // enable or disable zooming (default enabled)
1003            dblClickZoomEnabled: true, // enable or disable zooming by double clicking (default enabled)
1004            mouseWheelZoomEnabled: true, // enable or disable zooming by mouse wheel (default enabled)
1005            preventMouseEventsDefault: true, // enable or disable preventDefault for mouse events
1006            zoomScaleSensitivity: 0.1, // Zoom sensitivity
1007            minZoom: 0.5, // Minimum Zoom level
1008            maxZoom: 10, // Maximum Zoom level
1009            fit: true, // enable or disable viewport fit in SVG (default true)
1010            contain: false, // enable or disable viewport contain the svg (default false)
1011            center: true, // enable or disable viewport centering in SVG (default true)
1012            refreshRate: "auto", // Maximum number of frames per second (altering SVG's viewport)
1013            beforeZoom: null,
1014            onZoom: null,
1015            beforePan: null,
1016            onPan: null,
1017            customEventsHandler: null,
1018            eventsListenerElement: null,
1019            onUpdatedCTM: null
1020        };
1021
1022        var passiveListenerOption = { passive: true };
1023
1024        SvgPanZoom.prototype.init = function(svg, options) {
1025            var that = this;
1026
1027            this.svg = svg;
1028            this.defs = svg.querySelector("defs");
1029
1030            // Add default attributes to SVG
1031            SvgUtils.setupSvgAttributes(this.svg);
1032
1033            // Set options
1034            this.options = Utils.extend(Utils.extend({}, optionsDefaults), options);
1035
1036            // Set default state
1037            this.state = "none";
1038
1039            // Get dimensions
1040            var boundingClientRectNormalized = SvgUtils.getBoundingClientRectNormalized(
1041                svg
1042            );
1043            this.width = boundingClientRectNormalized.width;
1044            this.height = boundingClientRectNormalized.height;
1045
1046            // Init shadow viewport
1047            this.viewport = ShadowViewport(
1048                SvgUtils.getOrCreateViewport(this.svg, this.options.viewportSelector),
1049                {
1050                    svg: this.svg,
1051                    width: this.width,
1052                    height: this.height,
1053                    fit: this.options.fit,
1054                    contain: this.options.contain,
1055                    center: this.options.center,
1056                    refreshRate: this.options.refreshRate,
1057                    // Put callbacks into functions as they can change through time
1058                    beforeZoom: function(oldScale, newScale) {
1059                        if (that.viewport && that.options.beforeZoom) {
1060                            return that.options.beforeZoom(oldScale, newScale);
1061                        }
1062                    },
1063                    onZoom: function(scale) {
1064                        if (that.viewport && that.options.onZoom) {
1065                            return that.options.onZoom(scale);
1066                        }
1067                    },
1068                    beforePan: function(oldPoint, newPoint) {
1069                        if (that.viewport && that.options.beforePan) {
1070                            return that.options.beforePan(oldPoint, newPoint);
1071                        }
1072                    },
1073                    onPan: function(point) {
1074                        if (that.viewport && that.options.onPan) {
1075                            return that.options.onPan(point);
1076                        }
1077                    },
1078                    onUpdatedCTM: function(ctm) {
1079                        if (that.viewport && that.options.onUpdatedCTM) {
1080                            return that.options.onUpdatedCTM(ctm);
1081                        }
1082                    }
1083                }
1084            );
1085
1086            // Wrap callbacks into public API context
1087            var publicInstance = this.getPublicInstance();
1088            publicInstance.setBeforeZoom(this.options.beforeZoom);
1089            publicInstance.setOnZoom(this.options.onZoom);
1090            publicInstance.setBeforePan(this.options.beforePan);
1091            publicInstance.setOnPan(this.options.onPan);
1092            publicInstance.setOnUpdatedCTM(this.options.onUpdatedCTM);
1093
1094            if (this.options.controlIconsEnabled) {
1095                ControlIcons.enable(this);
1096            }
1097
1098            // Init events handlers
1099            this.lastMouseWheelEventTime = Date.now();
1100            this.setupHandlers();
1101        };
1102
1103        /**
1104         * Register event handlers
1105         */
1106        SvgPanZoom.prototype.setupHandlers = function() {
1107            var that = this,
1108                prevEvt = null; // use for touchstart event to detect double tap
1109
1110            this.eventListeners = {
1111                // Mouse down group
1112                mousedown: function(evt) {
1113                    var result = that.handleMouseDown(evt, prevEvt);
1114                    prevEvt = evt;
1115                    return result;
1116                },
1117                touchstart: function(evt) {
1118                    var result = that.handleMouseDown(evt, prevEvt);
1119                    prevEvt = evt;
1120                    return result;
1121                },
1122
1123                // Mouse up group
1124                mouseup: function(evt) {
1125                    return that.handleMouseUp(evt);
1126                },
1127                touchend: function(evt) {
1128                    return that.handleMouseUp(evt);
1129                },
1130
1131                // Mouse move group
1132                mousemove: function(evt) {
1133                    return that.handleMouseMove(evt);
1134                },
1135                touchmove: function(evt) {
1136                    return that.handleMouseMove(evt);
1137                },
1138
1139                // Mouse leave group
1140                mouseleave: function(evt) {
1141                    return that.handleMouseUp(evt);
1142                },
1143                touchleave: function(evt) {
1144                    return that.handleMouseUp(evt);
1145                },
1146                touchcancel: function(evt) {
1147                    return that.handleMouseUp(evt);
1148                }
1149            };
1150
1151            // Init custom events handler if available
1152            // eslint-disable-next-line eqeqeq
1153            if (this.options.customEventsHandler != null) {
1154                this.options.customEventsHandler.init({
1155                    svgElement: this.svg,
1156                    eventsListenerElement: this.options.eventsListenerElement,
1157                    instance: this.getPublicInstance()
1158                });
1159
1160                // Custom event handler may halt builtin listeners
1161                var haltEventListeners = this.options.customEventsHandler
1162                    .haltEventListeners;
1163                if (haltEventListeners && haltEventListeners.length) {
1164                    for (var i = haltEventListeners.length - 1; i >= 0; i--) {
1165                        if (this.eventListeners.hasOwnProperty(haltEventListeners[i])) {
1166                            delete this.eventListeners[haltEventListeners[i]];
1167                        }
1168                    }
1169                }
1170            }
1171
1172            // Bind eventListeners
1173            for (var event in this.eventListeners) {
1174                // Attach event to eventsListenerElement or SVG if not available
1175                (this.options.eventsListenerElement || this.svg).addEventListener(
1176                    event,
1177                    this.eventListeners[event],
1178                    !this.options.preventMouseEventsDefault ? passiveListenerOption : false
1179                );
1180            }
1181
1182            // Zoom using mouse wheel
1183            if (this.options.mouseWheelZoomEnabled) {
1184                this.options.mouseWheelZoomEnabled = false; // set to false as enable will set it back to true
1185                this.enableMouseWheelZoom();
1186            }
1187        };
1188
1189        /**
1190         * Enable ability to zoom using mouse wheel
1191         */
1192        SvgPanZoom.prototype.enableMouseWheelZoom = function() {
1193            if (!this.options.mouseWheelZoomEnabled) {
1194                var that = this;
1195
1196                // Mouse wheel listener
1197                this.wheelListener = function(evt) {
1198                    return that.handleMouseWheel(evt);
1199                };
1200
1201                // Bind wheelListener
1202                var isPassiveListener = !this.options.preventMouseEventsDefault;
1203                Wheel.on(
1204                    this.options.eventsListenerElement || this.svg,
1205                    this.wheelListener,
1206                    isPassiveListener
1207                );
1208
1209                this.options.mouseWheelZoomEnabled = true;
1210            }
1211        };
1212
1213        /**
1214         * Disable ability to zoom using mouse wheel
1215         */
1216        SvgPanZoom.prototype.disableMouseWheelZoom = function() {
1217            if (this.options.mouseWheelZoomEnabled) {
1218                var isPassiveListener = !this.options.preventMouseEventsDefault;
1219                Wheel.off(
1220                    this.options.eventsListenerElement || this.svg,
1221                    this.wheelListener,
1222                    isPassiveListener
1223                );
1224                this.options.mouseWheelZoomEnabled = false;
1225            }
1226        };
1227
1228        /**
1229         * Handle mouse wheel event
1230         *
1231         * @param  {Event} evt
1232         */
1233        SvgPanZoom.prototype.handleMouseWheel = function(evt) {
1234            if (!this.options.zoomEnabled || this.state !== "none") {
1235                return;
1236            }
1237
1238            if (this.options.preventMouseEventsDefault) {
1239                if (evt.preventDefault) {
1240                    evt.preventDefault();
1241                } else {
1242                    evt.returnValue = false;
1243                }
1244            }
1245
1246            // Default delta in case that deltaY is not available
1247            var delta = evt.deltaY || 1,
1248                timeDelta = Date.now() - this.lastMouseWheelEventTime,
1249                divider = 3 + Math.max(0, 30 - timeDelta);
1250
1251            // Update cache
1252            this.lastMouseWheelEventTime = Date.now();
1253
1254            // Make empirical adjustments for browsers that give deltaY in pixels (deltaMode=0)
1255            if ("deltaMode" in evt && evt.deltaMode === 0 && evt.wheelDelta) {
1256                delta = evt.deltaY === 0 ? 0 : Math.abs(evt.wheelDelta) / evt.deltaY;
1257            }
1258
1259            delta =
1260                -0.3 < delta && delta < 0.3
1261                    ? delta
1262                    : ((delta > 0 ? 1 : -1) * Math.log(Math.abs(delta) + 10)) / divider;
1263
1264            var inversedScreenCTM = this.svg.getScreenCTM().inverse(),
1265                relativeMousePoint = SvgUtils.getEventPoint(evt, this.svg).matrixTransform(
1266                    inversedScreenCTM
1267                ),
1268                zoom = Math.pow(1 + this.options.zoomScaleSensitivity, -1 * delta); // multiplying by neg. 1 so as to make zoom in/out behavior match Google maps behavior
1269
1270            this.zoomAtPoint(zoom, relativeMousePoint);
1271        };
1272
1273        /**
1274         * Zoom in at a SVG point
1275         *
1276         * @param  {SVGPoint} point
1277         * @param  {Float} zoomScale    Number representing how much to zoom
1278         * @param  {Boolean} zoomAbsolute Default false. If true, zoomScale is treated as an absolute value.
1279         *                                Otherwise, zoomScale is treated as a multiplied (e.g. 1.10 would zoom in 10%)
1280         */
1281        SvgPanZoom.prototype.zoomAtPoint = function(zoomScale, point, zoomAbsolute) {
1282            var originalState = this.viewport.getOriginalState();
1283
1284            if (!zoomAbsolute) {
1285                // Fit zoomScale in set bounds
1286                if (
1287                    this.getZoom() * zoomScale <
1288                    this.options.minZoom * originalState.zoom
1289                ) {
1290                    zoomScale = (this.options.minZoom * originalState.zoom) / this.getZoom();
1291                } else if (
1292                    this.getZoom() * zoomScale >
1293                    this.options.maxZoom * originalState.zoom
1294                ) {
1295                    zoomScale = (this.options.maxZoom * originalState.zoom) / this.getZoom();
1296                }
1297            } else {
1298                // Fit zoomScale in set bounds
1299                zoomScale = Math.max(
1300                    this.options.minZoom * originalState.zoom,
1301                    Math.min(this.options.maxZoom * originalState.zoom, zoomScale)
1302                );
1303                // Find relative scale to achieve desired scale
1304                zoomScale = zoomScale / this.getZoom();
1305            }
1306
1307            var oldCTM = this.viewport.getCTM(),
1308                relativePoint = point.matrixTransform(oldCTM.inverse()),
1309                modifier = this.svg
1310                    .createSVGMatrix()
1311                    .translate(relativePoint.x, relativePoint.y)
1312                    .scale(zoomScale)
1313                    .translate(-relativePoint.x, -relativePoint.y),
1314                newCTM = oldCTM.multiply(modifier);
1315
1316            if (newCTM.a !== oldCTM.a) {
1317                this.viewport.setCTM(newCTM);
1318            }
1319        };
1320
1321        /**
1322         * Zoom at center point
1323         *
1324         * @param  {Float} scale
1325         * @param  {Boolean} absolute Marks zoom scale as relative or absolute
1326         */
1327        SvgPanZoom.prototype.zoom = function(scale, absolute) {
1328            this.zoomAtPoint(
1329                scale,
1330                SvgUtils.getSvgCenterPoint(this.svg, this.width, this.height),
1331                absolute
1332            );
1333        };
1334
1335        /**
1336         * Zoom used by public instance
1337         *
1338         * @param  {Float} scale
1339         * @param  {Boolean} absolute Marks zoom scale as relative or absolute
1340         */
1341        SvgPanZoom.prototype.publicZoom = function(scale, absolute) {
1342            if (absolute) {
1343                scale = this.computeFromRelativeZoom(scale);
1344            }
1345
1346            this.zoom(scale, absolute);
1347        };
1348
1349        /**
1350         * Zoom at point used by public instance
1351         *
1352         * @param  {Float} scale
1353         * @param  {SVGPoint|Object} point    An object that has x and y attributes
1354         * @param  {Boolean} absolute Marks zoom scale as relative or absolute
1355         */
1356        SvgPanZoom.prototype.publicZoomAtPoint = function(scale, point, absolute) {
1357            if (absolute) {
1358                // Transform zoom into a relative value
1359                scale = this.computeFromRelativeZoom(scale);
1360            }
1361
1362            // If not a SVGPoint but has x and y then create a SVGPoint
1363            if (Utils.getType(point) !== "SVGPoint") {
1364                if ("x" in point && "y" in point) {
1365                    point = SvgUtils.createSVGPoint(this.svg, point.x, point.y);
1366                } else {
1367                    throw new Error("Given point is invalid");
1368                }
1369            }
1370
1371            this.zoomAtPoint(scale, point, absolute);
1372        };
1373
1374        /**
1375         * Get zoom scale
1376         *
1377         * @return {Float} zoom scale
1378         */
1379        SvgPanZoom.prototype.getZoom = function() {
1380            return this.viewport.getZoom();
1381        };
1382
1383        /**
1384         * Get zoom scale for public usage
1385         *
1386         * @return {Float} zoom scale
1387         */
1388        SvgPanZoom.prototype.getRelativeZoom = function() {
1389            return this.viewport.getRelativeZoom();
1390        };
1391
1392        /**
1393         * Compute actual zoom from public zoom
1394         *
1395         * @param  {Float} zoom
1396         * @return {Float} zoom scale
1397         */
1398        SvgPanZoom.prototype.computeFromRelativeZoom = function(zoom) {
1399            return zoom * this.viewport.getOriginalState().zoom;
1400        };
1401
1402        /**
1403         * Set zoom to initial state
1404         */
1405        SvgPanZoom.prototype.resetZoom = function() {
1406            var originalState = this.viewport.getOriginalState();
1407
1408            this.zoom(originalState.zoom, true);
1409        };
1410
1411        /**
1412         * Set pan to initial state
1413         */
1414        SvgPanZoom.prototype.resetPan = function() {
1415            this.pan(this.viewport.getOriginalState());
1416        };
1417
1418        /**
1419         * Set pan and zoom to initial state
1420         */
1421        SvgPanZoom.prototype.reset = function() {
1422            this.resetZoom();
1423            this.resetPan();
1424        };
1425
1426        /**
1427         * Handle double click event
1428         * See handleMouseDown() for alternate detection method
1429         *
1430         * @param {Event} evt
1431         */
1432        SvgPanZoom.prototype.handleDblClick = function(evt) {
1433            if (this.options.preventMouseEventsDefault) {
1434                if (evt.preventDefault) {
1435                    evt.preventDefault();
1436                } else {
1437                    evt.returnValue = false;
1438                }
1439            }
1440
1441            // Check if target was a control button
1442            if (this.options.controlIconsEnabled) {
1443                var targetClass = evt.target.getAttribute("class") || "";
1444                if (targetClass.indexOf("svg-pan-zoom-control") > -1) {
1445                    return false;
1446                }
1447            }
1448
1449            var zoomFactor;
1450
1451            if (evt.shiftKey) {
1452                zoomFactor = 1 / ((1 + this.options.zoomScaleSensitivity) * 2); // zoom out when shift key pressed
1453            } else {
1454                zoomFactor = (1 + this.options.zoomScaleSensitivity) * 2;
1455            }
1456
1457            var point = SvgUtils.getEventPoint(evt, this.svg).matrixTransform(
1458                this.svg.getScreenCTM().inverse()
1459            );
1460            this.zoomAtPoint(zoomFactor, point);
1461        };
1462
1463        /**
1464         * Handle click event
1465         *
1466         * @param {Event} evt
1467         */
1468        SvgPanZoom.prototype.handleMouseDown = function(evt, prevEvt) {
1469            if (this.options.preventMouseEventsDefault) {
1470                if (evt.preventDefault) {
1471                    evt.preventDefault();
1472                } else {
1473                    evt.returnValue = false;
1474                }
1475            }
1476
1477            Utils.mouseAndTouchNormalize(evt, this.svg);
1478
1479            // Double click detection; more consistent than ondblclick
1480            if (this.options.dblClickZoomEnabled && Utils.isDblClick(evt, prevEvt)) {
1481                this.handleDblClick(evt);
1482            } else {
1483                // Pan mode
1484                this.state = "pan";
1485                this.firstEventCTM = this.viewport.getCTM();
1486                this.stateOrigin = SvgUtils.getEventPoint(evt, this.svg).matrixTransform(
1487                    this.firstEventCTM.inverse()
1488                );
1489            }
1490        };
1491
1492        /**
1493         * Handle mouse move event
1494         *
1495         * @param  {Event} evt
1496         */
1497        SvgPanZoom.prototype.handleMouseMove = function(evt) {
1498            if (this.options.preventMouseEventsDefault) {
1499                if (evt.preventDefault) {
1500                    evt.preventDefault();
1501                } else {
1502                    evt.returnValue = false;
1503                }
1504            }
1505
1506            if (this.state === "pan" && this.options.panEnabled) {
1507                // Pan mode
1508                var point = SvgUtils.getEventPoint(evt, this.svg).matrixTransform(
1509                    this.firstEventCTM.inverse()
1510                    ),
1511                    viewportCTM = this.firstEventCTM.translate(
1512                        point.x - this.stateOrigin.x,
1513                        point.y - this.stateOrigin.y
1514                    );
1515
1516                this.viewport.setCTM(viewportCTM);
1517            }
1518        };
1519
1520        /**
1521         * Handle mouse button release event
1522         *
1523         * @param {Event} evt
1524         */
1525        SvgPanZoom.prototype.handleMouseUp = function(evt) {
1526            if (this.options.preventMouseEventsDefault) {
1527                if (evt.preventDefault) {
1528                    evt.preventDefault();
1529                } else {
1530                    evt.returnValue = false;
1531                }
1532            }
1533
1534            if (this.state === "pan") {
1535                // Quit pan mode
1536                this.state = "none";
1537            }
1538        };
1539
1540        /**
1541         * Adjust viewport size (only) so it will fit in SVG
1542         * Does not center image
1543         */
1544        SvgPanZoom.prototype.fit = function() {
1545            var viewBox = this.viewport.getViewBox(),
1546                newScale = Math.min(
1547                    this.width / viewBox.width,
1548                    this.height / viewBox.height
1549                );
1550
1551            this.zoom(newScale, true);
1552        };
1553
1554        /**
1555         * Adjust viewport size (only) so it will contain the SVG
1556         * Does not center image
1557         */
1558        SvgPanZoom.prototype.contain = function() {
1559            var viewBox = this.viewport.getViewBox(),
1560                newScale = Math.max(
1561                    this.width / viewBox.width,
1562                    this.height / viewBox.height
1563                );
1564
1565            this.zoom(newScale, true);
1566        };
1567
1568        /**
1569         * Adjust viewport pan (only) so it will be centered in SVG
1570         * Does not zoom/fit/contain image
1571         */
1572        SvgPanZoom.prototype.center = function() {
1573            var viewBox = this.viewport.getViewBox(),
1574                offsetX =
1575                    (this.width - (viewBox.width + viewBox.x * 2) * this.getZoom()) * 0.5,
1576                offsetY =
1577                    (this.height - (viewBox.height + viewBox.y * 2) * this.getZoom()) * 0.5;
1578
1579            this.getPublicInstance().pan({ x: offsetX, y: offsetY });
1580        };
1581
1582        /**
1583         * Update content cached BorderBox
1584         * Use when viewport contents change
1585         */
1586        SvgPanZoom.prototype.updateBBox = function() {
1587            this.viewport.simpleViewBoxCache();
1588        };
1589
1590        /**
1591         * Pan to a rendered position
1592         *
1593         * @param  {Object} point {x: 0, y: 0}
1594         */
1595        SvgPanZoom.prototype.pan = function(point) {
1596            var viewportCTM = this.viewport.getCTM();
1597            viewportCTM.e = point.x;
1598            viewportCTM.f = point.y;
1599            this.viewport.setCTM(viewportCTM);
1600        };
1601
1602        /**
1603         * Relatively pan the graph by a specified rendered position vector
1604         *
1605         * @param  {Object} point {x: 0, y: 0}
1606         */
1607        SvgPanZoom.prototype.panBy = function(point) {
1608            var viewportCTM = this.viewport.getCTM();
1609            viewportCTM.e += point.x;
1610            viewportCTM.f += point.y;
1611            this.viewport.setCTM(viewportCTM);
1612        };
1613
1614        /**
1615         * Get pan vector
1616         *
1617         * @return {Object} {x: 0, y: 0}
1618         */
1619        SvgPanZoom.prototype.getPan = function() {
1620            var state = this.viewport.getState();
1621
1622            return { x: state.x, y: state.y };
1623        };
1624
1625        /**
1626         * Recalculates cached svg dimensions and controls position
1627         */
1628        SvgPanZoom.prototype.resize = function() {
1629            // Get dimensions
1630            var boundingClientRectNormalized = SvgUtils.getBoundingClientRectNormalized(
1631                this.svg
1632            );
1633            this.width = boundingClientRectNormalized.width;
1634            this.height = boundingClientRectNormalized.height;
1635
1636            // Recalculate original state
1637            var viewport = this.viewport;
1638            viewport.options.width = this.width;
1639            viewport.options.height = this.height;
1640            viewport.processCTM();
1641
1642            // Reposition control icons by re-enabling them
1643            if (this.options.controlIconsEnabled) {
1644                this.getPublicInstance().disableControlIcons();
1645                this.getPublicInstance().enableControlIcons();
1646            }
1647        };
1648
1649        /**
1650         * Unbind mouse events, free callbacks and destroy public instance
1651         */
1652        SvgPanZoom.prototype.destroy = function() {
1653            var that = this;
1654
1655            // Free callbacks
1656            this.beforeZoom = null;
1657            this.onZoom = null;
1658            this.beforePan = null;
1659            this.onPan = null;
1660            this.onUpdatedCTM = null;
1661
1662            // Destroy custom event handlers
1663            // eslint-disable-next-line eqeqeq
1664            if (this.options.customEventsHandler != null) {
1665                this.options.customEventsHandler.destroy({
1666                    svgElement: this.svg,
1667                    eventsListenerElement: this.options.eventsListenerElement,
1668                    instance: this.getPublicInstance()
1669                });
1670            }
1671
1672            // Unbind eventListeners
1673            for (var event in this.eventListeners) {
1674                (this.options.eventsListenerElement || this.svg).removeEventListener(
1675                    event,
1676                    this.eventListeners[event],
1677                    !this.options.preventMouseEventsDefault ? passiveListenerOption : false
1678                );
1679            }
1680
1681            // Unbind wheelListener
1682            this.disableMouseWheelZoom();
1683
1684            // Remove control icons
1685            this.getPublicInstance().disableControlIcons();
1686
1687            // Reset zoom and pan
1688            this.reset();
1689
1690            // Remove instance from instancesStore
1691            instancesStore = instancesStore.filter(function(instance) {
1692                return instance.svg !== that.svg;
1693            });
1694
1695            // Delete options and its contents
1696            delete this.options;
1697
1698            // Delete viewport to make public shadow viewport functions uncallable
1699            delete this.viewport;
1700
1701            // Destroy public instance and rewrite getPublicInstance
1702            delete this.publicInstance;
1703            delete this.pi;
1704            this.getPublicInstance = function() {
1705                return null;
1706            };
1707        };
1708
1709        /**
1710         * Returns a public instance object
1711         *
1712         * @return {Object} Public instance object
1713         */
1714        SvgPanZoom.prototype.getPublicInstance = function() {
1715            var that = this;
1716
1717            // Create cache
1718            if (!this.publicInstance) {
1719                this.publicInstance = this.pi = {
1720                    // Pan
1721                    enablePan: function() {
1722                        that.options.panEnabled = true;
1723                        return that.pi;
1724                    },
1725                    disablePan: function() {
1726                        that.options.panEnabled = false;
1727                        return that.pi;
1728                    },
1729                    isPanEnabled: function() {
1730                        return !!that.options.panEnabled;
1731                    },
1732                    pan: function(point) {
1733                        that.pan(point);
1734                        return that.pi;
1735                    },
1736                    panBy: function(point) {
1737                        that.panBy(point);
1738                        return that.pi;
1739                    },
1740                    getPan: function() {
1741                        return that.getPan();
1742                    },
1743                    // Pan event
1744                    setBeforePan: function(fn) {
1745                        that.options.beforePan =
1746                            fn === null ? null : Utils.proxy(fn, that.publicInstance);
1747                        return that.pi;
1748                    },
1749                    setOnPan: function(fn) {
1750                        that.options.onPan =
1751                            fn === null ? null : Utils.proxy(fn, that.publicInstance);
1752                        return that.pi;
1753                    },
1754                    // Zoom and Control Icons
1755                    enableZoom: function() {
1756                        that.options.zoomEnabled = true;
1757                        return that.pi;
1758                    },
1759                    disableZoom: function() {
1760                        that.options.zoomEnabled = false;
1761                        return that.pi;
1762                    },
1763                    isZoomEnabled: function() {
1764                        return !!that.options.zoomEnabled;
1765                    },
1766                    enableControlIcons: function() {
1767                        if (!that.options.controlIconsEnabled) {
1768                            that.options.controlIconsEnabled = true;
1769                            ControlIcons.enable(that);
1770                        }
1771                        return that.pi;
1772                    },
1773                    disableControlIcons: function() {
1774                        if (that.options.controlIconsEnabled) {
1775                            that.options.controlIconsEnabled = false;
1776                            ControlIcons.disable(that);
1777                        }
1778                        return that.pi;
1779                    },
1780                    isControlIconsEnabled: function() {
1781                        return !!that.options.controlIconsEnabled;
1782                    },
1783                    // Double click zoom
1784                    enableDblClickZoom: function() {
1785                        that.options.dblClickZoomEnabled = true;
1786                        return that.pi;
1787                    },
1788                    disableDblClickZoom: function() {
1789                        that.options.dblClickZoomEnabled = false;
1790                        return that.pi;
1791                    },
1792                    isDblClickZoomEnabled: function() {
1793                        return !!that.options.dblClickZoomEnabled;
1794                    },
1795                    // Mouse wheel zoom
1796                    enableMouseWheelZoom: function() {
1797                        that.enableMouseWheelZoom();
1798                        return that.pi;
1799                    },
1800                    disableMouseWheelZoom: function() {
1801                        that.disableMouseWheelZoom();
1802                        return that.pi;
1803                    },
1804                    isMouseWheelZoomEnabled: function() {
1805                        return !!that.options.mouseWheelZoomEnabled;
1806                    },
1807                    // Zoom scale and bounds
1808                    setZoomScaleSensitivity: function(scale) {
1809                        that.options.zoomScaleSensitivity = scale;
1810                        return that.pi;
1811                    },
1812                    setMinZoom: function(zoom) {
1813                        that.options.minZoom = zoom;
1814                        return that.pi;
1815                    },
1816                    setMaxZoom: function(zoom) {
1817                        that.options.maxZoom = zoom;
1818                        return that.pi;
1819                    },
1820                    // Zoom event
1821                    setBeforeZoom: function(fn) {
1822                        that.options.beforeZoom =
1823                            fn === null ? null : Utils.proxy(fn, that.publicInstance);
1824                        return that.pi;
1825                    },
1826                    setOnZoom: function(fn) {
1827                        that.options.onZoom =
1828                            fn === null ? null : Utils.proxy(fn, that.publicInstance);
1829                        return that.pi;
1830                    },
1831                    // Zooming
1832                    zoom: function(scale) {
1833                        that.publicZoom(scale, true);
1834                        return that.pi;
1835                    },
1836                    zoomBy: function(scale) {
1837                        that.publicZoom(scale, false);
1838                        return that.pi;
1839                    },
1840                    zoomAtPoint: function(scale, point) {
1841                        that.publicZoomAtPoint(scale, point, true);
1842                        return that.pi;
1843                    },
1844                    zoomAtPointBy: function(scale, point) {
1845                        that.publicZoomAtPoint(scale, point, false);
1846                        return that.pi;
1847                    },
1848                    zoomIn: function() {
1849                        this.zoomBy(1 + that.options.zoomScaleSensitivity);
1850                        return that.pi;
1851                    },
1852                    zoomOut: function() {
1853                        this.zoomBy(1 / (1 + that.options.zoomScaleSensitivity));
1854                        return that.pi;
1855                    },
1856                    getZoom: function() {
1857                        return that.getRelativeZoom();
1858                    },
1859                    // CTM update
1860                    setOnUpdatedCTM: function(fn) {
1861                        that.options.onUpdatedCTM =
1862                            fn === null ? null : Utils.proxy(fn, that.publicInstance);
1863                        return that.pi;
1864                    },
1865                    // Reset
1866                    resetZoom: function() {
1867                        that.resetZoom();
1868                        return that.pi;
1869                    },
1870                    resetPan: function() {
1871                        that.resetPan();
1872                        return that.pi;
1873                    },
1874                    reset: function() {
1875                        that.reset();
1876                        return that.pi;
1877                    },
1878                    // Fit, Contain and Center
1879                    fit: function() {
1880                        that.fit();
1881                        return that.pi;
1882                    },
1883                    contain: function() {
1884                        that.contain();
1885                        return that.pi;
1886                    },
1887                    center: function() {
1888                        that.center();
1889                        return that.pi;
1890                    },
1891                    // Size and Resize
1892                    updateBBox: function() {
1893                        that.updateBBox();
1894                        return that.pi;
1895                    },
1896                    resize: function() {
1897                        that.resize();
1898                        return that.pi;
1899                    },
1900                    getSizes: function() {
1901                        return {
1902                            width: that.width,
1903                            height: that.height,
1904                            realZoom: that.getZoom(),
1905                            viewBox: that.viewport.getViewBox()
1906                        };
1907                    },
1908                    // Destroy
1909                    destroy: function() {
1910                        that.destroy();
1911                        return that.pi;
1912                    }
1913                };
1914            }
1915
1916            return this.publicInstance;
1917        };
1918
1919        /**
1920         * Stores pairs of instances of SvgPanZoom and SVG
1921         * Each pair is represented by an object {svg: SVGSVGElement, instance: SvgPanZoom}
1922         *
1923         * @type {Array}
1924         */
1925        var instancesStore = [];
1926
1927        var svgPanZoom = function(elementOrSelector, options) {
1928            var svg = Utils.getSvg(elementOrSelector);
1929
1930            if (svg === null) {
1931                return null;
1932            } else {
1933                // Look for existent instance
1934                for (var i = instancesStore.length - 1; i >= 0; i--) {
1935                    if (instancesStore[i].svg === svg) {
1936                        return instancesStore[i].instance.getPublicInstance();
1937                    }
1938                }
1939
1940                // If instance not found - create one
1941                instancesStore.push({
1942                    svg: svg,
1943                    instance: new SvgPanZoom(svg, options)
1944                });
1945
1946                // Return just pushed instance
1947                return instancesStore[
1948                instancesStore.length - 1
1949                    ].instance.getPublicInstance();
1950            }
1951        };
1952
1953        module.exports = svgPanZoom;
1954
1955    },{"./control-icons":1,"./shadow-viewport":2,"./svg-utilities":5,"./uniwheel":6,"./utilities":7}],5:[function(require,module,exports){
1956        var Utils = require("./utilities"),
1957            _browser = "unknown";
1958
1959// http://stackoverflow.com/questions/9847580/how-to-detect-safari-chrome-ie-firefox-and-opera-browser
1960        if (/*@cc_on!@*/ false || !!document.documentMode) {
1961            // internet explorer
1962            _browser = "ie";
1963        }
1964
1965        module.exports = {
1966            svgNS: "http://www.w3.org/2000/svg",
1967            xmlNS: "http://www.w3.org/XML/1998/namespace",
1968            xmlnsNS: "http://www.w3.org/2000/xmlns/",
1969            xlinkNS: "http://www.w3.org/1999/xlink",
1970            evNS: "http://www.w3.org/2001/xml-events",
1971
1972            /**
1973             * Get svg dimensions: width and height
1974             *
1975             * @param  {SVGSVGElement} svg
1976             * @return {Object}     {width: 0, height: 0}
1977             */
1978            getBoundingClientRectNormalized: function(svg) {
1979                if (svg.clientWidth && svg.clientHeight) {
1980                    return { width: svg.clientWidth, height: svg.clientHeight };
1981                } else if (!!svg.getBoundingClientRect()) {
1982                    return svg.getBoundingClientRect();
1983                } else {
1984                    throw new Error("Cannot get BoundingClientRect for SVG.");
1985                }
1986            },
1987
1988            /**
1989             * Gets g element with class of "viewport" or creates it if it doesn't exist
1990             *
1991             * @param  {SVGSVGElement} svg
1992             * @return {SVGElement}     g (group) element
1993             */
1994            getOrCreateViewport: function(svg, selector) {
1995                var viewport = null;
1996
1997                if (Utils.isElement(selector)) {
1998                    viewport = selector;
1999                } else {
2000                    viewport = svg.querySelector(selector);
2001                }
2002
2003                // Check if there is just one main group in SVG
2004                if (!viewport) {
2005                    var childNodes = Array.prototype.slice
2006                        .call(svg.childNodes || svg.children)
2007                        .filter(function(el) {
2008                            return el.nodeName !== "defs" && el.nodeName !== "#text";
2009                        });
2010
2011                    // Node name should be SVGGElement and should have no transform attribute
2012                    // Groups with transform are not used as viewport because it involves parsing of all transform possibilities
2013                    if (
2014                        childNodes.length === 1 &&
2015                        childNodes[0].nodeName === "g" &&
2016                        childNodes[0].getAttribute("transform") === null
2017                    ) {
2018                        viewport = childNodes[0];
2019                    }
2020                }
2021
2022                // If no favorable group element exists then create one
2023                if (!viewport) {
2024                    var viewportId =
2025                        "viewport-" + new Date().toISOString().replace(/\D/g, "");
2026                    viewport = document.createElementNS(this.svgNS, "g");
2027                    viewport.setAttribute("id", viewportId);
2028
2029                    // Internet Explorer (all versions?) can't use childNodes, but other browsers prefer (require?) using childNodes
2030                    var svgChildren = svg.childNodes || svg.children;
2031                    if (!!svgChildren && svgChildren.length > 0) {
2032                        for (var i = svgChildren.length; i > 0; i--) {
2033                            // Move everything into viewport except defs
2034                            if (svgChildren[svgChildren.length - i].nodeName !== "defs") {
2035                                viewport.appendChild(svgChildren[svgChildren.length - i]);
2036                            }
2037                        }
2038                    }
2039                    svg.appendChild(viewport);
2040                }
2041
2042                // Parse class names
2043                var classNames = [];
2044                if (viewport.getAttribute("class")) {
2045                    classNames = viewport.getAttribute("class").split(" ");
2046                }
2047
2048                // Set class (if not set already)
2049                if (!~classNames.indexOf("svg-pan-zoom_viewport")) {
2050                    classNames.push("svg-pan-zoom_viewport");
2051                    viewport.setAttribute("class", classNames.join(" "));
2052                }
2053
2054                return viewport;
2055            },
2056
2057            /**
2058             * Set SVG attributes
2059             *
2060             * @param  {SVGSVGElement} svg
2061             */
2062            setupSvgAttributes: function(svg) {
2063                // Setting default attributes
2064                svg.setAttribute("xmlns", this.svgNS);
2065                svg.setAttributeNS(this.xmlnsNS, "xmlns:xlink", this.xlinkNS);
2066                svg.setAttributeNS(this.xmlnsNS, "xmlns:ev", this.evNS);
2067
2068                // Needed for Internet Explorer, otherwise the viewport overflows
2069                if (svg.parentNode !== null) {
2070                    var style = svg.getAttribute("style") || "";
2071                    if (style.toLowerCase().indexOf("overflow") === -1) {
2072                        svg.setAttribute("style", "overflow: hidden; " + style);
2073                    }
2074                }
2075            },
2076
2077            /**
2078             * How long Internet Explorer takes to finish updating its display (ms).
2079             */
2080            internetExplorerRedisplayInterval: 300,
2081
2082            /**
2083             * Forces the browser to redisplay all SVG elements that rely on an
2084             * element defined in a 'defs' section. It works globally, for every
2085             * available defs element on the page.
2086             * The throttling is intentionally global.
2087             *
2088             * This is only needed for IE. It is as a hack to make markers (and 'use' elements?)
2089             * visible after pan/zoom when there are multiple SVGs on the page.
2090             * See bug report: https://connect.microsoft.com/IE/feedback/details/781964/
2091             * also see svg-pan-zoom issue: https://github.com/ariutta/svg-pan-zoom/issues/62
2092             */
2093            refreshDefsGlobal: Utils.throttle(
2094                function() {
2095                    var allDefs = document.querySelectorAll("defs");
2096                    var allDefsCount = allDefs.length;
2097                    for (var i = 0; i < allDefsCount; i++) {
2098                        var thisDefs = allDefs[i];
2099                        thisDefs.parentNode.insertBefore(thisDefs, thisDefs);
2100                    }
2101                },
2102                this ? this.internetExplorerRedisplayInterval : null
2103            ),
2104
2105            /**
2106             * Sets the current transform matrix of an element
2107             *
2108             * @param {SVGElement} element
2109             * @param {SVGMatrix} matrix  CTM
2110             * @param {SVGElement} defs
2111             */
2112            setCTM: function(element, matrix, defs) {
2113                var that = this,
2114                    s =
2115                        "matrix(" +
2116                        matrix.a +
2117                        "," +
2118                        matrix.b +
2119                        "," +
2120                        matrix.c +
2121                        "," +
2122                        matrix.d +
2123                        "," +
2124                        matrix.e +
2125                        "," +
2126                        matrix.f +
2127                        ")";
2128
2129                element.setAttributeNS(null, "transform", s);
2130                if ("transform" in element.style) {
2131                    element.style.transform = s;
2132                } else if ("-ms-transform" in element.style) {
2133                    element.style["-ms-transform"] = s;
2134                } else if ("-webkit-transform" in element.style) {
2135                    element.style["-webkit-transform"] = s;
2136                }
2137
2138                // IE has a bug that makes markers disappear on zoom (when the matrix "a" and/or "d" elements change)
2139                // see http://stackoverflow.com/questions/17654578/svg-marker-does-not-work-in-ie9-10
2140                // and http://srndolha.wordpress.com/2013/11/25/svg-line-markers-may-disappear-in-internet-explorer-11/
2141                if (_browser === "ie" && !!defs) {
2142                    // this refresh is intended for redisplaying the SVG during zooming
2143                    defs.parentNode.insertBefore(defs, defs);
2144                    // this refresh is intended for redisplaying the other SVGs on a page when panning a given SVG
2145                    // it is also needed for the given SVG itself, on zoomEnd, if the SVG contains any markers that
2146                    // are located under any other element(s).
2147                    window.setTimeout(function() {
2148                        that.refreshDefsGlobal();
2149                    }, that.internetExplorerRedisplayInterval);
2150                }
2151            },
2152
2153            /**
2154             * Instantiate an SVGPoint object with given event coordinates
2155             *
2156             * @param {Event} evt
2157             * @param  {SVGSVGElement} svg
2158             * @return {SVGPoint}     point
2159             */
2160            getEventPoint: function(evt, svg) {
2161                var point = svg.createSVGPoint();
2162
2163                Utils.mouseAndTouchNormalize(evt, svg);
2164
2165                point.x = evt.clientX;
2166                point.y = evt.clientY;
2167
2168                return point;
2169            },
2170
2171            /**
2172             * Get SVG center point
2173             *
2174             * @param  {SVGSVGElement} svg
2175             * @return {SVGPoint}
2176             */
2177            getSvgCenterPoint: function(svg, width, height) {
2178                return this.createSVGPoint(svg, width / 2, height / 2);
2179            },
2180
2181            /**
2182             * Create a SVGPoint with given x and y
2183             *
2184             * @param  {SVGSVGElement} svg
2185             * @param  {Number} x
2186             * @param  {Number} y
2187             * @return {SVGPoint}
2188             */
2189            createSVGPoint: function(svg, x, y) {
2190                var point = svg.createSVGPoint();
2191                point.x = x;
2192                point.y = y;
2193
2194                return point;
2195            }
2196        };
2197
2198    },{"./utilities":7}],6:[function(require,module,exports){
2199// uniwheel 0.1.2 (customized)
2200// A unified cross browser mouse wheel event handler
2201// https://github.com/teemualap/uniwheel
2202
2203        module.exports = (function(){
2204
2205            //Full details: https://developer.mozilla.org/en-US/docs/Web/Reference/Events/wheel
2206
2207            var prefix = "", _addEventListener, _removeEventListener, support, fns = [];
2208            var passiveOption = {passive: true};
2209
2210            // detect event model
2211            if ( window.addEventListener ) {
2212                _addEventListener = "addEventListener";
2213                _removeEventListener = "removeEventListener";
2214            } else {
2215                _addEventListener = "attachEvent";
2216                _removeEventListener = "detachEvent";
2217                prefix = "on";
2218            }
2219
2220            // detect available wheel event
2221            support = "onwheel" in document.createElement("div") ? "wheel" : // Modern browsers support "wheel"
2222                document.onmousewheel !== undefined ? "mousewheel" : // Webkit and IE support at least "mousewheel"
2223                    "DOMMouseScroll"; // let's assume that remaining browsers are older Firefox
2224
2225
2226            function createCallback(element,callback) {
2227
2228                var fn = function(originalEvent) {
2229
2230                    !originalEvent && ( originalEvent = window.event );
2231
2232                    // create a normalized event object
2233                    var event = {
2234                        // keep a ref to the original event object
2235                        originalEvent: originalEvent,
2236                        target: originalEvent.target || originalEvent.srcElement,
2237                        type: "wheel",
2238                        deltaMode: originalEvent.type == "MozMousePixelScroll" ? 0 : 1,
2239                        deltaX: 0,
2240                        delatZ: 0,
2241                        preventDefault: function() {
2242                            originalEvent.preventDefault ?
2243                                originalEvent.preventDefault() :
2244                                originalEvent.returnValue = false;
2245                        }
2246                    };
2247
2248                    // calculate deltaY (and deltaX) according to the event
2249                    if ( support == "mousewheel" ) {
2250                        event.deltaY = - 1/40 * originalEvent.wheelDelta;
2251                        // Webkit also support wheelDeltaX
2252                        originalEvent.wheelDeltaX && ( event.deltaX = - 1/40 * originalEvent.wheelDeltaX );
2253                    } else {
2254                        event.deltaY = originalEvent.detail;
2255                    }
2256
2257                    // it's time to fire the callback
2258                    return callback( event );
2259
2260                };
2261
2262                fns.push({
2263                    element: element,
2264                    fn: fn,
2265                });
2266
2267                return fn;
2268            }
2269
2270            function getCallback(element) {
2271                for (var i = 0; i < fns.length; i++) {
2272                    if (fns[i].element === element) {
2273                        return fns[i].fn;
2274                    }
2275                }
2276                return function(){};
2277            }
2278
2279            function removeCallback(element) {
2280                for (var i = 0; i < fns.length; i++) {
2281                    if (fns[i].element === element) {
2282                        return fns.splice(i,1);
2283                    }
2284                }
2285            }
2286
2287            function _addWheelListener(elem, eventName, callback, isPassiveListener ) {
2288                var cb;
2289
2290                if (support === "wheel") {
2291                    cb = callback;
2292                } else {
2293                    cb = createCallback(elem, callback);
2294                }
2295
2296                elem[_addEventListener](prefix + eventName, cb, isPassiveListener ? passiveOption : false);
2297            }
2298
2299            function _removeWheelListener(elem, eventName, callback, isPassiveListener ) {
2300
2301                var cb;
2302
2303                if (support === "wheel") {
2304                    cb = callback;
2305                } else {
2306                    cb = getCallback(elem);
2307                }
2308
2309                elem[_removeEventListener](prefix + eventName, cb, isPassiveListener ? passiveOption : false);
2310
2311                removeCallback(elem);
2312            }
2313
2314            function addWheelListener( elem, callback, isPassiveListener ) {
2315                _addWheelListener(elem, support, callback, isPassiveListener );
2316
2317                // handle MozMousePixelScroll in older Firefox
2318                if( support == "DOMMouseScroll" ) {
2319                    _addWheelListener(elem, "MozMousePixelScroll", callback, isPassiveListener );
2320                }
2321            }
2322
2323            function removeWheelListener(elem, callback, isPassiveListener){
2324                _removeWheelListener(elem, support, callback, isPassiveListener);
2325
2326                // handle MozMousePixelScroll in older Firefox
2327                if( support == "DOMMouseScroll" ) {
2328                    _removeWheelListener(elem, "MozMousePixelScroll", callback, isPassiveListener);
2329                }
2330            }
2331
2332            return {
2333                on: addWheelListener,
2334                off: removeWheelListener
2335            };
2336
2337        })();
2338
2339    },{}],7:[function(require,module,exports){
2340        module.exports = {
2341            /**
2342             * Extends an object
2343             *
2344             * @param  {Object} target object to extend
2345             * @param  {Object} source object to take properties from
2346             * @return {Object}        extended object
2347             */
2348            extend: function(target, source) {
2349                target = target || {};
2350                for (var prop in source) {
2351                    // Go recursively
2352                    if (this.isObject(source[prop])) {
2353                        target[prop] = this.extend(target[prop], source[prop]);
2354                    } else {
2355                        target[prop] = source[prop];
2356                    }
2357                }
2358                return target;
2359            },
2360
2361            /**
2362             * Checks if an object is a DOM element
2363             *
2364             * @param  {Object}  o HTML element or String
2365             * @return {Boolean}   returns true if object is a DOM element
2366             */
2367            isElement: function(o) {
2368                return (
2369                    o instanceof HTMLElement ||
2370                    o instanceof SVGElement ||
2371                    o instanceof SVGSVGElement || //DOM2
2372                    (o &&
2373                        typeof o === "object" &&
2374                        o !== null &&
2375                        o.nodeType === 1 &&
2376                        typeof o.nodeName === "string")
2377                );
2378            },
2379
2380            /**
2381             * Checks if an object is an Object
2382             *
2383             * @param  {Object}  o Object
2384             * @return {Boolean}   returns true if object is an Object
2385             */
2386            isObject: function(o) {
2387                return Object.prototype.toString.call(o) === "[object Object]";
2388            },
2389
2390            /**
2391             * Checks if variable is Number
2392             *
2393             * @param  {Integer|Float}  n
2394             * @return {Boolean}   returns true if variable is Number
2395             */
2396            isNumber: function(n) {
2397                return !isNaN(parseFloat(n)) && isFinite(n);
2398            },
2399
2400            /**
2401             * Search for an SVG element
2402             *
2403             * @param  {Object|String} elementOrSelector DOM Element or selector String
2404             * @return {Object|Null}                   SVG or null
2405             */
2406            getSvg: function(elementOrSelector) {
2407                var element, svg;
2408
2409                if (!this.isElement(elementOrSelector)) {
2410                    // If selector provided
2411                    if (
2412                        typeof elementOrSelector === "string" ||
2413                        elementOrSelector instanceof String
2414                    ) {
2415                        // Try to find the element
2416                        element = document.querySelector(elementOrSelector);
2417
2418                        if (!element) {
2419                            throw new Error(
2420                                "Provided selector did not find any elements. Selector: " +
2421                                elementOrSelector
2422                            );
2423                            return null;
2424                        }
2425                    } else {
2426                        throw new Error("Provided selector is not an HTML object nor String");
2427                        return null;
2428                    }
2429                } else {
2430                    element = elementOrSelector;
2431                }
2432
2433                if (element.tagName.toLowerCase() === "svg") {
2434                    svg = element;
2435                } else {
2436                    if (element.tagName.toLowerCase() === "object") {
2437                        svg = element.contentDocument.documentElement;
2438                    } else {
2439                        if (element.tagName.toLowerCase() === "embed") {
2440                            svg = element.getSVGDocument().documentElement;
2441                        } else {
2442                            if (element.tagName.toLowerCase() === "img") {
2443                                throw new Error(
2444                                    'Cannot script an SVG in an "img" element. Please use an "object" element or an in-line SVG.'
2445                                );
2446                            } else {
2447                                throw new Error("Cannot get SVG.");
2448                            }
2449                            return null;
2450                        }
2451                    }
2452                }
2453
2454                return svg;
2455            },
2456
2457            /**
2458             * Attach a given context to a function
2459             * @param  {Function} fn      Function
2460             * @param  {Object}   context Context
2461             * @return {Function}           Function with certain context
2462             */
2463            proxy: function(fn, context) {
2464                return function() {
2465                    return fn.apply(context, arguments);
2466                };
2467            },
2468
2469            /**
2470             * Returns object type
2471             * Uses toString that returns [object SVGPoint]
2472             * And than parses object type from string
2473             *
2474             * @param  {Object} o Any object
2475             * @return {String}   Object type
2476             */
2477            getType: function(o) {
2478                return Object.prototype.toString
2479                    .apply(o)
2480                    .replace(/^\[object\s/, "")
2481                    .replace(/\]$/, "");
2482            },
2483
2484            /**
2485             * If it is a touch event than add clientX and clientY to event object
2486             *
2487             * @param  {Event} evt
2488             * @param  {SVGSVGElement} svg
2489             */
2490            mouseAndTouchNormalize: function(evt, svg) {
2491                // If no clientX then fallback
2492                if (evt.clientX === void 0 || evt.clientX === null) {
2493                    // Fallback
2494                    evt.clientX = 0;
2495                    evt.clientY = 0;
2496
2497                    // If it is a touch event
2498                    if (evt.touches !== void 0 && evt.touches.length) {
2499                        if (evt.touches[0].clientX !== void 0) {
2500                            evt.clientX = evt.touches[0].clientX;
2501                            evt.clientY = evt.touches[0].clientY;
2502                        } else if (evt.touches[0].pageX !== void 0) {
2503                            var rect = svg.getBoundingClientRect();
2504
2505                            evt.clientX = evt.touches[0].pageX - rect.left;
2506                            evt.clientY = evt.touches[0].pageY - rect.top;
2507                        }
2508                        // If it is a custom event
2509                    } else if (evt.originalEvent !== void 0) {
2510                        if (evt.originalEvent.clientX !== void 0) {
2511                            evt.clientX = evt.originalEvent.clientX;
2512                            evt.clientY = evt.originalEvent.clientY;
2513                        }
2514                    }
2515                }
2516            },
2517
2518            /**
2519             * Check if an event is a double click/tap
2520             * TODO: For touch gestures use a library (hammer.js) that takes in account other events
2521             * (touchmove and touchend). It should take in account tap duration and traveled distance
2522             *
2523             * @param  {Event}  evt
2524             * @param  {Event}  prevEvt Previous Event
2525             * @return {Boolean}
2526             */
2527            isDblClick: function(evt, prevEvt) {
2528                // Double click detected by browser
2529                if (evt.detail === 2) {
2530                    return true;
2531                }
2532                // Try to compare events
2533                else if (prevEvt !== void 0 && prevEvt !== null) {
2534                    var timeStampDiff = evt.timeStamp - prevEvt.timeStamp, // should be lower than 250 ms
2535                        touchesDistance = Math.sqrt(
2536                            Math.pow(evt.clientX - prevEvt.clientX, 2) +
2537                            Math.pow(evt.clientY - prevEvt.clientY, 2)
2538                        );
2539
2540                    return timeStampDiff < 250 && touchesDistance < 10;
2541                }
2542
2543                // Nothing found
2544                return false;
2545            },
2546
2547            /**
2548             * Returns current timestamp as an integer
2549             *
2550             * @return {Number}
2551             */
2552            now:
2553                Date.now ||
2554                function() {
2555                    return new Date().getTime();
2556                },
2557
2558            // From underscore.
2559            // Returns a function, that, when invoked, will only be triggered at most once
2560            // during a given window of time. Normally, the throttled function will run
2561            // as much as it can, without ever going more than once per `wait` duration;
2562            // but if you'd like to disable the execution on the leading edge, pass
2563            // `{leading: false}`. To disable execution on the trailing edge, ditto.
2564            throttle: function(func, wait, options) {
2565                var that = this;
2566                var context, args, result;
2567                var timeout = null;
2568                var previous = 0;
2569                if (!options) {
2570                    options = {};
2571                }
2572                var later = function() {
2573                    previous = options.leading === false ? 0 : that.now();
2574                    timeout = null;
2575                    result = func.apply(context, args);
2576                    if (!timeout) {
2577                        context = args = null;
2578                    }
2579                };
2580                return function() {
2581                    var now = that.now();
2582                    if (!previous && options.leading === false) {
2583                        previous = now;
2584                    }
2585                    var remaining = wait - (now - previous);
2586                    context = this; // eslint-disable-line consistent-this
2587                    args = arguments;
2588                    if (remaining <= 0 || remaining > wait) {
2589                        clearTimeout(timeout);
2590                        timeout = null;
2591                        previous = now;
2592                        result = func.apply(context, args);
2593                        if (!timeout) {
2594                            context = args = null;
2595                        }
2596                    } else if (!timeout && options.trailing !== false) {
2597                        timeout = setTimeout(later, remaining);
2598                    }
2599                    return result;
2600                };
2601            },
2602
2603            /**
2604             * Create a requestAnimationFrame simulation
2605             *
2606             * @param  {Number|String} refreshRate
2607             * @return {Function}
2608             */
2609            createRequestAnimationFrame: function(refreshRate) {
2610                var timeout = null;
2611
2612                // Convert refreshRate to timeout
2613                if (refreshRate !== "auto" && refreshRate < 60 && refreshRate > 1) {
2614                    timeout = Math.floor(1000 / refreshRate);
2615                }
2616
2617                if (timeout === null) {
2618                    return window.requestAnimationFrame || requestTimeout(33);
2619                } else {
2620                    return requestTimeout(timeout);
2621                }
2622            }
2623        };
2624
2625        /**
2626         * Create a callback that will execute after a given timeout
2627         *
2628         * @param  {Function} timeout
2629         * @return {Function}
2630         */
2631        function requestTimeout(timeout) {
2632            return function(callback) {
2633                window.setTimeout(callback, timeout);
2634            };
2635        }
2636
2637    },{}]},{},[3]);
2638/* End */
2639;
2640; /* Start:"a:4:{s:4:"full";s:58:"/o-klube/shema-territorii/assets/hammer.js?160241708078529";s:6:"source";s:42:"/o-klube/shema-territorii/assets/hammer.js";s:3:"min";s:0:"";s:3:"map";s:0:"";}"*/
2641/*! Hammer.JS - v2.0.4 - 2014-09-28
2642 * http://hammerjs.github.io/
2643 *
2644 * Copyright (c) 2014 Jorik Tangelder;
2645 * Licensed under the MIT license */
2646(function(window, document, exportName, undefined) {
2647    'use strict';
2648
2649    var VENDOR_PREFIXES = ['', 'webkit', 'moz', 'MS', 'ms', 'o'];
2650    var TEST_ELEMENT = document.createElement('div');
2651
2652    var TYPE_FUNCTION = 'function';
2653
2654    var round = Math.round;
2655    var abs = Math.abs;
2656    var now = Date.now;
2657
2658    /**
2659     * set a timeout with a given scope
2660     * @param {Function} fn
2661     * @param {Number} timeout
2662     * @param {Object} context
2663     * @returns {number}
2664     */
2665    function setTimeoutContext(fn, timeout, context) {
2666        return setTimeout(bindFn(fn, context), timeout);
2667    }
2668
2669    /**
2670     * if the argument is an array, we want to execute the fn on each entry
2671     * if it aint an array we don't want to do a thing.
2672     * this is used by all the methods that accept a single and array argument.
2673     * @param {*|Array} arg
2674     * @param {String} fn
2675     * @param {Object} [context]
2676     * @returns {Boolean}
2677     */
2678    function invokeArrayArg(arg, fn, context) {
2679        if (Array.isArray(arg)) {
2680            each(arg, context[fn], context);
2681            return true;
2682        }
2683        return false;
2684    }
2685
2686    /**
2687     * walk objects and arrays
2688     * @param {Object} obj
2689     * @param {Function} iterator
2690     * @param {Object} context
2691     */
2692    function each(obj, iterator, context) {
2693        var i;
2694
2695        if (!obj) {
2696            return;
2697        }
2698