1/*
2@license
3
4dhtmlxGantt v.6.3.5 Standard
5
6This version of dhtmlxGantt is distributed under GPL 2.0 license and can be legally used in GPL projects.
7
8To use dhtmlxGantt in non-GPL projects (and get Pro version of the product), please obtain Commercial/Enterprise or Ultimate license on our site https://dhtmlx.com/docs/products/dhtmlxGantt/#licensing or contact us at sales@dhtmlx.com
9
10(c) XB Software Ltd.
11
12*/
13(function webpackUniversalModuleDefinition(root, factory) {
14	if(typeof exports === 'object' && typeof module === 'object')
15		module.exports = factory();
16	else if(typeof define === 'function' && define.amd)
17		define("ext/dhtmlxgantt_tooltip", [], factory);
18	else if(typeof exports === 'object')
19		exports["ext/dhtmlxgantt_tooltip"] = factory();
20	else
21		root["ext/dhtmlxgantt_tooltip"] = factory();
22})(window, function() {
23return /******/ (function(modules) { // webpackBootstrap
24/******/ 	// The module cache
25/******/ 	var installedModules = {};
26/******/
27/******/ 	// The require function
28/******/ 	function __webpack_require__(moduleId) {
29/******/
30/******/ 		// Check if module is in cache
31/******/ 		if(installedModules[moduleId]) {
32/******/ 			return installedModules[moduleId].exports;
33/******/ 		}
34/******/ 		// Create a new module (and put it into the cache)
35/******/ 		var module = installedModules[moduleId] = {
36/******/ 			i: moduleId,
37/******/ 			l: false,
38/******/ 			exports: {}
39/******/ 		};
40/******/
41/******/ 		// Execute the module function
42/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
43/******/
44/******/ 		// Flag the module as loaded
45/******/ 		module.l = true;
46/******/
47/******/ 		// Return the exports of the module
48/******/ 		return module.exports;
49/******/ 	}
50/******/
51/******/
52/******/ 	// expose the modules object (__webpack_modules__)
53/******/ 	__webpack_require__.m = modules;
54/******/
55/******/ 	// expose the module cache
56/******/ 	__webpack_require__.c = installedModules;
57/******/
58/******/ 	// define getter function for harmony exports
59/******/ 	__webpack_require__.d = function(exports, name, getter) {
60/******/ 		if(!__webpack_require__.o(exports, name)) {
61/******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
62/******/ 		}
63/******/ 	};
64/******/
65/******/ 	// define __esModule on exports
66/******/ 	__webpack_require__.r = function(exports) {
67/******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
68/******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
69/******/ 		}
70/******/ 		Object.defineProperty(exports, '__esModule', { value: true });
71/******/ 	};
72/******/
73/******/ 	// create a fake namespace object
74/******/ 	// mode & 1: value is a module id, require it
75/******/ 	// mode & 2: merge all properties of value into the ns
76/******/ 	// mode & 4: return value when already ns object
77/******/ 	// mode & 8|1: behave like require
78/******/ 	__webpack_require__.t = function(value, mode) {
79/******/ 		if(mode & 1) value = __webpack_require__(value);
80/******/ 		if(mode & 8) return value;
81/******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
82/******/ 		var ns = Object.create(null);
83/******/ 		__webpack_require__.r(ns);
84/******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
85/******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
86/******/ 		return ns;
87/******/ 	};
88/******/
89/******/ 	// getDefaultExport function for compatibility with non-harmony modules
90/******/ 	__webpack_require__.n = function(module) {
91/******/ 		var getter = module && module.__esModule ?
92/******/ 			function getDefault() { return module['default']; } :
93/******/ 			function getModuleExports() { return module; };
94/******/ 		__webpack_require__.d(getter, 'a', getter);
95/******/ 		return getter;
96/******/ 	};
97/******/
98/******/ 	// Object.prototype.hasOwnProperty.call
99/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
100/******/
101/******/ 	// __webpack_public_path__
102/******/ 	__webpack_require__.p = "/codebase/sources/";
103/******/
104/******/
105/******/ 	// Load entry module and return exports
106/******/ 	return __webpack_require__(__webpack_require__.s = "./sources/ext/tooltip/index.ts");
107/******/ })
108/************************************************************************/
109/******/ ({
110
111/***/ "./sources/ext/tooltip/index.ts":
112/*!**************************************!*\
113  !*** ./sources/ext/tooltip/index.ts ***!
114  \**************************************/
115/*! no static exports found */
116/***/ (function(module, exports, __webpack_require__) {
117
118"use strict";
119
120Object.defineProperty(exports, "__esModule", { value: true });
121gantt.config.tooltip_timeout = 30;
122gantt.config.tooltip_offset_y = 20;
123gantt.config.tooltip_offset_x = 10;
124gantt.config.tooltip_hide_timeout = 30;
125var tooltipManager_1 = __webpack_require__(/*! ./tooltipManager */ "./sources/ext/tooltip/tooltipManager.ts");
126var tooltipManager = new tooltipManager_1.TooltipManager();
127gantt.ext.tooltips = tooltipManager;
128gantt.attachEvent("onGanttReady", function () {
129    tooltipManager.tooltipFor({
130        selector: "[" + gantt.config.task_attribute + "]:not(.gantt_task_row)",
131        html: function (event) {
132            if (gantt.config.touch && !gantt.config.touch_tooltip) {
133                return;
134            }
135            var targetTaskId = gantt.locate(event);
136            if (gantt.isTaskExists(targetTaskId)) {
137                var task = gantt.getTask(targetTaskId);
138                return gantt.templates.tooltip_text(task.start_date, task.end_date, task);
139            }
140            return null;
141        },
142        global: false
143    });
144});
145gantt.attachEvent("onDestroy", function () {
146    tooltipManager.destructor();
147});
148gantt.attachEvent("onLightbox", function () {
149    tooltipManager.hideTooltip();
150});
151var isLinkCreate = function () {
152    var state = gantt.getState();
153    return !!state.link_source_id;
154};
155gantt.attachEvent("onBeforeTooltip", function () {
156    if (isLinkCreate()) {
157        return false;
158    }
159});
160gantt.attachEvent("onGanttScroll", function () {
161    tooltipManager.hideTooltip();
162});
163
164
165/***/ }),
166
167/***/ "./sources/ext/tooltip/tooltip.ts":
168/*!****************************************!*\
169  !*** ./sources/ext/tooltip/tooltip.ts ***!
170  \****************************************/
171/*! no static exports found */
172/***/ (function(module, exports, __webpack_require__) {
173
174"use strict";
175
176Object.defineProperty(exports, "__esModule", { value: true });
177var domHelpers = __webpack_require__(/*! ../../utils/dom_helpers */ "./sources/utils/dom_helpers.js");
178var Tooltip = /** @class */ (function () {
179    function Tooltip() {
180    }
181    Tooltip.prototype.getNode = function () {
182        if (!this._tooltipNode) {
183            this._tooltipNode = document.createElement("div");
184            this._tooltipNode.className = "gantt_tooltip";
185            gantt._waiAria.tooltipAttr(this._tooltipNode);
186        }
187        return this._tooltipNode;
188    };
189    Tooltip.prototype.setViewport = function (node) {
190        this._root = node;
191        return this;
192    };
193    Tooltip.prototype.show = function (left, top) {
194        var container = document.body;
195        var node = this.getNode();
196        if (!domHelpers.isChildOf(node, container)) {
197            this.hide();
198            container.appendChild(node);
199        }
200        if (this._isLikeMouseEvent(left)) {
201            var position = this._calculateTooltipPosition(left);
202            top = position.top;
203            left = position.left;
204        }
205        node.style.top = top + "px";
206        node.style.left = left + "px";
207        gantt._waiAria.tooltipVisibleAttr(node);
208        return this;
209    };
210    Tooltip.prototype.hide = function () {
211        var node = this.getNode();
212        if (node && node.parentNode) {
213            node.parentNode.removeChild(node);
214        }
215        gantt._waiAria.tooltipHiddenAttr(node);
216        return this;
217    };
218    Tooltip.prototype.setContent = function (html) {
219        var node = this.getNode();
220        node.innerHTML = html;
221        return this;
222    };
223    // it is for salesforce, because it proxies event to it own events
224    Tooltip.prototype._isLikeMouseEvent = function (event) {
225        return "clientX" in event && "clientY" in event;
226    };
227    Tooltip.prototype._getViewPort = function () {
228        return this._root || document.body;
229    };
230    Tooltip.prototype._calculateTooltipPosition = function (event) {
231        // top/left coordinates inside the viewport by mouse position
232        var viewport = this._getViewPortSize();
233        var tooltipNode = this.getNode();
234        var tooltip = {
235            top: 0,
236            left: 0,
237            width: tooltipNode.offsetWidth,
238            height: tooltipNode.offsetHeight,
239            bottom: 0,
240            right: 0
241        };
242        var offsetX = gantt.config.tooltip_offset_x;
243        var offsetY = gantt.config.tooltip_offset_y;
244        var container = document.body;
245        var mouse = domHelpers.getRelativeEventPosition(event, container);
246        var containerPos = domHelpers.getNodePosition(container);
247        mouse.y += containerPos.y; // to fix margin collapsing
248        tooltip.top = mouse.y;
249        tooltip.left = mouse.x;
250        tooltip.top += offsetY;
251        tooltip.left += offsetX;
252        tooltip.bottom = tooltip.top + tooltip.height;
253        tooltip.right = tooltip.left + tooltip.width;
254        var scrollTop = window.scrollY + container.scrollTop; // to fix margin collapsing
255        // edge cases when the tooltip element can be partially hidden by edges of the viewport
256        if (tooltip.top < viewport.top - scrollTop) {
257            tooltip.top = viewport.top;
258            tooltip.bottom = tooltip.top + tooltip.height;
259        }
260        else if (tooltip.bottom > viewport.bottom) {
261            tooltip.bottom = viewport.bottom;
262            tooltip.top = tooltip.bottom - tooltip.height;
263        }
264        if (tooltip.left < viewport.left) {
265            tooltip.left = viewport.left;
266            tooltip.right = viewport.left + tooltip.width;
267        }
268        else if (tooltip.right > viewport.right) {
269            tooltip.right = viewport.right;
270            tooltip.left = tooltip.right - tooltip.width;
271        }
272        if (mouse.x >= tooltip.left && mouse.x <= tooltip.right) {
273            tooltip.left = mouse.x - tooltip.width - offsetX;
274            tooltip.right = tooltip.left + tooltip.width;
275        }
276        if (mouse.y >= tooltip.top && mouse.y <= tooltip.bottom) {
277            tooltip.top = mouse.y - tooltip.height - offsetY;
278            tooltip.bottom = tooltip.top + tooltip.height;
279        }
280        return tooltip;
281    };
282    Tooltip.prototype._getViewPortSize = function () {
283        var container = this._getViewPort();
284        var viewport = container;
285        var scrollTop = window.scrollY + document.body.scrollTop;
286        var scrollLeft = window.scrollX + document.body.scrollLeft;
287        var pos;
288        // support for the initial tooltip mode where the tooltip element was attached to the data area of gantt
289        if (container === gantt.$task_data) {
290            viewport = gantt.$task;
291            scrollTop = 0;
292            scrollLeft = 0;
293            pos = domHelpers.getNodePosition(gantt.$task);
294        }
295        else {
296            pos = domHelpers.getNodePosition(viewport);
297        }
298        return {
299            left: pos.x + scrollLeft,
300            top: pos.y + scrollTop,
301            width: pos.width,
302            height: pos.height,
303            bottom: pos.y + pos.height + scrollTop,
304            right: pos.x + pos.width + scrollLeft
305        };
306    };
307    return Tooltip;
308}());
309exports.Tooltip = Tooltip;
310
311
312/***/ }),
313
314/***/ "./sources/ext/tooltip/tooltipManager.ts":
315/*!***********************************************!*\
316  !*** ./sources/ext/tooltip/tooltipManager.ts ***!
317  \***********************************************/
318/*! no static exports found */
319/***/ (function(module, exports, __webpack_require__) {
320
321"use strict";
322
323Object.defineProperty(exports, "__esModule", { value: true });
324var domEventsScope = __webpack_require__(/*! ../../utils/dom_event_scope */ "./sources/utils/dom_event_scope.js");
325var domHelpers = __webpack_require__(/*! ../../utils/dom_helpers */ "./sources/utils/dom_helpers.js");
326var helpers = __webpack_require__(/*! ../../utils/helpers */ "./sources/utils/helpers.js");
327var tooltip_1 = __webpack_require__(/*! ./tooltip */ "./sources/ext/tooltip/tooltip.ts");
328var TooltipManager = /** @class */ (function () {
329    function TooltipManager() {
330        this.tooltip = new tooltip_1.Tooltip();
331        this._listeners = {};
332        this._domEvents = domEventsScope();
333        this._initDelayedFunctions();
334    }
335    TooltipManager.prototype.destructor = function () {
336        this.tooltip.hide();
337        this._domEvents.detachAll();
338    };
339    TooltipManager.prototype.hideTooltip = function () {
340        this.delayHide();
341    };
342    TooltipManager.prototype.attach = function (config) {
343        var _this = this;
344        var root = document.body;
345        if (!config.global) {
346            root = gantt.$root;
347        }
348        var watchableTarget = null;
349        var handler = function (event) {
350            var eventTarget = domHelpers.getTargetNode(event);
351            var targetNode = domHelpers.closest(eventTarget, config.selector);
352            if (domHelpers.isChildOf(eventTarget, _this.tooltip.getNode())) {
353                return;
354            }
355            var doOnMouseEnter = function () {
356                watchableTarget = targetNode;
357                config.onmouseenter(event, targetNode);
358            };
359            if (watchableTarget) {
360                if (targetNode && targetNode === watchableTarget) {
361                    config.onmousemove(event, targetNode);
362                }
363                else {
364                    config.onmouseleave(event, watchableTarget);
365                    watchableTarget = null;
366                    if (targetNode && targetNode !== watchableTarget) {
367                        doOnMouseEnter();
368                    }
369                }
370            }
371            else {
372                if (targetNode) {
373                    doOnMouseEnter();
374                }
375            }
376        };
377        this.detach(config.selector);
378        this._domEvents.attach(root, "mousemove", handler);
379        this._listeners[config.selector] = {
380            node: root,
381            handler: handler
382        };
383    };
384    TooltipManager.prototype.detach = function (selector) {
385        var listener = this._listeners[selector];
386        if (listener) {
387            this._domEvents.detach(listener.node, "mousemove", listener.handler);
388        }
389    };
390    TooltipManager.prototype.tooltipFor = function (config) {
391        var _this = this;
392        var cloneDomEvent = function (event) {
393            var clone = event;
394            // making events survive timeout in ie
395            // tslint:disable-next-line no-string-literal
396            if (document["createEventObject"] && !document.createEvent) {
397                // tslint:disable-next-line no-string-literal
398                clone = document["createEventObject"](event);
399            }
400            return clone;
401        };
402        this._initDelayedFunctions();
403        this.attach({
404            selector: config.selector,
405            global: config.global,
406            onmouseenter: function (event, node) {
407                var html = config.html(event, node);
408                if (html) {
409                    _this.delayShow(cloneDomEvent(event), html);
410                }
411            },
412            onmousemove: function (event, node) {
413                var html = config.html(event, node);
414                if (html) {
415                    _this.delayShow(cloneDomEvent(event), html);
416                }
417                else {
418                    _this.delayShow.$cancelTimeout();
419                    _this.delayHide();
420                }
421            },
422            onmouseleave: function () {
423                _this.delayShow.$cancelTimeout();
424                _this.delayHide();
425            },
426        });
427    };
428    TooltipManager.prototype._initDelayedFunctions = function () {
429        var _this = this;
430        // reset delayed functions in order to apply current values of tooltip_timeout
431        if (this.delayShow) {
432            this.delayShow.$cancelTimeout();
433        }
434        if (this.delayHide) {
435            this.delayHide.$cancelTimeout();
436        }
437        this.tooltip.hide();
438        this.delayShow = helpers.delay(function (event, html) {
439            if (gantt.callEvent("onBeforeTooltip", [event]) === false) {
440                _this.tooltip.hide();
441            }
442            else {
443                _this.tooltip.setContent(html);
444                _this.tooltip.show(event);
445            }
446        }, gantt.config.tooltip_timeout || 1);
447        this.delayHide = helpers.delay(function () {
448            _this.delayShow.$cancelTimeout();
449            _this.tooltip.hide();
450        }, gantt.config.tooltip_hide_timeout || 1);
451    };
452    return TooltipManager;
453}());
454exports.TooltipManager = TooltipManager;
455
456
457/***/ }),
458
459/***/ "./sources/utils/dom_event_scope.js":
460/*!******************************************!*\
461  !*** ./sources/utils/dom_event_scope.js ***!
462  \******************************************/
463/*! no static exports found */
464/***/ (function(module, exports, __webpack_require__) {
465
466var utils = __webpack_require__(/*! ./utils */ "./sources/utils/utils.js");
467
468function createScope(addEvent, removeEvent) {
469	addEvent = addEvent || utils.event;
470	removeEvent = removeEvent || utils.eventRemove;
471
472	var handlers = [];
473
474	var eventScope = {
475		attach: function(el, event, callback, capture){
476			handlers.push({element: el, event:event, callback: callback, capture: capture});
477			addEvent(el, event, callback, capture);
478		},
479		detach: function(el, event, callback, capture){
480			removeEvent(el, event, callback, capture);
481			for(var i = 0; i < handlers.length; i++){
482				var handler = handlers[i];
483				if (handler.element === el && handler.event === event && handler.callback === callback && handler.capture === capture) {
484					handlers.splice(i, 1);
485					i--;
486				}
487			}
488		},
489		detachAll: function () {
490			var staticArray = handlers.slice();
491			// original handlers array can be spliced on every iteration
492			for (var i = 0; i < staticArray.length; i++){
493				var handler = staticArray[i];
494				eventScope.detach(handler.element, handler.event, handler.callback, handler.capture);
495				eventScope.detach(handler.element, handler.event, handler.callback, undefined);
496				eventScope.detach(handler.element, handler.event, handler.callback, false);
497				eventScope.detach(handler.element, handler.event, handler.callback, true);
498			}
499			handlers.splice(0, handlers.length);
500		},
501		extend: function(){
502			return createScope(this.event, this.eventRemove);
503		}
504	};
505
506	if (!window.scopes) {
507		window.scopes = [];
508	}
509	window.scopes.push(handlers);
510	return eventScope;
511}
512
513module.exports = createScope;
514
515/***/ }),
516
517/***/ "./sources/utils/dom_helpers.js":
518/*!**************************************!*\
519  !*** ./sources/utils/dom_helpers.js ***!
520  \**************************************/
521/*! no static exports found */
522/***/ (function(module, exports) {
523
524//returns position of html element on the page
525function elementPosition(elem) {
526	var top=0, left=0, right=0, bottom=0;
527	if (elem.getBoundingClientRect) { //HTML5 method
528		var box = elem.getBoundingClientRect();
529		var body = document.body;
530		var docElem = (document.documentElement ||
531			document.body.parentNode ||
532			document.body);
533
534		var scrollTop = window.pageYOffset || docElem.scrollTop || body.scrollTop;
535		var scrollLeft = window.pageXOffset || docElem.scrollLeft || body.scrollLeft;
536		var clientTop = docElem.clientTop || body.clientTop || 0;
537		var clientLeft = docElem.clientLeft || body.clientLeft || 0;
538		top  = box.top +  scrollTop - clientTop;
539		left = box.left + scrollLeft - clientLeft;
540
541		right = document.body.offsetWidth - box.right;
542		bottom = document.body.offsetHeight - box.bottom;
543	} else { //fallback to naive approach
544		while(elem) {
545			top = top + parseInt(elem.offsetTop,10);
546			left = left + parseInt(elem.offsetLeft,10);
547			elem = elem.offsetParent;
548		}
549
550		right = document.body.offsetWidth - elem.offsetWidth - left;
551		bottom = document.body.offsetHeight - elem.offsetHeight - top;
552	}
553	return { y: Math.round(top), x: Math.round(left), width:elem.offsetWidth, height:elem.offsetHeight, right: Math.round(right), bottom: Math.round(bottom) };
554}
555
556function isVisible(node){
557	var display = false,
558		visibility = false;
559	if(window.getComputedStyle){
560		var style = window.getComputedStyle(node, null);
561		display = style["display"];
562		visibility = style["visibility"];
563	}else if(node.currentStyle){
564		display = node.currentStyle["display"];
565		visibility = node.currentStyle["visibility"];
566	}
567	return (display != "none" && visibility != "hidden");
568}
569
570function hasNonNegativeTabIndex(node){
571	return !isNaN(node.getAttribute("tabindex")) && (node.getAttribute("tabindex")*1 >= 0);
572}
573
574function hasHref(node){
575	var canHaveHref = {"a": true, "area": true};
576	if(canHaveHref[node.nodeName.loLowerCase()]){
577		return !!node.getAttribute("href");
578	}
579	return true;
580}
581
582function isEnabled(node){
583	var canDisable = {"input":true, "select":true, "textarea":true, "button":true, "object":true};
584	if(canDisable[node.nodeName.toLowerCase()]){
585		return !node.hasAttribute("disabled");
586	}
587
588	return true;
589}
590
591function getFocusableNodes(root){
592	var nodes = root.querySelectorAll([
593		"a[href]",
594		"area[href]",
595		"input",
596		"select",
597		"textarea",
598		"button",
599		"iframe",
600		"object",
601		"embed",
602		"[tabindex]",
603		"[contenteditable]"
604	].join(", "));
605
606	var nodesArray = Array.prototype.slice.call(nodes, 0);
607	for(var i = 0; i < nodesArray.length; i++){
608		var node = nodesArray[i];
609		var isValid = (hasNonNegativeTabIndex(node)  || isEnabled(node) || hasHref(node)) && isVisible(node);
610		if(!isValid){
611			nodesArray.splice(i, 1);
612			i--;
613		}
614	}
615	return nodesArray;
616}
617
618function getScrollSize(){
619	var div = document.createElement("div");
620	div.style.cssText="visibility:hidden;position:absolute;left:-1000px;width:100px;padding:0px;margin:0px;height:110px;min-height:100px;overflow-y:scroll;";
621
622	document.body.appendChild(div);
623	var width = div.offsetWidth-div.clientWidth;
624	document.body.removeChild(div);
625
626	return width;
627}
628
629function getClassName(node){
630	if(!node) return "";
631
632	var className = node.className || "";
633	if(className.baseVal)//'className' exist but not a string - IE svg element in DOM
634		className = className.baseVal;
635
636	if(!className.indexOf)
637		className = "";
638
639	return _trimString(className);
640}
641
642function addClassName(node, className){
643	if (className && node.className.indexOf(className) === -1) {
644		node.className += " " + className;
645	}
646}
647
648function removeClassName(node, name) {
649	name = name.split(" ");
650	for (var i = 0; i < name.length; i++) {
651		var regEx = new RegExp("\\s?\\b" + name[i] + "\\b(?![-_.])", "");
652		node.className = node.className.replace(regEx, "");
653	}
654}
655
656function hasClass(element, className){
657	if ('classList' in element) {
658		return element.classList.contains(className);
659	} else {
660		return new RegExp("\\b" + className + "\\b").test(element.className);
661	}
662}
663
664function toNode(node) {
665	if (typeof node === "string") {
666		return (document.getElementById(node) || document.querySelector(node) || document.body);
667	}
668	return node || document.body;
669}
670
671var _slave = document.createElement("div");
672function insert(node, newone) {
673	_slave.innerHTML = newone;
674	var child = _slave.firstChild;
675	node.appendChild(child);
676	return child;
677}
678
679function remove(node) {
680	if (node && node.parentNode) {
681		node.parentNode.removeChild(node);
682	}
683}
684
685function getChildren(node, css) {
686	var ch = node.childNodes;
687	var len = ch.length;
688	var out = [];
689	for (var i = 0; i < len; i++) {
690		var obj = ch[i];
691		if (obj.className && obj.className.indexOf(css) !== -1) {
692			out.push(obj);
693		}
694	}
695	return out;
696}
697
698function getTargetNode(e){
699	var trg;
700	if (e.tagName)
701		trg = e;
702	else {
703		e=e||window.event;
704		trg=e.target||e.srcElement;
705	}
706	return trg;
707}
708
709function locateAttribute(e, attribute) {
710	if(!attribute) return;
711
712	var trg = getTargetNode(e);
713
714	while (trg){
715		if (trg.getAttribute){	//text nodes has not getAttribute
716			var test = trg.getAttribute(attribute);
717			if (test) return trg;
718		}
719		trg=trg.parentNode;
720	}
721	return null;
722}
723
724function _trimString(str){
725	var func = String.prototype.trim || function(){ return this.replace(/^\s+|\s+$/g, ""); };
726	return func.apply(str);
727}
728
729function locateClassName(e, classname, strict){
730	var trg = getTargetNode(e);
731	var css = "";
732
733	if(strict === undefined)
734		strict = true;
735
736	while (trg){
737		css = getClassName(trg);
738		if(css){
739			var ind = css.indexOf(classname);
740			if (ind >= 0){
741				if (!strict)
742					return trg;
743
744				//check that we have exact match
745				var left = (ind === 0) || (!_trimString(css.charAt(ind - 1)));
746				var right = ((ind + classname.length >= css.length)) || (!_trimString(css.charAt(ind + classname.length)));
747
748				if (left && right)
749					return trg;
750			}
751		}
752		trg=trg.parentNode;
753	}
754	return null;
755}
756
757/*
758event position relatively to DOM element
759 */
760function getRelativeEventPosition(ev, node){
761	var d = document.documentElement;
762	var box = elementPosition(node);
763
764	return {
765		x: ev.clientX + d.scrollLeft - d.clientLeft - box.x + node.scrollLeft,
766		y: ev.clientY + d.scrollTop - d.clientTop - box.y + node.scrollTop
767	};
768}
769
770function isChildOf(child, parent){
771	if(!child || !parent){
772		return false;
773	}
774
775	while(child && child != parent) {
776		child = child.parentNode;
777	}
778
779	return child === parent;
780}
781
782function closest(element, selector){
783	if(element.closest){
784		return element.closest(selector);
785	}else if(element.matches || element.msMatchesSelector || element.webkitMatchesSelector){
786		var el = element;
787		if (!document.documentElement.contains(el)) return null;
788		do {
789			var method = el.matches || el.msMatchesSelector || el.webkitMatchesSelector;
790
791			if (method.call(el, selector)) return el;
792			el = el.parentElement || el.parentNode;
793		} while (el !== null && el.nodeType === 1);
794		return null;
795	}else{
796		// eslint-disable-next-line no-console
797		console.error("Your browser is not supported");
798		return null;
799	}
800}
801
802module.exports = {
803	getNodePosition: elementPosition,
804	getFocusableNodes: getFocusableNodes,
805	getScrollSize: getScrollSize,
806	getClassName: getClassName,
807	addClassName: addClassName,
808	removeClassName: removeClassName,
809	insertNode: insert,
810	removeNode: remove,
811	getChildNodes: getChildren,
812	toNode: toNode,
813	locateClassName:locateClassName,
814	locateAttribute: locateAttribute,
815	getTargetNode: getTargetNode,
816	getRelativeEventPosition: getRelativeEventPosition,
817	isChildOf: isChildOf,
818	hasClass: hasClass,
819	closest: closest
820};
821
822/***/ }),
823
824/***/ "./sources/utils/helpers.js":
825/*!**********************************!*\
826  !*** ./sources/utils/helpers.js ***!
827  \**********************************/
828/*! no static exports found */
829/***/ (function(module, exports) {
830
831var units = {
832	"second": 1,
833	"minute": 60,
834	"hour": 60 * 60,
835	"day": 60 * 60 * 24,
836	"week": 60 * 60 * 24 * 7,
837	"month": 60 * 60 * 24 * 30,
838	"quarter": 60 * 60 * 24 * 30 * 3,
839	"year": 60 * 60 * 24 * 365
840};
841function getSecondsInUnit(unit){
842	return units[unit] || units.hour;
843}
844
845function forEach(arr, callback) {
846	if (arr.forEach) {
847		arr.forEach(callback);
848	} else {
849		var workArray = arr.slice();
850		for (var i = 0; i < workArray.length; i++) {
851			callback(workArray[i], i);
852		}
853	}
854}
855
856function arrayMap(arr, callback) {
857	if (arr.map) {
858		return arr.map(callback);
859	} else {
860		var workArray = arr.slice();
861		var resArray = [];
862
863		for (var i = 0; i < workArray.length; i++) {
864			resArray.push(callback(workArray[i], i));
865		}
866		return resArray;
867	}
868}
869
870
871function arrayFind(arr, callback) {
872	if (arr.find) {
873		return arr.find(callback);
874	} else {
875		for (var i = 0; i < arr.length; i++) {
876			if (callback(arr[i], i)) {
877				return arr[i];
878			}
879		}
880	}
881}
882
883// iframe-safe array type check instead of using instanceof
884function isArray(obj){
885	if(Array.isArray){
886		return Array.isArray(obj);
887	}else{
888		// close enough
889		return (obj && obj.length !== undefined && obj.pop && obj.push);
890	}
891}
892
893// non-primitive string object, e.g. new String("abc")
894function isStringObject(obj){
895	return obj && typeof obj === "object"
896		&& Function.prototype.toString.call(obj.constructor) === "function String() { [native code] }";
897}
898
899// non-primitive number object, e.g. new Number(5)
900function isNumberObject(obj){
901	return obj && typeof obj === "object"
902		&& Function.prototype.toString.call(obj.constructor) === "function Number() { [native code] }";
903}
904
905// non-primitive number object, e.g. new Boolean(true)
906function isBooleanObject(obj){
907	return obj && typeof obj === "object"
908		&& Function.prototype.toString.call(obj.constructor) === "function Boolean() { [native code] }";
909}
910
911function isDate(obj) {
912	if (obj && typeof obj === "object") {
913		return !!(obj.getFullYear && obj.getMonth && obj.getDate);
914	} else {
915		return false;
916	}
917}
918
919function isValidDate(obj){
920	return isDate(obj) && !isNaN(obj.getTime());
921}
922
923function arrayFilter(arr, callback) {
924	var result = [];
925
926	if (arr.filter) {
927		return arr.filter(callback);
928	} else {
929		for (var i = 0; i < arr.length; i++) {
930			if (callback(arr[i], i)) {
931				result[result.length] = arr[i];
932			}
933		}
934		return result;
935	}
936}
937
938function hashToArray(hash) {
939	var result = [];
940
941	for (var key in hash) {
942		if (hash.hasOwnProperty(key)) {
943			result.push(hash[key]);
944		}
945	}
946
947	return result;
948}
949
950function arraySome(arr, callback) {
951	if (arr.length === 0) return false;
952
953	for (var i = 0; i < arr.length; i++) {
954		if (callback(arr[i], i, arr)) {
955			return true;
956		}
957	}
958	return false;
959}
960
961function arrayDifference(arr, callback) {
962	return arrayFilter(arr, function(item, i) {
963		return !callback(item, i);
964	});
965}
966
967function throttle (callback, timeout) {
968	var wait = false;
969
970	return function () {
971		if (!wait) {
972			callback.apply(null, arguments);
973			wait = true;
974			setTimeout(function () {
975				wait = false;
976			}, timeout);
977		}
978	};
979}
980
981function delay (callback, timeout){
982	var timer;
983
984	var result = function() {
985		result.$cancelTimeout();
986		callback.$pending = true;
987		var args = Array.prototype.slice.call(arguments);
988		timer = setTimeout(function(){
989			callback.apply(this, args);
990			result.$pending = false;
991		}, timeout);
992	};
993
994	result.$pending = false;
995	result.$cancelTimeout = function(){
996		clearTimeout(timer);
997		callback.$pending = false;
998	};
999	result.$execute = function(){
1000		callback();
1001		callback.$cancelTimeout();
1002	};
1003
1004	return result;
1005}
1006
1007function sortArrayOfHash(arr, field, desc) {
1008	var compare = function(a, b) {
1009		return a < b;
1010	};
1011
1012	arr.sort(function(a, b) {
1013		if (a[field] === b[field]) return 0;
1014
1015		return desc ? compare(a[field], b[field]) : compare(b[field], a[field]);
1016	});
1017}
1018
1019function objectKeys(obj) {
1020	if (Object.keys) {
1021		return Object.keys(obj);
1022	}
1023	var result = [];
1024	var key;
1025	for (key in obj) {
1026		if (Object.prototype.hasOwnProperty.call(obj, key)) {
1027			result.push(key);
1028		}
1029	}
1030	return result;
1031}
1032
1033function requestAnimationFrame(callback) {
1034	var w = window;
1035	var foundRequestAnimationFrame = w.requestAnimationFrame
1036		|| w.webkitRequestAnimationFrame
1037		|| w.msRequestAnimationFrame
1038		|| w.mozRequestAnimationFrame
1039		|| w.oRequestAnimationFrame
1040		|| function(cb) { setTimeout(cb, 1000/60); };
1041	return foundRequestAnimationFrame(callback);
1042}
1043
1044function isEventable(obj) {
1045	return obj.attachEvent && obj.detachEvent;
1046}
1047
1048module.exports = {
1049	getSecondsInUnit: getSecondsInUnit,
1050	forEach: forEach,
1051	arrayMap: arrayMap,
1052	arrayFind: arrayFind,
1053	arrayFilter: arrayFilter,
1054	arrayDifference: arrayDifference,
1055	arraySome: arraySome,
1056	hashToArray: hashToArray,
1057	sortArrayOfHash: sortArrayOfHash,
1058	throttle: throttle,
1059	isArray: isArray,
1060	isDate: isDate,
1061	isValidDate: isValidDate,
1062	isStringObject: isStringObject,
1063	isNumberObject: isNumberObject,
1064	isBooleanObject: isBooleanObject,
1065	delay: delay,
1066	objectKeys: objectKeys,
1067	requestAnimationFrame: requestAnimationFrame,
1068	isEventable: isEventable
1069};
1070
1071/***/ }),
1072
1073/***/ "./sources/utils/utils.js":
1074/*!********************************!*\
1075  !*** ./sources/utils/utils.js ***!
1076  \********************************/
1077/*! no static exports found */
1078/***/ (function(module, exports, __webpack_require__) {
1079
1080var helpers = __webpack_require__(/*! ./helpers */ "./sources/utils/helpers.js");
1081
1082function isCustomType(object){
1083	var constructorString = object.constructor.toString();
1084	var plainObjectConstructor = ({}).constructor.toString();
1085
1086	return constructorString !== plainObjectConstructor;
1087}
1088
1089function copy(object) {
1090	var i, result; // iterator, types array, result
1091
1092	if (object && typeof object == "object") {
1093
1094		switch (true){
1095			case (helpers.isDate(object)):
1096				result = new Date(object);
1097				break;
1098			case (helpers.isArray(object)):
1099				result = new Array(object.length);
1100				for(i = 0; i < object.length; i++){
1101					result[i] = copy(object[i]);
1102				}
1103				break;
1104			case (helpers.isStringObject(object)):
1105				result = new String(object);
1106				break;
1107			case (helpers.isNumberObject(object)):
1108				result = new Number(object);
1109				break;
1110			case (helpers.isBooleanObject(object)):
1111				result = new Boolean(object);
1112				break;
1113			default:
1114				if(isCustomType(object)){
1115					result = Object.create(object);
1116				}else{
1117					result = {};
1118				}
1119
1120				for (i in object) {
1121					if (Object.prototype.hasOwnProperty.apply(object, [i]))
1122						result[i] = copy(object[i]);
1123				}
1124			break;
1125		}
1126	}
1127	return result || object;
1128}
1129
1130function mixin (target, source, force){
1131	for (var f in source)
1132		if (((target[f] === undefined) || force)) target[f]=source[f];
1133	return target;
1134}
1135
1136function defined(obj) {
1137	return typeof(obj) != "undefined";
1138}
1139
1140var seed;
1141function uid() {
1142	if (!seed)
1143		seed = (new Date()).valueOf();
1144
1145	seed++;
1146	return seed;
1147}
1148
1149//creates function with specified "this" pointer
1150function bind(functor, object){
1151	if(functor.bind)
1152		return functor.bind(object);
1153	else
1154		return function(){ return functor.apply(object,arguments); };
1155}
1156
1157function event(el, event, handler, capture){
1158	if (el.addEventListener)
1159		el.addEventListener(event, handler, capture === undefined ? false : capture);
1160
1161	else if (el.attachEvent)
1162		el.attachEvent("on"+event, handler);
1163}
1164
1165function eventRemove(el, event, handler, capture){
1166	if (el.removeEventListener)
1167		el.removeEventListener(event, handler, capture === undefined ? false : capture);
1168
1169	else if (el.detachEvent)
1170		el.detachEvent("on"+event, handler);
1171}
1172
1173module.exports = {
1174	copy: copy,
1175	defined: defined,
1176	mixin: mixin,
1177	uid: uid,
1178	bind: bind,
1179	event: event,
1180	eventRemove: eventRemove
1181};
1182
1183/***/ })
1184
1185/******/ });
1186});