PageSourceSearch
Opt out API access

https://arrowsoft.ru/bitrix/templates/adaptive_s1/js/common.js?1614194538108957

js arrowsoft.ru collected 2026-10-07 23:48:11 UTC 108,957 bytes, 3,181 lines download raw bytes 

1'use strict';
2
3$.ajaxSettings.traditional = true;
4
5var $Common = function () {
6    var head = document.head || document.getElementsByTagName('head')[0],
7        style = document.createElement('style'),
8        styleSheet,
9        dataType = [
10            'String',
11            'Number',
12            'Boolean',
13            'Array',
14            'Function',
15            'Date',
16            'RegExp',
17            'Error',
18            'Symbol'
19        ],
20        nodeType = [
21            'Element',
22            'Attribute',
23            'Text Node',
24            'CDATA Section',
25            'Entity Reference',
26            'Entity',
27            'Processing Instruction',
28            'Comment',
29            'Document',
30            'Document Type',
31            'Document Fragment',
32            'Notation'
33        ],
34        _class;
35
36    head.appendChild(style);
37    styleSheet = document.styleSheets[document.styleSheets.length - 1];
38    _class = {
39        getType: function (target, requestType) {
40            var name = getName(target);
41
42            if (arguments.length == 2) {
43                switch (_class.getType(requestType)) {
44                    case 'String':
45                        requestType = requestType.replace(/\s+/, '').split(',');
46                    case 'Array':
47                        return compareString(requestType);
48                    case 'Number':
49                        if (isNaN(target)) {
50                            return isNaN(requestType);
51                        }
52                    default:
53                        return target === requestType;
54                }
55            } else {
56                return name;
57            }
58
59            function compareString (values) {
60                for (var i = 0; i < values.length; i++) {
61                    try {
62                        if (name.toLowerCase() == values[i].toLowerCase()) {
63                            return true;
64                        }
65                    } catch (z) {
66                        //return false;
67                    }
68                }
69
70                return false;
71            }
72
73            function getName (e) {
74                if (e === undefined || e === null) {
75                    return e;
76                } else {
77                    var type = typeof e;
78
79                    if (type != 'object') {
80                        return _class.getName(type);
81                    } else {
82                        type = Object.prototype.toString.call(e);
83
84                        if (type == '[object Object]') {
85                            dataType.forEach(function (value) {
86                                var constructor = window[value];
87
88                                if (constructor && constructor.prototype && e instanceof constructor) {
89                                    return value;
90                                }
91                            });
92                            return 'Object';
93                        } else {
94                            if (e instanceof Node && e.nodeType) {
95                                return nodeType[e.nodeType - 1];
96                            } else {
97                                type = type.match(/([\w\.]+)[^\w]*$/);
98
99                                if (type && dataType.indexOf(type[1]) >= 0) {
100                                    return type[1];
101                                } else {
102                                    return 'Unknown Type';
103                                }
104                            }
105                        }
106                    }
107                }
108            }
109        },
110
111        getName: function (value) {
112            return value.slice(0, 1).toUpperCase() + value.slice(1);
113        },
114
115        clone: function (currentObject) {
116            var newObject = new currentObject.constructor();
117
118            Object.keys(currentObject).forEach(function (name) {
119                newObject[name] = currentObject[name];
120            });
121
122            for (var i = 1; i < arguments.length; i++) {
123                var addObject = arguments[i];
124
125                switch (this.getType(addObject)) {
126                    case 'Object':
127                        Object.keys(addObject).forEach(function (name) {
128                            newObject[name] = addObject[name];
129                        });
130                        break;
131                }
132            }
133
134            return newObject;
135        },
136
137        createRule: function (selectors, rules, index) {
138            switch (this.getType(selectors)) {
139                case 'Array':
140                    selectors = selectors.join(',');
141                    break;
142                case 'String':
143                    break;
144                default:
145                    return;
146            }
147
148            switch (this.getType(rules)) {
149                case 'Array':
150                    rules = rules.join(';');
151                    break;
152                case 'String':
153                    break;
154                default:
155                    return;
156            }
157
158            if (!index && index != 0) {
159                index = styleSheet.cssRules.length;
160            }
161
162            styleSheet.insertRule(selectors + '{' + rules + '}', index);
163        },
164
165        deleteRule: function (value) {
166            switch (this.getType(value)) {
167                case 'String':
168                    var pair = clearText(value).replace(/\}/, '').split(/\{/),
169                        rule;
170
171                    for (var i = 0; i < styleSheet.cssRules.length; i++) {
172                        rule = clearText(styleSheet.cssRules[i].cssText, true);
173
174                        if (rule[0] == pair[0]) {
175                            if (!pair[1]) {
176                                _deleteRule(i);
177                            } else if (rule[0] == pair[0]) {
178                                _deleteRule(i);
179                            }
180                        }
181                    }
182
183                    break;
184                case 'Number':
185                    value = parseInt(value);
186
187                    if (value < styleSheet.cssRules.length) {
188                        _deleteRule(parseInt(value));
189                    }
190
191                    break;
192                default:
193                    $.each(styleSheet.cssRules, function (index) {
194                        _deleteRule(index);
195                    });
196                    break;
197            }
198
199            function _deleteRule (_index) {
200                styleSheet.deleteRule(_index);
201            }
202
203            function clearText (text, status) {
204                text = text
205                    .replace(/[\r\n'"]/g, '')
206                    .replace(/^\s+/, '')
207                    .replace(/\s+$/, '')
208                    .replace(/\s*([\;\,\:\{])\s*/g, '$1')
209                    .replace(/;?\s*(\})/, '$1')
210                    .replace(/\s+/g, ' ');
211
212                return status ? text.replace('}', '').split('{') : text;
213            }
214        },
215
216        pushState: function (options) {
217            state('push', options);
218            return this.getQuery();
219        },
220
221        replaceState: function (options) {
222            state('replace', options);
223            return this.getQuery();
224        },
225
226        getURLParts: function (url, hash) {
227            url = url !== undefined ? url : location.href;
228
229            var hash = url.split('#'),
230                search = hash[0].split('?'),
231                result = {
232                    hash: hash[1]
233                };
234
235            if (search[1]) {
236                result.path = search[0];
237                result.search = search[1];
238            } else if (/[&,=]/.test(search[0])) {
239                result.path = '';
240                result.search = search[0];
241            } else {
242                result.path = search[0];
243                result.search = '';
244            }
245
246            return result;
247        },
248
249        getURL: function (options) {
250            options = options || {};
251
252            var href = this.getURLParts(options.url),
253                query,
254                result = [];
255
256            options.url = href.search;
257            query = this.getQuery(options);

258            Object.keys(query).forEach(function (name) {
259                result.push(name + '=' + query[name].join(','));
260            });
261
262            if (href.path && result.length) {
263                href.path += '?';
264            }
265
266            result = href.path + result.join('&');
267
268            if (href.hash && options.hash) {
269                result += '#' + href.hash;
270            }
271
272            return result;
273        },
274
275        getFormData: function () {
276            var result = {};
277
278            for (var i = 0; i < arguments.length; i++) {
279                var set = arguments[i];
280
281                switch (this.getType(set)) {
282                    case 'String':
283                        set = set.split('&');
284                    case 'Array':
285                        set.forEach(function (pair) {
286                            pair = decodeURIComponent(pair).split('=');
287                            result[pair[0]] = pair[1];
288                        });
289                        break;
290                    case 'Object':
291                        Object.keys(set).forEach(function (name) {
292                            result[name] = set[name];
293                        });
294                        break;
295                }
296            }
297
298            return result;
299        },
300
301        getQuery: function (options) {
302            options = options || {};
303
304            if (!options.query) {
305                options.query = this.getURLParts(options.url).search;
306            }
307
308            var query = makeObject(options.query),
309                add = makeObject(options.add),
310                remove = makeObject(options.remove),
311                replace = makeObject(options.replace);
312
313            Object.keys(remove).forEach(function (id) {
314                if (remove[id]) {
315                    Object.keys(remove[id]).forEach(function (value) {
316                        removeItem(add[id], value);
317                        removeItem(replace[id], value);
318                        removeItem(query[id], value);
319                    });
320                } else {
321                    delete add[id];
322                    delete replace[id];
323                    delete query[id];
324                }
325            });
326
327            Object.keys(replace).forEach(function (id) {
328                if (replace[id].length) {
329                    query[id] = options.single ? replace[id][0] : replace[id];
330                } else {
331                    delete query[id];
332                }
333            });
334
335            Object.keys(add).forEach(function (id) {
336                if (!query[id] || !query[id].length) {
337                    query[id] = _class.mergeArray([], add[id]);
338                } else {
339                    query[id] = _class.mergeArray([], query[id], add[id]);
340                }
341            });
342
343            if (options.name) {
344                return query[options.name];
345            } else {
346                return query;
347            }
348
349            function removeItem (set, value) {
350                if (set) {
351                    var index = set.indexOf(value);
352
353                    if (index >= 0) {
354                        set.splice(index, 1);
355                    }
356                }
357            }
358
359            function makeObject (list) {
360                if (list) {
361                    switch (_class.getType(list)) {
362                        case 'String':
363                            list = list.split(/\s*&\s*/);
364
365                            if (list.length == 1 && !list[0]) {
366                                // list = list[0].split(/\s*,\s*/);
367
368                                // if (list.length == 1 && !list[0]) {
369                                // 	return {};
370                                // }
371
372                                if (!list.length) {
373                                    return {};
374                                }
375                            }
376                        case 'Array':
377                            var object = {};
378
379                            list.forEach(function (value) {
380                                var pair = value.split(/\s*=\s*/);
381
382                                if (pair[1]) {
383                                    object[pair[0]] = getValue(pair[1]);
384                                } else {
385                                    object[pair[0]] = [];
386                                }
387                            });
388                            return object;
389                        case 'Object':
390                            Object.keys(list).forEach(function (key) {
391                                if (list[key]) {
392                                    switch (_class.getType(list[key])) {
393                                        case 'String':
394                                            list[key] = getValue(list[key]);
395                                            break;
396                                        case 'Array':
397                                            break;
398                                        case 'Object':
399                                            list[key] = Object.keys(list[key]);
400                                            break;
401                                        default:
402                                            list[key] = [list[key].toString()];
403                                            break;
404                                    }
405                                } else {
406                                    list[key] = [];
407                                }
408                            });
409                            return list;
410                        default:
411                            return {};
412                    }
413                } else {
414                    return {};
415                }
416
417                function getValue (value) {
418                    if (value.match(/^\[(.+)\]$/)) {
419                        return [value];
420                    } else {
421                        return _class.getArray(value);
422                    }
423                }
424            }
425        },
426
427        mergeArray: function () {
428            var result = this.getArray(arguments[0]);
429
430            for (var i = 1; i < arguments.length; i++) {

431                this.getArray(arguments[i]).forEach(function (value) {
432                    if (result.indexOf(value) < 0) {
433                        result.push(value);
434                    }
435                });
436            }
437
438            return result;
439        },
440
441        getArray: function (object, separator) {
442            switch (this.getType(object)) {
443                case 'String':
444                    return object.replace(/^\s+/g, '').replace(/\s+$/g, '').split(/\s*,\s*/);
445                case 'Array':
446                    return object.slice();
447                case 'Object':
448                    return Object.keys(object);
449                default:
450                    return [];
451            }
452        },
453
454        getCookie: function (name) {
455            var cookies = document.cookie,
456                result = {};
457
458            if (cookies) {
459                cookies
460                    .replace(/^\s+/, '')
461                    .replace(/\s+$/, '')
462                    .split(/\s*;\s*/)
463                    .forEach(function (value) {
464                        value = value.split(/\s*=\s*/);
465                        result[value[0]] = value[1];
466                    });
467            }
468
469            return name ? result[name] : result;
470        },
471
472        setCookie: function (options) {
473            var cookies = this.getCookie(),
474                newCookies = [],
475                oldCookies = [],
476                // oldDate = new Date(0),
477                // expireDate = new Date(),
478                settings = [
479                    'path=/',
480                    'domain=' + location.hostname
481                ];
482
483            // expireDate.setDate(expireDate.getDate() + 30);
484
485            switch (this.getType(options)) {
486                case 'String':
487                    options = options
488                        .replace(/^\s+/, '')
489                        .replace(/\s+$/, '')
490                        .split(/\s*;\s*/);
491                case 'Array':
492                    options.forEach(function (value) {
493                        value = value.split(/\s*=\s*/);
494                        setResult(value[0], value[1]);
495                    });
496                    break;
497                case 'Object':
498                    Object.keys(options).forEach(function (name) {
499                        setResult(name, options[name]);
500                    });
501                    break;
502            }
503
504            if (oldCookies.length) {
505                oldCookies = oldCookies.concat(settings, 'max-age=0');
506                document.cookie = oldCookies.join('; ');
507            }
508
509            if (newCookies.length) {
510                newCookies = newCookies.concat(settings, 'max-age=' + 30 * 24 * 60 * 60);
511                document.cookie = newCookies.join('; ');
512            }
513
514            function setResult (name, value) {
515                switch (_class.getType(value)) {
516                    case undefined:
517                    case null:
518                        if (name in cookies) {
519                            if (cookies[name] === undefined) {
520                                oldCookies.push(name);
521                            } else {
522                                oldCookies.push(name + '=' + cookies[name]);
523                            }
524
525                            delete cookies[name];
526                        }
527
528                        break;
529                    default:
530                        newCookies.push(name + '=' + value);
531                        cookies[name] = value;
532                        break;
533                }
534            }
535        }
536    };
537
538    function state (type, options) {
539        try {
540            history[type + 'State'](
541                options.state || options.query,
542                options.title || document.title,
543                _class.getURL({
544                    url: options.href,
545                    replace: options.query,
546                    hash: !options.removeHash
547                })
548            );
549        } catch (z) {}
550    }
551
552    return _class;
553}();
554
555var $Params = function () {
556    var dummyStyle = document.documentElement.style,
557        transitionend = {
558            '': 'transitionend',
559            'webkit': 'webkitTransitionEnd',
560            'Moz': 'transitionend',
561            'O': 'otransitionend',
562            'ms': 'MSTransitionEnd'
563        },
564        vendor = (function () {
565            var result = false;

566
567            't,webkitT,MozT,msT,OT'.split(',').some(function (value) {
568                if (value + 'ransform' in dummyStyle) {
569                    result = value.slice(0, value.length - 1);
570                    return true;
571                }
572            });
573            return result;
574        })(),
575        touchPad = (/hp-tablet/gi).test(navigator.appVersion),
576        hasTouch = 'ontouchstart' in window && !touchPad;
577
578    function prefixStyle (style) {
579        if (vendor === '') {
580            return style;
581        }
582
583        style = style.charAt(0).toUpperCase() + style.substr(1);
584        return vendor + style;
585    }
586
587    return {
588        isAndroid: (/android/gi).test(navigator.appVersion),
589        isIDevice: (/iphone|ipad/gi).test(navigator.appVersion),
590        isTouchPad: touchPad,
591        cssVendor: vendor ? '-' + vendor.toLowerCase() + '-' : '',
592        has3d: prefixStyle('perspective') in dummyStyle,
593        hasTouch: hasTouch,
594        hasTransform: vendor !== false,
595        hasTransitionEnd: prefixStyle('transition') in dummyStyle,
596        transform: prefixStyle('transform'),
597        transformOrigin: prefixStyle('transformOrigin'),
598        transitionProperty: prefixStyle('transitionProperty'),
599        transitionDuration: prefixStyle('transitionDuration'),
600        transitionTimingFunction: prefixStyle('transitionTimingFunction'),
601        transitionDelay: prefixStyle('transitionDelay'),
602        deviceWidth: screen.width,
603        deviceHeight: screen.height,
604
605        altEvents: {
606            resize: 'onorientationchange' in window ? 'orientationchange' : 'resize',
607            start: hasTouch ? 'touchstart' : 'mousedown',
608            move: hasTouch ? 'touchmove' : 'mousemove',
609            end: hasTouch ? 'touchend' : 'mouseup',
610            cancel: hasTouch ? 'touchcancel' : 'mouseup',
611            transitionEnd: vendor !== false ? transitionend[vendor] : false
612        },
613
614        getTranslate: function(x, y) {
615            if (this.has3d) {
616                return 'translate3d(' + x + ', ' + y + ', 0)';
617            } else {
618                return 'translate(' + x + ', ' + y + ')';
619            }
620        }
621    }
622}();
623
624var $Mediator = function () {
625    var _class,
626        eventsList = {},
627        lastEventsList = {};
628
629    _class = {
630        on: function () {
631            checkHandlers({
632                args: Array.prototype.slice.call(arguments),
633                prepare: addHandlers
634            });
635            return this;
636        },
637
638        one: function () {
639            checkHandlers({
640                args: Array.prototype.slice.call(arguments),
641                once: true,
642                prepare: addHandlers
643            });
644            return this;
645        },
646
647        off: function () {
648            checkHandlers({
649                args: Array.prototype.slice.call(arguments),
650                once: true,
651                prepare: removeHandlers
652            });
653            return this;
654        },
655
656        fire: function (e) {
657            var args = Array.prototype.splice.call(arguments, 1),
658                names,
659                result = [];
660
661            switch ($Common.getType(e)) {
662                case 'String':
663                case 'Array':
664                    names = e;
665                    break;
666                case 'Object':
667                    names = e.name;
668                    break;
669                default:
670                    return;
671            }
672
673            checkValues(names, function (name) {
674                var event = getEvent(name),
675                    _event,
676                    _args,
677                    removeList = [];
678
679                switch ($Common.getType(e)) {
680                    case 'Object':
681                        _event = $Common.clone(e);
682                        break;
683                    default:
684                        _event = {};
685                        break;
686                }
687
688                _event.name = name;
689                _args = [_event].concat(args);
690                lastEventsList[name] = _args;
691
692                if (!event) {
693                    return;
694                }
695
696                event.progress = true;
697                execute(0);
698
699                function execute (index) {
700                    for (var i = index; i < event.handlers.length; i++) {
701                        var item = event.handlers[i],
702                            context = item.context || e.context || null;
703
704                        if (e.type && item.type != e.type) {
705                            continue;
706                        }
707
708                        if (item.once) {
709                            removeList.push(i);
710                        }
711
712                        if (item.async) {
713                            runHandler(item.handler, context, _args).then(function (_result) {
714                                if (item.report) {
715                                    result.push(_result);
716                                }
717
718                                execute(i + 1);
719                            });
720                            break;
721                        } else {
722                            if (item.report) {
723                                result.push(runHandler(item.handler, context, _args));
724                            } else {
725                                runHandler(item.handler, context, _args);
726                            }
727                        }
728                    }
729
730                    if (result.length == event.reportCount && e.callback) {
731                        e.callback.apply(e.context || null, result);
732                    }
733
734                    if (i == event.handlers.length) {
735                        for (var i = removeList.length; i--;) {
736                            if (event.handlers[i].report) {
737                                event.reportCount--;
738                            }
739
740                            event.handlers.splice(i, 1);
741                        }
742
743                        delete event.progress;
744                    }
745                }
746            });
747
748            return this;
749        }
750    };
751
752    return _class;
753

754    function runHandler (handler, context, args) {
755        return handler.apply(context, args);
756    }
757
758    function checkHandlers (options) {
759        if (!options.args) {
760            return
761        }
762
763        switch ($Common.getType(options.args[0])) {
764            case 'String':
765                options.prepare({
766                    name: options.args[0],
767                    handlers: options.args.slice(1)
768                }, options.once);
769                break;
770            case 'Object':
771                options.args.forEach(function (item) {
772                    options.prepare(item, options.once);
773                });
774                break;
775        }
776    }
777
778    function addHandlers (item, once) {
779        var handlers = item.handlers;
780
781        checkValues(item.name, function (name) {
782            var event = setEvent(name);
783
784            checkValues(handlers, function (execute) {
785                if (check(execute.handler || execute)) {
786                    return;
787                }
788
789                var data = set([
790                    'type',
791                    'async',
792                    'report',
793                    'track'
794                ], item, {
795                    context: item.context || null,
796                    order: item.order || 10,
797                    once: once
798                });
799
800                switch ($Common.getType(execute)) {
801                    case 'Object':
802                        set([
803                            'handler',
804                            'type',
805                            'context',
806                            'order',
807                            'async',
808                            'report',
809                            'track'
810                        ], execute, data);
811                        break;
812                    case 'Function':
813                        data.handler = execute;
814                        break;
815                }
816
817                setHandler(name, data);
818
819                if (data.track && lastEventsList[name] && !event.progress) {
820                    runHandler(data.handler, data.context, lastEventsList[name]);
821                }
822
823                function check (handler) {
824                    return event.handlers.some(function (item) {
825                        if (handler == item.handler && item.context == item.context) {
826                            return true;
827                        }
828                    });
829                }
830
831                function set (names, source, target) {
832                    names.forEach(function (name) {
833                        if (source[name] !== undefined) {
834                            target[name] = source[name];
835                        }
836                    });
837                    return target;
838                }
839            });
840        });
841    }
842
843    function removeHandlers (item) {
844        checkValues(item.name, function (name) {
845            if (item.handlers) {
846                checkValues(item.handlers, function (handler) {
847                    var options = {
848                        handler: handler
849                    };
850
851                    if (item.context) {
852                        options.context = item.context;
853                    }
854
855                    resetHandlers(name, options);
856                });
857            } else if (item.context) {
858                resetHandlers(name, {
859                    context: item.context
860                });
861            } else {
862                resetEvent(name);
863            }
864        });
865    }
866
867    function getEvent (name) {
868        return eventsList[name];
869    }
870
871    function setEvent (name) {
872        if (!eventsList[name]) {
873            eventsList[name] = {
874                handlers: [],
875                reportCount: 0
876            };
877        }
878
879        return eventsList[name];
880    }
881
882    function resetEvent (name) {
883        delete eventsList[name];
884    }
885
886    function resetHandlers (name, options) {
887        var event = eventsList[name];
888
889        if (!event) {
890            return;
891        }
892
893        var handlers = getHandlers(name);
894
895        if (!handlers || !handlers.length) {
896            return;
897        }
898
899        var keys = Object.keys(options);
900
901        for (var i = handlers.length ; i--;) {
902            if (check(handlers[i])) {
903                if (handlers[i].report) {
904                    event.reportCount--;
905                }
906
907                handlers.splice(i, 1);
908            }
909        }
910
911        function check (item) {
912            return keys.every(function (key) {
913                return options[key] == item[key];
914            });
915        }
916    }
917
918    function getHandlers (name) {
919        if (eventsList[name]) {
920            return eventsList[name].handlers;
921        }
922    }
923
924    function setHandler (name, data) {
925        var event = eventsList[name];
926
927        if (event) {
928            event.handlers.push(data);
929
930            if (data.report) {
931                event.reportCount++;
932            }
933
934            event.handlers.sort(function (a, b) {
935                return a.order - b.order;
936            });
937        }
938    }
939
940    function checkValues (values, callback) {
941        switch ($Common.getType(values)) {
942            case 'String':
943                values = values.split(/\s+/);
944            case 'Array':

945                values.forEach(function (value) {
946                    callback(value);
947                });
948                break;
949            case 'Function':
950                callback(values);
951                break;
952        }
953    }
954}();
955
956var $Input = function () {
957    var mainRules = [
958            'boxSizing',
959            'borderTopStyle',
960            'borderTopStyle',
961            'borderTopWidth',
962            'borderBottomStyle',
963            'borderBottomWidth',
964            'paddingTop',
965            'paddingRight',
966            'paddingBottom',
967            'paddingLeft',
968            'lineHeight',
969            'fontSize',
970            'fontFamily',
971            'fontWeight',
972            'fontStyle',
973            'fontVariant',
974            'fontStretch',
975            'fontSizeAdjust',
976            'textTransform',
977            'textDecoration',
978            'textIndent',
979            'wordSpacing',
980            'letterSpacing'
981        ],
982        sendDelay,
983        _class;
984
985    _class = {
986        prepareInput: function (options) {
987            if (!options.element) {
988                options.element = $(options.selector || 'textarea', options.context);
989            }
990
991            setTimeout(function () {
992                options.element.each(function () {
993                    var $item = $(this),
994                        rule = $item.data('rule'),
995                        cs = getComputedStyle(this, null),
996                        styles = {},
997                        itemStyle = {
998                            overflow: 'hidden',
999                            resize: 'none'
1000                        };
1001
1002                    for (var i = mainRules.length; i--;) {
1003                        if (cs[mainRules[i]] !== undefined) {
1004                            styles[mainRules[i]] = cs[mainRules[i]];
1005                        }
1006                    }
1007
1008                    if (rule) {
1009                        switch (rule) {
1010                            case 'max':
1011                            case 'fix':
1012                                itemStyle = {
1013                                    overflow: 'auto',
1014                                    resize: 'none'
1015                                };
1016
1017                                break;
1018                        }
1019
1020                        $item.data({
1021                            edge: getHeight(this, getFakeValue($item.data('size')))
1022                        });
1023                    }
1024
1025                    $item.css(itemStyle).data({
1026                        styles: styles,
1027                        offset: parseInt(cs.paddingTop) + parseInt(cs.paddingBottom)
1028                    });
1029
1030                    setInputHeight(this, true);
1031
1032                    $item
1033                        .on('mousemove', itemMouseMove)
1034                        .on('mousedown', itemMouseDown)
1035                        .on('mouseup', itemMouseUp)
1036                        .on('focus', itemFocus)
1037                        .on('input', itemContentChange);
1038                });
1039            }, 0);
1040
1041            function itemContentChange() {
1042                setInputHeight(this);
1043
1044                if (options.callback) {
1045                    options.callback(this);
1046                }
1047            }
1048
1049            function itemMouseMove (e) {
1050                e.stopPropagation();
1051            }
1052
1053            function itemMouseDown () {
1054                $(this).data({
1055                    width: this.offsetWidth,
1056                    height: this.offsetHeight
1057                });
1058            }
1059
1060            function itemMouseUp () {
1061                var $item = $(this);
1062
1063                if ($item.data('width') != this.offsetWidth || $item.data('height') != this.offsetHeight) {
1064                    setInputHeight(this);
1065                }
1066            }
1067
1068            function itemFocus () {
1069                _class.test.css($.extend($(this).data('styles'), {
1070                    width: this.offsetWidth
1071                }));
1072            }
1073
1074            function setInputHeight (item, status) {
1075                var $item = $(item),
1076                    rule = $item.data('rule'),
1077                    height = getHeight(item);
1078
1079                if (rule) {
1080                    var edge = $item.data('edge');
1081
1082                    switch (rule) {
1083                        case 'min':
1084                            if (height < edge) {
1085                                height = edge;
1086                            }
1087
1088                            break;
1089                        case 'max':
1090                            if (height > edge) {
1091                                height = edge;
1092                            }
1093
1094                            break;
1095                        case 'fix':
1096                            height = edge;
1097                            break;
1098                    }
1099                }
1100
1101                if ($item.data('height') != height) {
1102                    $item.css({
1103                        height: height + 'px'
1104                    }).data({
1105                        height: height
1106                    });
1107
1108                    if (!status) {
1109                        $item.trigger('height:input');
1110                    }
1111                }
1112            }
1113
1114            function getHeight (item, value) {
1115                var inputStyles = $(item).data('styles'),
1116                    delta = {
1117                        top: 0,
1118                        bottom: 0
1119                    };
1120
1121                switch (inputStyles.boxSizing) {
1122                    case 'border-box':
1123                        delta.top += parseInt(inputStyles.borderTopWidth);
1124                        delta.bottom += parseInt(inputStyles.borderBottomWidth);
1125                    case 'padding-box':
1126                        delta.top += parseInt(inputStyles.paddingTop);
1127                        delta.bottom += parseInt(inputStyles.paddingBottom);
1128                        break;
1129                }
1130
1131                _class.test.css($.extend(inputStyles, {
1132                    width: item.offsetWidth
1133                })).html(value || item.value.replace(/[\r\n]/g, '<br>').replace(/(<br>)$/, '$1*') || '*');
1134
1135                return _class.test.get(0).offsetHeight;
1136            }
1137
1138            function getFakeValue (size) {
1139                for (var value = '*', i = parseInt(size) - 1; i--;) {
1140                    value += '<br>*';
1141                }
1142
1143                return value;
1144            }
1145        }
1146    };
1147
1148    $(function () {
1149        _class.test = $('<div>').css({
1150            boxSizing: 'border-box',
1151            whiteSpace: 'pre-wrap',
1152            wordWrap: 'break-word'
1153        }).appendTo(
1154            $('<div>').css({
1155                position: 'absolute',
1156                overflow: 'hidden',
1157                width: 0,
1158                height: 0
1159            }).appendTo(
1160                $(document.body)
1161            )
1162        );
1163    });
1164
1165    return _class;
1166}();
1167
1168var $Franchise = function () {
1169    var _mainClass = {},
1170        root = document.documentElement,
1171        userMode = $(root).data('version'),
1172        iscrollOptions = {
1173            common: {
1174                scrollbars: 'custom'
1175            },
1176            X: {
1177                scrollX: true
1178            },
1179            Y: {
1180                scrollY: true,
1181                preventDefault: false
1182            }
1183        },
1184        iDeviceMode;
1185
1186    if ($Params.hasTouch) {
1187        // if ($Params.isIDevice) {
1188        $(root).addClass('idevice');
1189        iDeviceMode = true;
1190        // }
1191        $.extend(iscrollOptions.X, {
1192            eventPassthrough: true
1193        });
1194    } else {
1195        $.extend(iscrollOptions.Y, {
1196            // interactiveScrollbars: true,
1197            mouseWheel: true,
1198            click: true
1199        });
1200    }
1201
1202    if (document.documentMode && document.documentMode <= 11) {
1203        $(root).addClass('old-browser');
1204    }
1205
1206    $(window)
1207        .on('resize orientationchange', checkPageWidth)
1208        .on('scroll', checkPageScroll);
1209
1210    $.extend(_mainClass, {
1211        getOptions: function (url, param) {
1212            var result = $Common.getURLParts(url),
1213                _param = {};
1214
1215            for (var i = 1; i < arguments.length; i++) {
1216                _param = $.extend(_param, arguments[i]);
1217            }
1218
1219            return $.extend(result, {
1220                query: $Common.getQuery({
1221                    url: result.search,
1222                    add: _param
1223                })
1224            });
1225        },
1226
1227        getMethod: function (data) {
1228            var method;
1229
1230            if (data) {
1231                method = data.method;
1232

1233                if (!method) {
1234                    try {
1235                        method = data.attr('method');
1236                    } catch (z) {
1237                        try {
1238                            method = data.data('method');
1239                        } catch (z) {}
1240                    }
1241                }
1242            }
1243
1244            return method || 'POST';
1245        },
1246
1247        getSendParam: function (options, sendParam) {
1248            var result,
1249                sendData = $Common.clone.apply($Common, Array.prototype.slice.call(arguments, 2).concat([
1250                    options.query,
1251                    {
1252                        sessid: BX.bitrix_sessid()
1253                    }
1254                ]));
1255
1256            if (sendParam.method.toUpperCase() == 'GET') {
1257                result = {
1258                    url: $Common.getURL({
1259                        url: options.path,
1260                        query: sendData
1261                    }),
1262                    data: null
1263                };
1264            } else {
1265                result = {
1266                    url: options.path,
1267                    data: sendData
1268                };
1269            }
1270
1271            return $Common.clone(sendParam, result);
1272        },
1273
1274        send: function (sendData, success, error) {
1275            $.ajax(sendData)
1276                .done(function (data) {
1277                    success.call(null, data);
1278                }).fail(function () {
1279                error.apply(null, Array.prototype.slice.apply(arguments));
1280            });
1281        }
1282    });
1283
1284    _mainClass.$Cart = function () {
1285        var _class = {},
1286            activeClass = 'cart-menu-active',
1287            fixedStopClass = 'cart-fixed',
1288            scrollEvents = [
1289                // $Params.hasTouch ? 'touchmove' : 'scroll',
1290                'touchmove',
1291                'scroll',
1292                'resize',
1293                'orientationchange'
1294            ].join(' ');
1295
1296        $(function () {
1297            var headerWrapper = $('[data-wrapper="header"]');
1298
1299            $(window).on(scrollEvents, checkScroll);
1300            checkScroll.call(window);
1301
1302            function checkScroll () {
1303                var wrapperTop = headerWrapper.offset().top,
1304                    delta = headerWrapper.outerHeight(),
1305                    offset = $(this).scrollTop();
1306
1307                if (this.innerWidth > 768) {
1308                    if (wrapperTop + delta < offset) {
1309                        $(root).addClass(fixedStopClass);
1310                    } else {
1311                        $(root).removeClass(fixedStopClass);
1312                    }
1313                } else {
1314                    $(root).removeClass(fixedStopClass);
1315                }
1316            }
1317        });
1318
1319        $(document)
1320            .on('click', '[data-action="cart-toggle"]', function (e) {
1321                $(this).closest('[data-item="cart"]').toggleClass(activeClass);
1322            });
1323    }();
1324
1325    _mainClass.$Filter = function () {
1326        var _class = {},
1327
1328            filterActiveClass = 'filter-active',
1329            toggleActiveClass = 'toggle-active',
1330            checkedActiveClass = 'filter-checked',
1331            resultsActiveClass = 'filter-results-active',
1332            wideClass = 'wrapper-wide',
1333            parentClass = 'item-parent',
1334
1335            toggleWrapperSelector = '[data-action="toggle"]',
1336            listWrapperSelector = '[data-wrapper="filter"]',
1337            listItemSelector = '[data-item="filter"]',
1338            childListSelector = '[data-parent="filter"]',
1339            listItemChoiceSelector = '[data-action="choice"]',
1340            listItemActionSelector = '[data-action="filter"]',
1341            resultsWrapperSelector = '[data-wrapper="result"]',
1342            resultsContentSelector = '[data-content="result"]',
1343            inputWrapperSelector = '[data-wrapper="field"]',
1344            searchWrapperSelector = '[data-wrapper="search"]',
1345
1346            query = $Common.getQuery(),
1347            filterParam,
1348            listScrollOptions = $Common.clone(iscrollOptions.common, iscrollOptions.Y);
1349
1350        function Result (resultWrapper) {
1351            var resultItem = this,
1352                resultTemplate = getTemplate($('[data-template="result"]', resultWrapper));
1353
1354            $.extend(this, {
1355                wrapper: resultWrapper,
1356                target: $(resultsContentSelector, resultWrapper),
1357                template: resultTemplate,
1358                items: {}
1359            });
1360
1361            $Mediator
1362                .on('get:result', function (e, data) {
1363                    if (data) {

1364                        Object.keys(data).forEach(function (name) {
1365                            if (data[name]) {
1366                                resultItem.set(name, data[name]);
1367                            } else {
1368                                resultItem.remove(name);
1369                            }
1370                        });
1371                    } else {
1372                        Object.keys(resultItem.items).forEach(function (name) {
1373                            resultItem.remove(name);
1374                        });
1375                    }
1376                })
1377                .on('remove:result', function (e, name) {
1378                    resultItem.remove(name);
1379                });
1380
1381            resultWrapper
1382                .on('click', '[data-action="reset"]', function () {
1383                    $Mediator
1384                        .fire('reset:result')
1385                        .fire('get:result');
1386                    resultItem.target.empty();
1387                })
1388                .on('click', '[data-action="result"]', function () {
1389                    var item = $(this),
1390                        name = item.data('name'),
1391                        data = {};
1392
1393                    data[name] = null;
1394                    resultItem.remove(name);
1395                    $Mediator
1396                        .fire('reset:result', data)
1397                        .fire('get:result', data);
1398                });
1399        }
1400
1401        Result.prototype = {
1402            set: function (name, data) {
1403                if (!this.items[name]) {
1404                    var value = data.value
1405                            .replace(/</g, '&lt;')
1406                            .replace(/>/g, '&gt;'),
1407                        title = data.title ? data.title
1408                            .replace(/</g, '&lt;')
1409                            .replace(/>/g, '&gt;') : value,
1410                        item = this.template
1411                            .replace('{#name}', name)
1412                            .replace('{#value}', value)
1413                            .replace('{#title}', title);
1414
1415                    this.items[name] = $(item).appendTo(this.target);
1416                    this.wrapper.addClass(resultsActiveClass);
1417                }
1418            },
1419
1420            get: function (name) {
1421                return this.items[name];
1422            },
1423
1424            remove: function (name) {
1425                if (this.items[name]) {
1426                    this.items[name].remove();
1427                    delete this.items[name];
1428
1429                    if (!Object.keys(this.items).length) {
1430                        this.wrapper.removeClass(resultsActiveClass);
1431                    }
1432                }
1433            }
1434        };
1435
1436        function Search (searchWrapper) {
1437            var searchItem = this,
1438                input = $('input', searchWrapper),
1439                name = input.eq(0).attr('name'),
1440                searchDelay;
1441
1442            $.extend(this, {
1443                wrapper: searchWrapper,
1444                input: input
1445            });
1446
1447            if (query[name] && query[name][0]) {
1448                var data = {},
1449                    value = decodeURIComponent(query[name][0]);
1450
1451                data[name] = {
1452                    value: value
1453                };
1454                $Mediator.fire('get:result', data);
1455            }
1456
1457            _class.search[name] = this;
1458            searchWrapper
1459                .on('input', function () {
1460                    clearTimeout(searchDelay);
1461                    searchDelay = setTimeout(done, 500);
1462
1463                    function done () {
1464                        var data = {};
1465
1466                        $Mediator.fire('remove:result', name);
1467
1468                        if (input.val()) {
1469                            data[name] = {
1470                                value: input.val() || null
1471                            };
1472                        } else {
1473                            data[name] = null;
1474                            $Mediator.fire('reset:result', data);
1475                        }
1476
1477                        $Mediator.fire('get:result', data);
1478                    }
1479                });
1480
1481            $Mediator.on('reset:result', function (e, data) {
1482                if (!data || name in data) {
1483                    input.val('');
1484                }
1485            });
1486        }
1487
1488        function Input (inputWrapper) {
1489            var inputItem = this,
1490                inputs = $('input', inputWrapper),
1491                name = inputs.eq(0).attr('name');
1492
1493            $.extend(this, {
1494                wrapper: inputWrapper,
1495                inputs: inputs
1496            });
1497
1498            inputs.each(function () {
1499                inputItem.inputs[this.value] = {
1500                    input: this,
1501                    value: this.value,
1502                    title: $.trim($(this).closest('[data-item="label"]').text())
1503                };
1504            });
1505
1506            _class.input[name] = this;
1507
1508            if (query[name]) {
1509                var item = this.inputs[query[name][0]],
1510                    data = {};
1511
1512                item.input.checked = true;
1513                data[name] = item;
1514                $Mediator.fire('get:result', data);
1515            }
1516
1517            inputWrapper
1518                .on('change', 'input', function () {
1519                    var data = {};
1520
1521                    if (this.checked) {
1522                        data[name] = inputItem.inputs[this.value];
1523                    } else {
1524                        data[name] = null;
1525                    }
1526
1527                    $Mediator.fire('get:result', data);
1528                });
1529
1530            $Mediator.on('reset:result', function (e, data) {
1531                if (!data || name in data) {
1532                    inputs.each(function () {
1533                        this.checked = false;

1534                    });
1535                }
1536            });
1537        }
1538
1539        function List (listWrapper) {
1540            var listItem = this,
1541                name = listWrapper.data('name');
1542
1543            if (!name) {
1544                name = 'set_' + Object.keys(_class.list).length;
1545            }
1546
1547            _class.list[name] = this;
1548            $.extend(this, {
1549                wrapper: listWrapper,
1550                parent: listWrapper.closest(listWrapperSelector),
1551                scrollWrapper: $('[data-wrapper="scroll"]', listWrapper),
1552                name: name,
1553                checkedItems: {},
1554                activeItems: {},
1555                items: {}
1556            });
1557            $(listItemSelector, listWrapper).each(function () {
1558                new Field($(this), listItem);
1559            });
1560
1561            if (listWrapper.data('type') == 'scroll') {
1562                this.scrollType = true;
1563            }
1564
1565            listWrapper
1566                .on('click', toggleWrapperSelector, listItem.toggle.bind(this))
1567                .on('click', listItemActionSelector, function (e) {
1568                    var item = $(this).closest(listItemSelector),
1569                        id = item.data('name');
1570
1571                    e.stopPropagation();
1572                    listItem.items[id].toggleActive();
1573                })
1574                .on('click', listItemChoiceSelector, function (e) {
1575                    var item = $(this),
1576                        parent = item.closest(listItemSelector),
1577                        id = parent.data('name');
1578
1579                    e.stopPropagation();
1580
1581                    if (!listItem.getCheckedItems(id)) {
1582                        listItem.setCheckedItems(id);
1583                    } else {
1584                        listItem.resetCheckedItems(id);
1585                    }
1586                });
1587
1588            $Mediator.on('reset:result', function (e, data) {
1589                if (data) {
1590                    Object.keys(data).forEach(function (id) {
1591                        if (listItem.get(id)) {
1592                            listItem.resetCheckedItems(id);
1593                        }
1594                    });
1595                } else {
1596                    listItem.resetCheckedItems();
1597                }
1598            });
1599        }
1600
1601        List.prototype = {
1602            setScroll: function () {
1603                if (this.scroll) {
1604                    this.scroll.refresh();
1605                } else {
1606                    this.scroll = new IScroll(this.scrollWrapper.get(0), listScrollOptions);
1607                }
1608            },
1609
1610            resetScroll: function () {
1611                if (this.scroll) {
1612                    this.scroll.scroller.removeAttribute('style');
1613                    this.scroll.destroy();
1614                    delete this.scroll;
1615                }
1616            },
1617
1618            show: function () {
1619                if (_class.activeList) {
1620                    _class.activeList.close();
1621                }
1622
1623                this.wrapper.addClass(toggleActiveClass);
1624                _class.activeList = this;
1625
1626                if (_class.scrollType && this.scrollType) {
1627                    this.setScroll();
1628                }
1629            },
1630
1631            close: function () {
1632                this.wrapper.removeClass(toggleActiveClass);
1633                delete _class.activeList;
1634            },
1635
1636            toggle: function () {
1637                if (this != _class.activeList) {
1638                    this.show();
1639                } else {
1640                    this.close();
1641                }
1642            },
1643
1644            set: function (id, item) {
1645                this.items[id] = item;
1646            },
1647
1648            get: function (id) {
1649                return this.items[id];
1650            },
1651
1652            getActiveItems: function (level) {
1653                if (level !== undefined) {
1654                    return this.activeItems[level];
1655                } else {
1656                    return this.activeItems;
1657                }
1658            },
1659

1660            setActiveItems: function (id) {
1661                if (id !== undefined) {
1662                    var item = this.get(id);
1663
1664                    this.activeItems[item.level] = id;
1665                    this.parent.toggleClass(wideClass, !!this.get(this.activeItems[0]).children);
1666
1667                    if (!item.children) {
1668                        this.setCheckedItems(id);
1669                    }
1670                }
1671            },
1672
1673            resetActiveItems: function (id) {
1674                var item = this.get(id);
1675
1676                delete this.activeItems[item.level];
1677
1678                if (!Object.keys(this.activeItems).length) {
1679                    this.parent.removeClass(wideClass);
1680                }
1681            },
1682
1683            getCheckedItems: function (id) {
1684                if (id !== undefined) {
1685                    if (this.checkedItems[id]) {
1686                        return this.get(id);
1687                    }
1688                } else {
1689                    return Object.keys(this.checkedItems);
1690                }
1691            },
1692
1693            setCheckedItems: function (id) {
1694                if (id !== undefined) {
1695                    var item = this.get(id),
1696                        data;
1697
1698                    if (item) {
1699                        this._setCheckedItems(id);
1700                        data = this._setCheckedItems(id);
1701                        $Mediator.fire('get:result', data);
1702                    }
1703                }
1704            },
1705
1706            _setCheckedItems: function (id) {
1707                var item = this.get(id),
1708                    data = {};
1709
1710                if (item.children) {
1711                    item.children.forEach(function (_id) {
1712                        var _item = this.get(_id);
1713
1714                        this.setCheckedItem(_id);
1715                        item.activeChildren[_id] = true;
1716                        data[_id] = {
1717                            value: 'Y',
1718                            title: _item.title
1719                        };
1720                    }.bind(this));
1721                }
1722
1723                if (item.parent) {
1724                    item.parent.activeChildren[id] = true;
1725
1726                    if (item.parent.children.length == Object.keys(item.parent.activeChildren).length) {
1727                        this.setCheckedItem(item.parent.id);
1728                        data[item.parent.id] = {
1729                            value: 'Y',
1730                            title: item.parent.title
1731                        };
1732                    } else {
1733                        this.resetCheckedItem(item.parent.id);
1734                        data[item.parent.id] = null;
1735                    }
1736                }
1737
1738                this.setCheckedItem(id);
1739                data[id] = {
1740                    value: 'Y',
1741                    title: item.title
1742                };
1743                return data;
1744            },
1745
1746            setCheckedItem: function (id) {
1747                var item = this.get(id);
1748
1749                if (item) {
1750                    this.checkedItems[id] = true;
1751                    item.wrapper.addClass(checkedActiveClass);
1752                }
1753            },
1754
1755            resetCheckedItems: function (id) {
1756                if (id === undefined) {

1757                    this.getCheckedItems().forEach(function (id) {
1758                        this.resetCheckedItem(id);
1759                    }.bind(this));
1760                } else {
1761                    if (this.get(id)) {
1762                        var data = this._resetCheckedItems(id);
1763                        $Mediator.fire('get:result', data);
1764                    }
1765                }
1766            },
1767
1768            _resetCheckedItems: function (id) {
1769                var item = this.get(id),
1770                    data = {};
1771
1772                if (item.children) {
1773                    item.children.forEach(function (_id) {
1774                        this.resetCheckedItem(_id);
1775                        data[_id] = null;
1776                    }.bind(this));
1777                }
1778
1779                // if (item.parent) {
1780                // 	delete item.parent.activeChildren[id];
1781                // 	this.resetCheckedItem(item.parent.id);
1782                // 	data[item.parent.id] = null;
1783                // }
1784
1785                this.resetCheckedItem(id);
1786                data[id] = null;
1787                return data;
1788            },
1789
1790            resetCheckedItem: function (id) {
1791                var item = this.get(id);
1792
1793                if (item) {
1794                    delete this.checkedItems[id];
1795                    item.wrapper.removeClass(checkedActiveClass);
1796                }
1797            }
1798        };
1799
1800        function Field (itemWrapper, list) {
1801            var filterItem = this,
1802                id = itemWrapper.data('name'),
1803                parentItem = itemWrapper.parent().closest(listItemSelector),
1804                titleItem = itemWrapper.children(listItemActionSelector),
1805                childBlock = itemWrapper.children(childListSelector),
1806                status,
1807                data = {};
1808
1809            $.extend(this, {
1810                id: id,
1811                list: list,
1812                title: $.trim(titleItem.text()),
1813                wrapper: itemWrapper
1814            });
1815
1816            if (childBlock.length) {
1817                this.children = [];
1818                this.activeChildren = {};
1819                itemWrapper.addClass(parentClass);
1820            }
1821
1822            if (parentItem.length) {
1823                var parent = list.get(parentItem.data('name'));
1824
1825                this.level = parent.level + 1;
1826                this.parent = parent;
1827                parent.children.push(id);
1828
1829                if (list.getCheckedItems(parent.id)) {
1830                    status = true;
1831                }
1832            } else {
1833                this.level = 0;
1834            }
1835
1836            list.set(id, this);
1837
1838            if (query[id]) {
1839                status = true;
1840            }
1841
1842            if (status) {
1843                list.setCheckedItems(id);
1844            }
1845        }
1846
1847        Field.prototype = {

1848            setActive: function () {
1849                this.wrapper.addClass(filterActiveClass);
1850                this.list.setActiveItems(this.id);
1851            },
1852
1853            resetActive: function () {
1854                this.wrapper.removeClass(filterActiveClass);
1855                this.list.resetActiveItems(this.id);
1856            },
1857
1858            toggleActive: function () {
1859                if (this.children) {
1860                    var activeID = this.list.getActiveItems(this.level);
1861
1862                    if (activeID == this.id) {
1863                        this.resetActive();
1864                    } else {
1865                        if (activeID) {
1866                            this.list.get(activeID).resetActive();
1867                        }
1868
1869                        this.setActive();
1870                    }
1871                } else {
1872                    if (this.list.getCheckedItems(this.id)) {
1873                        this.list.resetCheckedItems(this.id);
1874                    } else {
1875                        this.list.setCheckedItems(this.id);
1876                    }
1877                }
1878            }
1879        };
1880
1881        $(function () {
1882            var filterWrapper = $('[data-wrapper="filter-fields"]'),
1883                paginationWrapper = $('[data-wrapper="pagination"]'),
1884                productWrapper = $('[data-wrapper="product-list"]'),
1885                formWrapper = $('[data-wrapper="form"]', filterWrapper),
1886                filterParam = getFullParam(formWrapper, 'filter'),
1887
1888                options = _mainClass.getOptions(formWrapper.attr('action'), getFullParam(formWrapper, 'param')),
1889                sendParam = {
1890                    method: _mainClass.getMethod(formWrapper),
1891                    dataType: 'json'
1892                },
1893                resultDelay;
1894
1895            if (!filterWrapper.length) {
1896                return;
1897            }
1898
1899            $.extend(_class, {
1900                list: {},
1901                input: {},
1902                search: {},
1903                data: {},
1904                send: function (data) {
1905                    var sendData = data || this.data,
1906                        param = {};
1907
1908                    switch (Object.keys(sendData).length) {
1909                        case 1:
1910                            if (filterParam.get in sendData) {
1911                                reset();
1912                            } else {
1913                                set();
1914                            }
1915
1916                            break;
1917                        case 0:
1918                            reset();
1919                            break;
1920                        default:
1921                            set();
1922                            break;
1923                    }
1924
1925                    _class.setURL(sendData);
1926                    param = _mainClass.getSendParam(options, sendParam, sendData, param);
1927                    _mainClass.send(param, function (data) {
1928                        productWrapper
1929                            .empty()
1930                            .append(data.items);
1931                        paginationWrapper.empty();
1932
1933                        if (data.count) {
1934                            paginationWrapper.append(data.pages);
1935                        }
1936                    }, function () {
1937
1938                    });
1939
1940                    function set () {
1941                        delete sendData[filterParam.reset];
1942                        // param[filterParam.get] = true;
1943                        sendData[filterParam.get] = true;
1944                    }
1945
1946                    function reset () {
1947                        delete sendData[filterParam.get];
1948                        // param[filterParam.reset] = true;
1949                        sendData[filterParam.reset] = true;
1950                    }
1951                },
1952                setURL: function (data) {
1953                    $Common.replaceState({
1954                        href: $Common.getURL({
1955                            href: location.href,
1956                            query: data || this.data
1957                        })
1958                    });
1959                }
1960            });
1961
1962            $(document)
1963                .on('click', function (e) {
1964                    if (_class.activeList && !$(e.target).closest(listWrapperSelector).length) {
1965                        _class.activeList.close();
1966                    }
1967                });
1968
1969            formWrapper
1970                .on('submit', function (e) {
1971                    e.preventDefault();
1972                });
1973
1974            paginationWrapper
1975                .on('click', '[data-action="pagination"]', function (e) {
1976                    var data = $Common.clone(_class.data),
1977                        search = this.search.replace('?', '').split('=');
1978
1979                    e.preventDefault();
1980                    data[search[0]] = search[1];
1981                    _class.send(data);
1982                });
1983
1984            $Mediator
1985                .on({
1986                    name: 'window:resize',
1987                    track: true,
1988                    handlers: function (e, data) {
1989                        if (data.innerWidth > 480) {
1990                            _class.scrollType = true;
1991
1992                            if (_class.activeList) {
1993                                _class.activeList.setScroll();
1994                            }
1995                        } else {
1996                            delete _class.scrollType;
1997
1998                            if (_class.activeList) {
1999                                _class.activeList.resetScroll();
2000                            }
2001                        }
2002                    }
2003                })
2004                .on('reset:result', function (e, data) {
2005                    if (data) {

2006                        Object.keys(data).forEach(function (id) {
2007                            delete _class.data[id];
2008                        });
2009                    } else {
2010                        _class.data = {};
2011                    }
2012
2013                    _class.setURL(_class.data);
2014                })
2015                .on('get:result', function (e, data) {
2016                    set(data);
2017
2018                    if (_class.complete) {
2019                        clearTimeout(resultDelay);
2020                        resultDelay = setTimeout(done, 0);
2021                    }
2022
2023                    function done () {
2024                        _class.send();
2025                    }
2026                });
2027
2028            new Result($(resultsWrapperSelector, filterWrapper));
2029            $(searchWrapperSelector, filterWrapper).each(function () {
2030                new Search($(this));
2031            });
2032            $(inputWrapperSelector, filterWrapper).each(function () {
2033                new Input($(this));
2034            });
2035            $(listWrapperSelector, filterWrapper).each(function () {
2036                new List($(this));
2037            });
2038            _class.complete = true;
2039
2040            function set (data) {
2041                switch ($Common.getType(data)) {
2042                    case 'Object':
2043                        Object.keys(data).forEach(function (name) {
2044                            switch ($Common.getType(data[name])) {
2045                                case 'String':
2046                                    _class.data[name] = data[name];
2047                                    break;
2048                                case 'Object':
2049                                    _class.data[name] = data[name].value;
2050                                    break;
2051                                default:
2052                                    delete _class.data[name];
2053                                    break;
2054                            }
2055                        });
2056                        break;
2057                    default:
2058                        _class.data = {};
2059                        break;
2060                }
2061            }
2062        });
2063    }();
2064
2065    _mainClass.$Tab = function () {
2066        var _class = {},
2067            tabActiveClass = 'tab-active',
2068
2069            tabItemSelector = '[data-item="tab"]',
2070
2071            startParams = getParameters(),
2072            tabActiveID = startParams.tab;
2073
2074        $(function () {
2075            var tabWrapper = $('[data-wrapper="tab"]'),
2076                tabItems = $(tabItemSelector, tabWrapper),
2077                tabButtons = $('[data-wrapper="tab-action"] [data-action="tab"]', tabWrapper);
2078
2079            $.extend(_class, {

2080                setActiveTab: function (id) {
2081                    if (id) {
2082                        if (id != tabActiveID) {
2083                            this.resetActiveTab();
2084                        }
2085
2086                        tabActiveID = id;
2087                        tabItems.filter('[data-id="' + id + '"]').addClass(tabActiveClass);
2088                        tabButtons.filter('[data-id="' + id + '"]').addClass(tabActiveClass);
2089                        $Common.replaceState({
2090                            query: {
2091                                tab: id
2092                            }
2093                        });
2094                    }
2095                },
2096                resetActiveTab: function (id) {
2097                    id = id || tabActiveID;
2098
2099                    if (id) {
2100                        tabItems.filter('[data-id="' + id + '"]').removeClass(tabActiveClass);
2101                        tabButtons.filter('[data-id="' + id + '"]').removeClass(tabActiveClass);
2102                    }
2103                },
2104                scrollToActiveTab: function (tab) {
2105                    if(typeof tab !== 'string') $('html, body').scrollTop(($(tab).offset().top) - 50);
2106                }
2107            });
2108
2109            tabItems.each(function () {
2110                var tab = $(this),
2111                    id = tab.data('id');
2112
2113                if (!tabActiveID) {
2114                    if (tab.hasClass(tabActiveClass)) {
2115                        _class.setActiveTab(id);
2116                    } else {
2117                        _class.resetActiveTab(id);
2118                    }
2119                } else {
2120                    if (id == tabActiveID) {
2121                        _class.setActiveTab(id);
2122                    } else {
2123                        _class.resetActiveTab(id);
2124                    }
2125                }
2126            });
2127
2128            if (!tabActiveID) {
2129                _class.setActiveTab(tabItems.eq(0).data('id'));
2130            }
2131
2132            tabWrapper
2133                .on('click', '[data-action="tab"]', function () {
2134                    var button = $(this),
2135                        id = button.data('id'),
2136                        tab;
2137
2138                    if (id) {
2139                        _class.setActiveTab(id);
2140                        _class.scrollToActiveTab(id);
2141                    } else{
2142                        tab = button.closest(tabItemSelector);
2143
2144                        if (tab.length) {
2145                            _class.setActiveTab(tab.data('id'));
2146                            _class.scrollToActiveTab(tab);
2147                        }
2148                    }
2149                });
2150        });
2151    }();
2152
2153    _mainClass.$Toggle = function () {
2154        var _class = {},
2155
2156            fieldsetDisableClass = 'form-fieldset-disable',
2157
2158            wrapperSelector = '[data-wrapper="toggle"]',
2159            actionSelector = '[data-action="toggle"]',
2160            targetSelector = '[data-target="toggle"]';
2161
2162        $(function () {
2163        });
2164
2165        $(document)
2166            .on('change', actionSelector, function () {
2167                var input = $(this),
2168                    id = input.data('id'),
2169                    wrapper = input.closest(wrapperSelector),
2170                    targets = wrapper.data('targets');
2171
2172                if (!targets) {
2173                    targets = $(targetSelector, wrapper);
2174                    wrapper.data('targets', targets);
2175                }
2176
2177                targets.each(function () {
2178                    var target = $(this);
2179
2180                    if (target.data('id') == id) {
2181                        target
2182                            .removeClass(fieldsetDisableClass)
2183                            .removeAttr('disabled');
2184                    } else {
2185                        target
2186                            .addClass(fieldsetDisableClass)
2187                            .attr('disabled', true);
2188                    }
2189                });
2190            });
2191    }();
2192
2193    _mainClass.$Menu = function () {
2194        var _class = {},
2195            menuScroll,
2196            overflowClass = 'page-overflow',
2197            menuActiveClass = 'menu-active',
2198            menuToggleClass = 'menu-toggle',
2199            contrastActiveClass = 'contrast-active',
2200            contrastViewClass = 'contrast-view',
2201            searchActiveClass = 'search-active',
2202            increaseFontClass = 'font-increase',
2203            activeFontClass = 'font-size-active',
2204
2205            menuWrapperSelector = '[data-wrapper="menu"]',
2206            menuContainerSelector = '[data-container="menu"]',
2207            menuItemSelector = '[data-item="menu"]',
2208
2209            menuScrollOptions = $Common.clone(iscrollOptions.common, iscrollOptions.Y),
2210            fontSize = $Common.getCookie('fontSize') || 1,
2211            contrast = $Common.getCookie('contrast') == 'yes';
2212
2213        if (contrast) {
2214            $(root).addClass(contrastActiveClass);
2215        }
2216
2217        if (fontSize == 2) {
2218            $(root).addClass(increaseFontClass);
2219        }
2220
2221        $(function () {
2222            var headerWrapper = $('[data-wrapper="header"]'),
2223                functionalWrapper = $('[data-wrapper="functional"]', headerWrapper),
2224                contrastWrapper = $('[data-wrapper="contrast"]', headerWrapper),
2225                fontItems = $('[data-action="font-size"]', contrastWrapper),
2226
2227                menuWrapper = $(menuWrapperSelector),
2228                menuContainer = $(menuContainerSelector, menuWrapper),
2229                menuItems = $(menuItemSelector, menuWrapper),
2230                menuScrollWrapper = $('[data-wrapper="scroll"][data-type="menu"]'),
2231

2232                searchWrapper = $('[data-wrapper="search"]', headerWrapper),
2233                searchInput = $('[data-action="input"]', searchWrapper),
2234                activeMenuItem = menuItems.filter('.' + menuActiveClass);
2235
2236            $.extend(_class, {
2237                menuOpen: function () {
2238                    $(root).addClass(overflowClass);
2239                    menuWrapper.addClass(menuActiveClass);
2240                    _class.menuScroll();
2241                    menuWrapper.on('click', this.checkMenu);
2242                },
2243                menuClose: function () {
2244                    menuWrapper.off('click', this.checkMenu);
2245                    $(root).removeClass(overflowClass);
2246                    menuWrapper.removeClass(menuActiveClass);
2247                },
2248                checkMenu: function (e) {
2249                    e.stopPropagation();
2250
2251                    if (!$(e.target).closest(menuContainer).length) {
2252                        this.menuClose();
2253                    }
2254                }.bind(_class),
2255                menuToggle: function (e) {
2256                    var target = $(e.target),
2257                        item = $(this);
2258
2259                    if (target.is('span') || target.is(item)) {
2260                        item.toggleClass(menuToggleClass);
2261                        _class.menuScroll();
2262                    }
2263                },
2264                menuScroll: function () {
2265                    if (menuScroll) {
2266                        menuScroll.refresh();
2267                    }
2268                },
2269                searchOpen: function () {
2270                    $(root).addClass(searchActiveClass);
2271                    searchInput.focus();
2272                },
2273                searchClose: function () {
2274                    $(root).removeClass(searchActiveClass);
2275                },
2276                contrastOpen: function () {
2277                    $(root).addClass(contrastActiveClass);
2278                    $Common.setCookie({
2279                        contrast: 'yes'
2280                    });
2281                },
2282                contrastClose: function () {
2283                    $(root).removeClass(contrastActiveClass);
2284                    _class.resetContrastMode();
2285                    $Common.setCookie({
2286                        contrast: 'no'
2287                    });
2288                },
2289                contrastToggle: function () {
2290                    if ($(root).hasClass(contrastActiveClass)) {
2291                        _class.contrastClose();
2292                    } else {
2293                        _class.contrastOpen();
2294                    }
2295                },
2296                setContrastMode: function () {
2297                    $(root).addClass(contrastViewClass);
2298                    _class.contrastOpen();
2299                },
2300                resetContrastMode: function () {
2301                    $(root).removeClass(contrastViewClass);
2302                },
2303                toggleFontSize: function () {
2304                    var item = $(this),
2305                        value = item.data('value');
2306
2307                    $(root).toggleClass(increaseFontClass, value > 1);
2308                    $Common.setCookie({
2309                        fontSize: value
2310                    });
2311                    setFontItem(item);
2312                }
2313            });
2314            setFontItem(fontItems.filter('[data-value="' + fontSize + '"]'));
2315
2316            if (activeMenuItem.length) {
2317                activeMenuItem.addClass(menuToggleClass);
2318            } else {
2319                activeMenuItem = undefined;
2320            }
2321
2322            function setFontItem (item) {
2323                if (!item.hasClass(activeFontClass)) {
2324                    item
2325                        .addClass(activeFontClass)
2326                        .siblings().removeClass(activeFontClass);
2327                }
2328            }
2329
2330            $(document)
2331                .on('click', '[data-action="additional"]', function () {
2332                    $(this).closest('[data-wrapper="additional"]').toggleClass('additional-active');
2333                });
2334
2335            contrastWrapper
2336                .on('click', '[data-action="font-size"]', _class.toggleFontSize)
2337                .on('click', '[data-action="close"]', _class.resetContrastMode)
2338                .on('click', '[data-action="reset"]', _class.contrastClose);
2339
2340            $Mediator.on({
2341                name: 'window:resize',
2342                track: true,
2343                handlers: function (e, options) {
2344                    if (options.innerWidth > 768) {
2345                        if (menuScroll) {
2346                            menuScroll.scroller.removeAttribute('style');
2347                            menuScroll.destroy();
2348                            menuScroll = null;
2349                        }
2350                    } else {
2351                        if (!menuScroll && menuScrollWrapper.length) {
2352                            menuScroll = new IScroll(menuScrollWrapper.get(0), menuScrollOptions);
2353                        }
2354                    }
2355                }
2356            });
2357
2358            headerWrapper
2359                .on('click', '[data-action="search"]', _class.searchOpen);
2360

2361            searchWrapper
2362                .on('click', '[data-action="close"]', _class.searchClose);
2363
2364            if ($Params.hasTouch) {
2365                headerWrapper
2366                    .on('focusin', 'input', function () {
2367                        $(root).addClass('fixfixed');
2368                    })
2369                    .on('focusout', 'input', function () {
2370                        $(root).removeClass('fixfixed');
2371                    });
2372            }
2373
2374            menuWrapper
2375                .on('click', '[data-action="open"]', _class.menuOpen.bind(_class))
2376                .on('click', '[data-action="close"]', _class.menuClose.bind(_class))
2377                .on('click', '[data-action="contrast"]', _class.setContrastMode)
2378                .on('click', menuItemSelector, _class.menuToggle);
2379        });
2380    }();
2381
2382    _mainClass.$Form = function () {
2383        var popupActiveClass = 'form-popup-active',
2384            popupErrorClass = 'form-popup-error',
2385            popupLoadingClass = 'form-popup-loading',
2386            orderedClass = 'ordered-item',
2387            errorFieldClass = 'error-field',
2388            errorFormClass = 'error-form',
2389
2390            formSelector = '[data-wrapper="form"]',
2391            cartItemSelector = '[data-item="cart"]';
2392
2393        $(function () {
2394            var headerWrapper = $('[data-wrapper="header"]'),
2395                popupWrapper = $('[data-wrapper="form-popup"]'),
2396                popupTarget = $('[data-target="form-popup"]', popupWrapper),
2397                cartItem = $(cartItemSelector, headerWrapper),
2398                popupScroll;
2399
2400            $.extend(_mainClass, {
2401                popupOpen: function (e) {
2402                    e.preventDefault();
2403                    $('.form-wrapper').append(" <div class='sk-wandering-cubes'><div class='sk-cube sk-cube-1'></div><div class='sk-cube sk-cube-2'></div></div>");
2404
2405                    var button = $(this),
2406                        item = button.closest('[data-item="form"]'),
2407                        formWrapper = button.closest('[data-wrapper="form"]'),
2408                        errorWrapper = $('[data-wrapper="error"]', formWrapper),
2409                        errorMessage = $('[data-message="error"]', errorWrapper),
2410                        id = getParam(button, 'id'),
2411                        additional = getParam(button, 'additional'),
2412                        method = getParam(button, 'method') || formWrapper.attr('method'),
2413                        type = getParam(button, 'type'),
2414                        behavior = getFullParam(button, 'ajax', type),
2415                        redirect = getFullParam(button, 'redirect', type),
2416                        address = getFullParam(button, 'url', type),
2417                        standardOptions = _mainClass.getOptions(address ? address : formWrapper.attr('action'), getFullParam(button, 'param'), {
2418                            id: id
2419                        }, additional),
2420                        standardSendParam = {
2421                            method: method || _mainClass.getMethod(),
2422                            dataType: 'html'
2423                        },
2424                        extendOptions = _mainClass.getOptions(behavior, getFullParam(button, 'param')),
2425                        extendSendParam = {
2426                            method: method || _mainClass.getMethod(),
2427                            dataType: 'json'
2428                        },
2429                        param = _mainClass.getSendParam(standardOptions, standardSendParam),
2430                        start;
2431
2432                    if (redirect) {
2433                        button.prop('disabled', true);
2434                        _mainClass.send(param, function (data) {
2435                            data = getJSON(data);
2436
2437                            if (data.STATUS == 'OK') {
2438                                __done(redirect);
2439                            } else {
2440                                _done();
2441                            }
2442                        }, _done);
2443                    } else if (behavior) {
2444                        button.prop('disabled', true);
2445                        _mainClass.send(param, function (data) {
2446                            $('.form-wrapper .sk-wandering-cubes').remove();
2447                            data = getJSON(data);
2448
2449                            switch (data.STATUS) {
2450                                case 'OK':
2451                                    param = _mainClass.getSendParam(extendOptions, standardSendParam);
2452                                    _mainClass.send(param, function (data) {
2453                                        var cart = $(data);
2454
2455                                        cartItem.replaceWith(cart);
2456                                        cartItem = cart;
2457                                        setCartCount();
2458                                        $Mediator
2459                                            .fire('set:result', getCartCount(id))
2460                                            .off('set:result', setResult);
2461                                        _done();
2462                                    }, _done);
2463                                    break;
2464                                case 'ERROR':
2465                                    errorMessage.text(data.MESSAGE);
2466                                    formWrapper.addClass(errorFormClass);
2467                                    // _done();
2468                                    break;
2469                            }
2470                        }, _done);
2471                    } else {
2472                        $(root).addClass(popupActiveClass);
2473                        reset();
2474                        popupWrapper.addClass(popupLoadingClass);
2475                        _mainClass.send(param, function (data) {
2476                            $('.form-wrapper .sk-wandering-cubes').remove();
2477                            data = data
2478                                .replace(/[\r\n]/g, '')
2479                                .replace(/^.+(<form)/img, '$1')
2480                                .replace(/(<\/form[^>]>).+$/img, '$1');
2481
2482                            if ($(data).data('wrapper') == 'form') {
2483                                done(data);
2484                            } else {
2485                                popupWrapper.addClass(popupErrorClass);
2486                            }
2487                        }, function () {
2488                            popupWrapper.addClass(popupErrorClass);
2489                        });
2490
2491                        if (button.data('type') == 'order') {
2492                            $Mediator.on({
2493                                name: 'set:result',
2494                                context: button,
2495                                handlers: setResult
2496                            });
2497                        }
2498                    }
2499
2500                    function _done () {
2501                        button.removeAttr('disabled');
2502                        _mainClass.popupClose();
2503                    }
2504
2505                    function done (data) {
2506                        var form = $(data).filter('form'),
2507                            images = $('img', form),
2508                            count = images.length;
2509
2510                        if ($Params.hasTouch) {
2511                            start = document.body.scrollTop;
2512                            setTimeout(function () {
2513                                $(window).scrollTop(start);
2514                            }, 0);
2515                        }
2516
2517                        reset();
2518                        popupTarget.prepend(form);
2519
2520                        if (count) {
2521                            images.each(function () {
2522                                if (this.complete) {
2523                                    count--;
2524                                } else {
2525                                    $(this).on('load', function () {
2526                                        count--;
2527
2528                                        if (!count) {
2529                                            set();
2530                                        }
2531                                    });
2532                                }
2533                            });
2534
2535                            if (!count) {
2536                                set();
2537                            }
2538                        } else {
2539                            set();
2540                        }
2541
2542                        // $Mediator.fire('content:change', form);
2543                        // $('input, textarea, select', form).filter(':visible').eq(0).focus();
2544                        form.data('additional', $Common.getFormData(form.serialize()));
2545

2546                        function set () {
2547                            popupScroll.set($('[data-wrapper="scroll"]', form));
2548                            $Mediator.fire('content:change', form);
2549                            form
2550                                .on('height:input', function () {
2551                                    popupScroll.item.refresh();
2552                                });
2553
2554                            setTimeout(function () {
2555                                $Input.prepareInput({
2556                                    context: form,
2557                                    // selector: 'textarea',
2558                                    // callback: function () {}
2559                                });
2560                            }, 0);
2561                        }
2562                    }
2563
2564                    function reset () {
2565                        $(formSelector, popupTarget).remove();
2566                        popupWrapper
2567                            .removeClass(popupErrorClass)
2568                            .removeClass(popupLoadingClass);
2569                    }
2570                },
2571                popupClose: function () {
2572                    $(root).removeClass(popupActiveClass);
2573                    popupScroll.destroy();
2574                    popupWrapper.removeClass(popupErrorClass);
2575                }
2576            });
2577
2578            popupScroll = {
2579                options: $Common.clone(iscrollOptions.common, iscrollOptions.Y, {
2580                    click: false
2581                }),
2582                set: function (wrapper) {
2583                    this.wrapper = wrapper;
2584
2585                    if (!iDeviceMode) {
2586                        this.item = new IScroll(wrapper.get(0), this.options);
2587                    }
2588
2589                    this.setHeight();
2590
2591                    if (window.BX && BX.UserConsent) {
2592                        this.control = BX.UserConsent.load(BX(wrapper.get(0)));
2593                        BX.onCustomEvent('submit-form', []);
2594                        BX.addCustomEvent(
2595                            this.control,
2596                            BX.UserConsent.events.save,
2597                            function (data) {
2598                                popupScroll.accepted = true;
2599                            }
2600                        );
2601                        BX.addCustomEvent(
2602                            this.control,
2603                            BX.UserConsent.events.accepted,
2604                            function () {
2605                                popupScroll.accepted = true;
2606                            }
2607                        );
2608                        BX.addCustomEvent(
2609                            this.control,
2610                            BX.UserConsent.events.refused,
2611                            function () {
2612                                delete popupScroll.accepted;
2613                            }
2614                        );
2615                    }
2616                },
2617                refresh: function () {
2618                    if (!iDeviceMode) {
2619                        setTimeout(function () {
2620                            this.item.refresh();
2621                        }.bind(this), 0);
2622                    }
2623                },
2624                destroy: function () {
2625                    delete this.accepted;
2626
2627                    if (!iDeviceMode) {
2628                        if (this.item) {
2629                            this.item.scroller.removeAttribute('style');
2630                            this.item.destroy();
2631                            delete this.item;
2632                        }
2633                    }
2634
2635                    if (this.wrapper) {
2636                        delete this.wrapper;
2637                    }
2638                },
2639                check: function (e, data) {
2640                    if (data !== undefined) {
2641                        this.dims = data;
2642                        this.setHeight();
2643                    }
2644                },
2645                setHeight: function () {
2646                    if (this.wrapper) {
2647                        setTimeout(function () {
2648                            if (iDeviceMode) {
2649                                this.wrapper.height(Math.min(this.wrapper.get(0).scrollHeight, this.dims.innerHeight - 50));
2650                            } else {
2651                                this.wrapper.height(Math.min(this.item.scroller.offsetHeight, this.dims.innerHeight - 50));
2652                                this.refresh();
2653                            }
2654                        }.bind(this), 0);
2655                    }
2656                },
2657                resetHeight: function () {
2658                    if (this.wrapper) {
2659                        this.wrapper.height('auto');
2660
2661                        if (!iDeviceMode) {
2662                            this.refresh();
2663                        }
2664                    }
2665                }
2666            };
2667
2668            setCartCount();
2669
2670            $('[data-item="form"]').each(function () {
2671                var item = $(this),
2672                    id = item.data('id'),
2673                    button = $('[data-action="form"][data-type="order"]', item),
2674                    result = getCartCount(id);
2675
2676                if (result) {
2677                    button.attr('data-count', result);
2678                } else {
2679                    button.removeAttr('data-count');
2680                }
2681            });
2682            $Mediator.on('window:resize', popupScroll.check.bind(popupScroll));
2683
2684            $(document)
2685                .on('click', '[data-action="form"]', _mainClass.popupOpen)
2686                .on('click', '[data-action="change"]', function () {
2687                    var item = $(this),
2688                        id = item.data('id'),
2689                        wrapper = item.closest('[data-wrapper="change"]'),
2690                        form = $('[data-wrapper="form"][data-id="' + id + '"]', wrapper);
2691
2692                    if (form.length) {
2693                        item.closest('[data-wrapper="form"]').addClass('form-hidden');
2694                        form.removeClass('form-hidden');
2695                        $('input, select, textarea', form).eq(0).focus();
2696                    }
2697                })
2698                .on('click', '[data-wrapper="social"] [data-action="toggle"]', function () {
2699                    $(this).closest('[data-wrapper="social"]').toggleClass('social-active');
2700                })
2701                .on('click', '[data-action="list"][data-type="delete"]', function () {
2702
2703                });
2704
2705            popupWrapper
2706                .on('input', '[data-item="count"]', function () {
2707                    var form = $(this).closest('[data-wrapper="form"]'),
2708                        additional = form.data('additional');
2709
2710                    if (!additional) {
2711                        additional = {};
2712                    }
2713
2714                    this.value = this.value.replace(/[^\d]/g, '');
2715                    additional[this.name] = this.value;
2716                    form.data('additional', additional);
2717                })
2718                .on('click', '[data-action="count"]', function () {
2719                    var button = $(this),
2720                        type = button.data('type'),
2721                        wrapper = button.closest('[data-wrapper="count"]'),
2722                        input = $('[data-item="count"]', wrapper),
2723                        name = input.attr('name'),
2724                        value = Number(input.val()),
2725                        form = button.closest('[data-wrapper="form"]'),
2726                        additional = form.data('additional');
2727
2728                    if (!additional) {
2729                        additional = {};
2730                    }
2731
2732                    if (value) {
2733                        switch (type) {
2734                            case 'less':
2735                                if (value > 1) {
2736                                    value--;
2737                                }
2738
2739                                break;
2740                            case 'more':
2741                                value++;
2742                                break;
2743                        }
2744
2745                        additional[name] = value;
2746                        input.val(value);
2747                        form.data('additional', additional);
2748                    }
2749                })
2750                .on('click', '[data-action="close"]', _mainClass.popupClose)
2751                .on('submit', formSelector, popupSend);
2752
2753            function popupSend (e) {
2754                e.preventDefault();
2755
2756                if (popupScroll.control && !popupScroll.accepted) {
2757                    return;
2758                }
2759
2760                var form = $(formSelector, popupWrapper),
2761                    options = _mainClass.getOptions(form.attr('action'), form.data('param')),
2762                    sendParam = {
2763                        method: _mainClass.getMethod(form),
2764                        dataType: 'json'
2765                    },
2766                    button = form.find('.form-button'),
2767                    param = _mainClass.getSendParam(options, sendParam, $Common.getFormData(form.serialize()));
2768
2769                $(button).attr('disabled', true);
2770
2771                _mainClass.send(param, function (data) {
2772                    if (data.success) {
2773                        // $('[data-item="success"]', form).replaceWith(data.success);
2774                        // $('[data-item="error"]', form).empty();
2775                        // popupScroll.setHeight();
2776                        $(popupScroll.wrapper).replaceWith(data.success);
2777                        $(button).attr('disabled', false);
2778                        popupScroll.destroy();
2779                    } else if (data.error) {
2780                        $(button).attr('disabled', false);
2781                        $('[data-wrapper="field"]', form).each(function () {
2782                            var field = $(this),
2783                                elements = $('input, select, textarea', field),
2784                                name = elements.eq(0).attr('name');
2785
2786                            if (data.error[name]) {
2787                                field.addClass(errorFieldClass);
2788                                field.attr('data-error-message', data.error[name]);
2789                            } else {
2790                                field.removeClass(errorFieldClass);
2791                                field.removeAttr('data-error-message');
2792                            }
2793                        });
2794                        popupScroll.setHeight();
2795                        // popupWrapper.addClass(popupErrorClass);
2796                    }
2797                }, function () {
2798                    // popupWrapper.addClass(popupErrorClass);
2799                });
2800            }
2801
2802            function setResult (e, result) {
2803                if (result) {
2804                    this.attr('data-count', result);
2805                } else {
2806                    this.removeAttr('data-count');
2807                }
2808            }
2809
2810            function getJSON (data) {
2811                return JSON.parse(data
2812                    .replace(/'[\r\n\s]*?:[\r\n\s]*?'/g, '":"')
2813                    .replace(/'[\r\n\s]*?,[\r\n\s]*?'/g, '","')
2814                    .replace(/\{[\r\n\s]*?'/g, '{"')
2815                    .replace(/'[\r\n\s]*?\}/g, '"}'));
2816            }
2817
2818            function __done (redirect) {
2819                location.href = redirect;
2820            }
2821
2822            function setCartCount () {
2823                var staff = cartItem.data('staff');
2824
2825                if (!staff) {
2826                    return;
2827                }
2828
2829                if (staff) {
2830                    var result = {};
2831
2832                    staff
2833                        .replace(/^\{/, '')
2834                        .replace(/\}$/, '')
2835                        .split(',')
2836                        .forEach(function (value) {
2837                            value = value.split(':');
2838                            result[value[0]] = value[1];
2839                        });
2840
2841                    cartItem
2842                        .removeAttr('staff')
2843                        .data('staff', result);
2844                }
2845            }
2846
2847            function getCartCount (id) {
2848                var staff = cartItem.data('staff');
2849
2850                if (id && staff) {
2851                    return staff[id];
2852                }
2853            }
2854        });
2855    }();
2856
2857    $Mediator.on({
2858        name: 'content:change',
2859        track: true,
2860        handlers: function (e, context) {
2861            $('[data-wrapper="screenshots"]', context).slick({
2862                dots: true,
2863                infinite: true,
2864                speed: 300,
2865                slidesToShow: 1,
2866                adaptiveHeight: true
2867            });
2868
2869            $('[data-wrapper="slider"] [data-content="slider"]', context).each(function () {
2870                var item = $(this),
2871                    wrapper = item.closest('[data-wrapper="slider"]'),
2872                    data = {
2873                        adaptiveHeight: true,
2874                        prevArrow: $('[data-action="slider"][data-type="next"]'),
2875                        nextArrow: $('[data-action="slider"][data-type="prev"]')
2876                    };
2877
2878                if ('autoplay' in wrapper.data()) {
2879                    data.autoplay = true;
2880                    data.autoplaySpeed = wrapper.data('autoplay') || 3000;
2881                }
2882
2883                item.slick(data);
2884            });
2885
2886            $('[data-carousel]', context).slick({
2887                slidesToShow: 5,
2888                slidesToScroll: 1,
2889                dots: false,
2890                prevArrow: $('[data-carousel-prev]'),
2891                nextArrow: $('[data-carousel-next]'),

2892                responsive: [
2893                    {
2894                        breakpoint: 768,
2895                        settings: {
2896                            slidesToShow: 4
2897                        }
2898                    },
2899                    {
2900                        breakpoint: 640,
2901                        settings: {
2902                            slidesToShow: 2
2903                        }
2904                    }
2905                ]
2906            });
2907
2908            $('[data-mobile-carousel]', context).slick({
2909                slidesToShow: 3,
2910                slidesToScroll: 1,
2911                dots: false,
2912                prevArrow: $('[data-mobile-carousel-prev]'),
2913                nextArrow: $('[data-mobile-carousel-next]'),
2914                arrows: false,
2915                responsive: [
2916                    {
2917                        breakpoint: 640,
2918                        settings: {
2919                            slidesToShow: 2,
2920                            arrows: true
2921                        }
2922                    },
2923                    {
2924                        breakpoint: 550,
2925                        settings: {
2926                            slidesToShow: 1,
2927                            arrows: true
2928                        }
2929                    }
2930                ]
2931            });
2932
2933            // $('[data-wrapper="field"] select', context).select2({
2934            // 	minimumResultsForSearch: Infinity
2935            // });
2936            setTimeout(function () {
2937                $('[data-wrapper="field"] select', context).styler({
2938                    selectSearch: true
2939                });
2940                window.dispatchEvent(new Event('resize'));
2941            });
2942
2943            $('main table', context).each(function () {
2944                var table = $(this),
2945                    width = table.attr('width'),
2946                    wrapper,
2947                    scrollOptions = $Common.clone(iscrollOptions.common, iscrollOptions.X);
2948
2949                table.wrap($('<div>', {
2950                    'data-wrapper': 'table',
2951                    'class': 'table-wrapper'
2952                }));
2953
2954                if (width) {
2955                    table
2956                        .removeAttr('width')
2957                        .css({
2958                            'min-width': width + 'px'
2959                        });
2960                }
2961
2962                wrapper = table.closest('[data-wrapper="table"]');
2963                wrapper.data('scroll', new IScroll(wrapper.get(0), scrollOptions));
2964            });
2965
2966            $('main img', context).each(function () {
2967                var image = $(this),
2968                    width = image.attr('width'),
2969                    height = image.attr('height');
2970
2971                if (width) {
2972                    image
2973                        .removeAttr('width')
2974                        .css({
2975                            'max-width': width + 'px'
2976                        });
2977                }
2978
2979                if (height) {
2980                    image
2981                        .removeAttr('height')
2982                        .css({
2983                            'max-height': height + 'px'
2984                        });
2985                }
2986            });
2987        }
2988    });
2989
2990    $(function () {
2991        var searchActiveClass = 'search-active';
2992
2993        checkPageWidth();
2994        checkPageScroll();
2995        $Mediator.fire('content:change');
2996
2997        $(document)
2998            .on('focus', '[data-wrapper="search"] input', function () {
2999                $(this).closest('[data-wrapper="search"]').addClass(searchActiveClass);
3000            })
3001            .on('blur', '[data-wrapper="search"] input', function () {
3002                $(this).closest('[data-wrapper="search"]').removeClass(searchActiveClass);
3003            });
3004    });
3005
3006    return _mainClass;
3007
3008    function getParam (element, name) {
3009        var param = element.data(name) || get('item') || get('wrapper');
3010
3011        if (param) {
3012            element.data(name, param);
3013        }
3014
3015        return param;
3016
3017        function get (part) {
3018            return element.closest('[data-' + part + '="form"]').data(name);
3019        }
3020    }
3021
3022    function getFullParam (element, name, _name) {
3023        var result = element.data(name);
3024
3025        switch ($Common.getType(result)) {
3026            case 'Object':
3027                return done();
3028                break;
3029            default:
3030                var value = getParam(element, name);
3031
3032                if (value) {
3033                    result = redefine(value);
3034                    element.removeAttr('data-' + name);
3035                    element.data(name, result);
3036                    return done();
3037                }
3038
3039                break;
3040        }
3041
3042        function redefine (data) {
3043            var _result = {};
3044
3045            data
3046                .replace(/^\{/, '')
3047                .replace(/\}$/, '')
3048                .split(',')
3049                .forEach(function (pair) {
3050                    pair = pair.split(/\s*:\s*/);
3051                    _result[pair[0]] = pair[1];
3052                });
3053            return _result;
3054        }
3055
3056        function done () {
3057            return _name ? result[_name] : result;
3058        }
3059    }
3060
3061    function getParameters () {
3062        var params = location.search.slice(1),
3063            result = {};
3064
3065        if (params) {
3066            params.split('&').forEach(function (value) {
3067                var values = value.split('=');
3068
3069                result[values[0]] = values[1];
3070            });
3071        }
3072
3073        return result;
3074    }
3075
3076    function checkPageWidth () {
3077        $Mediator.fire('window:resize', {
3078            innerWidth: window.innerWidth,
3079            innerHeight: window.innerHeight,
3080            scrollTop: root.scrollTop,
3081            scrollLeft: root.scrollLeft
3082        });
3083    }
3084
3085    function checkPageScroll () {
3086        $Mediator.fire('window:scroll', {
3087            scrollTop: root.scrollTop
3088        });
3089    }
3090
3091    function getTemplate (item) {
3092        if (item) {
3093            return item.text()
3094                .replace(/^\s+/, '')
3095                .replace(/\s+$/, '')
3096                .replace(/>[\s\r\n]+</, '><');
3097        }
3098    }
3099}();
3100
3101var $Tariff = function () {
3102    $(document)
3103        .on('click', '.table-toggle-title', function () {
3104            $(this).parent().toggleClass('open');
3105        })
3106        .on('mouseover', '.tooltipe sup', function () {
3107            $(this).parent().find('.tooltipe-text').fadeIn();
3108        })
3109        .on('mouseleave', '.tooltipe sup', function () {
3110            $(this).parent().find('.tooltipe-text').fadeOut();
3111        })
3112        .on('click', '.tariff-table-order', function () {
3113            $('body').find('.form-wrapper.form-popup').addClass('tariff-form-popup');
3114        })
3115        .on('click', '._scroll-target', function (e) {
3116            e.preventDefault();
3117            $('html, body').animate({
3118                scrollTop: $("div.table-toggle-wrapper").offset().top
3119            }, 1000)
3120            $('.table-toggle-wrapper').addClass('open');
3121        })
3122        .on('focus', '.main-search-input', function(){
3123            if ( /^((?!chrome|android).)*safari/i.test(navigator.userAgent)) {
3124                $('html, body').animate({
3125                    scrollTop: $(".page-wrapper").offset().top
3126                }, 1000)
3127            }
3128        })
3129        //			.on('click', '.tariff-form-popup form .form-button', function (e) {
3130        //				if(!$('.tariff-form-popup form').children('input.tel').length > 0 ) {
3131        //					let error=0;
3132        //					let phone = $("input.tel").val();
3133        //					if(!isValidPhone(phone) ){
3134        //						 error=2;
3135        //						$("input.tel").parent().parent()
3136        //	                    	.addClass('error-field')
3137        //	                    	.attr('data-error-message', "Неправильный номер" );
3138        //	                    	window.dispatchEvent(new Event('resize'));
3139        //					}
3140        //					else {
3141        //						$("input.tel").parent().parent()
3142        //	                    	.removeClass('error-field')
3143        //	                    	.removeAttr('data-error-message');
3144        //	                    	window.dispatchEvвапent(new Event('resize'));
3145        //	                }
3146        //				}
3147        //				if(error==0){
3148        //	                return true;
3149        //	            }
3150        //	            else{
3151        //		            return false;

3152        //	            }
3153        //			})
3154        .on('mouseup', 'body',  function (e) {
3155            var div = $(".main-user-consent-request-popup-cont");
3156            var popup = $(".form-popup");
3157            if ((!div.is(e.target) && !popup.is(e.target) )
3158                && (div.has(e.target).length === 0 &&  popup.has(e.target).length === 0)) {
3159                $('html').removeClass('form-popup-active');
3160            }
3161        });
3162    function isValidPhone(phoneNumber) {
3163        var pattern = new RegExp(/^((8|\+7)[\-]?)?(\(?\d{3}\)?[\-]?)?[\d\-]{7,10}$/);
3164        return pattern.test(phoneNumber);
3165    }
3166
3167    $(document).scroll(function() {
3168        if ($(document).scrollTop() >= 70) {
3169            $('.page-header').addClass('sticky');
3170        } else {
3171            $('.page-header').removeClass('sticky');
3172        }
3173    });
3174
3175}();
3176
3177
3178
3179
3180// console.log()
3181// arguments.callee.caller

Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.