https://ahro.co.kr/ind-script/optimizer_user.php?filename=jc_BDcIw…928ca8f961047bd14080fbe&t=1781758928&user=T

917,
918                $list: null,
919                touchObject: {},
920                transformsEnabled: false,
921                unslicked: false
922            };
923
924            $.extend(_, _.initials);
925
926            _.activeBreakpoint = null;
927            _.animType = null;
928            _.animProp = null;
929            _.breakpoints = [];
930            _.breakpointSettings = [];
931            _.cssTransitions = false;
932            _.focussed = false;
933            _.interrupted = false;
934            _.hidden = 'hidden';
935            _.paused = true;
936            _.positionProp = null;
937            _.respondTo = null;
938            _.rowCount = 1;
939            _.shouldClick = true;
940            _.$slider = $(element);
941            _.$slidesCache = null;
942            _.transformType = null;
943            _.transitionType = null;
944            _.visibilityChange = 'visibilitychange';
945            _.windowWidth = 0;
946            _.windowTimer = null;
947
948            dataSettings = $(element).data('slick') || {};
949
950            _.options = $.extend({}, _.defaults, settings, dataSettings);
951
952            _.currentSlide = _.options.initialSlide;
953
954            _.originalSettings = _.options;
955
956            if (typeof document.mozHidden !== 'undefined') {
957                _.hidden = 'mozHidden';
958                _.visibilityChange = 'mozvisibilitychange';
959            } else if (typeof document.webkitHidden !== 'undefined') {
960                _.hidden = 'webkitHidden';
961                _.visibilityChange = 'webkitvisibilitychange';
962            }
963
964            _.autoPlay = $.proxy(_.autoPlay, _);
965            _.autoPlayClear = $.proxy(_.autoPlayClear, _);
966            _.autoPlayIterator = $.proxy(_.autoPlayIterator, _);
967            _.changeSlide = $.proxy(_.changeSlide, _);
968            _.clickHandler = $.proxy(_.clickHandler, _);
969            _.selectHandler = $.proxy(_.selectHandler, _);
970            _.setPosition = $.proxy(_.setPosition, _);
971            _.swipeHandler = $.proxy(_.swipeHandler, _);
972            _.dragHandler = $.proxy(_.dragHandler, _);
973            _.keyHandler = $.proxy(_.keyHandler, _);
974
975            _.instanceUid = instanceUid++;
976
977            // A simple way to check for HTML strings
978            // Strict HTML recognition (must start with <)
979            // Extracted from jQuery v1.11 source
980            _.htmlExpr = /^(?:\s*(<[\w\W]+>)[^>]*)$/;
981
982
983            _.registerBreakpoints();
984            _.init(true);
985
986        }
987
988        return Slick;
989
990    }());
991
992    Slick.prototype.activateADA = function() {
993        var _ = this;
994
995        _.$slideTrack.find('.slick-active').attr({
996            'aria-hidden': 'false'
997        }).find('a, input, button, select').attr({
998            'tabindex': '0'
999        });
1000
1001    };
1002
1003    Slick.prototype.addSlide = Slick.prototype.slickAdd = function(markup, index, addBefore) {
1004
1005        var _ = this;
1006
1007        if (typeof(index) === 'boolean') {
1008            addBefore = index;
1009            index = null;
1010        } else if (index < 0 || (index >= _.slideCount)) {
1011            return false;
1012        }
1013
1014        _.unload();
1015
1016        if (typeof(index) === 'number') {
1017            if (index === 0 && _.$slides.length === 0) {
1018                $(markup).appendTo(_.$slideTrack);
1019            } else if (addBefore) {
1020                $(markup).insertBefore(_.$slides.eq(index));
1021            } else {
1022                $(markup).insertAfter(_.$slides.eq(index));
1023            }
1024        } else {
1025            if (addBefore === true) {
1026                $(markup).prependTo(_.$slideTrack);
1027            } else {
1028                $(markup).appendTo(_.$slideTrack);
1029            }
1030        }
1031
1032        _.$slides = _.$slideTrack.children(this.options.slide);
1033
1034        _.$slideTrack.children(this.options.slide).detach();
1035
1036        _.$slideTrack.append(_.$slides);
1037
1038        _.$slides.each(function(index, element) {
1039            $(element).attr('data-slick-index', index);
1040        });
1041
1042        _.$slidesCache = _.$slides;
1043
1044        _.reinit();
1045
1046    };
1047
1048    Slick.prototype.animateHeight = function() {
1049        var _ = this;
1050        if (_.options.slidesToShow === 1 && _.options.adaptiveHeight === true && _.options.vertical === false) {
1051            var targetHeight = _.$slides.eq(_.currentSlide).outerHeight(true);
1052            _.$list.animate({
1053                height: targetHeight
1054            }, _.options.speed);
1055        }
1056    };
1057
1058    Slick.prototype.animateSlide = function(targetLeft, callback) {
1059
1060        var animProps = {},
1061            _ = this;
1062
1063        _.animateHeight();
1064
1065        if (_.options.rtl === true && _.options.vertical === false) {
1066            targetLeft = -targetLeft;
1067        }
1068        if (_.transformsEnabled === false) {
1069            if (_.options.vertical === false) {
1070                _.$slideTrack.animate({
1071                    left: targetLeft
1072                }, _.options.speed, _.options.easing, callback);
1073            } else {
1074                _.$slideTrack.animate({
1075                    top: targetLeft
1076                }, _.options.speed, _.options.easing, callback);
1077            }
1078
1079        } else {
1080
1081            if (_.cssTransitions === false) {
1082                if (_.options.rtl === true) {
1083                    _.currentLeft = -(_.currentLeft);
1084                }
1085                $({
1086                    animStart: _.currentLeft
1087                }).animate({
1088                    animStart: targetLeft
1089                }, {
1090                    duration: _.options.speed,
1091                    easing: _.options.easing,
1092                    step: function(now) {
1093                        now = Math.ceil(now);
1094                        if (_.options.vertical === false) {
1095                            animProps[_.animType] = 'translate(' +
1096                                now + 'px, 0px)';
1097                            _.$slideTrack.css(animProps);
1098                        } else {
1099                            animProps[_.animType] = 'translate(0px,' +
1100                                now + 'px)';
1101                            _.$slideTrack.css(animProps);
1102                        }
1103                    },
1104                    complete: function() {
1105                        if (callback) {
1106                            callback.call();
1107                        }
1108                    }
1109                });
1110
1111            } else {
1112
1113                _.applyTransition();
1114                targetLeft = Math.ceil(targetLeft);
1115
1116                if (_.options.vertical === false) {
1117                    animProps[_.animType] = 'translate3d(' + targetLeft + 'px, 0px, 0px)';
1118                } else {
1119                    animProps[_.animType] = 'translate3d(0px,' + targetLeft + 'px, 0px)';
1120                }
1121                _.$slideTrack.css(animProps);
1122
1123                if (callback) {
1124                    setTimeout(function() {
1125
1126                        _.disableTransition();
1127
1128                        callback.call();
1129                    }, _.options.speed);
1130                }
1131
1132            }
1133
1134        }
1135
1136    };
1137
1138    Slick.prototype.getNavTarget = function() {
1139
1140        var _ = this,
1141            asNavFor = _.options.asNavFor;
1142
1143        if ( asNavFor && asNavFor !== null ) {
1144            asNavFor = $(asNavFor).not(_.$slider);
1145        }
1146
1147        return asNavFor;
1148
1149    };
1150
1151    Slick.prototype.asNavFor = function(index) {
1152
1153        var _ = this,
1154            asNavFor = _.getNavTarget();
1155
1156        if ( asNavFor !== null && typeof asNavFor === 'object' ) {
1157            asNavFor.each(function() {
1158                var target = $(this).slick('getSlick');
1159                if(!target.unslicked) {
1160                    target.slideHandler(index, true);
1161                }
1162            });
1163        }
1164
1165    };
1166
1167    Slick.prototype.applyTransition = function(slide) {
1168
1169        var _ = this,
1170            transition = {};
1171
1172        if (_.options.fade === false) {
1173            transition[_.transitionType] = _.transformType + ' ' + _.options.speed + 'ms ' + _.options.cssEase;
1174        } else {
1175            transition[_.transitionType] = 'opacity ' + _.options.speed + 'ms ' + _.options.cssEase;
1176        }
1177
1178        if (_.options.fade === false) {
1179            _.$slideTrack.css(transition);
1180        } else {
1181            _.$slides.eq(slide).css(transition);
1182        }
1183
1184    };
1185
1186    Slick.prototype.autoPlay = function() {
1187
1188        var _ = this;
1189
1190        _.autoPlayClear();
1191
1192        if ( _.slideCount > _.options.slidesToShow ) {
1193            _.autoPlayTimer = setInterval( _.autoPlayIterator, _.options.autoplaySpeed );
1194        }
1195
1196    };
1197
1198    Slick.prototype.autoPlayClear = function() {
1199
1200        var _ = this;
1201
1202        if (_.autoPlayTimer) {
1203            clearInterval(_.autoPlayTimer);
1204        }
1205
1206    };
1207
1208    Slick.prototype.autoPlayIterator = function() {
1209
1210        var _ = this,
1211            slideTo = _.currentSlide + _.options.slidesToScroll;
1212
1213        if ( !_.paused && !_.interrupted && !_.focussed ) {
1214
1215            if ( _.options.infinite === false ) {
1216
1217                if ( _.direction === 1 && ( _.currentSlide + 1 ) === ( _.slideCount - 1 )) {
1218                    _.direction = 0;
1219                }
1220
1221                else if ( _.direction === 0 ) {
1222
1223                    slideTo = _.currentSlide - _.options.slidesToScroll;
1224
1225                    if ( _.currentSlide - 1 === 0 ) {
1226                        _.direction = 1;
1227                    }
1228
1229                }
1230
1231            }
1232
1233            _.slideHandler( slideTo );
1234
1235        }
1236
1237    };
1238
1239    Slick.prototype.buildArrows = function() {
1240
1241        var _ = this;
1242
1243        if (_.options.arrows === true ) {
1244
1245            _.$prevArrow = $(_.options.prevArrow).addClass('slick-arrow');
1246            _.$nextArrow = $(_.options.nextArrow).addClass('slick-arrow');
1247
1248            if( _.slideCount > _.options.slidesToShow ) {
1249
1250                _.$prevArrow.removeClass('slick-hidden').removeAttr('aria-hidden tabindex');
1251                _.$nextArrow.removeClass('slick-hidden').removeAttr('aria-hidden tabindex');
1252
1253                if (_.htmlExpr.test(_.options.prevArrow)) {
1254                    _.$prevArrow.prependTo(_.options.appendArrows);
1255                }
1256
1257                if (_.htmlExpr.test(_.options.nextArrow)) {
1258                    _.$nextArrow.appendTo(_.options.appendArrows);
1259                }
1260
1261                if (_.options.infinite !== true) {
1262                    _.$prevArrow
1263                        .addClass('slick-disabled')
1264                        .attr('aria-disabled', 'true');
1265                }
1266
1267            } else {
1268
1269                _.$prevArrow.add( _.$nextArrow )
1270
1271                    .addClass('slick-hidden')
1272                    .attr({
1273                        'aria-disabled': 'true',
1274                        'tabindex': '-1'
1275                    });
1276
1277            }
1278
1279        }
1280
1281    };
1282
1283    Slick.prototype.buildDots = function() {
1284
1285        var _ = this,
1286            i, dot;
1287
1288        if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {
1289
1290            _.$slider.addClass('slick-dotted');
1291
1292            dot = $('<ul />').addClass(_.options.dotsClass);
1293
1294            for (i = 0; i <= _.getDotCount(); i += 1) {
1295                dot.append($('<li />').append(_.options.customPaging.call(this, _, i)));
1296            }
1297
1298            _.$dots = dot.appendTo(_.options.appendDots);
1299
1300            _.$dots.find('li').first().addClass('slick-active')

1300.attr('aria-hidden', 'false');
1301
1302        }
1303
1304    };
1305
1306    Slick.prototype.buildOut = function() {
1307
1308        var _ = this;
1309
1310        _.$slides =
1311            _.$slider
1312                .children( _.options.slide + ':not(.slick-cloned)')
1313                .addClass('slick-slide');
1314
1315        _.slideCount = _.$slides.length;
1316
1317        _.$slides.each(function(index, element) {
1318            $(element)
1319                .attr('data-slick-index', index)
1320                .data('originalStyling', $(element).attr('style') || '');
1321        });
1322
1323        _.$slider.addClass('slick-slider');
1324
1325        _.$slideTrack = (_.slideCount === 0) ?
1326            $('<div class="slick-track"/>').appendTo(_.$slider) :
1327            _.$slides.wrapAll('<div class="slick-track"/>').parent();
1328
1329        _.$list = _.$slideTrack.wrap(
1330            '<div aria-live="polite" class="slick-list"/>').parent();
1331        _.$slideTrack.css('opacity', 0);
1332
1333        if (_.options.centerMode === true || _.options.swipeToSlide === true) {
1334            _.options.slidesToScroll = 1;
1335        }
1336
1337        $('img[data-lazy]', _.$slider).not('[src]').addClass('slick-loading');
1338
1339        _.setupInfinite();
1340
1341        _.buildArrows();
1342
1343        _.buildDots();
1344
1345        _.updateDots();
1346
1347
1348        _.setSlideClasses(typeof _.currentSlide === 'number' ? _.currentSlide : 0);
1349
1350        if (_.options.draggable === true) {
1351            _.$list.addClass('draggable');
1352        }
1353
1354    };
1355
1356    Slick.prototype.buildRows = function() {
1357
1358        var _ = this, a, b, c, newSlides, numOfSlides, originalSlides,slidesPerSection;
1359
1360        newSlides = document.createDocumentFragment();
1361        originalSlides = _.$slider.children();
1362
1363        if(_.options.rows > 1) {
1364
1365            slidesPerSection = _.options.slidesPerRow * _.options.rows;
1366            numOfSlides = Math.ceil(
1367                originalSlides.length / slidesPerSection
1368            );
1369
1370            for(a = 0; a < numOfSlides; a++){
1371                var slide = document.createElement('div');
1372                for(b = 0; b < _.options.rows; b++) {
1373                    var row = document.createElement('div');
1374                    for(c = 0; c < _.options.slidesPerRow; c++) {
1375                        var target = (a * slidesPerSection + ((b * _.options.slidesPerRow) + c));
1376                        if (originalSlides.get(target)) {
1377                            row.appendChild(originalSlides.get(target));
1378                        }
1379                    }
1380                    slide.appendChild(row);
1381                }
1382                newSlides.appendChild(slide);
1383            }
1384
1385            _.$slider.empty().append(newSlides);
1386            _.$slider.children().children().children()
1387                .css({
1388                    'width':(100 / _.options.slidesPerRow) + '%',
1389                    'display': 'inline-block'
1390                });
1391
1392        }
1393
1394    };
1395
1396    Slick.prototype.checkResponsive = function(initial, forceUpdate) {
1397
1398        var _ = this,
1399            breakpoint, targetBreakpoint, respondToWidth, triggerBreakpoint = false;
1400        var sliderWidth = _.$slider.width();
1401        var windowWidth = window.innerWidth || $(window).width();
1402
1403        if (_.respondTo === 'window') {
1404            respondToWidth = windowWidth;
1405        } else if (_.respondTo === 'slider') {
1406            respondToWidth = sliderWidth;
1407        } else if (_.respondTo === 'min') {
1408            respondToWidth = Math.min(windowWidth, sliderWidth);
1409        }
1410
1411        if ( _.options.responsive &&
1412            _.options.responsive.length &&
1413            _.options.responsive !== null) {
1414
1415            targetBreakpoint = null;
1416
1417            for (breakpoint in _.breakpoints) {
1418                if (_.breakpoints.hasOwnProperty(breakpoint)) {
1419                    if (_.originalSettings.mobileFirst === false) {
1420                        if (respondToWidth < _.breakpoints[breakpoint]) {
1421                            targetBreakpoint = _.breakpoints[breakpoint];
1422                        }
1423                    } else {
1424                        if (respondToWidth > _.breakpoints[breakpoint]) {
1425                            targetBreakpoint = _.breakpoints[breakpoint];
1426                        }
1427                    }
1428                }
1429            }
1430
1431            if (targetBreakpoint !== null) {
1432                if (_.activeBreakpoint !== null) {
1433                    if (targetBreakpoint !== _.activeBreakpoint || forceUpdate) {
1434                        _.activeBreakpoint =
1435                            targetBreakpoint;
1436                        if (_.breakpointSettings[targetBreakpoint] === 'unslick') {
1437                            _.unslick(targetBreakpoint);
1438                        } else {
1439                            _.options = $.extend({}, _.originalSettings,
1440                                _.breakpointSettings[
1441                                    targetBreakpoint]);
1442                            if (initial === true) {
1443                                _.currentSlide = _.options.initialSlide;
1444                            }
1445                            _.refresh(initial);
1446                        }
1447                        triggerBreakpoint = targetBreakpoint;
1448                    }
1449                } else {
1450                    _.activeBreakpoint = targetBreakpoint;
1451                    if (_.breakpointSettings[targetBreakpoint] === 'unslick') {
1452                        _.unslick(targetBreakpoint);
1453                    } else {
1454                        _.options = $.extend({}, _.originalSettings,
1455                            _.breakpointSettings[
1456                                targetBreakpoint]);
1457                        if (initial === true) {
1458                            _.currentSlide = _.options.initialSlide;
1459                        }
1460                        _.refresh(initial);
1461                    }
1462                    triggerBreakpoint = targetBreakpoint;
1463                }
1464            } else {
1465                if (_.activeBreakpoint !== null) {
1466                    _.activeBreakpoint = null;
1467                    _.options = _.originalSettings;
1468                    if (initial === true) {
1469                        _.currentSlide = _.options.initialSlide;
1470                    }
1471                    _.refresh(initial);
1472                    triggerBreakpoint = targetBreakpoint;
1473                }
1474            }
1475
1476            // only trigger breakpoints during an actual break. not on initialize.
1477            if( !initial && triggerBreakpoint !== false ) {
1478                _.$slider.trigger('breakpoint', [_, triggerBreakpoint]);
1479            }
1480        }
1481
1482    };
1483
1484    Slick.prototype.changeSlide = function(event, dontAnimate) {
1485
1486        var _ = this,
1487            $target = $(event.currentTarget),
1488            indexOffset, slideOffset, unevenOffset;
1489
1490        // If target is a link, prevent default action.
1491        if($target.is('a')) {
1492            event.preventDefault();
1493        }
1494
1495        // If target is not the <li> element (ie: a child), find the <li>.
1496        if(!$target.is('li')) {
1497            $target = $target.closest('li');
1498        }
1499
1500        unevenOffset = (_.slideCount % _.options.slidesToScroll !== 0);
1501        indexOffset = unevenOffset ? 0 : (_.slideCount - _.currentSlide) % _.options.slidesToScroll;
1502
1503        switch (event.data.message) {
1504
1505            case 'previous':
1506                slideOffset = indexOffset === 0 ? _.options.slidesToScroll : _.options.slidesToShow - indexOffset;
1507                if (_.slideCount > _.options.slidesToShow) {
1508                    _.slideHandler(_.currentSlide - slideOffset, false, dontAnimate);
1509                }
1510                break;
1511
1512            case 'next':
1513                slideOffset = indexOffset === 0 ? _.options.slidesToScroll : indexOffset;
1514                if (_.slideCount > _.options.slidesToShow) {
1515                    _.slideHandler(_.currentSlide + slideOffset, false, dontAnimate);
1516                }
1517                break;
1518
1519            case 'index':
1520                var index = event.data.index === 0 ? 0 :
1521                    event.data.index || $target.index() * _.options.slidesToScroll;
1522
1523                _.slideHandler(_.checkNavigable(index), false, dontAnimate);
1524                $target.children().trigger('focus');
1525                break;
1526
1527            default:
1528                return;
1529        }
1530
1531    };
1532
1533    Slick.prototype.checkNavigable = function(index) {
1534
1535        var _ = this,
1536            navigables, prevNavigable;
1537
1538        navigables = _.getNavigableIndexes();
1539        prevNavigable = 0;
1540        if (index > navigables[navigables.length - 1]) {
1541            index = navigables[navigables.length - 1];
1542        } else {
1543            for (var n in navigables) {
1544                if (index < navigables[n]) {
1545                    index = prevNavigable;
1546                    break;
1547                }
1548                prevNavigable = navigables[n];
1549            }
1550        }
1551
1552        return index;
1553    };
1554
1555    Slick.prototype.cleanUpEvents = function() {
1556
1557        var _ = this;
1558
1559        if (_.options.dots && _.$dots !== null) {
1560
1561            $('li', _.$dots)
1562                .off('click.slick', _.changeSlide)
1563                .off('mouseenter.slick', $.proxy(_.interrupt, _, true))
1564                .off('mouseleave.slick', $.proxy(_.interrupt, _, false));
1565
1566        }
1567
1568        _.$slider.off('focus.slick blur.slick');
1569
1570        if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {
1571            _.$prevArrow && _.$prevArrow.off('click.slick', _.changeSlide);
1572            _.$nextArrow && _.$nextArrow.off('click.slick', _.changeSlide);
1573        }
1574
1575        _.$list.off('touchstart.slick mousedown.slick', _.swipeHandler);
1576        _.$list.off('touchmove.slick mousemove.slick', _.swipeHandler);
1577        _.$list.off('touchend.slick mouseup.slick', _.swipeHandler);
1578        _.$list.off('touchcancel.slick mouseleave.slick', _.swipeHandler);
1579
1580        _.$list.off('click.slick', _.clickHandler);
1581
1582        $(document).off(_.visibilityChange, _.visibility);
1583
1584        _.cleanUpSlideEvents();
1585
1586        if (_.options.accessibility === true) {
1587            _.$list.off('keydown.slick', _.keyHandler);
1588        }
1589
1590        if (_.options.focusOnSelect === true) {
1591            $(_.$slideTrack).children().off('click.slick', _.selectHandler);
1592        }
1593
1594        $(window).off('orientationchange.slick.slick-' + _.instanceUid, _.orientationChange);
1595
1596        $(window).off('resize.slick.slick-' + _.instanceUid, _.resize);
1597
1598        $('[draggable!=true]', _.$slideTrack).off('dragstart', _.preventDefault);
1599
1600        $(window).off('load.slick.slick-' + _.instanceUid, _.setPosition);
1601        $(document).off('ready.slick.slick-' + _.instanceUid, _.setPosition);
1602
1603    };
1604
1605    Slick.prototype.cleanUpSlideEvents = function() {
1606
1607        var _ = this;
1608
1609        _.$list.off('mouseenter.slick', $.proxy(_.interrupt, _, true));
1610        _.$list.off('mouseleave.slick', $.proxy(_.interrupt, _, false));
1611
1612    };
1613
1614    Slick.prototype.cleanUpRows = function() {
1615
1616        var _ = this, originalSlides;
1617
1618        if(_.options.rows > 1) {
1619            originalSlides = _.$slides.children().children();
1620            originalSlides.removeAttr('style');
1621            _.$slider.empty().append(originalSlides);
1622        }
1623
1624    };
1625
1626    Slick.prototype.clickHandler = function(event) {
1627
1628        var _ = this;
1629
1630        if (_.shouldClick === false) {
1631            event.stopImmediatePropagation();
1632            event.stopPropagation();
1633            event.preventDefault();
1634        }
1635
1636    };
1637
1638    Slick.prototype.destroy = function(refresh) {
1639
1640        var _ = this;
1641
1642        _.autoPlayClear();
1643
1644        _.touchObject = {};
1645
1646        _.cleanUpEvents();
1647
1648        $('.slick-cloned', _.$slider).detach();
1649
1650        if (_.$dots) {
1651            _.$dots.remove();
1652        }
1653
1654
1655        if ( _.$prevArrow && _.$prevArrow.length ) {
1656
1657            _.$prevArrow
1658                .removeClass('slick-disabled slick-arrow slick-hidden')
1659                .removeAttr('aria-hidden aria-disabled tabindex')
1660                .css('display','');
1661
1662            if ( _.htmlExpr.test( _.options.prevArrow )) {
1663                _.$prevArrow.remove();
1664            }
1665        }
1666
1667        if ( _.$nextArrow && _.$nextArrow.length ) {
1668
1669            _.$nextArrow
1670                .removeClass('slick-disabled slick-arrow slick-hidden')
1671                .removeAttr('aria-hidden aria-disabled tabindex')
1672                .css('display','');
1673
1674            if ( _.htmlExpr.test( _.options.nextArrow )) {
1675                _.$nextArrow.remove();
1676            }
1677
1678        }
1679
1680
1681        if (_.$slides) {
1682
1683            _.$slides
1684                .removeClass('slick-slide slick-active slick-center slick-visible slick-current')
1685                .removeAttr('aria-hidden')
1686                .removeAttr('data-slick-index')
1687                .each(function(){
1688                    $(this).attr('style', $(this).data('originalStyling'));
1689                });
1690
1691            _.$slideTrack.children(this.options.slide).detach();
1692
1693            _.$slideTrack.detach();
1694
1695            _.$list.detach();
1696
1697            _.$slider.append(_.$slides);
1698        }
1699
1700        _.cleanUpRows();
1701
1702        _.$slider.removeClass('slick-slider');
1703        _.$slider.removeClass('slick-initialized');
1704        _.$slider.removeClass('slick-dotted');
1705
1706        _.unslicked = true;
1707
1708        if(!refresh) {
1709            _.$slider.trigger('destroy', [_]);
1710        }
1711
1712    };
1713
1714    Slick.prototype.disableTransition = function(slide) {
1715
1716        var _ = this,
1717            transition = {};
1718
1719        transition[_.transitionType] = '';
1720
1721        if (_.options.fade === false) {
1722            _.$slideTrack.css(transition);
1723        } else {
1724            _.$slides.eq(slide).css(transition);
1725        }
1726
1727    };
1728
1729    Slick.prototype.fadeSlide = function(slideIndex, callback) {
1730
1731        var _ = this;
1732
1733        if (_.cssTransitions === false) {
1734
1735            _.$slides.eq(slideIndex).css({
1736                zIndex: _.options.zIndex
1737            });
1738
1739            _.$slides.eq(slideIndex).animate({
1740                opacity: 1
1741            }, _.options.speed, _.options.easing, callback);
1742
1743        } else {
1744
1745            _.applyTransition(slideIndex);
1746
1747            _.$slides.eq(slideIndex).css({
1748                opacity: 1,
1749                zIndex: _.options.zIndex
1750            });
1751
1752            if (callback) {
1753                setTimeout(function() {
1754
1755                    _.disableTransition(slideIndex);
1756
1757                    callback.call();
1758                }, _.options.speed);
1759            }
1760
1761        }
1762
1763    };
1764
1765    Slick.prototype.fadeSlideOut = function(slideIndex) {
1766
1767        var _ = this;
1768
1769        if (_.cssTransitions === false) {
1770
1771            _.$slides.eq(slideIndex).animate({
1772                opacity: 0,
1773                zIndex: _.options.zIndex - 2
1774            }, _.options.speed, _.options.easing);
1775
1776        } else {
1777
1778            _.applyTransition(slideIndex);
1779
1780            _.$slides.eq(slideIndex).css({
1781                opacity: 0,
1782                zIndex: _.options.zIndex - 2
1783            });
1784
1785        }
1786
1787    };
1788

