https://icontrast.ru/tools/iexModal/iexModal.bundle.js

1(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){
2/*
3 * anime.js v3.2.2
4 * (c) 2023 Julian Garnier
5 * Released under the MIT license
6 * animejs.com
7 */
8
9'use strict';
10
11// Defaults
12
13var defaultInstanceSettings = {
14  update: null,
15  begin: null,
16  loopBegin: null,
17  changeBegin: null,
18  change: null,
19  changeComplete: null,
20  loopComplete: null,
21  complete: null,
22  loop: 1,
23  direction: 'normal',
24  autoplay: true,
25  timelineOffset: 0
26};
27
28var defaultTweenSettings = {
29  duration: 1000,
30  delay: 0,
31  endDelay: 0,
32  easing: 'easeOutElastic(1, .5)',
33  round: 0
34};
35
36var validTransforms = ['translateX', 'translateY', 'translateZ', 'rotate', 'rotateX', 'rotateY', 'rotateZ', 'scale', 'scaleX', 'scaleY', 'scaleZ', 'skew', 'skewX', 'skewY', 'perspective', 'matrix', 'matrix3d'];
37
38// Caching
39
40var cache = {
41  CSS: {},
42  springs: {}
43};
44
45// Utils
46
47function minMax(val, min, max) {
48  return Math.min(Math.max(val, min), max);
49}
50
51function stringContains(str, text) {
52  return str.indexOf(text) > -1;
53}
54
55function applyArguments(func, args) {
56  return func.apply(null, args);
57}
58
59var is = {
60  arr: function (a) { return Array.isArray(a); },
61  obj: function (a) { return stringContains(Object.prototype.toString.call(a), 'Object'); },
62  pth: function (a) { return is.obj(a) && a.hasOwnProperty('totalLength'); },
63  svg: function (a) { return a instanceof SVGElement; },
64  inp: function (a) { return a instanceof HTMLInputElement; },
65  dom: function (a) { return a.nodeType || is.svg(a); },
66  str: function (a) { return typeof a === 'string'; },
67  fnc: function (a) { return typeof a === 'function'; },
68  und: function (a) { return typeof a === 'undefined'; },
69  nil: function (a) { return is.und(a) || a === null; },
70  hex: function (a) { return /(^#[0-9A-F]{6}$)|(^#[0-9A-F]{3}$)/i.test(a); },
71  rgb: function (a) { return /^rgb/.test(a); },
72  hsl: function (a) { return /^hsl/.test(a); },
73  col: function (a) { return (is.hex(a) || is.rgb(a) || is.hsl(a)); },
74  key: function (a) { return !defaultInstanceSettings.hasOwnProperty(a) && !defaultTweenSettings.hasOwnProperty(a) && a !== 'targets' && a !== 'keyframes'; },
75};
76
77// Easings
78
79function parseEasingParameters(string) {
80  var match = /\(([^)]+)\)/.exec(string);
81  return match ? match[1].split(',').map(function (p) { return parseFloat(p); }) : [];
82}
83
84// Spring solver inspired by Webkit Copyright © 2016 Apple Inc. All rights reserved. https://webkit.org/demos/spring/spring.js
85
86function spring(string, duration) {
87
88  var params = parseEasingParameters(string);
89  var mass = minMax(is.und(params[0]) ? 1 : params[0], .1, 100);
90  var stiffness = minMax(is.und(params[1]) ? 100 : params[1], .1, 100);
91  var damping = minMax(is.und(params[2]) ? 10 : params[2], .1, 100);
92  var velocity =  minMax(is.und(params[3]) ? 0 : params[3], .1, 100);
93  var w0 = Math.sqrt(stiffness / mass);
94  var zeta = damping / (2 * Math.sqrt(stiffness * mass));
95  var wd = zeta < 1 ? w0 * Math.sqrt(1 - zeta * zeta) : 0;
96  var a = 1;
97  var b = zeta < 1 ? (zeta * w0 + -velocity) / wd : -velocity + w0;
98
99  function solver(t) {
100    var progress = duration ? (duration * t) / 1000 : t;
101    if (zeta < 1) {
102      progress = Math.exp(-progress * zeta * w0) * (a * Math.cos(wd * progress) + b * Math.sin(wd * progress));
103    } else {
104      progress = (a + b * progress) * Math.exp(-progress * w0);
105    }
106    if (t === 0 || t === 1) { return t; }
107    return 1 - progress;
108  }
109
110  function getDuration() {
111    var cached = cache.springs[string];
112    if (cached) { return cached; }
113    var frame = 1/6;
114    var elapsed = 0;
115    var rest = 0;
116    while(true) {
117      elapsed += frame;
118      if (solver(elapsed) === 1) {
119        rest++;
120        if (rest >= 16) { break; }
121      } else {
122        rest = 0;
123      }
124    }
125    var duration = elapsed * frame * 1000;
126    cache.springs[string] = duration;
127    return duration;
128  }
129
130  return duration ? solver : getDuration;
131
132}
133
134// Basic steps easing implementation https://developer.mozilla.org/fr/docs/Web/CSS/transition-timing-function
135
136function steps(steps) {
137  if ( steps === void 0 ) steps = 10;
138
139  return function (t) { return Math.ceil((minMax(t, 0.000001, 1)) * steps) * (1 / steps); };
140}
141
142// BezierEasing https://github.com/gre/bezier-easing
143
144var bezier = (function () {
145
146  var kSplineTableSize = 11;
147  var kSampleStepSize = 1.0 / (kSplineTableSize - 1.0);
148
149  function A(aA1, aA2) { return 1.0 - 3.0 * aA2 + 3.0 * aA1 }
150  function B(aA1, aA2) { return 3.0 * aA2 - 6.0 * aA1 }
151  function C(aA1)      { return 3.0 * aA1 }
152
153  function calcBezier(aT, aA1, aA2) { return ((A(aA1, aA2) * aT + B(aA1, aA2)) * aT + C(aA1)) * aT }
154  function getSlope(aT, aA1, aA2) { return 3.0 * A(aA1, aA2) * aT * aT + 2.0 * B(aA1, aA2) * aT + C(aA1) }
155
156  function binarySubdivide(aX, aA, aB, mX1, mX2) {
157    var currentX, currentT, i = 0;
158    do {
159      currentT = aA + (aB - aA) / 2.0;
160      currentX = calcBezier(currentT, mX1, mX2) - aX;
161      if (currentX > 0.0) { aB = currentT; } else { aA = currentT; }
162    } while (Math.abs(currentX) >

162 0.0000001 && ++i < 10);
163    return currentT;
164  }
165
166  function newtonRaphsonIterate(aX, aGuessT, mX1, mX2) {
167    for (var i = 0; i < 4; ++i) {
168      var currentSlope = getSlope(aGuessT, mX1, mX2);
169      if (currentSlope === 0.0) { return aGuessT; }
170      var currentX = calcBezier(aGuessT, mX1, mX2) - aX;
171      aGuessT -= currentX / currentSlope;
172    }
173    return aGuessT;
174  }
175
176  function bezier(mX1, mY1, mX2, mY2) {
177
178    if (!(0 <= mX1 && mX1 <= 1 && 0 <= mX2 && mX2 <= 1)) { return; }
179    var sampleValues = new Float32Array(kSplineTableSize);
180
181    if (mX1 !== mY1 || mX2 !== mY2) {
182      for (var i = 0; i < kSplineTableSize; ++i) {
183        sampleValues[i] = calcBezier(i * kSampleStepSize, mX1, mX2);
184      }
185    }
186
187    function getTForX(aX) {
188
189      var intervalStart = 0;
190      var currentSample = 1;
191      var lastSample = kSplineTableSize - 1;
192
193      for (; currentSample !== lastSample && sampleValues[currentSample] <= aX; ++currentSample) {
194        intervalStart += kSampleStepSize;
195      }
196
197      --currentSample;
198
199      var dist = (aX - sampleValues[currentSample]) / (sampleValues[currentSample + 1] - sampleValues[currentSample]);
200      var guessForT = intervalStart + dist * kSampleStepSize;
201      var initialSlope = getSlope(guessForT, mX1, mX2);
202
203      if (initialSlope >= 0.001) {
204        return newtonRaphsonIterate(aX, guessForT, mX1, mX2);
205      } else if (initialSlope === 0.0) {
206        return guessForT;
207      } else {
208        return binarySubdivide(aX, intervalStart, intervalStart + kSampleStepSize, mX1, mX2);
209      }
210
211    }
212
213    return function (x) {
214      if (mX1 === mY1 && mX2 === mY2) { return x; }
215      if (x === 0 || x === 1) { return x; }
216      return calcBezier(getTForX(x), mY1, mY2);
217    }
218
219  }
220
221  return bezier;
222
223})();
224
225var penner = (function () {
226
227  // Based on jQuery UI's implemenation of easing equations from Robert Penner (http://www.robertpenner.com/easing)
228
229  var eases = { linear: function () { return function (t) { return t; }; } };
230
231  var functionEasings = {
232    Sine: function () { return function (t) { return 1 - Math.cos(t * Math.PI / 2); }; },
233    Expo: function () { return function (t) { return t ? Math.pow(2, 10 * t - 10) : 0; }; },
234    Circ: function () { return function (t) { return 1 - Math.sqrt(1 - t * t); }; },
235    Back: function () { return function (t) { return t * t * (3 * t - 2); }; },
236    Bounce: function () { return function (t) {
237      var pow2, b = 4;
238      while (t < (( pow2 = Math.pow(2, --b)) - 1) / 11) {}
239      return 1 / Math.pow(4, 3 - b) - 7.5625 * Math.pow(( pow2 * 3 - 2 ) / 22 - t, 2)
240    }; },
241    Elastic: function (amplitude, period) {
242      if ( amplitude === void 0 ) amplitude = 1;
243      if ( period === void 0 ) period = .5;
244
245      var a = minMax(amplitude, 1, 10);
246      var p = minMax(period, .1, 2);
247      return function (t) {
248        return (t === 0 || t === 1) ? t : 
249          -a * Math.pow(2, 10 * (t - 1)) * Math.sin((((t - 1) - (p / (Math.PI * 2) * Math.asin(1 / a))) * (Math.PI * 2)) / p);
250      }
251    }
252  };
253
254  var baseEasings = ['Quad', 'Cubic', 'Quart', 'Quint'];
255
256  baseEasings.forEach(function (name, i) {
257    functionEasings[name] = function () { return function (t) { return Math.pow(t, i + 2); }; };
258  });
259
260  Object.keys(functionEasings).forEach(function (name) {
261    var easeIn = functionEasings[name];
262    eases['easeIn' + name] = easeIn;
263    eases['easeOut' + name] = function (a, b) { return function (t) { return 1 - easeIn(a, b)(1 - t); }; };
264    eases['easeInOut' + name] = function (a, b) { return function (t) { return t < 0.5 ? easeIn(a, b)(t * 2) / 2 : 
265      1 - easeIn(a, b)(t * -2 + 2) / 2; }; };
266    eases['easeOutIn' + name] = function (a, b) { return function (t) { return t < 0.5 ? (1 - easeIn(a, b)(1 - t * 2)) / 2 : 
267      (easeIn(a, b)(t * 2 - 1) + 1) / 2; }; };
268  });
269
270  return eases;
271
272})();
273
274function parseEasings(easing, duration) {
275  if (is.fnc(easing)) { return easing; }
276  var name = easing.split('(')[0];
277  var ease = penner[name];
278  var args = parseEasingParameters(easing);
279  switch (name) {
280    case 'spring' : return spring(easing, duration);
281    case 'cubicBezier' : return applyArguments(bezier, args);
282    case 'steps' : return applyArguments(steps, args);
283    default : return applyArguments(ease, args);
284  }
285}
286
287// Strings
288

289function selectString(str) {
290  try {
291    var nodes = document.querySelectorAll(str);
292    return nodes;
293  } catch(e) {
294    return;
295  }
296}
297
298// Arrays
299
300function filterArray(arr, callback) {
301  var len = arr.length;
302  var thisArg = arguments.length >= 2 ? arguments[1] : void 0;
303  var result = [];
304  for (var i = 0; i < len; i++) {
305    if (i in arr) {
306      var val = arr[i];
307      if (callback.call(thisArg, val, i, arr)) {
308        result.push(val);
309      }
310    }
311  }
312  return result;
313}
314
315function flattenArray(arr) {
316  return arr.reduce(function (a, b) { return a.concat(is.arr(b) ? flattenArray(b) : b); }, []);
317}
318
319function toArray(o) {
320  if (is.arr(o)) { return o; }
321  if (is.str(o)) { o = selectString(o) || o; }
322  if (o instanceof NodeList || o instanceof HTMLCollection) { return [].slice.call(o); }
323  return [o];
324}
325
326function arrayContains(arr, val) {
327  return arr.some(function (a) { return a === val; });
328}
329
330// Objects
331
332function cloneObject(o) {
333  var clone = {};
334  for (var p in o) { clone[p] = o[p]; }
335  return clone;
336}
337
338function replaceObjectProps(o1, o2) {
339  var o = cloneObject(o1);
340  for (var p in o1) { o[p] = o2.hasOwnProperty(p) ? o2[p] : o1[p]; }
341  return o;
342}
343
344function mergeObjects(o1, o2) {
345  var o = cloneObject(o1);
346  for (var p in o2) { o[p] = is.und(o1[p]) ? o2[p] : o1[p]; }
347  return o;
348}
349
350// Colors
351
352function rgbToRgba(rgbValue) {
353  var rgb = /rgb\((\d+,\s*[\d]+,\s*[\d]+)\)/g.exec(rgbValue);
354  return rgb ? ("rgba(" + (rgb[1]) + ",1)") : rgbValue;
355}
356
357function hexToRgba(hexValue) {
358  var rgx = /^#?([a-f\d])([a-f\d])([a-f\d])$/i;
359  var hex = hexValue.replace(rgx, function (m, r, g, b) { return r + r + g + g + b + b; } );
360  var rgb = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
361  var r = parseInt(rgb[1], 16);
362  var g = parseInt(rgb[2], 16);
363  var b = parseInt(rgb[3], 16);
364  return ("rgba(" + r + "," + g + "," + b + ",1)");
365}
366
367function hslToRgba(hslValue) {
368  var hsl = /hsl\((\d+),\s*([\d.]+)%,\s*([\d.]+)%\)/g.exec(hslValue) || /hsla\((\d+),\s*([\d.]+)%,\s*([\d.]+)%,\s*([\d.]+)\)/g.exec(hslValue);
369  var h = parseInt(hsl[1], 10) / 360;
370  var s = parseInt(hsl[2], 10) / 100;
371  var l = parseInt(hsl[3], 10) / 100;
372  var a = hsl[4] || 1;
373  function hue2rgb(p, q, t) {
374    if (t < 0) { t += 1; }
375    if (t > 1) { t -= 1; }
376    if (t < 1/6) { return p + (q - p) * 6 * t; }
377    if (t < 1/2) { return q; }
378    if (t < 2/3) { return p + (q - p) * (2/3 - t) * 6; }
379    return p;
380  }
381  var r, g, b;
382  if (s == 0) {
383    r = g = b = l;
384  } else {
385    var q = l < 0.5 ? l * (1 + s) : l + s - l * s;
386    var p = 2 * l - q;
387    r = hue2rgb(p, q, h + 1/3);
388    g = hue2rgb(p, q, h);
389    b = hue2rgb(p, q, h - 1/3);
390  }
391  return ("rgba(" + (r * 255) + "," + (g * 255) + "," + (b * 255) + "," + a + ")");
392}
393
394function colorToRgb(val) {
395  if (is.rgb(val)) { return rgbToRgba(val); }
396  if (is.hex(val)) { return hexToRgba(val); }
397  if (is.hsl(val)) { return hslToRgba(val); }
398}
399
400// Units
401
402function getUnit(val) {
403  var split = /[+-]?\d*\.?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?(%|px|pt|em|rem|in|cm|mm|ex|ch|pc|vw|vh|vmin|vmax|deg|rad|turn)?$/.exec(val);
404  if (split) { return split[1]; }
405}
406
407function getTransformUnit(propName) {
408  if (stringContains(propName, 'translate') || propName === 'perspective') { return 'px'; }
409  if (stringContains(propName, 'rotate') || stringContains(propName, 'skew')) { return 'deg'; }
410}
411
412// Values
413
414function getFunctionValue(val, animatable) {
415  if (!is.fnc(val)) { return val; }
416  return val(animatable.target, animatable.id, animatable.total);
417}
418
419function getAttribute(el, prop) {
420  return el.getAttribute(prop);
421}
422
423function convertPxToUnit(el, value, unit) {
424  var valueUnit = getUnit(value);
425  if (arrayContains([unit, 'deg', 'rad', 'turn'], valueUnit)) { return value; }
426  var cached = cache.CSS[value + unit];
427  if (!is.und(cached)) { return cached; }
428  var baseline = 100;
429  var tempEl = document.createElement(el.tagName);
430  var parentEl = (el.parentNode && (el.parentNode !== document)) ? el.parentNode : document.body;
431  parentEl.appendChild(tempEl);
432  tempEl.style.position = 'absolute';
433  tempEl.style.width = baseline + unit;
434  var factor = baseline / tempEl.offsetWidth;
435  parentEl.removeChild(tempEl);
436  var convertedUnit = factor * parseFloat(value);
437  cache.CSS[value + unit] = convertedUnit;
438  return convertedUnit;
439}
440
441function getCSSValue(el, prop, unit) {
442  if (prop in el.style) {
443    var uppercasePropName = prop.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
444    var value = el.style[prop] || getComputedStyle(el).getPropertyValue(uppercasePropName) || '0';
445    return unit ? convertPxToUnit(el, value, unit) : value;
446  }
447}
448
449function getAnimationType(el, prop) {
450  if (is.dom(el) && !is.inp(el) && (!is.nil(getAttribute(el, prop)) || (is.svg(el) && el[prop]))) { return 'attribute'; }
451  if (is.dom(el) && arrayContains(validTransforms, prop)) { return 'transform'; }
452  if (is.dom(el) && (prop !== 'transform' && getCSSValue(el, prop))) { return 'css'; }
453  if (el[prop] != null) { return 'object'; }
454}
455
456function getElementTransforms(el) {
457  if (!is.dom(el)) { return; }
458  var str = el.style.transform || '';
459  var reg  = /(\w+)\(([^)]*)\)/g;
460  var transforms = new Map();
461  var m; while (m = reg.exec(str)) { transforms.set(m[1], m[2]); }
462  return transforms;
463}
464
465function getTransformValue(el, propName, animatable, unit) {
466  var defaultVal = stringContains(propName, 'scale') ? 1 : 0 + getTransformUnit(propName);
467  var value = getElementTransforms(el).get(propName) || defaultVal;
468  if (animatable) {
469    animatable.transforms.list.set(propName, value);
470    animatable.transforms['last'] = propName;
471  }
472  return unit ? convertPxToUnit(el, value, unit) : value;
473}
474
475function getOriginalTargetValue(target, propName, unit, animatable) {
476  switch (getAnimationType(target, propName)) {
477    case 'transform': return getTransformValue(target, propName, animatable, unit);
478    case 'css': return getCSSValue(target, propName, unit);
479    case 'attribute': return getAttribute(target, propName);
480    default: return target[propName] || 0;
481  }
482}
483
484function getRelativeValue(to, from) {
485  var operator = /^(\*=|\+=|-=)/.exec(to);
486  if (!operator) { return to; }
487  var u = getUnit(to) || 0;
488  var x = parseFloat(from);
489  var y = parseFloat(to.replace(operator[0], ''));
490  switch (operator[0][0]) {
491    case '+': return x + y + u;
492    case '-': return x - y + u;
493    case '*': return x * y + u;
494  }
495}
496
497function validateValue(val, unit) {
498  if (is.col(val)) { return colorToRgb(val); }
499  if (/\s/g.test(val)) { return val; }
500  var originalUnit = getUnit(val);
501  var unitLess = originalUnit ? val.substr(0, val.length - originalUnit.length) : val;
502  if (unit) { return unitLess + unit; }
503  return unitLess;
504}
505
506// getTotalLength() equivalent for circle, rect, polyline, polygon and line shapes
507// adapted from https://gist.github.com/SebLambla/3e0550c496c236709744
508
509function getDistance(p1, p2) {
510  return Math.sqrt(Math.pow(p2.x - p1.x, 2) + Math.pow(p2.y - p1.y, 2));
511}
512
513function getCircleLength(el) {
514  return Math.PI * 2 * getAttribute(el, 'r');
515}
516
517function getRectLength(el) {
518  return (getAttribute(el, 'width') * 2) + (getAttribute(el, 'height') * 2);
519}
520
521function getLineLength(el) {
522  return getDistance(
523    {x: getAttribute(el, 'x1'), y: getAttribute(el, 'y1')}, 
524    {x: getAttribute(el, 'x2'), y: getAttribute(el, 'y2')}
525  );
526}
527
528function getPolylineLength(el) {
529  var points = el.points;
530  var totalLength = 0;
531  var previousPos;
532  for (var i = 0 ; i < points.numberOfItems; i++) {
533    var currentPos = points.getItem(i);
534    if (i > 0) { totalLength += getDistance(previousPos, currentPos); }
535    previousPos = currentPos;
536  }
537  return totalLength;
538}
539
540function getPolygonLength(el) {
541  var points = el.points;
542  return getPolylineLength(el) + getDistance(points.getItem(points.numberOfItems - 1), points.getItem(0));
543}
544
545// Path animation
546
547function getTotalLength(el) {
548  if (el.getTotalLength) { return el.getTotalLength(); }
549  switch(el.tagName.toLowerCase()) {
550    case 'circle': return getCircleLength(el);
551    case 'rect': return getRectLength(el);
552    case 'line': return getLineLength(el);
553    case 'polyline': return getPolylineLength(el);
554    case 'polygon': return getPolygonLength(el);
555  }
556}
557
558function setDashoffset(el) {
559  var pathLength = getTotalLength(el);
560  el.setAttribute('stroke-dasharray', pathLength);
561  return pathLength;
562}
563
564// Motion path
565
566function getParentSvgEl(el) {
567  var parentEl = el.parentNode;
568  while (is.svg(parentEl)) {
569    if (!is.svg(parentEl.parentNode)) { break; }
570    parentEl = parentEl.parentNode;
571  }
572  return parentEl;
573}
574
575function getParentSvg(pathEl, svgData) {
576  var svg = svgData || {};
577  var parentSvgEl = svg.el || getParentSvgEl(pathEl);
578  var rect = parentSvgEl.getBoundingClientRect();
579  var viewBoxAttr = getAttribute(parentSvgEl, 'viewBox');
580  var width = rect.width;
581  var height = rect.height;

582  var viewBox = svg.viewBox || (viewBoxAttr ? viewBoxAttr.split(' ') : [0, 0, width, height]);
583  return {
584    el: parentSvgEl,
585    viewBox: viewBox,
586    x: viewBox[0] / 1,
587    y: viewBox[1] / 1,
588    w: width,
589    h: height,
590    vW: viewBox[2],
591    vH: viewBox[3]
592  }
593}
594
595function getPath(path, percent) {
596  var pathEl = is.str(path) ? selectString(path)[0] : path;
597  var p = percent || 100;
598  return function(property) {
599    return {
600      property: property,
601      el: pathEl,
602      svg: getParentSvg(pathEl),
603      totalLength: getTotalLength(pathEl) * (p / 100)
604    }
605  }
606}
607
608function getPathProgress(path, progress, isPathTargetInsideSVG) {
609  function point(offset) {
610    if ( offset === void 0 ) offset = 0;
611
612    var l = progress + offset >= 1 ? progress + offset : 0;
613    return path.el.getPointAtLength(l);
614  }
615  var svg = getParentSvg(path.el, path.svg);
616  var p = point();
617  var p0 = point(-1);
618  var p1 = point(+1);
619  var scaleX = isPathTargetInsideSVG ? 1 : svg.w / svg.vW;
620  var scaleY = isPathTargetInsideSVG ? 1 : svg.h / svg.vH;
621  switch (path.property) {
622    case 'x': return (p.x - svg.x) * scaleX;
623    case 'y': return (p.y - svg.y) * scaleY;
624    case 'angle': return Math.atan2(p1.y - p0.y, p1.x - p0.x) * 180 / Math.PI;
625  }
626}
627
628// Decompose value
629
630function decomposeValue(val, unit) {
631  // const rgx = /-?\d*\.?\d+/g; // handles basic numbers
632  // const rgx = /[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?/g; // handles exponents notation
633  var rgx = /[+-]?\d*\.?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?/g; // handles exponents notation
634  var value = validateValue((is.pth(val) ? val.totalLength : val), unit) + '';
635  return {
636    original: value,
637    numbers: value.match(rgx) ? value.match(rgx).map(Number) : [0],
638    strings: (is.str(val) || unit) ? value.split(rgx) : []
639  }
640}
641
642// Animatables
643
644function parseTargets(targets) {
645  var targetsArray = targets ? (flattenArray(is.arr(targets) ? targets.map(toArray) : toArray(targets))) : [];
646  return filterArray(targetsArray, function (item, pos, self) { return self.indexOf(item) === pos; });
647}
648
649function getAnimatables(targets) {
650  var parsed = parseTargets(targets);
651  return parsed.map(function (t, i) {
652    return {target: t, id: i, total: parsed.length, transforms: { list: getElementTransforms(t) } };
653  });
654}
655
656// Properties
657
658function normalizePropertyTweens(prop, tweenSettings) {
659  var settings = cloneObject(tweenSettings);
660  // Override duration if easing is a spring
661  if (/^spring/.test(settings.easing)) { settings.duration = spring(settings.easing); }
662  if (is.arr(prop)) {
663    var l = prop.length;
664    var isFromTo = (l === 2 && !is.obj(prop[0]));
665    if (!isFromTo) {
666      // Duration divided by the number of tweens
667      if (!is.fnc(tweenSettings.duration)) { settings.duration = tweenSettings.duration / l; }
668    } else {
669      // Transform [from, to] values shorthand to a valid tween value
670      prop = {value: prop};
671    }
672  }
673  var propArray = is.arr(prop) ? prop : [prop];
674  return propArray.map(function (v, i) {
675    var obj = (is.obj(v) && !is.pth(v)) ? v : {value: v};
676    // Default delay value should only be applied to the first tween
677    if (is.und(obj.delay)) { obj.delay = !i ? tweenSettings.delay : 0; }
678    // Default endDelay value should only be applied to the last tween
679    if (is.und(obj.endDelay)) { obj.endDelay = i === propArray.length - 1 ? tweenSettings.endDelay : 0; }
680    return obj;
681  }).map(function (k) { return mergeObjects(k, settings); });
682}
683
684
685function flattenKeyframes(keyframes) {
686  var propertyNames = filterArray(flattenArray(keyframes.map(function (key) { return Object.keys(key); })), function (p) { return is.key(p); })
687  .reduce(function (a,b) { if (a.indexOf(b) < 0) { a.push(b); } return a; }, []);
688  var properties = {};
689  var loop = function ( i ) {
690    var propName = propertyNames[i];
691    properties[propName] = keyframes.map(function (key) {
692      var newKey = {};
693      for (var p in key) {
694        if (is.key(p)) {
695          if (p == propName) { newKey.value = key[p]; }
696        } else {
697          newKey[p] = key[p];
698        }
699      }
700      return newKey;
701    });
702  };
703
704  for (var i = 0; i < propertyNames.length; i++) loop( i );
705  return properties;
706}
707

708function getProperties(tweenSettings, params) {
709  var properties = [];
710  var keyframes = params.keyframes;
711  if (keyframes) { params = mergeObjects(flattenKeyframes(keyframes), params); }
712  for (var p in params) {
713    if (is.key(p)) {
714      properties.push({
715        name: p,
716        tweens: normalizePropertyTweens(params[p], tweenSettings)
717      });
718    }
719  }
720  return properties;
721}
722
723// Tweens
724
725function normalizeTweenValues(tween, animatable) {
726  var t = {};
727  for (var p in tween) {
728    var value = getFunctionValue(tween[p], animatable);
729    if (is.arr(value)) {
730      value = value.map(function (v) { return getFunctionValue(v, animatable); });
731      if (value.length === 1) { value = value[0]; }
732    }
733    t[p] = value;
734  }
735  t.duration = parseFloat(t.duration);
736  t.delay = parseFloat(t.delay);
737  return t;
738}
739
740function normalizeTweens(prop, animatable) {
741  var previousTween;
742  return prop.tweens.map(function (t) {
743    var tween = normalizeTweenValues(t, animatable);
744    var tweenValue = tween.value;
745    var to = is.arr(tweenValue) ? tweenValue[1] : tweenValue;
746    var toUnit = getUnit(to);
747    var originalValue = getOriginalTargetValue(animatable.target, prop.name, toUnit, animatable);
748    var previousValue = previousTween ? previousTween.to.original : originalValue;
749    var from = is.arr(tweenValue) ? tweenValue[0] : previousValue;
750    var fromUnit = getUnit(from) || getUnit(originalValue);
751    var unit = toUnit || fromUnit;
752    if (is.und(to)) { to = previousValue; }
753    tween.from = decomposeValue(from, unit);
754    tween.to = decomposeValue(getRelativeValue(to, from), unit);
755    tween.start = previousTween ? previousTween.end : 0;
756    tween.end = tween.start + tween.delay + tween.duration + tween.endDelay;
757    tween.easing = parseEasings(tween.easing, tween.duration);
758    tween.isPath = is.pth(tweenValue);
759    tween.isPathTargetInsideSVG = tween.isPath && is.svg(animatable.target);
760    tween.isColor = is.col(tween.from.original);
761    if (tween.isColor) { tween.round = 1; }
762    previousTween = tween;
763    return tween;
764  });
765}
766
767// Tween progress
768
769var setProgressValue = {
770  css: function (t, p, v) { return t.style[p] = v; },
771  attribute: function (t, p, v) { return t.setAttribute(p, v); },
772  object: function (t, p, v) { return t[p] = v; },
773  transform: function (t, p, v, transforms, manual) {
774    transforms.list.set(p, v);
775    if (p === transforms.last || manual) {
776      var str = '';
777      transforms.list.forEach(function (value, prop) { str += prop + "(" + value + ") "; });
778      t.style.transform = str;
779    }
780  }
781};
782
783// Set Value helper
784
785function setTargetsValue(targets, properties) {
786  var animatables = getAnimatables(targets);
787  animatables.forEach(function (animatable) {
788    for (var property in properties) {
789      var value = getFunctionValue(properties[property], animatable);
790      var target = animatable.target;
791      var valueUnit = getUnit(value);
792      var originalValue = getOriginalTargetValue(target, property, valueUnit, animatable);
793      var unit = valueUnit || getUnit(originalValue);
794      var to = getRelativeValue(validateValue(value, unit), originalValue);
795      var animType = getAnimationType(target, property);
796      setProgressValue[animType](target, property, to, animatable.transforms, true);
797    }
798  });
799}
800
801// Animations
802
803function createAnimation(animatable, prop) {
804  var animType = getAnimationType(animatable.target, prop.name);
805  if (animType) {
806    var tweens = normalizeTweens(prop, animatable);
807    var lastTween = tweens[tweens.length - 1];
808    return {
809      type: animType,
810      property: prop.name,
811      animatable: animatable,
812      tweens: tweens,
813      duration: lastTween.end,
814      delay: tweens[0].delay,
815      endDelay: lastTween.endDelay
816    }
817  }
818}
819
820function getAnimations(animatables, properties) {
821  return filterArray(flattenArray(animatables.map(function (animatable) {
822    return properties.map(function (prop) {
823      return createAnimation(animatable, prop);
824    });
825  })), function (a) { return !is.und(a); });
826}
827
828// Create Instance
829
830function getInstanceTimings(animations, tweenSettings) {
831  var animLength = animations.length;
832  var getTlOffset = function (anim) { return anim.timelineOffset ? anim.timelineOffset : 0; };
833  var timings = {};
834  timings.duration = animLength ? Math.max.apply(Math, animations.map(function (anim) { return getTlOffset(anim) + anim.duration; }

834)) : tweenSettings.duration;
835  timings.delay = animLength ? Math.min.apply(Math, animations.map(function (anim) { return getTlOffset(anim) + anim.delay; })) : tweenSettings.delay;
836  timings.endDelay = animLength ? timings.duration - Math.max.apply(Math, animations.map(function (anim) { return getTlOffset(anim) + anim.duration - anim.endDelay; })) : tweenSettings.endDelay;
837  return timings;
838}
839
840var instanceID = 0;
841
842function createNewInstance(params) {
843  var instanceSettings = replaceObjectProps(defaultInstanceSettings, params);
844  var tweenSettings = replaceObjectProps(defaultTweenSettings, params);
845  var properties = getProperties(tweenSettings, params);
846  var animatables = getAnimatables(params.targets);
847  var animations = getAnimations(animatables, properties);
848  var timings = getInstanceTimings(animations, tweenSettings);
849  var id = instanceID;
850  instanceID++;
851  return mergeObjects(instanceSettings, {
852    id: id,
853    children: [],
854    animatables: animatables,
855    animations: animations,
856    duration: timings.duration,
857    delay: timings.delay,
858    endDelay: timings.endDelay
859  });
860}
861
862// Core
863
864var activeInstances = [];
865
866var engine = (function () {
867  var raf;
868
869  function play() {
870    if (!raf && (!isDocumentHidden() || !anime.suspendWhenDocumentHidden) && activeInstances.length > 0) {
871      raf = requestAnimationFrame(step);
872    }
873  }
874  function step(t) {
875    // memo on algorithm issue:
876    // dangerous iteration over mutable `activeInstances`
877    // (that collection may be updated from within callbacks of `tick`-ed animation instances)
878    var activeInstancesLength = activeInstances.length;
879    var i = 0;
880    while (i < activeInstancesLength) {
881      var activeInstance = activeInstances[i];
882      if (!activeInstance.paused) {
883        activeInstance.tick(t);
884        i++;
885      } else {
886        activeInstances.splice(i, 1);
887        activeInstancesLength--;
888      }
889    }
890    raf = i > 0 ? requestAnimationFrame(step) : undefined;
891  }
892
893  function handleVisibilityChange() {
894    if (!anime.suspendWhenDocumentHidden) { return; }
895
896    if (isDocumentHidden()) {
897      // suspend ticks
898      raf = cancelAnimationFrame(raf);
899    } else { // is back to active tab
900      // first adjust animations to consider the time that ticks were suspended
901      activeInstances.forEach(
902        function (instance) { return instance ._onDocumentVisibility(); }
903      );
904      engine();
905    }
906  }
907  if (typeof document !== 'undefined') {
908    document.addEventListener('visibilitychange', handleVisibilityChange);
909  }
910
911  return play;
912})();
913
914function isDocumentHidden() {
915  return !!document && document.hidden;
916}
917
918// Public Instance
919
920function anime(params) {
921  if ( params === void 0 ) params = {};
922
923
924  var startTime = 0, lastTime = 0, now = 0;
925  var children, childrenLength = 0;
926  var resolve = null;
927
928  function makePromise(instance) {
929    var promise = window.Promise && new Promise(function (_resolve) { return resolve = _resolve; });
930    instance.finished = promise;
931    return promise;
932  }
933
934  var instance = createNewInstance(params);
935  var promise = makePromise(instance);
936
937  function toggleInstanceDirection() {
938    var direction = instance.direction;
939    if (direction !== 'alternate') {
940      instance.direction = direction !== 'normal' ? 'normal' : 'reverse';
941    }
942    instance.reversed = !instance.reversed;
943    children.forEach(function (child) { return child.reversed = instance.reversed; });
944  }
945
946  function adjustTime(time) {
947    return instance.reversed ? instance.duration - time : time;
948  }
949
950  function resetTime() {
951    startTime = 0;
952    lastTime = adjustTime(instance.currentTime) * (1 / anime.speed);
953  }
954
955  function seekChild(time, child) {
956    if (child) { child.seek(time - child.timelineOffset); }
957  }
958
959  function syncInstanceChildren(time) {
960    if (!instance.reversePlayback) {
961      for (var i = 0; i < childrenLength; i++) { seekChild(time, children[i]); }
962    } else {
963      for (var i$1 = childrenLength; i$1--;) { seekChild(time, children[i$1]); }
964    }
965  }
966
967  function setAnimationsProgress(insTime) {
968    var i = 0;
969    var animations = instance.animations;
970    var animationsLength = animations.length;
971    while (i < animationsLength) {
972      var anim = animations[i];
973      var animatable = anim.animatable;
974      var tweens = anim.tweens;
975      var tweenLength = tweens.length - 1;
976      var tween = tweens[tweenLength];
977      // Only check for keyframes if there is more than one tween
978      if (tweenLength) { tween = filterArray(tweens, function (t) { return (insTime < t.end); })[0] || tween; }

979      var elapsed = minMax(insTime - tween.start - tween.delay, 0, tween.duration) / tween.duration;
980      var eased = isNaN(elapsed) ? 1 : tween.easing(elapsed);
981      var strings = tween.to.strings;
982      var round = tween.round;
983      var numbers = [];
984      var toNumbersLength = tween.to.numbers.length;
985      var progress = (void 0);
986      for (var n = 0; n < toNumbersLength; n++) {
987        var value = (void 0);
988        var toNumber = tween.to.numbers[n];
989        var fromNumber = tween.from.numbers[n] || 0;
990        if (!tween.isPath) {
991          value = fromNumber + (eased * (toNumber - fromNumber));
992        } else {
993          value = getPathProgress(tween.value, eased * toNumber, tween.isPathTargetInsideSVG);
994        }
995        if (round) {
996          if (!(tween.isColor && n > 2)) {
997            value = Math.round(value * round) / round;
998          }
999        }
1000        numbers.push(value);
1001      }
1002      // Manual Array.reduce for better performances
1003      var stringsLength = strings.length;
1004      if (!stringsLength) {
1005        progress = numbers[0];
1006      } else {
1007        progress = strings[0];
1008        for (var s = 0; s < stringsLength; s++) {
1009          var a = strings[s];
1010          var b = strings[s + 1];
1011          var n$1 = numbers[s];
1012          if (!isNaN(n$1)) {
1013            if (!b) {
1014              progress += n$1 + ' ';
1015            } else {
1016              progress += n$1 + b;
1017            }
1018          }
1019        }
1020      }
1021      setProgressValue[anim.type](animatable.target, anim.property, progress, animatable.transforms);
1022      anim.currentValue = progress;
1023      i++;
1024    }
1025  }
1026
1027  function setCallback(cb) {
1028    if (instance[cb] && !instance.passThrough) { instance[cb](instance); }
1029  }
1030
1031  function countIteration() {
1032    if (instance.remaining && instance.remaining !== true) {
1033      instance.remaining--;
1034    }
1035  }
1036
1037  function setInstanceProgress(engineTime) {
1038    var insDuration = instance.duration;
1039    var insDelay = instance.delay;
1040    var insEndDelay = insDuration - instance.endDelay;
1041    var insTime = adjustTime(engineTime);
1042    instance.progress = minMax((insTime / insDuration) * 100, 0, 100);
1043    instance.reversePlayback = insTime < instance.currentTime;
1044    if (children) { syncInstanceChildren(insTime); }
1045    if (!instance.began && instance.currentTime > 0) {
1046      instance.began = true;
1047      setCallback('begin');
1048    }
1049    if (!instance.loopBegan && instance.currentTime > 0) {
1050      instance.loopBegan = true;
1051      setCallback('loopBegin');
1052    }
1053    if (insTime <= insDelay && instance.currentTime !== 0) {
1054      setAnimationsProgress(0);
1055    }
1056    if ((insTime >= insEndDelay && instance.currentTime !== insDuration) || !insDuration) {
1057      setAnimationsProgress(insDuration);
1058    }
1059    if (insTime > insDelay && insTime < insEndDelay) {
1060      if (!instance.changeBegan) {
1061        instance.changeBegan = true;
1062        instance.changeCompleted = false;
1063        setCallback('changeBegin');
1064      }
1065      setCallback('change');
1066      setAnimationsProgress(insTime);
1067    } else {
1068      if (instance.changeBegan) {
1069        instance.changeCompleted = true;
1070        instance.changeBegan = false;
1071        setCallback('changeComplete');
1072      }
1073    }
1074    instance.currentTime = minMax(insTime, 0, insDuration);
1075    if (instance.began) { setCallback('update'); }
1076    if (engineTime >= insDuration) {
1077      lastTime = 0;
1078      countIteration();
1079      if (!instance.remaining) {
1080        instance.paused = true;
1081        if (!instance.completed) {
1082          instance.completed = true;
1083          setCallback('loopComplete');
1084          setCallback('complete');
1085          if (!instance.passThrough && 'Promise' in window) {
1086            resolve();
1087            promise = makePromise(instance);
1088          }
1089        }
1090      } else {
1091        startTime = now;
1092        setCallback('loopComplete');
1093        instance.loopBegan = false;
1094        if (instance.direction === 'alternate') {
1095          toggleInstanceDirection();
1096        }
1097      }
1098    }
1099  }
1100
1101  instance.reset = function() {
1102    var direction = instance.direction;
1103    instance.passThrough = false;
1104    instance.currentTime = 0;
1105    instance.progress = 0;
1106    instance.paused = true;

1107    instance.began = false;
1108    instance.loopBegan = false;
1109    instance.changeBegan = false;
1110    instance.completed = false;
1111    instance.changeCompleted = false;
1112    instance.reversePlayback = false;
1113    instance.reversed = direction === 'reverse';
1114    instance.remaining = instance.loop;
1115    children = instance.children;
1116    childrenLength = children.length;
1117    for (var i = childrenLength; i--;) { instance.children[i].reset(); }
1118    if (instance.reversed && instance.loop !== true || (direction === 'alternate' && instance.loop === 1)) { instance.remaining++; }
1119    setAnimationsProgress(instance.reversed ? instance.duration : 0);
1120  };
1121
1122  // internal method (for engine) to adjust animation timings before restoring engine ticks (rAF)
1123  instance._onDocumentVisibility = resetTime;
1124
1125  // Set Value helper
1126
1127  instance.set = function(targets, properties) {
1128    setTargetsValue(targets, properties);
1129    return instance;
1130  };
1131
1132  instance.tick = function(t) {
1133    now = t;
1134    if (!startTime) { startTime = now; }
1135    setInstanceProgress((now + (lastTime - startTime)) * anime.speed);
1136  };
1137
1138  instance.seek = function(time) {
1139    setInstanceProgress(adjustTime(time));
1140  };
1141
1142  instance.pause = function() {
1143    instance.paused = true;
1144    resetTime();
1145  };
1146
1147  instance.play = function() {
1148    if (!instance.paused) { return; }
1149    if (instance.completed) { instance.reset(); }
1150    instance.paused = false;
1151    activeInstances.push(instance);
1152    resetTime();
1153    engine();
1154  };
1155
1156  instance.reverse = function() {
1157    toggleInstanceDirection();
1158    instance.completed = instance.reversed ? false : true;
1159    resetTime();
1160  };
1161
1162  instance.restart = function() {
1163    instance.reset();
1164    instance.play();
1165  };
1166
1167  instance.remove = function(targets) {
1168    var targetsArray = parseTargets(targets);
1169    removeTargetsFromInstance(targetsArray, instance);
1170  };
1171
1172  instance.reset();
1173
1174  if (instance.autoplay) { instance.play(); }
1175
1176  return instance;
1177
1178}
1179
1180// Remove targets from animation
1181
1182function removeTargetsFromAnimations(targetsArray, animations) {
1183  for (var a = animations.length; a--;) {
1184    if (arrayContains(targetsArray, animations[a].animatable.target)) {
1185      animations.splice(a, 1);
1186    }
1187  }
1188}
1189
1190function removeTargetsFromInstance(targetsArray, instance) {
1191  var animations = instance.animations;
1192  var children = instance.children;
1193  removeTargetsFromAnimations(targetsArray, animations);
1194  for (var c = children.length; c--;) {
1195    var child = children[c];
1196    var childAnimations = child.animations;
1197    removeTargetsFromAnimations(targetsArray, childAnimations);
1198    if (!childAnimations.length && !child.children.length) { children.splice(c, 1); }
1199  }
1200  if (!animations.length && !children.length) { instance.pause(); }
1201}
1202
1203function removeTargetsFromActiveInstances(targets) {
1204  var targetsArray = parseTargets(targets);
1205  for (var i = activeInstances.length; i--;) {
1206    var instance = activeInstances[i];
1207    removeTargetsFromInstance(targetsArray, instance);
1208  }
1209}
1210
1211// Stagger helpers
1212
1213function stagger(val, params) {
1214  if ( params === void 0 ) params = {};
1215
1216  var direction = params.direction || 'normal';
1217  var easing = params.easing ? parseEasings(params.easing) : null;
1218  var grid = params.grid;
1219  var axis = params.axis;
1220  var fromIndex = params.from || 0;
1221  var fromFirst = fromIndex === 'first';
1222  var fromCenter = fromIndex === 'center';
1223  var fromLast = fromIndex === 'last';
1224  var isRange = is.arr(val);
1225  var val1 = isRange ? parseFloat(val[0]) : parseFloat(val);
1226  var val2 = isRange ? parseFloat(val[1]) : 0;
1227  var unit = getUnit(isRange ? val[1] : val) || 0;
1228  var start = params.start || 0 + (isRange ? val1 : 0);
1229  var values = [];
1230  var maxValue = 0;
1231  return function (el, i, t) {
1232    if (fromFirst) { fromIndex = 0; }
1233    if (fromCenter) { fromIndex = (t - 1) / 2; }
1234    if (fromLast) { fromIndex = t - 1; }
1235    if (!values.length) {
1236      for (var index = 0; index < t; index++) {
1237        if (!grid) {
1238          values.push(Math.abs(fromIndex - index));
1239        } else {
1240          var fromX = !fromCenter ? fromIndex%grid[0] : (grid[0]-1)/2;
1241          var fromY = !fromCenter ? Math.floor(fromIndex/grid[0]) : (grid[1]-1)/2;
1242          var toX = index%grid[0];
1243          var toY = Math.floor(index/grid[0]);
1244          var distanceX = fromX - toX;
1245          var distanceY = fromY - toY;
1246          var value = Math.sqrt(distanceX * distanceX + distanceY * distanceY);
1247          if (axis === 'x') { value = -distanceX; }
1248          if (axis === 'y') { value = -distanceY; }
1249          values.push(value);
1250        }
1251        maxValue = Math.max.apply(Math, values);
1252      }
1253      if (easing) { values = values.map(function (val) { return easing(val / maxValue) * maxValue; }); }
1254      if (direction === 'reverse') { values = values.map(function (val) { return axis ? (val < 0) ? val * -1 : -val : Math.abs(maxValue - val); }); }
1255    }
1256    var spacing = isRange ? (val2 - val1) / maxValue : val1;
1257    return start + (spacing * (Math.round(values[i] * 100) / 100)) + unit;
1258  }
1259}
1260
1261// Timeline
1262
1263function timeline(params) {
1264  if ( params === void 0 ) params = {};
1265
1266  var tl = anime(params);
1267  tl.duration = 0;
1268  tl.add = function(instanceParams, timelineOffset) {
1269    var tlIndex = activeInstances.indexOf(tl);
1270    var children = tl.children;
1271    if (tlIndex > -1) { activeInstances.splice(tlIndex, 1); }
1272    function passThrough(ins) { ins.passThrough = true; }
1273    for (var i = 0; i < children.length; i++) { passThrough(children[i]); }
1274    var insParams = mergeObjects(instanceParams, replaceObjectProps(defaultTweenSett

1274ings, params));
1275    insParams.targets = insParams.targets || params.targets;
1276    var tlDuration = tl.duration;
1277    insParams.autoplay = false;
1278    insParams.direction = tl.direction;
1279    insParams.timelineOffset = is.und(timelineOffset) ? tlDuration : getRelativeValue(timelineOffset, tlDuration);
1280    passThrough(tl);
1281    tl.seek(insParams.timelineOffset);
1282    var ins = anime(insParams);
1283    passThrough(ins);
1284    children.push(ins);
1285    var timings = getInstanceTimings(children, params);
1286    tl.delay = timings.delay;
1287    tl.endDelay = timings.endDelay;
1288    tl.duration = timings.duration;
1289    tl.seek(0);
1290    tl.reset();
1291    if (tl.autoplay) { tl.play(); }
1292    return tl;
1293  };
1294  return tl;
1295}
1296
1297anime.version = '3.2.2';
1298anime.speed = 1;
1299// TODO:#review: naming, documentation
1300anime.suspendWhenDocumentHidden = true;
1301anime.running = activeInstances;
1302anime.remove = removeTargetsFromActiveInstances;
1303anime.get = getOriginalTargetValue;
1304anime.set = setTargetsValue;
1305anime.convertPx = convertPxToUnit;
1306anime.path = getPath;
1307anime.setDashoffset = setDashoffset;
1308anime.stagger = stagger;
1309anime.timeline = timeline;
1310anime.easing = parseEasings;
1311anime.penner = penner;
1312anime.random = function (min, max) { return Math.floor(Math.random() * (max - min + 1)) + min; };
1313
1314module.exports = anime;
1315
1316},{}],2:[function(require,module,exports){
1317/**
1318 * iexModal
1319 * @constructor
1320 */
1321window.IexModal = function($){
1322    var app = this;
1323
1324    app.PerfectScrollbar = require('./perfect-srollbar.js');
1325    app.AnimeJs = require('./anime.js');
1326
1327    app.$window = $(window);
1328    app.$document = $(document);
1329    app.$html = $('html');
1330    app.$body = $('body');
1331
1332    app.classWrap = 'iexmodal';
1333
1334    // Классы элементов интерфейса
1335    app.classPopup = app.classWrap+'-popup';
1336    app.classClose = app.classWrap+'-close';
1337    app.classCloseAll = app.classWrap+'-close-all';
1338    app.classInner = app.classWrap+'-inner';
1339    app.classInnerWrap = app.classWrap+'-inner-wrap';
1340    app.classBtn = app.classWrap+'-show';
1341    app.classSprite = app.classWrap+'-sprite';
1342    app.classContent = app.classWrap+'-content';
1343    app.classContentWrap = app.classWrap+'-content-wrap';
1344    app.classDebugWrap = app.classWrap+'-debug-wrap';
1345    app.classDebugCode = app.classWrap+'-debug-code';
1346
1347    // Классы-модификаторы (классы состояния)
1348    app.classOpened = app.classWrap+'-opened';
1349    app.classOuterScroll = app.classWrap+'-outerscroll';
1350    app.classLoading = app.classWrap+'-loading';
1351    app.classBottom = app.classWrap+'-bottom';
1352    app.classOverflowY = app.classWrap+'-overflow-y';
1353    app.classOverflowX = app.classWrap+'-overflow-x';
1354
1355    app.popupWidthDefault = 450; // px
1356    // в качестве app.popupHeightDefault используется высота контента модала
1357    app.popupHeightDefaultForTopBottom = 250; // px
1358    app.popupIndentX = 10;
1359    app.popupIndentY = 10;
1360
1361    app.windowWidth = 0;
1362    app.windowHeight = 0;
1363
1364    app.fadeInTime = 500;
1365    app.fadeOutTime = 300;
1366    app.ajaxTimeOut = 25000;
1367
1368    app.errLogMsg = 'iexModal: Ошибка показа окна!';
1369    app.errAjaxMsg = 'iexModal: Ошибка загрузки контента!';
1370    app.errScriptLoadingMsg = 'iexModal: Отменена повторная инициализация скрипта! Уже загружена другая копия/версия iexModal, - ее настройки и состояние затронуты не были!';
1371    app.repAjaxMsg = 'iexModal: Отчет об ajax-запросе';
1372
1373    /**
1374     * Поддерживаемые варианты получения html-контента для показа в модальном окне
1375     * @type {string[]}
1376     */
1377    app.loadTypes = [ 
1378        'url',
1379        'html',
1380        'id',
1381        'selector', 
1382        'jquery'
1383    ];
1384
1385    /**
1386     * Атрибуты, которые разрешено считывать с кнопки/ссылки показа окна и враппера контента
1387     * и соответсвующие им параметры для app.show()
1388     */
1389    app.attrsAndParams = {
1390        'href':                          'url',
1391        'data-iexmodal-html':            'html',
1392        'data-iexmodal-selector':        'selector',
1393        'data-iexmodal-id':              'id',
1394        'data-iexmodal-mode':            'mode',
1395        'data-iexmodal-classes':         'classes',
1396        'data-iexmodal-width':           'width',
1397        'data-iexmodal-height':          'height',
1398        'data-iexmodal-overlay':         'overlay',
1399        'data-iexmodal-content-wrap':    'contentWrap',
1400        'data-iexmodal-content-scroll':  'contentScroll',
1401        'data-iexmodal-document-scroll': 'documentScroll',
1402        'data-iexmodal-outer-scroll':    'outerScroll',
1403        'data-iexmodal-timeout':         'timeout',
1404        'data-iexmodal-ajax-report':     'ajaxReport',
1405        'data-iexmodal-calc-zindex':     'calcZindex',
1406    };
1407
1408    /**
1409     * Атрибуты из app.attrsAndParams, которые разрешено использовать модулю iexForm на кнопках/ссылках показа всплывающих форм
1410     */
1411    app.iexFormAttrs = [
1412        'data-iexmodal-mode',
1413        'data-iexmodal-classes',
1414        'data-iexmodal-width',
1415        'data-iexmodal-height',
1416        'data-iexmodal-overlay',
1417        'data-iexmodal-content-scroll',
1418        'data-iexmodal-document-scroll',
1419        'data-iexmodal-outer-scroll',
1420        'data-iexmodal-timeout',
1421        'data-iexmodal-ajax-report',
1422        'data-iexmodal-calc-zindex',
1423    ];
1424
1425    /**
1426     * Названия разрешенных пользовательских коллбэÐ

1426ºÐ¾Ð²
1427     * @type {Array}
1428     */
1429    app.userCallbackNames = [
1430        'onBeforeShow',
1431        'onAfterContentLoad',
1432        'onAfterShow',
1433        'onBeforeClose',
1434        'onAfterClose'
1435    ];
1436
1437    /**
1438     * Массив разрешенных параметров для app.show().
1439     * Перечень параметров берется из:
1440     * 1) из самого массива
1441     * 2) app.attrsAndParams (эти параметры можно передавать как через API так и через data-атрибуты)
1442     * 3) app.userCallbackNames (эти параметры можно передавать только через API)
1443     * Заполняется в app.__init().
1444     */
1445    app.params = [
1446        'jquery'
1447    ];
1448
1449    /**
1450     * Colorbox
1451     */
1452    app.$colorboxOverlay = null;
1453    app.$colorboxWindow = null;
1454    app.colorboxFound = false;
1455
1456    /**
1457     * Возможные режимы показа модального окна.
1458     * @property {object}
1459     */
1460    app.modes = {
1461        'default':'default',
1462        'fullscreen':'fullscreen',
1463        'top':'top',
1464        'right':'right',
1465        'bottom':'bottom',
1466        'left':'left',
1467        'alert':'alert'
1468    };
1469
1470    /**
1471     * Объект-коллекция модальных окон
1472     * @type {object}
1473     */
1474    app.modals = {};
1475
1476    /**
1477     * Id самого верхнего окна (по z-index)
1478     * @type {boolean}
1479     */
1480    app.modalsTopId = false;
1481
1482    /**
1483     * В мобильном IE console отсутствует и вызов его методов вызовет ошибки
1484     * Попутно используем app.debugPanel.log()
1485     */
1486    app.log = function(){
1487        if ( window.console && window.console.log ) {
1488            console.log.apply(console, arguments);
1489        }
1490        app.debugPanel.log.apply(app.debugPanel, arguments);
1491    };
1492
1493    app.getIEVersion = function () {
1494        var sAgent = window.navigator.userAgent;
1495        var Idx = sAgent.indexOf("MSIE");
1496
1497        // IE, return version number.
1498        if (Idx > 0) {
1499            return parseInt(sAgent.substring(Idx + 5, sAgent.indexOf(".", Idx)));
1500
1501        // IE 11 then look for Updated user agent string.
1502        } else if (!!navigator.userAgent.match(/Trident\/7\./)) {
1503            return 11;
1504
1505        // not IE
1506        } else {
1507            return 0;
1508        }
1509    };
1510
1511    /**
1512     * Панель (окно) отладки для мобильных платформ (вместо console.log).
1513     *
1514     * Можно использовать после вызова:
1515     *      app.debugPanel.on()
1516     * Пример использования:
1517     *      app.debugPanel.log($x, $y, $z)
1518     * Стили можно править через CSS или:
1519     *      app.debugPanel.$wrap.css('стили')
1520     */
1521    app.DebugPanel = function(){
1522        var panel = this;
1523
1524        panel.active = false;
1525        panel.time = false;
1526        panel.$wrap = $();
1527        panel.msg = '-----------------------\niexModal: Панель отладки\n-----------------------';
1528        panel.html = '<div class="iexmodal-debug-panel">'+panel.msg+'</div>';
1529
1530        panel._add = function () {
1531            panel.$wrap = $(panel.html).appendTo(app.$body);
1532        };
1533        panel._remove = function () {
1534            panel.$wrap.remove();
1535            panel.$wrap = $();
1536        };
1537
1538        panel._ts = function(){
1539            var time = new Date();
1540
1541            function format2(val){
1542                return ("0"+val).slice(-2);
1543            }
1544            function format3(val){
1545                return (val+"00").slice(0,3);
1546            }
1547
1548            return (
1549                format2(time.getHours()) + ':' +
1550                format2(time.getMinutes()) + ':' +
1551                format2(time.getSeconds()) + ':' +
1552                format3(time.getMilliseconds())
1553            )
1554        };
1555
1556        panel.clear = function(){
1557            panel.$wrap.html(panel.msg)
1558        };
1559
1560        panel.on = function(params){
1561            params = params || {};
1562            panel.time = (typeof params.time === 'boolean') ? params.time : false;

1563
1564            if ( panel.$wrap.length ) {
1565                panel._remove();
1566            }
1567            panel._add();
1568            panel.active = true;
1569        };
1570        panel.off = function(){
1571            panel._remove();
1572            panel.active = false;
1573        };
1574
1575        panel.log = function(){
1576            if ( !panel.active ) return;
1577
1578            var time = panel.time ? panel._ts() + ' ' : '';
1579
1580            var args = [].slice.call(arguments);
1581            var text = '';
1582            $(args).each(function (i,val) {
1583                text += typeof val === 'object' ? JSON.stringify(val) : val;
1584                text += ' ';
1585            });
1586
1587            panel.$wrap.text(panel.$wrap.text() + '\n' + time + text);
1588            panel.$wrap[0].scrollTop = panel.$wrap[0].scrollHeight;
1589        };
1590    };
1591    app.debugPanel = new app.DebugPanel();
1592
1593    /**
1594     * Возвращает объект самого верхнего по z-индексу модала
1595     *
1596     * @return {undefined|object}
1597     */
1598    app.getTopModal = ()=>{
1599        if (app.modalsTopId) {
1600            return app.modals[app.modalsTopId];
1601        }
1602        return undefined;
1603    }
1604
1605    /**
1606     * Возвращает объект модала по wrapId
1607     *
1608     * @param wrapId {string}
1609     * @return {undefined|object}
1610     */
1611    app.getModalByWrapId = (wrapId)=>{
1612        if (typeof wrapId !== 'string') {
1613            return undefined;
1614        }
1615        return app.modals[wrapId];
1616    };
1617
1618    /**
1619     * Возвращает объект модала id из атрибута data-iexmodal-id
1620     *
1621     * @param id {string}
1622     * @return {undefined|object}
1623     */
1624    app.getModalById = (id)=>{
1625        return app.getModalByWrapId('id-'+id);
1626    }
1627
1628    /**
1629     * Возвращает модал либо по wrapId, либо по id, либо самый верхний по z-индексу
1630     *
1631     * @param id
1632     * @returns {Object|undefined}
1633     */
1634    app.getModal = (id)=>{
1635        return app.getModalById(id) || app.getModalByWrapId(id) || app.getTopModal();
1636    }
1637
1638    /**
1639     * Имеется ли окно с заданным id в списке открытых
1640     *
1641     * @param id
1642     * @return {*}
1643     */
1644    app.isOpened = function (id){
1645        return id && app.modals[id];
1646    };
1647
1648    /**
1649     * Возвращает UID из 5 цифр
1650     * @return {number}
1651     */
1652    app.getUid = function(){
1653        return Math.floor(10000 + Math.random()*89999);
1654    };
1655
1656    app.inArray = function (val, arr) {
1657        if ( typeof arr !== 'object') return false;
1658        return arr.indexOf(val) > -1;
1659    };
1660
1661    /**
1662     * Достает первое по порядку значение в объекте
1663     * @param obj
1664     * @returns {*}
1665     */
1666    app.firstInObj = function (obj) {
1667        if (typeof obj !== 'object') return false;
1668        return obj[Object.keys(obj)[0]];
1669    };
1670
1671    /**
1672     * Достает ключ последнего по порядку элемента в объекте
1673     * @param obj
1674     * @returns {*}
1675     */
1676    app.lastKeyInObj = function (obj) {
1677        if (typeof obj !== 'object') {
1678            return false;
1679        }
1680        var keys = Object.keys(obj);
1681        return keys.length ? keys[keys.length - 1] : false;
1682    };
1683
1684    /**
1685     * Возвращает последний элемент в массиве или false
1686     * @param arr {object}
1687     * @returns {object|false}
1688     */
1689    app.lastInArr = function (arr) {
1690        if (typeof arr !== 'object') return false;
1691        return arr.length ? arr[ arr.length-1 ] : false;
1692    };
1693
1694    /**
1695     * Получает допустимый режим показа окна из кнопки/ссылки
1696     * @returns {string}
1697     */
1698    app.getMode = function (mode) {
1699        if (!mode) return app.firstInObj(app.modes);
1700        return app.modes[mode] ? mode : app.firstInObj(app.modes);
1701    };
1702
1703    /**
1704     * Получает CSS-класс-модификатор для режима показа
1705     * @returns {string}
1706     */
1707    app.getModeClass = function (mode) {
1708        return mode==='default' ? '' : app.classWrap+'-'+mode;
1709    };
1710
1711    /**
1712     * Вычисление ширины скробара (у каждого браузера она своя)
1713     * Позаимствовано из bootstrap.modal.js
1714     */
1715    app.getScrollbarWidth = function () {
1716        var divStyles =
1717            'position: absolute; '+
1718            'top: -9999px; '+
1719            'width: 50px; '+
1720            'height: 50px; '+
1721            'overflow: scroll;';
1722        var scrollDiv = document.createElement('div');
1723        scrollDiv.setAttribute('style', divStyles);
1724        app.$body.append(scrollDiv);
1725        var scrollbarWidth = scrollDiv.offsetWidth - scrollDiv.clientWidth;
1726        app.$body[0].removeChild(scrollDiv);
1727        return scrollbarWidth
1728    };
1729
1730    /**
1731     * Интеграция с Colorbox.
1732     * Нужна когда из iexModal-окна открываются Сolorbox-окна.
1733     * Устанавливаем Сolorbox-окну z-index больший чем у iexModal-окна.
1734     */
1735    app.onColorboxOpen = function(){
1736        if (app.modalsTopId) {
1737            var zIndex = app.getWrapZindex();
1738            app.$colorboxOverlay.css('z-index', zIndex+1);
1739            app.$colorboxWindow.css('z-index', zIndex+2);
1740        }
1741    };
1742    app.onColorboxClosed = function(){
1743        if (app.modalsTopId) {
1744            app.$colorboxOverlay.css('z-index', '');
1745            app.$colorboxWindow.css('z-index', '');
1746        }
1747    };
1748    app.colorboxInit = function(){
1749        app.$colorboxOverlay = $('#cboxOverlay');
1750        app.$colorboxWindow = $('#colorbox');
1751        app.colorboxFound = app.$colorboxOverlay.length && app.$colorboxWindow.length;
1752        if (app.colorboxFound) {
1753            app.$document
1754                .on('cbox_open', app.onColorboxOpen)
1755                .on('cbox_closed', app.onColorboxClosed);
1756        }
1757    };
1758
1759    /**

1760     * Текущий размер окна браузера в виде объекта {width: 450px, height: 600px}.
1761     * @return {object}
1762     */
1763    app.getWindowSize = function () {
1764        if (window.visualViewport) {
1765            app.windowWidth = window.visualViewport.width;
1766            app.windowHeight = window.visualViewport.height;
1767        } else {
1768            app.windowWidth = app.$window.width();
1769            app.windowHeight = app.$window.height();
1770            // Алтернатива для вышерасположенный кода, если он срабатывает некорректно (замечено на некторых сайтах)
1771            // app.windowWidth = document.body.clientWidth;
1772            // app.windowHeight = document.body.clientHeight;
1773        }
1774        return {width: app.windowWidth, height: app.windowHeight}
1775    };
1776
1777    /**
1778     * Получить максимальный z-index на странице
1779     * @return {int}
1780     */
1781    app.getMaxZIndex = function (){
1782        var maxZ = -1;
1783        $('body *').not('.iexmodal-debug-panel').each(function(i,el){
1784            var pos = $(el).css('position');
1785            if(pos === 'absolute' || pos === 'fixed'){
1786                var z = parseInt($(el).css('z-index')) || 1;
1787                maxZ = Math.max(z, maxZ);
1788            }
1789        });
1790        return maxZ;
1791    };
1792
1793    app.getWrapZindex = function () {
1794        var zMax = app.getMaxZIndex();
1795        /*
1796        var zCur = parseInt( app.$wrap.css('z-index') );
1797        return (zMax===zCur ? zMax : zMax+1);
1798        */
1799        return zMax+1;
1800    };
1801
1802    /**
1803     * Корректировка размера и положения окна по горизонтали
1804     * Не вызывается для режимов fullscreen, top и bottom
1805     *
1806     * @param modal {object} Объект модального окна из app.modals
1807     * @param animate {bool} Выполнять анимацию при изменении CSS-свойств
1808     */
1809    app.correctPositionX = function (modal, animate = false) {
1810        let cssParams = {}, animateParams = {};
1811        let maxPopupWidth = modal.width || app.popupWidthDefault;
1812        let maxPopupWidthInWindow = app.windowWidth - app.popupIndentX * 2;
1813        let maxMarginLeftInWindow = -1 * parseInt(maxPopupWidthInWindow/2);
1814        let breakpointWidth = parseInt(maxPopupWidth) + app.popupIndentX * modal.identXCoeff;
1815        let overflowX = app.windowWidth <= breakpointWidth;
1816        
1817        let enableOverflowMode = ()=>{
1818            modal.$wrap.addClass(app.classOverflowX);
1819            modal.$popup.css('width', '');
1820            if (!modal.outerScroll) {
1821                modal.$popup.css('margin-left', '');
1822            }
1823        }
1824
1825        if (!overflowX && modal.overflowX) {
1826            modal.$wrap.removeClass(app.classOverflowX);
1827        }
1828
1829        if (overflowX && !modal.overflowX) {
1830            modal.calculatedX = false;
1831            if (animate) {
1832                animateParams = {
1833                    width: maxPopupWidthInWindow,
1834                    complete: function(anim) {
1835                        enableOverflowMode();
1836                    }
1837                };
1838                if (modal.identXCoeff === 2) { // не режим left/right
1839                    animateParams.marginLeft = maxMarginLeftInWindow
1840                }
1841                app.animation.popupChange(modal, animateParams)
1842            } else {
1843                enableOverflowMode();
1844            }            
1845        }
1846
1847        if (
1848            !overflowX && (modal.overflowX || !modal.calculatedX || animate)
1849        ) {
1850            modal.calculatedX = true;
1851
1852            
1853            cssParams.width = maxPopupWidth;
1854            if (modal.overflowX && animate) {
1855                animateParams.width = [maxPopupWidthInWindow, maxPopupWidth];
1856            } else {
1857                animateParams.width = maxPopupWidth;
1858            }
1859
1860            if (
1861                modal.mode === 'default' &&
1862                !modal.outerScroll
1863            ) {
1864                let mLeft = -1 * parseInt(maxPopupWidth)/2;
1865                cssParams.marginLeft = mLeft+'px'
1866                if (modal.overflowX && animate) {

1867                    animateParams.marginLeft = [maxMarginLeftInWindow, mLeft];
1868                } else {
1869                    animateParams.marginLeft = mLeft;
1870                }
1871            }
1872
1873            if (animate) {
1874                app.animation.popupChange(modal, animateParams);
1875            } else {
1876                modal.$popup.css(cssParams);
1877            }
1878        }
1879
1880        modal.overflowX = overflowX;
1881    };
1882
1883    /**
1884     * Возвращает высоту контента попапа в сумме с вертикальными паддингами modal.$inner
1885     *
1886     * @param modal {object} Объект модального окна из app.modals
1887     * @return {int} Пиксели
1888     */
1889    app.getContentHeight = function(modal) {
1890        return Math.ceil(
1891            modal.$innerWrap.outerHeight() +
1892            parseInt(modal.$inner.css('padding-top')) +
1893            parseInt(modal.$inner.css('padding-bottom'))
1894        );
1895    };
1896
1897    /**
1898     *
1899     * @param modal {object} Объект модального окна из app.modals
1900     * @param animate {bool} Выполнять анимацию при изменении CSS-свойств
1901     */
1902    app.setPopupSizeY = (modal, animate = false)=>{
1903        let cssParams = {}, animateParams = {};
1904        
1905        let enableOverflowMode = ()=>{
1906            modal.$wrap.addClass(app.classOverflowY);
1907            cssParams.marginTop = '';
1908            cssParams.height = '';
1909            modal.$popup.css(cssParams);
1910        }
1911
1912        if (modal.overflowYdetected && !modal.overflowY) {
1913            modal.calculatedY = false;

1914            modal.overflowY = true;
1915            if (animate) {
1916                animateParams = {
1917                    height: modal.popupMaxHeightInWindow,
1918                    complete: function(anim) {
1919                        enableOverflowMode();
1920                    }
1921                }
1922                if (modal.identYCoeff === 2) { // не режим top/bottom
1923                    animateParams.marginTop = modal.popupMaxMarginTopInWindow;
1924                }
1925                app.animation.popupChange(modal, animateParams)
1926            } else {
1927                enableOverflowMode();
1928            }            
1929        }
1930
1931        if (
1932            !modal.overflowYdetected && (modal.overflowY || !modal.calculatedY || animate)
1933        ) {
1934            modal.calculatedY = true;
1935
1936            if (modal.overflowY) {
1937                modal.$wrap.removeClass(app.classOverflowY);
1938            }
1939
1940            if (modal.mode === 'default') {
1941                let marginTop = -1 * parseInt(modal.popupMaxHeight/2);
1942                cssParams.marginTop = marginTop+'px';
1943                if (modal.overflowY && animate) {
1944                    animateParams.marginTop = [modal.popupMaxMarginTopInWindow, marginTop];
1945                } else {
1946                    animateParams.marginTop = marginTop;
1947                }
1948            }
1949
1950            cssParams.height = modal.popupMaxHeight+'px';
1951            if (modal.overflowY && animate) {
1952                animateParams.height = [modal.popupMaxHeightInWindow, modal.popupMaxHeight];
1953            } else {
1954                animateParams.height = modal.popupMaxHeight;
1955            }
1956
1957            if (animate) {
1958                app.animation.popupChange(modal, animateParams)
1959            } else {
1960                modal.$popup.css(cssParams);
1961            }
1962
1963            modal.overflowY = false;
1964        }
1965    }
1966
1967    /**
1968     * Корректировка размера и положения окна по вертикали.
1969     * Предусмотрена работа только в режимах default, alert, top, bottom.
1970     *
1971     * @param modal {object} Объект модального окна из app.modals
1972     * @param animate {bool} Выполнять анимацию при изменении CSS-свойств
1973     */
1974    app.correctPositionY = function (modal, animate = false) {
1975        if (modal.positionFirstMesurement) {
1976            modal.isTopBottom = app.inArray(modal.mode, ['top','bottom']);
1977            modal.popupStoredTop = false;
1978            modal.popupStoredBottom = false;
1979            modal.popupContentHeight = app.getContentHeight(modal);
1980            modal.popupMaxHeight = app.getPopupMaxHeight(modal);
1981            modal.breakpointHeight = modal.popupMaxHeight + app.popupIndentY * modal.identYCoeff;
1982            modal.popupMaxHeightInWindow = app.windowHeight - app.popupIndentY * modal.identYCoeff;
1983            modal.popupMaxMarginTopInWindow = -1 * parseInt(modal.popupMaxHeightInWindow/2);
1984            modal.positionFirstMesurement = false;
1985        }
1986
1987        modal.overflowYdetected = app.windowHeight <= modal.breakpointHeight;
1988        app.setPopupSizeY(modal, animate);
1989
1990        if (modal.mode === 'alert') {
1991
1992            if (!modal.overflowY && !modal.overflowYdetected) {
1993                let popupClientRect = modal.$popup[0].getBoundingClientRect();
1994                if ((popupClientRect.bottom + app.popupIndentY) > app.windowHeight) {
1995                    modal.overflowYdetected = true;
1996                    modal.popupStoredBottom = popupClientRect.bottom + app.popupIndentY;
1997                }
1998                if (!modal.overflowYdetected && popupClientRect.top < app.popupIndentY) {
1999                    modal.overflowYdetected = true;
2000                    modal.popupStoredTop = popupClientRect.top;
2001                }
2002                app.setPopupSizeY(modal, animate);
2003            }
2004
2005            if (modal.overflowY) {
2006                if (
2007                    modal.overflowYdetected &&
2008                    modal.popupStoredBottom !== false &&
2009                    modal.popupStoredBottom < app.windowHeight
2010                ) {
2011                    modal.overflowYdetected = false;

2012                    modal.popupStoredBottom = false;
2013                }
2014
2015                if (
2016                    modal.overflowYdetected &&
2017                    modal.popupStoredTop !== false &&
2018                    modal.popupStoredTop > app.popupIndentY
2019                ) {
2020                    modal.overflowYdetected = false;
2021                    modal.popupStoredTop = false;
2022                }
2023
2024                app.setPopupSizeY(modal, animate);
2025            }
2026
2027        }
2028    };
2029
2030    /**
2031     * Корректировка размерров и положения открытых окон.
2032     * Автоматически выполняется при каждом изменении размера окна браузера (onresize) и повороте мобильного устройства (onorientationchange).
2033     * Нужно вызывать после изменения количества контента в окне/окнах, чтобы расположение на экране оставалось оптимальным.
2034     *
2035     * @return {boolean}
2036     */
2037    app.correctPosition = function(){
2038        if ( !app.modalsTopId ) return false;
2039
2040        $.each(app.modals, function (wrapId, modal) {
2041            if (modal.mode === 'fullscreen') {
2042                return true;
2043            }
2044
2045            // Установка ширины дожна выполняться ДО установки высоты, чтобы inline/inline-block
2046            // элементы правильно распределились по строкам и дали правильную высоту контента
2047            if (!app.inArray(modal.mode, ['top', 'bottom'])) {
2048                app.correctPositionX(modal);
2049            }
2050            if (!app.inArray(modal.mode, ['left', 'right'])) {
2051                app.correctPositionY(modal);
2052            }
2053            if (modal.ps) {
2054                modal.ps.update();
2055            }
2056        });
2057
2058        return false;
2059    };
2060
2061    /**
2062     * Возвращает максимально возможную высоту попапа
2063     *
2064     * @param modal {object} Объект модального окна из app.modals
2065     * @return {object} app
2066     */
2067    app.getPopupMaxHeight = function(modal){
2068        let height = parseInt(modal.height);
2069        if (
2070            !height &&
2071            app.inArray(modal.mode, ['top','bottom'])
2072        ) {
2073            height = app.popupHeightDefaultForTopBottom;
2074        }
2075        if (!height) {
2076            height = modal.popupContentHeight; // в качестве app.popupHeightDefault используется высота контента модала
2077        }
2078        return height;
2079    };
2080
2081    app.setPopupHeightOnceAfterLoad = false;
2082
2083    /**
2084     * Изменение высоты модала
2085     *
2086     * @param height {string} Ширина модала
2087     * @param id {string} id существующего модала из app.modals
2088     */
2089    app.setHeight = (height, id)=>{
2090        let modal = app.getModal(id);
2091        if (!modal || app.inArray(modal.mode, ['fullscreen', 'left', 'right'])) {
2092            return;
2093        }
2094
2095        if (!height) {
2096            height = 'content';
2097        }
2098        if (height === 'max') {
2099            height = app.windowHeight+'px';
2100        }
2101
2102        modal.height = height === 'content' ? null : height;
2103        modal.positionFirstMesurement = true;
2104        app.correctPositionY(modal, true);
2105    }
2106
2107    /**
2108     * Изменение ширины модала
2109     *
2110     * @param width {string} Ширина модала
2111     * @param id {string} id существующего модала из app.modals
2112     */
2113    app.setWidth = (width, id)=>{
2114        let modal = app.getModal(id);
2115        if (!modal || app.inArray(modal.mode, ['fullscreen', 'top', 'bottom'])) {
2116            return;
2117        }
2118
2119        if (!width) {
2120            width = app.popupWidthDefault+'px';
2121        }
2122
2123        modal.width = (width === 'max') ? (app.windowWidth+'px') : width;
2124        app.correctPositionX(modal, true);
2125    }
2126
2127    /**
2128     * Рендерит html-код для модального окна, добавляет его Ð

2128½Ð°Ñ‡Ð°Ð»Ð¾ документа и возвращает jQuery-ссылку
2129     *
2130     * @param id {string} Уникальный id модального окна из app.modals
2131     * @return {jQuery} jQuery-ссылка на вставленный html
2132     */
2133    app.insertWrap = function(id) {
2134        var html =
2135            '<div class="' + app.classWrap + '" data-iexmodal-id="' + id + '">\n'+
2136            '    <div class="' + app.classClose + ' iexmodal-close-outer">\n'+
2137            '        <svg class="iexmodal-icon"><use xlink:href="#close"></use></svg>\n'+
2138            '    </div>\n'+
2139            '    <div class="' + app.classPopup + '">\n'+
2140            '        <div class="' + app.classInner + '"><div class="'+app.classInnerWrap + '"></div></div>\n'+
2141            '        <div class="' + app.classClose + ' iexmodal-close-inner">\n'+
2142            '            <svg class="iexmodal-icon"><use xlink:href="#close"></use></svg>\n'+
2143            '        </div>\n'+
2144            '    </div>\n'+
2145            '    <div class="iexmodal-spinner"></div>\n'+
2146            '</div>';
2147        return $(html).appendTo('body');
2148    };
2149
2150    /**
2151     * Вставляет SVG-спрайт в начало документа и возвращает jQuery-ссылку
2152     *
2153     * @return {jQuery}
2154     */
2155    app.insertSprite = function() {
2156        var html =
2157            '<svg class="' + app.classSprite + '" aria-hidden="true" style="position: absolute; width: 0; height: 0; overflow: hidden;" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">\n'+
2158            '    <defs>\n'+
2159            '        <symbol id="close" viewBox="0 0 18 18">\n'+
2160            '            <title>close</title>\n'+
2161            '            <line x1="2" y1="2" x2="16" y2="16"/>\n'+
2162            '            <line x1="2" y1="16" x2="16" y2="2"/>\n'+
2163            '        </symbol>\n'+
2164            '    </defs>\n'+
2165            '</svg>';
2166        return $(html).appendTo('body');
2167    };
2168
2169    /**
2170     * jQuery-ссылка на вставленный в документ SVG-спрайт.
2171     *
2172     * @type {*}
2173     */
2174    app.$sprite = false;
2175
2176    /**
2177     * Используется при app.loadType равным 'selector' или 'jquery'
2178     *
2179     * @return {jQuery}
2180     */
2181    app.insertPlaceholder = function($sibling) {
2182        var html = '<div class="iexmodal-content-placeholder"></div>';
2183        return $(html).insertAfter($sibling);
2184    };
2185
2186    /**
2187     * Получение data-атрибутов кнопки/ссылки
2188     * в виде объекта c параметрами для app.show()
2189     *
2190     * @param $btn - jQuery-ссылка на кнопку/ссылку
2191     * @return {*}
2192     */
2193    app.parseBtnAttrs = function ($btn) {
2194        if (!($btn instanceof jQuery && $btn.length)) return false;
2195        var obParsed = {};
2196        $.each(app.attrsAndParams, function (btnAttr, showParam) {
2197            obParsed[showParam] = $btn.attr(btnAttr) || ''; // $.data() может отдавать закэшированные (старые) значения при уже изменившемся DOM
2198        });
2199        return obParsed;
2200    };
2201
2202    /**
2203     * Подсчет количества переданных способов загрузки html-контента.
2204     * Используется в app.validateParams() для проверки, что передан ровно один способ.
2205     *
2206     * @param params Параметры для app.show()
2207     * @return {number}
2208     */
2209    app.loadTypesCnt = function (params) {
2210        var cnt = 0;
2211        $.each(app.loadTypes, function (key,val) {
2212            cnt += params[val] ? 1 : 0;
2213        });
2214        return cnt;
2215    };
2216
2217    /**
2218     * Получение способа загрузки html-контента из параметров app.show()
2219     *
2220     * @param params Параметры для app.show()
2221     * @return {boolean}
2222     */
2223    app.getLoadType = function (params) {
2224        var loadType = false;

2225        $.each(app.loadTypes, function (key,val) {
2226            if ( !!params[val] ) {
2227                loadType = val;
2228                return false
2229            }
2230        });
2231        return loadType;
2232    };
2233
2234    app.getContentWrap = function(id){
2235        return app.$body.find('.'+app.classContent+'[data-iexmodal-id="' + id + '"]').first();
2236    };
2237
2238    /**
2239     * Отчет об аякс-запросе, выполненного методом $.ajax()
2240     *
2241     * @param url {string} Урл загружаемого контента
2242     * @param jqXHR {jqXHR} jqXHR-объект, который вернул метод $.ajax()
2243     * @return {string} Html-код с отчетом
2244     */
2245    app.ajaxReport = function(url, jqXHR){
2246        if ( !url || !jqXHR ) return '';
2247
2248        var responseText = jqXHR.responseJSON ? JSON.stringify(jqXHR.responseJSON) : jqXHR.responseText;
2249        responseText = $('<div></div>').text(responseText).html();
2250
2251        return (
2252            '<div class="' + app.classDebugWrap + '">' +
2253            'URL: <a href="' + url + '" target="_blank">' + url + '</a><br>' +
2254            'Timeout: ' + app.ajaxTimeOut/1000 + ' sec<br>' +
2255            '<br>' +
2256            'jqXHR.readyState: ' + jqXHR.readyState + '<br>' +
2257            'jqXHR.status: ' + jqXHR.status + '<br>' +
2258            'jqXHR.statusText: ' + jqXHR.statusText +
2259            '<br><br>' +
2260            'jqXHR.responseText / jqXHR.responseJSON:' +
2261            '<div class="' + app.classDebugCode + '">' + responseText + '</div>' +
2262            '</div>'
2263        );
2264    };
2265
2266    /**
2267     * Валидация параметров для app.show().
2268     * @param rawParams {object} Объект с 'сырыми' параметрами для проверки-исправления
2269     * @return {object} Объект с проверенными-исправленными параметрами
2270     */
2271    app.validateParams = function(rawParams){
2272        if (!rawParams) {
2273            app.log(app.errLogMsg+' Не задан объект с параметрами. Смотрите документацию по iexModal.show().');
2274            return false;
2275        }
2276        var validParams = {};
2277
2278        $.each(app.params, function(key, param) {
2279            if ( app.inArray(param, app.userCallbackNames) ) {
2280                if (typeof rawParams[param] === 'function') {
2281                    validParams[param] = rawParams[param];
2282                }
2283            } else if ( app.inArray(param, ['jquery','selector']) || (typeof rawParams[param] === 'boolean' ) ) {
2284                validParams[param] = rawParams[param];
2285            } else {
2286                validParams[param] = $.trim(rawParams[param] || '');
2287            }
2288
2289            if (
2290                param==='url' &&
2291                validParams[param] &&
2292                (
2293                    validParams[param].indexOf('#')===0 ||
2294                    validParams[param].indexOf('javascript:')>-1
2295                )
2296            ) {
2297                validParams[param] = '';
2298            }
2299
2300            if ( param==='mode' ) {
2301                validParams[param] = app.getMode(validParams[param]);
2302            }
2303
2304            if (
2305                (param==='overlay' || param==='ajaxReport') &&
2306                (typeof validParams[param] !== 'boolean')
2307            ) {
2308                validParams[param] = validParams[param]==='true';
2309            }
2310
2311            if (
2312                (param==='contentWrap' || param==='contentScroll' || param==='calcZindex') &&
2313                (typeof validParams[param] !== 'boolean')
2314            ) {
2315                validParams[param] = validParams[param]!=='false';
2316            }
2317
2318            if (
2319                (param==='documentScroll' || param==='outerScroll') &&
2320                (typeof validParams[param] !== 'boolean')
2321            ) {
2322                validParams[param] = validParams[param]==='true';
2323            }
2324
2325            if ( param==='timeout' ) {
2326                validParams[param] = parseInt(validParams[param]) || 0;
2327            }
2328        });
2329
2330        if (validParams['mode'] && validParams['mode'] !== 'default') {
2331            validParams['classes'] = validParams['classes'] ? ' '+validParams['classes'] : '';
2332            validParams['classes'] = app.getModeClass(validParams['mode']) + validParams['classes'];
2333        }
2334
2335        if (validParams['outerScroll']) {
2336            validParams['classes'] += ' ' + app.classOuterScroll;
2337        }
2338
2339        // if (validParams['mode'] === 'fullscreen') {
2340        //     validParams['width'] = '';

2341        //     validParams['height'] = '';
2342        // }
2343
2344        var
2345            errMsg = '',
2346            loadType = app.getLoadType(validParams),
2347            loadTypesCnt = app.loadTypesCnt(validParams);
2348
2349        if (
2350            !loadTypesCnt
2351        ) {
2352            errMsg = 'Не задан способ загрузки html-контента: ' + app.loadTypes.join(', ');
2353
2354        } else if (
2355            app.loadTypesCnt(validParams) > 1
2356        ) {
2357            errMsg = 'Из списка параметров ' + app.loadTypes.join(', ') + ' одновременно можно передавать только ОДИН!';
2358
2359        } else if (
2360            loadType==='selector' &&
2361            !$(validParams['selector']).length
2362        ) {
2363            errMsg = 'Элемент с селектором "' + validParams['selector'] + '" не найден на странице!';
2364
2365        } else if (
2366            loadType==='jquery' &&
2367            !(validParams['jquery'] instanceof jQuery)
2368        ) {
2369            errMsg = 'Элемент, переданный в параметр jquery, не является экземпляром jQuery!';
2370
2371        } else if (
2372            loadType==='jquery' &&
2373            !validParams['jquery'].length
2374        ) {
2375            errMsg = 'Элемент, переданный в параметр jquery, не найден на странице!';
2376
2377        } else if (
2378            loadType==='id' &&
2379            !app.getContentWrap(validParams['id']).length
2380        ) {
2381            errMsg = 'Не найден враппер контента с data-iexmodal-id="' + validParams['id'] + '".';
2382
2383        } else if (
2384            validParams['outerScroll'] &&
2385            !app.inArray(validParams['mode'], ['default','fullscreen'])
2386        ) {
2387            errMsg = 'Опция с прокруткой всего модала и внешним скроллбаром (data-iexmodal-outer-scroll="true") работает только в режимах default и fullscreen!';
2388        }
2389
2390        if ( errMsg ) {
2391            app.log(app.errLogMsg +' ' + errMsg + ' Переданные параметры:', validParams);
2392            return false
2393        }
2394
2395        return validParams;
2396    };
2397
2398    /**
2399     * Добавляет модальное окно в HTML-кода и коллекцию app.modals
2400     *
2401     * @param params - параметры для app.show()
2402     * @return {object} - объект созданного модального окна
2403     */
2404    app.create = function (params) {
2405        var loadType = app.getLoadType(params);
2406        var wrapId = loadType + '-' + ( loadType==='id' ? params.id : app.getUid() );
2407        var $wrap = app.insertWrap(wrapId);
2408
2409        // перечень всех возможных полей объекта modal
2410        var modal = app.modals[wrapId] = {
2411            wrapId: wrapId,
2412            loadType: loadType,
2413            timeoutId: false,
2414            contentArray: [],
2415            $wrap: $wrap,
2416            $popup: $wrap.find('.'+app.classPopup),
2417            $inner: $wrap.find('.'+app.classInner),
2418            $innerWrap: $wrap.find('.'+app.classInnerWrap),
2419            $currWrapper: null,
2420            $currContent: null,
2421            $contentPlaceholder: null,
2422            mouseLeftButtonPushed: false,
2423            overflowY: false,
2424            overflowX: false,
2425            calculatedY: false,
2426            calculatedX: false,
2427            identXCoeff: 2,
2428            identYCoeff: 2,
2429            positionFirstMesurement: true,
2430            ps: null,
2431            psDragging: false,
2432            isVisible: false, // устанавливается в true после завершения анамации показа
2433            
2434            // приходят из параметров метода show() и атрибутов data-iexmodal-*
2435            url: null,
2436            html: null,
2437            selector: null,
2438            id: null,
2439            mode: null,
2440            classes: null,
2441            width: null,
2442            height: null,
2443            overlay: null,
2444            contentScroll: null,
2445            documentScroll: false,
2446            outerScroll: false,
2447            timeout: null,
2448            ajaxReport: null,
2449            calcZindex: null,
2450            

2451            // коллбэки
2452            onBeforeShow: ()=>{},
2453            onAfterContentLoad: ()=>{},
2454            onAfterShow: ()=>{},
2455            onBeforeClose: ()=>{},
2456            onAfterClose: ()=>{}
2457        };
2458        modal = $.extend(modal, params);
2459
2460        modal.identXCoeff = app.inArray(modal.mode, ['left','right']) ? 1 : 2;
2461        modal.identYCoeff = app.inArray(modal.mode, ['top','bottom']) ? 1 : 2;
2462
2463        // Заботимся чтобы во время перетаскивании скроллбара мышью случайно не кликался .iexmodal и окно не закрывалось
2464        function resetWrapSetts() {
2465            modal.psDragging = false;
2466            modal.$wrap.css('cursor','');
2467        }
2468
2469        if ( !modal.outerScroll && modal.contentScroll ) {
2470            modal.ps = new app.PerfectScrollbar( modal.$inner[0], {
2471                    wheelSpeed: 1, // сделать зависимой длинны (высоты контента) = parseInt(modal.$inner.outerHeight() / modal.$popup.outerHeight() * 2)
2472                    wheelPropagation: false,
2473                    minScrollbarLength: 60
2474                }
2475            );
2476            modal.$wrap.find('.ps__thumb-y')
2477                .on('mousedown', function (e) {
2478                    // e.which = 1 (левая), 2 (средня), 3 (правая)
2479                    modal.psDragging = true;
2480                    modal.$wrap.css('cursor','default');
2481                })
2482                .on('mouseup', function (e) {
2483                    resetWrapSetts();
2484                });
2485            modal.$wrap.find('.ps').on('mouseup', function (e) {
2486                if ( modal.psDragging ) {
2487                    resetWrapSetts();
2488                }
2489            });
2490        }
2491
2492        modal.$wrap
2493            .on('mousedown', function (e) { // если нажали именно над оверлеем и именно левую кнопку
2494                modal.mouseLeftButtonPushed = ( e.target === this && e.which === 1 );
2495            })
2496            .on('click', function (e) {
2497                if ( e.target === this ) {
2498                    if ( modal.ps && modal.psDragging ) {
2499                        resetWrapSetts();
2500                    } else {
2501                        if ( modal.mouseLeftButtonPushed ) {
2502                            app.close();
2503                        }
2504                    }
2505                }
2506            });
2507
2508        app.modalsTopId = wrapId;
2509
2510        return modal;
2511    };
2512
2513    /**
2514     * Перенос контента модального окна для типов загрузки 'selector' и 'jquery'
2515     * - moveToPopup() в модальное окно
2516     * - moveBack() обратно во враппер контента
2517     */
2518    app.contentArray = {
2519
2520        moveToPopup: function (modal) {
2521
2522            function arrayContentPush($el) {
2523                modal.contentArray.push({
2524                    '$currContent': $el,
2525                    '$contentPlaceholder': app.insertPlaceholder($el),
2526                });
2527                $el.appendTo( modal.$innerWrap );
2528            }
2529
2530            if ( modal.loadType==='jquery' ) {
2531                modal.jquery.each(function (i, el) {
2532                   arrayContentPush($(el))
2533                });
2534            }
2535
2536            // Cелекторы с запятыми разбиваем на отдельные jQuery-объекты, чтобы сохранить порядок выборки блоков
2537            // с контентом именно таким, как указано в селекторе, в противном случае порядок будет таким как в DOM-дереве.
2538            if ( modal.loadType==='selector' ) {
2539                var arSelectors = modal.selector.split(',');
2540
2541                $.each(arSelectors, function (index,selector) {
2542                    selector = selector.trim();
2543                    if (selector) {
2544                        $(selector).each(function (i, el) {
2545                            arrayContentPush($(el))
2546                        });
2547                    }
2548                });
2549            }
2550        },
2551
2552        moveBack: function (modal) {
2553
2554            $.each( modal.contentArray, function (key, item) {
2555                item.$currContent.insertAfter(item.$contentPlaceholder);
2556                item.$contentPlaceholder.remove();
2557            });
2558
2559        }
2560
2561    };
2562
2563    /**
2564     * Удаляет модальное окно из HTML-кода и коллекции app.modals
2565     *
2566     * @param {object} modal - удаляемое модальное окно (объект из коллекции app.modals)
2567     * @return {boolean}
2568     */
2569    app.remove = function (modal) {
2570        if (
2571            typeof modal !== 'object' ||
2572            typeof app.modals[modal.wrapId] !== 'object'
2573        ) {
2574            return false;

2575        }
2576
2577        if (modal.loadType==='selector' || modal.loadType==='jquery') {
2578            app.contentArray.moveBack(modal);
2579        }
2580        if (modal.loadType==='id') {
2581            modal.$currContent.appendTo( modal.$currWrapper );
2582        }
2583        if ( modal.ps ) {
2584            modal.ps.destroy();
2585            modal.ps = null; // to make sure garbages are collected
2586        }
2587
2588        modal.$wrap.remove();
2589        delete app.modals[modal.wrapId];
2590        app.modalsTopId = app.lastKeyInObj(app.modals);
2591
2592        return true;
2593    };
2594
2595    /**
2596     * Функционал для анимации
2597     *
2598     * @constructor
2599     */
2600    app.Animation = function(){
2601        var anim = this;
2602
2603        anim.timeIn = 400;
2604        anim.timeOut = 300;
2605        
2606        anim.popupAnimations = {
2607            default: {
2608                in: {translateY: [-50, 0], opacity: 1},
2609                out: {translateY: [0, 70], opacity: 0},
2610            },
2611            fullscreen: {
2612                in: {opacity: 1},
2613                out: {opacity: 0},
2614            },
2615            alert: {
2616                in: {translateX: ['100%', 0], opacity: 1},
2617                out: {translateX: [0, '100%'], opacity: 0},
2618            },
2619            top: {
2620                in: {translateY: ['-100%', 0], opacity: 1},
2621                out: {translateY: [0, '-100%'], opacity: 0},
2622            },
2623            right: {
2624                in: {translateX: ['100%', 0], opacity: 1},
2625                out: {translateX: [0, '100%'], opacity: 0},
2626            },
2627            bottom: {
2628                in: {translateY: ['100%', 0], opacity: 1},
2629                out: {translateY: [0, '100%'], opacity: 0},
2630            },
2631            left: {
2632                in: {translateX: ['-100%', 0], opacity: 1},
2633                out: {translateX: [0, '-100%'], opacity: 0},
2634            },
2635        }
2636
2637        anim.wrapIn = function(modal) {
2638            if (modal.calcZindex) {
2639                modal.$wrap.css('z-index', app.getWrapZindex());
2640            }
2641            
2642            modal.$wrap
2643                .css('display', 'block')
2644                .addClass(modal.classes + ' ' + app.classLoading);
2645
2646            let params = {
2647                targets: modal.$wrap[0],
2648                opacity: 1,
2649                easing: 'linear',
2650                duration: anim.timeIn
2651            };
2652            app.AnimeJs(params);
2653        };
2654
2655        anim.popupIn = function(modal) {
2656            modal.$wrap.removeClass(app.classLoading);
2657
2658            let params = anim.popupAnimations[modal.mode]['in'];
2659            params.easing = modal.mode === 'alert' ? 'easeInOutBack' : 'easeInOutSine'; // по-умолчанию выбран 'easeOutElastic(1, .5)' (резиновый, пружинящий)
2660            params.duration = modal.mode === 'alert' ? anim.timeIn + 200 : anim.timeIn;
2661
2662            $.extend(params, {
2663                targets: modal.$popup[0],
2664                complete: function(anim) {
2665                    modal.isVisible = true;
2666                    app.callbacks.onAfterShow(modal);
2667                }
2668            });
2669            app.AnimeJs(params);
2670        };
2671
2672        anim.popupChange = function(modal, props) {
2673            app.AnimeJs($.extend(props, {
2674                targets: modal.$popup[0],
2675                duration: anim.timeOut,
2676                easing: 'easeInOutSine'
2677            }));
2678        }
2679
2680        anim.allOut = function(modal) {
2681            app.AnimeJs({
2682                targets: modal.$wrap[0],
2683                opacity: 0,
2684                easing: 'linear',
2685                duration: anim.timeOut,
2686            });
2687
2688            let params = anim.popupAnimations[modal.mode]['out'];
2689            params.easing = modal.mode === 'alert'? 'easeInOutBack' : 'easeInOutSine'; // по-умолчанию выбран 'easeOutElastic(1, .5)' (резиновый, пружинящий)
2690            params.duration = modal.mode === 'alert' ? anim.timeOut + 200 : anim.timeIn;
2691
2692            app.AnimeJs($.extend(params, {
2693                targets: modal.$popup[0],
2694                complete: function(anim) {
2695                    app.callbacks.onAfterClose(modal);
2696                }
2697            }));
2698        };
2699    };
2700    app.animation = new app.Animation();
2701
2702    /**
2703     * Показ модального окна
2704     * @param {object} params
2705     * - selector {string} - jQuery-селектор на враппер с html-контентом
2706     * - jquery {jquery} - jQuery-ссылка на враппер с html-контентом
2707     * - html {string} - html-строка с контентом
2708     * - url {string} - урл загружаемого контента
2709     * - id {string}- Значение атрибута data-iexmodal-id враппера с контентом, который нужно показать
2710     * - mode {string} - Режим показа модального окна из app.modes (по-умолчанию 'default')
2711     * - classes {string}- Список CSS-классов (через пробел), которые нужно добавить к модальному окну
2712     * - width {string}- Ширина модального окна с единицами измерения (px, %, em и т.д.). По-умолчанию ширина равна 450px. Игнорируется при modal.mode !== 'default'.
2713     * - overlay {boolean}