1889ideIndex - _.slideCount)) * _.slideWidth) * -1;
1890                        verticalOffset = ((_.options.slidesToShow - (slideIndex - _.slideCount)) * verticalHeight) * -1;
1891                    } else {
1892                        _.slideOffset = ((_.slideCount % _.options.slidesToScroll) * _.slideWidth) * -1;
1893                        verticalOffset = ((_.slideCount % _.options.slidesToScroll) * verticalHeight) * -1;
1894                    }
1895                }
1896            }
1897        } else {
1898            if (slideIndex + _.options.slidesToShow > _.slideCount) {
1899                _.slideOffset = ((slideIndex + _.options.slidesToShow) - _.slideCount) * _.slideWidth;
1900                verticalOffset = ((slideIndex + _.options.slidesToShow) - _.slideCount) * verticalHeight;
1901            }
1902        }
1903
1904        if (_.slideCount <= _.options.slidesToShow) {
1905            _.slideOffset = 0;
1906            verticalOffset = 0;
1907        }
1908
1909       

1909 if (_.options.centerMode === true && _.options.infinite === true) {
1910            _.slideOffset += _.slideWidth * Math.floor(_.options.slidesToShow / 2) - _.slideWidth;
1911        } else if (_.options.centerMode === true) {
1912            _.slideOffset = 0;
1913            _.slideOffset += _.slideWidth * Math.floor(_.options.slidesToShow / 2);
1914        }
1915
1916        if (_.options.vertical === false) {
1917            targetLeft = ((slideIndex * _.slideWidth) * -1) + _.slideOffset;
1918        } else {
1919            targetLeft = ((slideIndex * verticalHeight) * -1) + verticalOffset;
1920        }
1921
1922        if (_.options.variableWidth === true) {
1923
1924            if (_.slideCount <= _.options.slidesToShow || _.options.infinite === false) {
1925                targetSlide = _.$slideTrack.children('.slick-slide').eq(slideIndex);
1926            } else {
1927                targetSlide = _.$slideTrack.children('.slick-slide').eq(slideIndex + _.options.slidesToShow);
1928            }
1929
1930            if (_.options.rtl === true) {
1931                if (targetSlide[0]) {
1932                    targetLeft = (_.$slideTrack.width() - targetSlide[0].offsetLeft - targetSlide.width()) * -1;
1933                } else {
1934                    targetLeft =  0;
1935                }
1936            } else {
1937                targetLeft = targetSlide[0] ? targetSlide[0].offsetLeft * -1 : 0;
1938            }
1939
1940            if (_.options.centerMode === true) {
1941                if (_.slideCount <= _.options.slidesToShow || _.options.infinite === false) {
1942                    targetSlide = _.$slideTrack.children('.slick-slide').eq(slideIndex);
1943                } else {
1944                    targetSlide = _.$slideTrack.children('.slick-slide').eq(slideIndex + _.options.slidesToShow + 1);
1945                }
1946
1947                if (_.options.rtl === true) {
1948                    if (targetSlide[0]) {
1949                        targetLeft = (_.$slideTrack.width() - targetSlide[0].offsetLeft - targetSlide.width()) * -1;
1950                    } else {
1951                        targetLeft =  0;
1952                    }
1953                } else {
1954                    targetLeft = targetSlide[0] ? targetSlide[0].offsetLeft * -1 : 0;
1955                }
1956
1957                targetLeft += (_.$list.width() - targetSlide.outerWidth()) / 2;
1958            }
1959        }
1960
1961        return targetLeft;
1962
1963    };
1964
1965    Slick.prototype.getOption = Slick.prototype.slickGetOption = function(option) {
1966
1967        var _ = this;
1968
1969        return _.options[option];
1970
1971    };
1972
1973    Slick.prototype.getNavigableIndexes = function() {
1974
1975        var _ = this,
1976            breakPoint = 0,
1977            counter = 0,
1978            indexes = [],
1979            max;
1980
1981        if (_.options.infinite === false) {
1982            max = _.slideCount;
1983        } else {
1984            breakPoint = _.options.slidesToScroll * -1;
1985            counter = _.options.slidesToScroll * -1;
1986            max = _.slideCount * 2;
1987        }
1988
1989        while (breakPoint < max) {
1990            indexes.push(breakPoint);
1991            breakPoint = counter + _.options.slidesToScroll;
1992            counter += _.options.slidesToScroll <= _.options.slidesToShow ? _.options.slidesToScroll : _.options.slidesToShow;
1993        }
1994
1995        return indexes;
1996
1997    };
1998
1999    Slick.prototype.getSlick = function() {
2000
2001        return this;
2002
2003    };
2004
2005    Slick.prototype.getSlideCount = function() {
2006
2007        var _ = this,
2008            slidesTraversed, swipedSlide, centerOffset;
2009
2010        centerOffset = _.options.centerMode === true ? _.slideWidth * Math.floor(_.options.slidesToShow / 2) : 0;
2011
2012        if (_.options.swipeToSlide === true) {
2013            _.$slideTrack.find('.slick-slide').each(function(index, slide) {
2014                if (slide.offsetLeft - centerOffset + ($(slide).outerWidth() / 2) > (_.swipeLeft * -1)) {
2015                    swipedSlide = slide;
2016                    return false;
2017                }
2018            });
2019
2020            slidesTraversed = Math.abs($(swipedSlide).attr('data-slick-index') - _.currentSlide) || 1;
2021
2022            return slidesTraversed;
2023
2024        } else {
2025            return _.options.slidesToScroll;
2026        }
2027
2028    };
2029
2030    Slick.prototype.goTo = Slick.prototype.slickGoTo = function(slide, dontAnimate) {
2031
2032        var _ = this;
2033
2034        _.changeSlide({
2035            data: {
2036                message: 'index',
2037                index: parseInt(slide)
2038            }
2039        }, dontAnimate);
2040
2041    };
2042
2043    Slick.prototype.init = function(creation) {
2044
2045        var _ = this;
2046
2047        if (!$(_.$slider).hasClass('slick-initialized')) {
2048
2049            $(_.$slider).addClass('slick-initialized');
2050
2051            _.buildRows();
2052            _.buildOut();
2053            _.setProps();
2054            _.startLoad();
2055            _.loadSlider();
2056            _.initializeEvents();
2057            _.updateArrows();
2058            _.updateDots();
2059            _.checkResponsive(true);
2060            _.focusHandler();
2061
2062        }
2063
2064        if (creation) {
2065            _.$slider.trigger('init', [_]);
2066        }
2067
2068        if (_.options.accessibility === true) {
2069            _.initADA();
2070        }
2071
2072        if ( _.options.autoplay ) {
2073
2074            _.paused = false;
2075            _.autoPlay();
2076
2077        }
2078
2079    };
2080
2081    Slick.prototype.initADA = function() {
2082        var _ = this

2186        _.$list.on('touchcancel.slick mouseleave.slick', {
2187            action: 'end'
2188        }, _.swipeHandler);
2189
2190        _.$list.on('click.slick', _.clickHandler);
2191
2192        $(document).on(_.visibilityChange, $.proxy(_.visibility, _));
2193
2194        if (_.options.accessibility === true) {
2195            _.$list.on('keydown.slick', _.keyHandler);
2196        }
2197
2198        if (_.options.focusOnSelect === true) {
2199            $(_.$slideTrack).children().on('click.slick', _.selectHandler);
2200        }
2201
2202        $(window).on('orientationchange.slick.slick-' + _.instanceUid, $.proxy(_.orientationChange, _));
2203
2204        $(window).on('resize.slick.slick-' + _.instanceUid, $.proxy(_.resize, _));
2205
2206        $('[draggable!=true]', _.$slideTrack).on('dragstart', _.preventDefault);
2207
2208        $(window).on('load.slick.slick-' + _.instanceUid, _.setPosition);
2209        $(document).on('ready.slick.slick-' + _.instanceUid, _.setPosition);
2210
2211    };
2212
2213    Slick.prototype.initUI = function() {
2214
2215        var _ = this;
2216
2217        if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {
2218
2219            _.$prevArrow.show();
2220            _.$nextArrow.show();
2221
2222        }
2223
2224        if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {
2225
2226            _.$dots.show();
2227
2228        }
2229
2230    };
2231
2232    Slick.prototype.keyHandler = function(event) {
2233
2234        var _ = this;
2235         //Dont slide if the cursor is inside the form fields and arrow keys are pressed
2236        if(!event.target.tagName.match('TEXTAREA|INPUT|SELECT')) {
2237            if (event.keyCode === 37 && _.options.accessibility === true) {
2238                _.changeSlide({
2239                    data: {
2240                        message: _.options.rtl === true ? 'next' :  'previous'
2241                    }
2242                });
2243            } else if (event.keyCode === 39 && _.options.accessibility === true) {
2244                _.changeSlide({
2245                    data: {
2246                        message: _.options.rtl === true ? 'previous' : 'next'
2247                    }
2248                });
2249            }
2250        }
2251
2252    };
2253
2254    Slick.prototype.lazyLoad = function() {
2255
2256        var _ = this,
2257            loadRange, cloneRange, rangeStart, rangeEnd;
2258
2259        function loadImages(imagesScope) {
2260
2261            $('img[data-lazy]', imagesScope).each(function() {
2262
2263                var image = $(this),
2264                    imageSource = $(this).attr('data-lazy'),
2265                    imageToLoad = document.createElement('img');
2266
2267                imageToLoad.onload = function() {
2268
2269                    image
2270                        .animate({ opacity: 0 }, 100, function() {
2271                            image
2272                                .attr('src', imageSource)
2273                                .animate({ opacity: 1 }, 200, function() {
2274                                    image
2275                                        .removeAttr('data-lazy')
2276                                        .removeClass('slick-loading');
2277                                });
2278                            _.$slider.trigger('lazyLoaded', [_, image, imageSource]);
2279                        });
2280
2281                };
2282
2283                imageToLoad.onerror = function() {
2284
2285                    image
2286                        .removeAttr( 'data-lazy' )
2287                        .removeClass( 'slick-loading' )
2288                        .addClass( 'slick-lazyload-error' );
2289
2290                    _.$slider.trigger('lazyLoadError', [ _, image, imageSource ]);
2291
2292                };
2293
2294                imageToLoad.src = imageSource;
2295
2296            });
2297
2298        }
2299
2300        if (_.options.centerMode === true) {
2301            if (_.options.infinite === true) {
2302                rangeStart = _.currentSlide + (_.options.slidesToShow / 2 + 1);
2303                rangeEnd = rangeStart + _.options.slidesToShow + 2;
2304            } else {
2305                rangeStart = Math.max(0, _.currentSlide - (_.options.slidesToShow / 2 + 1));
2306                rangeEnd = 2 + (_.options.slidesToShow / 2 + 1) + _.currentSlide;
2307            }
2308        } else {
2309            rangeStart = _.options.infinite ? _.options.slidesToShow + _.currentSlide : _.currentSlide;
2310            rangeEnd = Math.ceil(rangeStart + _.options.slidesToShow);
2311            if (_.options.fade === true) {
2312                if (rangeStart > 0) rangeStart--;
2313                if (rangeEnd <= _.slideCount) rangeEnd++;
2314            }
2315        }
2316
2317        loadRange = _.$slider.find('.slick-slide').slice(rangeStart, rangeEnd);
2318        loadImages(loadRange);
2319
2320        if (_.slideCount <= _.options.slidesToShow) {
2321            cloneRange = _.$slider.find('.slick-slide');
2322            loadImages(cloneRange);
2323        } else
2324        if (_.currentSlide >= _.slideCount - _.options.slidesToShow) {
2325            cloneRange = _.$slider.find('.slick-cloned').slice(0, _.options.slidesToShow);
2326            loadImages(cloneRange);
2327        } else if (_.currentSlide === 0) {
2328            cloneRange = _.$slider.find('.slick-cloned').slice(_.options.slidesToShow * -1);
2329            loadImages(cloneRange);
2330        }
2331
2332    };
2333
2334    Slick.prototype.loadSlider = function() {
2335
2336        var _ = this;
2337
2338        _.setPosition();
2339
2340        _.$slideTrack.css({
2341            opacity: 1
2342        });
2343
2344        _.$slider.removeClass('slick-loading');
2345
2346        _.initUI();
2347
2348        if (_.options.lazyLoad === 'progressive') {
2349            _.progressiveLazyLoad();
2350        }
2351
2352    };
2353
2354    Slick.prototype.next = Slick.prototype.slickNext = function() {
2355
2356        var _ = this;
2357
2358        _.changeSlide({
2359            data: {
2360                message: 'next'
2361            }
2362        });
2363
2364    };
2365
2366    Slick.prototype.orientationChange = function() {
2367
2368        var _ = this;
2369
2370        _.checkResponsive();
2371        _.setPosition();
2372
2373    };
2374
2375    Slick.prototype.pause = Slick.prototype.slickPause = function() {
2376
2377        var _ = this;
2378
2379        _.autoPlayClear();
2380        _.paused = true;
2381
2382    };
2383
2384    Slick.prototype.play = Slick.prototype.slickPlay = function() {
2385
2386        var _ = this;
2387
2388        _.autoPlay();
2389        _.options.autoplay = true;
2390        _.paused = false;
2391        _.focussed = false;
2392        _.interrupted = false;
2393
2394    };
2395
2396    Slick.prototype.postSlide = function(index) {
2397
2398        var _ = this;
2399
2400        if( !_.unslicked ) {
2401
2402            _.$slider.trigger('afterChange', [_, index]);
2403
2404            _.animating = false;
2405
2406            _.setPosition();
2407
2408            _.swipeLeft = null;
2409
2410            if ( _.options.autoplay ) {
2411                _.autoPlay();
2412            }
2413
2414            if (_.options.accessibility === true) {
2415                _.initADA();
2416            }
2417
2418        }
2419
2420    };
2421
2422    Slick.prototype.prev = Slick.prototype.slickPrev = function() {
2423
2424        var _ = this;
2425
2426        _.changeSlide({
2427            data: {
2428                message: 'previous'
2429            }
2430        });
2431
2432    };
2433
2434    Slick.prototype.preventDefault = function(event) {
2435
2436        event.preventDefault();
2437
2438    };
2439
2440    Slick.prototype.progressiveLazyLoad = function( tryCount ) {
2441
2442        tryCount = tryCount || 1;
2443
2444        var _ = this,
2445            $imgsToLoad = $( 'img[data-lazy]', _.$slider ),
2446            image,
2447            imageSource,
2448            imageToLoad;
2449
2450        if ( $imgsToLoad.length ) {
2451
2452            image = $imgsToLoad.first();
2453            imageSource = image.attr('data-lazy');
2454            imageToLoad = document.createElement('img');
2455
2456            imageToLoad.onload = function() {
2457
2458                image
2459                    .attr( 'src', imageSource )
2460                    .removeAttr('data-lazy')
2461                    .removeClass('slick-loading');
2462
2463                if ( _.options.adaptiveHeight === true ) {
2464                    _.setPosition();
2465                }
2466
2467                _.$slider.trigger('lazyLoaded', [ _, image, imageSource ]);
2468                _.progressiveLazyLoad();
2469
2470            };
2471
2472            imageToLoad.onerror = function() {
2473
2474                if ( tryCount < 3 ) {
2475
2476                    /**
2477                     * try to load the image 3 times,
2478                     * leave a slight delay so we don't get
2479                     * servers blocking the request.
2480                     */
2481                    setTimeout( function() {
2482                        _.progressiveLazyLoad( tryCount + 1 );
2483                    }, 500 );
2484
2485                } else {
2486
2487                    image
2488                        .removeAttr( 'data-lazy' )
2489                        .removeClass( 'slick-loading' )
2490                        .addClass( 'slick-lazyload-error' );
2491
2492                    _.$slider.trigger('lazyLoadError', [ _, image, imageSource ]);
2493
2494                    _.progressiveLazyLoad();
2495
2496                }
2497
2498            };
2499
2500            imageToLoad.src = imageSource;
2501
2502        } else {
2503
2504            _.$slider.trigger('allImagesLoaded', [ _ ]);
2505
2506        }
2507
2508    };
2509
2510    Slick.prototype.refresh = function( initializing ) {
2511
2512        var _ = this, currentSlide, lastVisibleIndex;
2513
2514        lastVisibleIndex = _.slideCount - _.options.slidesToShow;
2515
2516        // in non-infinite sliders, we don't want to go past the
2517        // last visible index.
2518        if( !_.options.infinite && ( _.currentSlide > lastVisibleIndex )) {
2519            _.currentSlide = lastVisibleIndex;
2520        }
2521
2522        // if less slides than to show, go to start.
2523        if ( _.slideCount <= _.options.slidesToShow ) {
2524            _.currentSlide = 0;
2525
2526        }
2527
2528        currentSlide = _.currentSlide;
2529
2530        _.destroy(true);
2531
2532        $.extend(_, _.initials, { currentSlide: currentSlide });
2533
2534        _.init();
2535
2536        if( !initializing ) {
2537
2538            _.changeSlide({
2539                data: {
2540                    message: 'index',
2541                    index: currentSlide
2542                }
2543            }, false);
2544
2545        }
2546
2547    };
2548
2549    Slick.prototype.registerBreakpoints = function() {
2550
2551        var _ = this, breakpoint, currentBreakpoint, l,
2552            responsiveSettings = _.options.responsive || null;
2553
2554        if ( $.type(responsiveSettings) === 'array' && responsiveSettings.length ) {
2555
2556            _.respondTo = _.options.respondTo || 'window';
2557
2558            for ( breakpoint in responsiveSettings ) {
2559
2560                l = _.breakpoints.length-1;
2561                currentBreakpoint = responsiveSettings[breakpoint].breakpoint;
2562
2563                if (responsiveSettings.hasOwnProperty(breakpoint)) {

2563
2564
2565                    // loop through the breakpoints and cut out any existing
2566                    // ones with the same breakpoint number, we don't want dupes.
2567                    while( l >= 0 ) {
2568                        if( _.breakpoints[l] && _.breakpoints[l] === currentBreakpoint ) {
2569                            _.breakpoints.splice(l,1);
2570                        }
2571                        l--;
2572                    }
2573
2574                    _.breakpoints.push(currentBreakpoint);
2575                    _.breakpointSettings[currentBreakpoint] = responsiveSettings[breakpoint].settings;
2576
2577                }
2578
2579            }
2580
2581            _.breakpoints.sort(function(a, b) {
2582                return ( _.options.mobileFirst ) ? a-b : b-a;
2583            });
2584
2585        }
2586
2587    };
2588
2589    Slick.prototype.reinit = function() {
2590
2591        var _ = this;
2592
2593        _.$slides =
2594            _.$slideTrack
2595                .children(_.options.slide)
2596                .addClass('slick-slide');
2597
2598        _.slideCount = _.$slides.length;
2599
2600        if (_.currentSlide >= _.slideCount && _.currentSlide !== 0) {
2601            _.currentSlide = _.currentSlide - _.options.slidesToScroll;
2602        }
2603
2604        if (_.slideCount <= _.options.slidesToShow) {
2605            _.currentSlide = 0;
2606        }
2607
2608        _.registerBreakpoints();
2609
2610        _.setProps();
2611        _.setupInfinite();
2612        _.buildArrows();
2613        _.updateArrows();
2614        _.initArrowEvents();
2615        _.buildDots();
2616        _.updateDots();
2617        _.initDotEvents();
2618        _.cleanUpSlideEvents();
2619        _.initSlideEvents();
2620
2621        _.checkResponsive(false, true);
2622
2623        if (_.options.focusOnSelect === true) {
2624            $(_.$slideTrack).children().on('click.slick', _.selectHandler);
2625        }
2626
2627        _.setSlideClasses(typeof _.currentSlide === 'number' ? _.currentSlide : 0);
2628
2629        _.setPosition();
2630        _.focusHandler();
2631
2632        _.paused = !_.options.autoplay;
2633        _.autoPlay();
2634
2635        _.$slider.trigger('reInit', [_]);
2636
2637    };
2638
2639    Slick.prototype.resize = function() {
2640
2641        var _ = this;
2642
2643        if ($(window).width() !== _.windowWidth) {
2644            clearTimeout(_.windowDelay);
2645            _.windowDelay = window.setTimeout(function() {
2646                _.windowWidth = $(window).width();
2647                _.checkResponsive();
2648                if( !_.unslicked ) { _.setPosition(); }
2649            }, 50);
2650        }
2651    };
2652
2653    Slick.prototype.removeSlide = Slick.prototype.slickRemove = function(index, removeBefore, removeAll) {
2654
2655        var _ = this;
2656
2657        if (typeof(index) === 'boolean') {
2658            removeBefore = index;
2659            index = removeBefore === true ? 0 : _.slideCount - 1;
2660        } else {
2661            index = removeBefore === true ? --index : index;
2662        }
2663
2664        if (_.slideCount < 1 || index < 0 || index > _.slideCount - 1) {
2665            return false;
2666        }
2667
2668        _.unload();
2669
2670        if (removeAll === true) {
2671            _.$slideTrack.children().remove();
2672        } else {
2673            _.$slideTrack.children(this.options.slide).eq(index).remove();
2674        }
2675
2676        _.$slides = _.$slideTrack.children(this.options.slide);
2677
2678        _.$slideTrack.children(this.options.slide).detach();
2679
2680        _.$slideTrack.append(_.$slides);
2681
2682        _.$slidesCache = _.$slides;
2683
2684        _.reinit();
2685
2686    };
2687
2688    Slick.prototype.setCSS = function(position) {
2689
2690        var _ = this,
2691            positionProps = {},
2692            x, y;
2693
2694        if (_.options.rtl === true) {
2695            position = -position;
2696        }
2697        x = _.positionProp == 'left' ? Math.ceil(position) + 'px' : '0px';
2698        y = _.positionProp == 'top' ? Math.ceil(position) + 'px' : '0px';
2699
2700        positionProps[_.positionProp] = position;
2701
2702        if (_.transformsEnabled === false) {
2703            _.$slideTrack.css(positionProps);
2704        } else {
2705            positionProps = {};
2706            if (_.cssTransitions === false) {
2707                positionProps[_.animType] = 'translate(' + x + ', ' + y + ')';
2708                _.$slideTrack.css(positionProps);
2709            } else {
2710                positionProps[_.animType] = 'translate3d(' + x + ', ' + y + ', 0px)';
2711                _.$slideTrack.css(positionProps);
2712            }
2713        }
2714
2715    };
2716
2717    Slick.prototype.setDimensions = function() {
2718
2719        var _ = this;
2720
2721        if (_.options.vertical === false) {
2722            if (_.options.centerMode === true) {
2723                _.$list.css({
2724                    padding: ('0px ' + _.options.centerPadding)
2725                });
2726            }
2727        } else {
2728            _.$list.height(_.$slides.first().outerHeight(true) * _.options.slidesToShow);
2729            if (_.options.centerMode === true) {
2730                _.$list.css({
2731                    padding: (_.options.centerPadding + ' 0px')
2732                });
2733            }
2734        }
2735
2736        _.listWidth = _.$list.width();
2737        _.listHeight = _.$list.height();
2738
2739
2740        if (_.options.vertical === false && _.options.variableWidth === false) {
2741            _.slideWidth = Math.ceil(_.listWidth / _.options.slidesToShow);
2742            _.$slideTrack.width(Math.ceil((_.slideWidth * _.$slideTrack.children('.slick-slide').length)));
2743
2744        } else if (_.options.variableWidth === true) {
2745            _.$slideTrack.width(5000 * _.slideCount);
2746        } else {
2747            _.slideWidth = Math.ceil(_.listWidth);
2748            _.$slideTrack.height(Math.ceil((_.$slides.first().outerHeight(true) * _.$slideTrack.children('.slick-slide').length)));
2749        }
2750
2751        var offset = _.$slides.first().outerWidth(true) - _.$slides.first().width();
2752        if (_.options.variableWidth === false) _.$slideTrack.children('.slick-slide').width(_.slideWidth - offset);
2753
2754    };
2755
2756    Slick.prototype.setFade = function() {
2757
2758        var _ = this,
2759            targetLeft;
2760
2761        _.$slides.each(function(index, element) {
2762            targetLeft = (_.slideWidth * index) * -1;
2763            if (_.options.rtl === true) {
2764                $(element).css({
2765                    position: 'relative',
2766                    right: targetLeft,
2767                    top: 0,
2768                    zIndex: _.options.zIndex - 2,
2769                    opacity: 0
2770                });
2771            } else {
2772                $(element).css({
2773                    position: 'relative',
2774                    left: targetLeft,
2775                    top: 0,
2776                    zIndex: _.options.zIndex - 2,
2777                    opacity: 0
2778                });
2779            }
2780        });
2781
2782        _.$slides.eq(_.currentSlide).css({
2783            zIndex: _.options.zIndex - 1,
2784            opacity: 1
2785        });
2786
2787    };
2788
2789    Slick.prototype.setHeight = function() {
2790
2791        var _ = this;
2792
2793        if (_.options.slidesToShow === 1 && _.options.adaptiveHeight === true && _.options.vertical === false) {
2794            var targetHeight = _.$slides.eq(_.currentSlide).outerHeight(true);
2795            _.$list.css('height', targetHeight);
2796        }
2797
2798    };
2799
2800    Slick.prototype.setOption =
2801    Slick.prototype.slickSetOption = function() {
2802
2803        /**
2804         * accepts arguments in format of:
2805         *
2806         *  - for changing a single option's value:
2807         *     .slick("setOption", option, value, refresh )
2808         *
2809         *  - for changing a set of responsive options:
2810         *     .slick("setOption", 'responsive', [{}, ...], refresh )
2811         *
2812         *  - for updating multiple values at once (not responsive)
2813         *     .slick("setOption", { 'option': value, ... }, refresh )
2814         */
2815
2816        var _ = this, l, item, option, value, refresh = false, type;
2817
2818        if( $.type( arguments[0] ) === 'object' ) {
2819
2820            option =  arguments[0];
2821            refresh = arguments[1];
2822            type = 'multiple';
2823
2824        } else if ( $.type( arguments[0] ) === 'string' ) {
2825
2826            option =  arguments[0];
2827            value = arguments[1];
2828            refresh = arguments[2];
2829
2830            if ( arguments[0] === 'responsive' && $.type( arguments[1] ) === 'array' ) {
2831
2832                type = 'responsive';
2833
2834            } else if ( typeof arguments[1] !== 'undefined' ) {
2835
2836                type = 'single';
2837
2838            }
2839
2840        }
2841
2842        if ( type === 'single' ) {
2843
2844            _.options[option] = value;
2845
2846
2847        } else if ( type === 'multiple' ) {
2848
2849            $.each( option , function( opt, val ) {
2850
2851                _.options[opt] = val;
2852
2853            });
2854
2855
2856        } else if ( type === 'responsive' ) {
2857
2858            for ( item in value ) {
2859
2860                if( $.type( _.options.responsive ) !== 'array' ) {
2861
2862                    _.options.responsive = [ value[item] ];
2863
2864                } else {
2865
2866                    l = _.options.responsive.length-1;
2867
2868                    // loop through the responsive object and splice out duplicates.
2869                    while( l >= 0 ) {
2870
2871                        if( _.options.responsive[l].breakpoint === value[item].breakpoint ) {
2872
2873                            _.options.responsive.splice(l,1);
2874
2875                        }
2876
2877                        l--;
2878
2879                    }
2880
2881                    _.options.responsive.push( value[item] );
2882
2883                }
2884
2885            }
2886
2887        }
2888
2889        if ( refresh ) {
2890
2891            _.unload();
2892            _.reinit();
2893
2894        }
2895
2896    };
2897
2898    Slick.prototype.setPosition = function() {
2899
2900        var _ = this;
2901
2902        _.setDimensions();
2903
2904        _.setHeight();
2905
2906        if (_.options.fade === false) {
2907            _.setCSS(_.getLeft(_.currentSlide));
2908        } else {
2909            _.setFade();
2910        }
2911
2912        _.$slider.trigger('setPosition', [_]);
2913
2914    };
2915
2916    Slick.prototype.setProps = function() {
2917
2918        var _ = this,
2919            bodyStyle = document.body.style;
2920
2921        _.positionProp = _.options.vertical === true ? 'top' : 'left';
2922
2923        if (_.positionProp === 'top') {
2924            _.$slider.addClass('slick-vertical');
2925        } else {
2926            _.$slider.removeClass('slick-vertical');
2927        }
2928
2929        if (bodyStyle.WebkitTransition !== undefined ||
2930            bodyStyle.MozTransition !== undefined ||
2931            bodyStyle.msTransition !== undefined) {
2932            if (_.options.useCSS === true) {
2933                _.cssTransitions = true;
2934            }
2935        }
2936
2937        if ( _.options.fade ) {
2938            if ( typeof _.options.zIndex === 'number' ) {
2939                if( _.options.zIndex < 3 ) {
2940                    _.options.zIndex = 3;
2941                }
2942            } else {
2943                _.options.zIndex = _.defaults.zIndex;
2944            }
2945        }
2946
2947        if (bodyStyle.OTransform !== undefined) {
2948            _.animType = 'OTransform';
2949            _.transformType = '-o-transform';
2950            _.transitionType = 'OTransition';
2951            if (bodyStyle.perspectiveProperty === undefined && bodyStyle.webkitPerspective === undefined) _.animType = false;
2952        }
2953        if (bodyStyle.MozTransform !== undefined) {
2954            _.animType = 'MozTransform';
2955            _.transformType = '-moz-transform';
2956            _.transitionType = 'MozTransition';
2957            if (bodyStyle.perspectiveProperty === undefined && bodyStyle.MozPerspective === undefined) _.animType = false;
2958        }
2959        if (bodyStyle.webkitTransform !== undefined) {
2960            _.animType = 'webkitTransform';
2961            _.transformType = '-webkit-transform';
2962            _.transitionType = 'webkitTransition';
2963            if (bodyStyle.perspectiveProperty === undefined && bodyStyle.webkitPerspective === undefined) _.animType = false;
2964        }
2965        if (bodyStyle.msTransform !== undefined) {
2966            _.animType = 'msTransform';
2967            _.transformType = '-ms-transform';
2968            _.transitionType = 'msTransition';
2969            if (bodyStyle.msTransform === undefined) _.animType = false;
2970        }
2971        if (bodyStyle.transform !== undefined && _.animType !== false) {
2972            _.animType = 'transform';
2973            _.transformType = 'transform';
2974            _.transitionType = 'transition';
2975        }
2976        _.transformsEnabled = _.options.useTransform && (_.animType !== null && _.animType !== false);
2977    };
2978
2979
2980    Slick.prototype.setSlideClasses = function(index) {
2981
2982        var _ = this,
2983            centerOffset, allSlides, indexOffset, remainder;
2984
2985        allSlides = _.$slider
2986            .find('.slick-slide')
2987            .removeClass('slick-active slick-center slick-current')
2988            .attr('aria-hidden', 'true');
2989
2990        _.$slides
2991            .eq(index)
2992            .addClass('slick-current');
2993
2994        if (_.options.centerMode === true) {
2995
2996