https://suubc.kr/ind-script/optimizer_user.php?filename=jc_NDYMwDA…9f9ebc01513a08c458e2786&t=1787576512&user=T

1054,
1055                $list: null,
1056                touchObject: {},
1057                transformsEnabled: false,
1058                unslicked: false
1059            };
1060
1061            $.extend(_, _.initials);
1062
1063            _.activeBreakpoint = null;
1064            _.animType = null;
1065            _.animProp = null;
1066            _.breakpoints = [];
1067            _.breakpointSettings = [];
1068            _.cssTransitions = false;
1069            _.focussed = false;
1070            _.interrupted = false;
1071            _.hidden = 'hidden';
1072            _.paused = true;
1073            _.positionProp = null;
1074            _.respondTo = null;
1075            _.rowCount = 1;
1076            _.shouldClick = true;
1077            _.$slider = $(element);
1078            _.$slidesCache = null;
1079            _.transformType = null;
1080            _.transitionType = null;
1081            _.visibilityChange = 'visibilitychange';
1082            _.windowWidth = 0;
1083            _.windowTimer = null;
1084
1085            dataSettings = $(element).data('slick') || {};
1086
1087            _.options = $.extend({}, _.defaults, settings, dataSettings);
1088
1089            _.currentSlide = _.options.initialSlide;
1090
1091            _.originalSettings = _.options;
1092
1093            if (typeof document.mozHidden !== 'undefined') {
1094                _.hidden = 'mozHidden';
1095                _.visibilityChange = 'mozvisibilitychange';
1096            } else if (typeof document.webkitHidden !== 'undefined') {
1097                _.hidden = 'webkitHidden';
1098                _.visibilityChange = 'webkitvisibilitychange';
1099            }
1100
1101            _.autoPlay = $.proxy(_.autoPlay, _);
1102            _.autoPlayClear = $.proxy(_.autoPlayClear, _);
1103            _.autoPlayIterator = $.proxy(_.autoPlayIterator, _);
1104            _.changeSlide = $.proxy(_.changeSlide, _);
1105            _.clickHandler = $.proxy(_.clickHandler, _);
1106            _.selectHandler = $.proxy(_.selectHandler, _);
1107            _.setPosition = $.proxy(_.setPosition, _);
1108            _.swipeHandler = $.proxy(_.swipeHandler, _);
1109            _.dragHandler = $.proxy(_.dragHandler, _);
1110            _.keyHandler = $.proxy(_.keyHandler, _);
1111
1112            _.instanceUid = instanceUid++;
1113
1114            // A simple way to check for HTML strings
1115            // Strict HTML recognition (must start with <)
1116            // Extracted from jQuery v1.11 source
1117            _.htmlExpr = /^(?:\s*(<[\w\W]+>)[^>]*)$/;
1118
1119
1120            _.registerBreakpoints();
1121            _.init(true);
1122
1123        }
1124
1125        return Slick;
1126
1127    }());
1128
1129    Slick.prototype.activateADA = function() {
1130        var _ = this;
1131
1132        _.$slideTrack.find('.slick-active').attr({
1133            'aria-hidden': 'false'
1134        }).find('a, input, button, select').attr({
1135            'tabindex': '0'
1136        });
1137
1138    };
1139
1140    Slick.prototype.addSlide = Slick.prototype.slickAdd = function(markup, index, addBefore) {
1141
1142        var _ = this;
1143
1144        if (typeof(index) === 'boolean') {
1145            addBefore = index;
1146            index = null;
1147        } else if (index < 0 || (index >= _.slideCount)) {
1148            return false;
1149        }
1150
1151        _.unload();
1152
1153        if (typeof(index) === 'number') {
1154            if (index === 0 && _.$slides.length === 0) {
1155                $(markup).appendTo(_.$slideTrack);
1156            } else if (addBefore) {
1157                $(markup).insertBefore(_.$slides.eq(index));
1158            } else {
1159                $(markup).insertAfter(_.$slides.eq(index));
1160            }
1161        } else {
1162            if (addBefore === true) {
1163                $(markup).prependTo(_.$slideTrack);
1164            } else {
1165                $(markup).appendTo(_.$slideTrack);
1166            }
1167        }
1168
1169        _.$slides = _.$slideTrack.children(this.options.slide);
1170
1171        _.$slideTrack.children(this.options.slide).detach();
1172
1173        _.$slideTrack.append(_.$slides);
1174
1175        _.$slides.each(function(index, element) {
1176            $(element).attr('data-slick-index', index);
1177        });
1178
1179        _.$slidesCache = _.$slides;
1180
1181        _.reinit();
1182
1183    };
1184
1185    Slick.prototype.animateHeight = function() {
1186        var _ = this;
1187        if (_.options.slidesToShow === 1 && _.options.adaptiveHeight === true && _.options.vertical === false) {
1188            var targetHeight = _.$slides.eq(_.currentSlide).outerHeight(true);
1189            _.$list.animate({
1190                height: targetHeight
1191            }, _.options.speed);
1192        }
1193    };
1194
1195    Slick.prototype.animateSlide = function(targetLeft, callback) {
1196
1197        var animProps = {},
1198            _ = this;
1199
1200        _.animateHeight();
1201
1202        if (_.options.rtl === true && _.options.vertical === false) {
1203            targetLeft = -targetLeft;
1204        }
1205        if (_.transformsEnabled === false) {
1206            if (_.options.vertical === false) {
1207                _.$slideTrack.animate({
1208                    left: targetLeft
1209                }, _.options.speed, _.options.easing, callback);
1210            } else {
1211                _.$slideTrack.animate({
1212                    top: targetLeft
1213                }, _.options.speed, _.options.easing, callback);
1214            }
1215
1216        } else {
1217
1218            if (_.cssTransitions === false) {
1219                if (_.options.rtl === true) {
1220                    _.currentLeft = -(_.currentLeft);
1221                }
1222                $({
1223                    animStart: _.currentLeft
1224                }).animate({
1225                    animStart: targetLeft
1226                }, {
1227                    duration: _.options.speed,
1228                    easing: _.options.easing,
1229                    step: function(now) {
1230                        now = Math.ceil(now);
1231                        if (_.options.vertical === false) {
1232                            animProps[_.animType] = 'translate(' +
1233                                now + 'px, 0px)';
1234                            _.$slideTrack.css(animProps);
1235                        } else {
1236                            animProps[_.animType] = 'translate(0px,' +
1237                                now + 'px)';
1238                            _.$slideTrack.css(animProps);
1239                        }
1240                    },
1241                    complete: function() {
1242                        if (callback) {
1243                            callback.call();
1244                        }
1245                    }
1246                });
1247
1248            } else {
1249
1250                _.applyTransition();
1251                targetLeft = Math.ceil(targetLeft);
1252
1253                if (_.options.vertical === false) {
1254                    animProps[_.animType] = 'translate3d(' + targetLeft + 'px, 0px, 0px)';
1255                } else {
1256                    animProps[_.animType] = 'translate3d(0px,' + targetLeft + 'px, 0px)';
1257                }
1258                _.$slideTrack.css(animProps);
1259
1260                if (callback) {
1261                    setTimeout(function() {
1262
1263                        _.disableTransition();
1264
1265                        callback.call();
1266                    }, _.options.speed);
1267                }
1268
1269            }
1270
1271        }
1272
1273    };
1274
1275    Slick.prototype.getNavTarget = function() {
1276
1277        var _ = this,
1278            asNavFor = _.options.asNavFor;
1279
1280        if ( asNavFor && asNavFor !== null ) {
1281            asNavFor = $(asNavFor).not(_.$slider);
1282        }
1283
1284        return asNavFor;
1285
1286    };
1287
1288    Slick.prototype.asNavFor = function(index) {
1289
1290        var _ = this,
1291            asNavFor = _.getNavTarget();
1292
1293        if ( asNavFor !== null && typeof asNavFor === 'object' ) {
1294            asNavFor.each(function() {
1295                var target = $(this).slick('getSlick');
1296                if(!target.unslicked) {
1297                    target.slideHandler(index, true);
1298                }
1299            });
1300        }
1301
1302    };
1303
1304    Slick.prototype.applyTransition = function(slide) {
1305
1306        var _ = this,
1307            transition = {};
1308
1309        if (_.options.fade === false) {
1310            transition[_.transitionType] = _.transformType + ' ' + _.options.speed + 'ms ' + _.options.cssEase;
1311        } else {
1312            transition[_.transitionType] = 'opacity ' + _.options.speed + 'ms ' + _.options.cssEase;
1313        }
1314
1315        if (_.options.fade === false) {
1316            _.$slideTrack.css(transition);
1317        } else {
1318            _.$slides.eq(slide).css(transition);
1319        }
1320
1321    };
1322
1323    Slick.prototype.autoPlay = function() {
1324
1325        var _ = this;
1326
1327        _.autoPlayClear();
1328
1329        if ( _.slideCount > _.options.slidesToShow ) {
1330            _.autoPlayTimer = setInterval( _.autoPlayIterator, _.options.autoplaySpeed );
1331        }
1332
1333    };
1334
1335    Slick.prototype.autoPlayClear = function() {
1336
1337        var _ = this;
1338
1339        if (_.autoPlayTimer) {
1340            clearInterval(_.autoPlayTimer);
1341        }
1342
1343    };
1344
1345    Slick.prototype.autoPlayIterator = function() {
1346
1347        var _ = this,
1348            slideTo = _.currentSlide + _.options.slidesToScroll;
1349
1350        if ( !_.paused && !_.interrupted && !_.focussed ) {
1351
1352            if ( _.options.infinite === false ) {
1353
1354                if ( _.direction === 1 && ( _.currentSlide + 1 ) === ( _.slideCount - 1 )) {
1355                    _.direction = 0;
1356                }
1357
1358                else if ( _.direction === 0 ) {
1359
1360                    slideTo = _.currentSlide - _.options.slidesToScroll;
1361
1362                    if ( _.currentSlide - 1 === 0 ) {
1363                        _.direction = 1;
1364                    }
1365
1366                }
1367
1368            }
1369
1370            _.slideHandler( slideTo );
1371
1372        }
1373
1374    };
1375
1376    Slick.prototype.buildArrows = function() {
1377
1378        var _ = this;
1379
1380        if (_.options.arrows === true ) {
1381
1382            _.$prevArrow = $(_.options.prevArrow).addClass('slick-arrow');
1383            _.$nextArrow = $(_.options.nextArrow).addClass('slick-arrow');
1384
1385            if( _.slideCount > _.options.slidesToShow ) {
1386
1387                _.$prevArrow.removeClass('slick-hidden').removeAttr('aria-hidden tabindex');
1388                _.$nextArrow.removeClass('slick-hidden').removeAttr('aria-hidden tabindex');
1389
1390                if (_.htmlExpr.test(_.options.prevArrow)) {
1391                    _.$prevArrow.prependTo(_.options.appendArrows);
1392                }
1393
1394                if (_.htmlExpr.test(_.options.nextArrow)) {
1395                    _.$nextArrow.appendTo(_.options.appendArrows);
1396                }
1397
1398                if (_.options.infinite !== true) {
1399                    _.$prevArrow
1400                        .addClass('slick-disabled')
1401                        .attr('aria-disabled', 'true');
1402                }
1403
1404            } else {
1405
1406                _.$prevArrow.add( _.$nextArrow )
1407
1408                    .addClass('slick-hidden')
1409                    .attr({
1410                    

1410'aria-disabled': 'true',
1411                    'tabindex': '-1'
1412                });
1413
1414            }
1415
1416        }
1417
1418    };
1419
1420    Slick.prototype.buildDots = function() {
1421
1422        var _ = this,
1423            i, dot;
1424
1425        if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {
1426
1427            _.$slider.addClass('slick-dotted');
1428
1429            dot = $('<ul />').addClass(_.options.dotsClass);
1430
1431            for (i = 0; i <= _.getDotCount(); i += 1) {
1432                dot.append($('<li />').append(_.options.customPaging.call(this, _, i)));
1433            }
1434
1435            _.$dots = dot.appendTo(_.options.appendDots);
1436
1437            _.$dots.find('li').first().addClass('slick-active').attr('aria-hidden', 'false');
1438
1439        }
1440
1441    };
1442
1443    Slick.prototype.buildOut = function() {
1444
1445        var _ = this;
1446
1447        _.$slides =
1448            _.$slider
1449            .children( _.options.slide + ':not(.slick-cloned)')
1450            .addClass('slick-slide');
1451
1452        _.slideCount = _.$slides.length;
1453
1454        _.$slides.each(function(index, element) {
1455            $(element)
1456                .attr('data-slick-index', index)
1457                .data('originalStyling', $(element).attr('style') || '');
1458        });
1459
1460        _.$slider.addClass('slick-slider');
1461
1462        _.$slideTrack = (_.slideCount === 0) ?
1463            $('<div class="slick-track"/>').appendTo(_.$slider) :
1464        _.$slides.wrapAll('<div class="slick-track"/>').parent();
1465
1466        _.$list = _.$slideTrack.wrap(
1467            '<div aria-live="polite" class="slick-list"/>').parent();
1468        _.$slideTrack.css('opacity', 0);
1469
1470        if (_.options.centerMode === true || _.options.swipeToSlide === true) {
1471            _.options.slidesToScroll = 1;
1472        }
1473
1474        $('img[data-lazy]', _.$slider).not('[src]').addClass('slick-loading');
1475
1476        _.setupInfinite();
1477
1478        _.buildArrows();
1479
1480        _.buildDots();
1481
1482        _.updateDots();
1483
1484
1485        _.setSlideClasses(typeof _.currentSlide === 'number' ? _.currentSlide : 0);
1486
1487        if (_.options.draggable === true) {
1488            _.$list.addClass('draggable');
1489        }
1490
1491    };
1492
1493    Slick.prototype.buildRows = function() {
1494
1495        var _ = this, a, b, c, newSlides, numOfSlides, originalSlides,slidesPerSection;
1496
1497        newSlides = document.createDocumentFragment();
1498        originalSlides = _.$slider.children();
1499
1500        if(_.options.rows > 1) {
1501
1502            slidesPerSection = _.options.slidesPerRow * _.options.rows;
1503            numOfSlides = Math.ceil(
1504                originalSlides.length / slidesPerSection
1505            );
1506
1507            for(a = 0; a < numOfSlides; a++){
1508                var slide = document.createElement('div');
1509                for(b = 0; b < _.options.rows; b++) {
1510                    var row = document.createElement('div');
1511                    for(c = 0; c < _.options.slidesPerRow; c++) {
1512                        var target = (a * slidesPerSection + ((b * _.options.slidesPerRow) + c));
1513                        if (originalSlides.get(target)) {
1514                            row.appendChild(originalSlides.get(target));
1515                        }
1516                    }
1517                    slide.appendChild(row);
1518                }
1519                newSlides.appendChild(slide);
1520            }
1521
1522            _.$slider.empty().append(newSlides);
1523            _.$slider.children().children().children()
1524                .css({
1525                'width':(100 / _.options.slidesPerRow) + '%',
1526                'display': 'inline-block'
1527            });
1528
1529        }
1530
1531    };
1532
1533    Slick.prototype.checkResponsive = function(initial, forceUpdate) {
1534
1535        var _ = this,
1536            breakpoint, targetBreakpoint, respondToWidth, triggerBreakpoint = false;
1537        var sliderWidth = _.$slider.width();
1538        var windowWidth = window.innerWidth || $(window).width();
1539
1540        if (_.respondTo === 'window') {
1541            respondToWidth = windowWidth;
1542        } else if (_.respondTo === 'slider') {
1543            respondToWidth = sliderWidth;
1544        } else if (_.respondTo === 'min') {
1545            respondToWidth = Math.min(windowWidth, sliderWidth);
1546        }
1547
1548        if ( _.options.responsive &&
1549            _.options.responsive.length &&
1550            _.options.responsive !== null) {
1551
1552            targetBreakpoint = null;
1553
1554            for (breakpoint in _.breakpoints) {
1555                if (_.breakpoints.hasOwnProperty(breakpoint)) {
1556                    if (_.originalSettings.mobileFirst === false) {
1557                        if (respondToWidth < _.breakpoints[breakpoint]) {
1558                            targetBreakpoint = _.breakpoints[breakpoint];
1559                        }
1560                    } else {
1561                        if (respondToWidth > _.breakpoints[breakpoint]) {
1562                            targetBreakpoint = _.breakpoints[breakpoint];
1563                        }
1564                    }
1565                }
1566            }
1567
1568            if (targetBreakpoint !== null) {
1569                if (_.activeBreakpoint !== null) {
1570                    if (targetBreakpoint !== _.activeBreakpoint || forceUpdate) {
1571                        _.activeBreakpoint =
1572                            targetBreakpoint;
1573                        if (_.breakpointSettings[targetBreakpoint] === 'unslick') {
1574                            _.unslick(targetBreakpoint);
1575                        } else {
1576                            _.options = $.extend({}, _.originalSettings,
1577                                                 _.breakpointSettings[
1578                                targetBreakpoint]);
1579                            if (initial === true) {
1580                                _.currentSlide = _.options.initialSlide;
1581                            }
1582                            _.refresh(initial);
1583                        }
1584                        triggerBreakpoint = targetBreakpoint;
1585                    }
1586                } else {
1587                    _.activeBreakpoint = targetBreakpoint;
1588                    if (_.breakpointSettings[targetBreakpoint] === 'unslick') {
1589                        _.unslick(targetBreakpoint);
1590                    } else {
1591                        _.options = $.extend({}, _.originalSettings,
1592                                             _.breakpointSettings[
1593                            targetBreakpoint]);
1594                        if (initial === true) {
1595                            _.currentSlide = _.options.initialSlide;
1596                        }
1597                        _.refresh(initial);
1598                    }
1599                    triggerBreakpoint = targetBreakpoint;
1600                }
1601            } else {
1602                if (_.activeBreakpoint !== null) {
1603                    _.activeBreakpoint = null;
1604                    _.options = _.originalSettings;
1605                    if (initial === true) {
1606                        _.currentSlide = _.options.initialSlide;
1607                    }
1608                    _.refresh(initial);
1609                    triggerBreakpoint = targetBreakpoint;
1610                }
1611            }
1612
1613            // only trigger breakpoints during an actual break. not on initialize.
1614            if( !initial && triggerBreakpoint !== false ) {
1615                _.$slider.trigger('breakpoint', [_, triggerBreakpoint]);
1616            }
1617        }
1618
1619    };
1620
1621    Slick.prototype.changeSlide = function(event, dontAnimate) {
1622
1623        var _ = this,
1624            $target = $(event.currentTarget),
1625            indexOffset, slideOffset, unevenOffset;
1626
1627        // If target is a link, prevent default action.
1628        if($target.is('a')) {
1629            event.preventDefault();
1630        }
1631
1632        // If target is not the <li> element (ie: a child), find the <li>.
1633        if(!$target.is('li')) {
1634            $target = $target.closest('li');
1635        }
1636
1637        unevenOffset = (_.slideCount % _.options.slidesToScroll !== 0);
1638        indexOffset = unevenOffset ? 0 : (_.slideCount - _.currentSlide) % _.options.slidesToScroll;
1639
1640        switch (event.data.message) {
1641
1642            case 'previous':
1643                slideOffset = indexOffset === 0 ? _.options.slidesToScroll : _.options.slidesToShow - indexOffset;
1644                if (_.slideCount > _.options.slidesToShow) {
1645                    _.slideHandler(_.currentSlide - slideOffset, false, dontAnimate);
1646                }
1647                break;
1648
1649            case 'next':
1650                slideOffset = indexOffset === 0 ? _.options.slidesToScroll : indexOffset;
1651                if (_.slideCount > _.options.slidesToShow) {
1652                    _.slideHandler(_.currentSlide + slideOffset, false, dontAnimate);
1653                }
1654                break;
1655
1656            case 'index':
1657                var index = event.data.index === 0 ? 0 :
1658                event.data.index || $target.index() * _.options.slidesToScroll;
1659
1660                _.slideHandler(_.checkNavigable(index), false, dontAnimate);
1661                $target.children().trigger('focus');
1662                break;
1663
1664            default:
1665                return;
1666        }
1667
1668    };
1669
1670    Slick.prototype.checkNavigable = function(index) {
1671
1672        var _ = this,
1673            navigables, prevNavigable;
1674
1675        navigables = _.getNavigableIndexes();
1676        prevNavigable = 0;
1677        if (index > navigables[navigables.length - 1]) {
1678            index = navigables[navigables.length - 1];
1679        } else {
1680            for (var n in navigables) {
1681                if (index < navigables[n]) {
1682                    index = prevNavigable;
1683                    break;
1684                }
1685                prevNavigable = navigables[n];
1686            }
1687        }
1688
1689        return index;
1690    };
1691
1692    Slick.prototype.cleanUpEvents = function() {
1693
1694        var _ = this;
1695
1696        if (_.options.dots && _.$dots !== null) {
1697
1698            $('li', _.$dots)
1699                .off('click.slick', _.changeSlide)
1700                .off('mouseenter.slick', $.proxy(_.interrupt, _, true))
1701                .off('mouseleave.slick', $.proxy(_.interrupt, _, false));
1702
1703        }
1704
1705        _.$slider.off('focus.slick blur.slick');
1706
1707        if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {
1708            _.$prevArrow && _.$prevArrow.off('click.slick', _.changeSlide);
1709            _.$nextArrow && _.$nextArrow.off('click.slick', _.changeSlide);
1710        }
1711
1712        _.$list.off('touchstart.slick mousedown.slick', _.swipeHandler);
1713        _.$list.off('touchmove.slick mousemove.slick', _.swipeHandler);
1714        _.$list.off('touchend.slick mouseup.slick', _.swipeHandler);
1715        _.$list.off('touchcancel.slick mouseleave.slick', _.swipeHandler);
1716
1717        _.$list.off('click.slick', _.clickHandler);
1718
1719        $(document).off(_.visibilityChange, _.visibility);
1720
1721        _.cleanUpSlideEvents();
1722
1723        if (_.options.accessibility === true) {
1724            _.$list.off('keydown.slick', _.keyHandler);
1725        }
1726
1727        if (_.options.focusOnSelect === true) {
1728            $(_.$slideTrack).children().off('click.slick', _.selectHandler);
1729        }
1730
1731        $(window).off('orientationchange.slick.slick-' + _.instanceUid, _.orientationChange);
1732
1733        $(window).off('resize.slick.slick-' + _.instanceUid, _.resize);
1734
1735        $('[draggable!=true]', _.$slideTrack).off('dragstart', _.preventDefault);
1736
1737        $(window).off('load.slick.slick-' + _.instanceUid, _.setPosition);
1738        $(document).off('ready.slick.slick-' + _.instanceUid, _.setPosition);
1739
1740    };
1741
1742    Slick.prototype.cleanUpSlideEvents = function() {
1743
1744        var _ = this;
1745
1746        _.$list.off('mouseenter.slick', $.proxy(_.interrupt, _, true));
1747        _.$list.off('mouseleave.slick', $.proxy(_.interrupt, _, false));
1748
1749    };
1750
1751    Slick.prototype.cleanUpRows = function() {
1752
1753        var _ = this, originalSlides;
1754
1755        if(_.options.rows > 1) {
1756            originalSlides = _.$slides.children().children();
1757            originalSlides.removeAttr('style');
1758            _.$slider.empty().append(originalSlides);
1759        }
1760
1761    };
1762
1763    Slick.prototype.clickHandler = function(event) {
1764
1765        var _ = this;
1766
1767        if (_.shouldClick === false) {
1768            event.stopImmediatePropagation();
1769            event.stopPropagation();
1770            event.preventDefault();
1771        }
1772
1773    };
1774
1775    Slick.prototype.destroy = function(refresh) {
1776
1777        var _ = this;
1778
1779        _.autoPlayClear();
1780
1781        _.touchObject = {};
1782
1783        _.cleanUpEvents();
1784
1785        $('.slick-cloned', _.$slider).detach();
1786
1787        if (_.$dots) {
1788            _.$dots.remove();
1789        }
1790
1791
1792        if ( _.$prevArrow && _.$prevArrow.length ) {
1793
1794            _.$prevArrow
1795                .removeClass('slick-disabled slick-arrow slick-hidden')
1796                .removeAttr('aria-hidden aria-disabled tabindex')
1797                .css('display','');
1798
1799            if ( _.htmlExpr.test( _.options.prevArrow )) {
1800                _.$prevArrow.remove();
1801            }
1802        }
1803
1804        if ( _.$nextArrow && _.$nextArrow.length ) {
1805
1806            _.$nextArrow
1807                .removeClass('slick-disabled slick-arrow slick-hidden')
1808                .removeAttr('aria-hidden aria-disabled tabindex')
1809                .css('display','');
1810
1811            if ( _.htmlExpr.test( _.options.nextArrow )) {
1812                _.$nextArrow.remove();
1813            }
1814
1815        }
1816
1817
1818        if (_.$slides) {
1819
1820            _.$slides
1821                .removeClass('slick-slide slick-active slick-center slick-visible slick-current')
1822                .removeAttr('aria-hidden')
1823                .removeAttr('data-slick-index')
1824                .each(function(){
1825                $(this).attr('style', $(this).data('originalStyling'));
1826            });
1827
1828            _.$slideTrack.children(this.options.slide).detach();
1829
1830            _.$slideTrack.detach();
1831
1832            _.$list.detach();
1833
1834            _.$slider.append(_.$slides);
1835        }
1836
1837        _.cleanUpRows();
1838
1839        _.$slider.removeClass('slick-slider');
1840        _.$slider.removeClass('slick-initialized');
1841        _.$slider.removeClass('slick-dotted');
1842
1843        _.unslicked = true;
1844
1845        if(!refresh) {
1846            _.$slider.trigger('destroy', [_]);
1847        }
1848
1849    };
1850
1851    Slick.prototype.disableTransition = function(slide) {
1852
1853        var _ = this,
1854            transition = {};
1855
1856        transition[_.transitionType] = '';
1857
1858        if (_.options.fade === false) {
1859            _.$slideTrack.css(transition);
1860        } else {
1861            _.$slides.eq(slide).css(transition);
1862        }
1863
1864    };
1865
1866    Slick.prototype.fadeSlide = function(slideIndex, callback) {
1867
1868        var _ = this;
1869
1870        if (_.cssTransitions === false) {
1871
1872            _.$slides.eq(slideIndex).css({
1873                zIndex: _.options.zIndex
1874            });
1875
1876            _.$slides.eq(slideIndex).animate({
1877                opacity: 1
1878            }, _.options.speed, _.options.easing, callback);
1879
1880        } else {
1881
1882            _.applyTransition(slideIndex);
1883
1884            _.$slides.eq(slideIndex).css({
1885                opacity: 1,
1886                zIndex: _.options.zIndex
1887            });
1888
1889            if (callback) {
1890                setTimeout(function() {
1891
1892                    _.disableTransition(slideIndex);
1893
1894                    callback.call();
1895                }, _.options.speed);
1896            }
1897
1898        }
1899
1900    };
1901
1902    Slick.prototype.fadeSlideOut = function(slideIndex) {
1903
1904        var _ = this;
1905
1906        if (_.cssTransitions === false) {
1907
1908            _.$slides.eq(slideIndex).animate({
1909                opacity: 0,
1910                zIndex: _.options.zIndex - 2
1911            }, _.options.speed, _.options.easing);
1912
1913        } else {
1914
1915            _.applyTransition(slideIndex);
1916
1917            _.$slides.eq(slideIndex).css({
1918                opacity: 0,
1919                zIndex: _.options.zIndex - 2
1920            });
1921
1922        }
1923
1924    };
1925

2026ideIndex - _.slideCount)) * _.slideWidth) * -1;
2027                        verticalOffset = ((_.options.slidesToShow - (slideIndex - _.slideCount)) * verticalHeight) * -1;
2028                    } else {
2029                        _.slideOffset = ((_.slideCount % _.options.slidesToScroll) * _.slideWidth) * -1;
2030                        verticalOffset = ((_.slideCount % _.options.slidesToScroll) * verticalHeight) * -1;
2031                    }
2032                }
2033            }
2034        } else {
2035            if (slideIndex + _.options.slidesToShow > _.slideCount) {
2036                _.slideOffset = ((slideIndex + _.options.slidesToShow) - _.slideCount) * _.slideWidth;
2037                verticalOffset = ((slideIndex + _.options.slidesToShow) - _.slideCount) * verticalHeight;
2038            }
2039        }
2040
2041        if (_.slideCount <= _.options.slidesToShow) {
2042            _.slideOffset = 0;
2043            verticalOffset = 0;
2044        }
2045
2046       

2046 if (_.options.centerMode === true && _.options.infinite === true) {
2047            _.slideOffset += _.slideWidth * Math.floor(_.options.slidesToShow / 2) - _.slideWidth;
2048        } else if (_.options.centerMode === true) {
2049            _.slideOffset = 0;
2050            _.slideOffset += _.slideWidth * Math.floor(_.options.slidesToShow / 2);
2051        }
2052
2053        if (_.options.vertical === false) {
2054            targetLeft = ((slideIndex * _.slideWidth) * -1) + _.slideOffset;
2055        } else {
2056            targetLeft = ((slideIndex * verticalHeight) * -1) + verticalOffset;
2057        }
2058
2059        if (_.options.variableWidth === true) {
2060
2061            if (_.slideCount <= _.options.slidesToShow || _.options.infinite === false) {
2062                targetSlide = _.$slideTrack.children('.slick-slide').eq(slideIndex);
2063            } else {
2064                targetSlide = _.$slideTrack.children('.slick-slide').eq(slideIndex + _.options.slidesToShow);
2065            }
2066
2067            if (_.options.rtl === true) {
2068                if (targetSlide[0]) {
2069                    targetLeft = (_.$slideTrack.width() - targetSlide[0].offsetLeft - targetSlide.width()) * -1;
2070                } else {
2071                    targetLeft =  0;
2072                }
2073            } else {
2074                targetLeft = targetSlide[0] ? targetSlide[0].offsetLeft * -1 : 0;
2075            }
2076
2077            if (_.options.centerMode === true) {
2078                if (_.slideCount <= _.options.slidesToShow || _.options.infinite === false) {
2079                    targetSlide = _.$slideTrack.children('.slick-slide').eq(slideIndex);
2080                } else {
2081                    targetSlide = _.$slideTrack.children('.slick-slide').eq(slideIndex + _.options.slidesToShow + 1);
2082                }
2083
2084                if (_.options.rtl === true) {
2085                    if (targetSlide[0]) {
2086                        targetLeft = (_.$slideTrack.width() - targetSlide[0].offsetLeft - targetSlide.width()) * -1;
2087                    } else {
2088                        targetLeft =  0;
2089                    }
2090                } else {
2091                    targetLeft = targetSlide[0] ? targetSlide[0].offsetLeft * -1 : 0;
2092                }
2093
2094                targetLeft += (_.$list.width() - targetSlide.outerWidth()) / 2;
2095            }
2096        }
2097
2098        return targetLeft;
2099
2100    };
2101
2102    Slick.prototype.getOption = Slick.prototype.slickGetOption = function(option) {
2103
2104        var _ = this;
2105
2106        return _.options[option];
2107
2108    };
2109
2110    Slick.prototype.getNavigableIndexes = function() {
2111
2112        var _ = this,
2113            breakPoint = 0,
2114            counter = 0,
2115            indexes = [],
2116            max;
2117
2118        if (_.options.infinite === false) {
2119            max = _.slideCount;
2120        } else {
2121            breakPoint = _.options.slidesToScroll * -1;
2122            counter = _.options.slidesToScroll * -1;
2123            max = _.slideCount * 2;
2124        }
2125
2126        while (breakPoint < max) {
2127            indexes.push(breakPoint);
2128            breakPoint = counter + _.options.slidesToScroll;
2129            counter += _.options.slidesToScroll <= _.options.slidesToShow ? _.options.slidesToScroll : _.options.slidesToShow;
2130        }
2131
2132        return indexes;
2133
2134    };
2135
2136    Slick.prototype.getSlick = function() {
2137
2138        return this;
2139
2140    };
2141
2142    Slick.prototype.getSlideCount = function() {
2143
2144        var _ = this,
2145            slidesTraversed, swipedSlide, centerOffset;
2146
2147        centerOffset = _.options.centerMode === true ? _.slideWidth * Math.floor(_.options.slidesToShow / 2) : 0;
2148
2149        if (_.options.swipeToSlide === true) {
2150            _.$slideTrack.find('.slick-slide').each(function(index, slide) {
2151                if (slide.offsetLeft - centerOffset + ($(slide).outerWidth() / 2) > (_.swipeLeft * -1)) {
2152                    swipedSlide = slide;
2153                    return false;
2154                }
2155            });
2156
2157            slidesTraversed = Math.abs($(swipedSlide).attr('data-slick-index') - _.currentSlide) || 1;
2158
2159            return slidesTraversed;
2160
2161        } else {
2162            return _.options.slidesToScroll;
2163        }
2164
2165    };
2166
2167    Slick.prototype.goTo = Slick.prototype.slickGoTo = function(slide, dontAnimate) {
2168
2169        var _ = this;
2170
2171        _.changeSlide({
2172            data: {
2173                message: 'index',
2174                index: parseInt(slide)
2175            }
2176        }, dontAnimate);
2177
2178    };
2179
2180    Slick.prototype.init = function(creation) {
2181
2182        var _ = this;
2183
2184        if (!$(_.$slider).hasClass('slick-initialized')) {
2185
2186            $(_.$slider).addClass('slick-initialized');
2187
2188            _.buildRows();
2189            _.buildOut();
2190            _.setProps();
2191            _.startLoad();
2192            _.loadSlider();
2193            _.initializeEvents();
2194            _.updateArrows();
2195            _.updateDots();
2196            _.checkResponsive(true);
2197            _.focusHandler();
2198
2199        }
2200
2201        if (creation) {
2202            _.$slider.trigger('init', [_]);
2203        }
2204
2205        if (_.options.accessibility === true) {
2206            _.initADA();
2207        }
2208
2209        if ( _.options.autoplay ) {
2210
2211            _.paused = false;
2212            _.autoPlay();
2213
2214        }
2215
2216    };
2217
2218    Slick.prototype.initADA = function() {
2219        var _ = this

2323        _.$list.on('touchcancel.slick mouseleave.slick', {
2324            action: 'end'
2325        }, _.swipeHandler);
2326
2327        _.$list.on('click.slick', _.clickHandler);
2328
2329        $(document).on(_.visibilityChange, $.proxy(_.visibility, _));
2330
2331        if (_.options.accessibility === true) {
2332            _.$list.on('keydown.slick', _.keyHandler);
2333        }
2334
2335        if (_.options.focusOnSelect === true) {
2336            $(_.$slideTrack).children().on('click.slick', _.selectHandler);
2337        }
2338
2339        $(window).on('orientationchange.slick.slick-' + _.instanceUid, $.proxy(_.orientationChange, _));
2340
2341        $(window).on('resize.slick.slick-' + _.instanceUid, $.proxy(_.resize, _));
2342
2343        $('[draggable!=true]', _.$slideTrack).on('dragstart', _.preventDefault);
2344
2345        $(window).on('load.slick.slick-' + _.instanceUid, _.setPosition);
2346        $(document).on('ready.slick.slick-' + _.instanceUid, _.setPosition);
2347
2348    };
2349
2350    Slick.prototype.initUI = function() {
2351
2352        var _ = this;
2353
2354        if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {
2355
2356            _.$prevArrow.show();
2357            _.$nextArrow.show();
2358
2359        }
2360
2361        if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {
2362
2363            _.$dots.show();
2364
2365        }
2366
2367    };
2368
2369    Slick.prototype.keyHandler = function(event) {
2370
2371        var _ = this;
2372        //Dont slide if the cursor is inside the form fields and arrow keys are pressed
2373        if(!event.target.tagName.match('TEXTAREA|INPUT|SELECT')) {
2374            if (event.keyCode === 37 && _.options.accessibility === true) {
2375                _.changeSlide({
2376                    data: {
2377                        message: _.options.rtl === true ? 'next' :  'previous'
2378                    }
2379                });
2380            } else if (event.keyCode === 39 && _.options.accessibility === true) {
2381                _.changeSlide({
2382                    data: {
2383                        message: _.options.rtl === true ? 'previous' : 'next'
2384                    }
2385                });
2386            }
2387        }
2388
2389    };
2390
2391    Slick.prototype.lazyLoad = function() {
2392
2393        var _ = this,
2394            loadRange, cloneRange, rangeStart, rangeEnd;
2395
2396        function loadImages(imagesScope) {
2397
2398            $('img[data-lazy]', imagesScope).each(function() {
2399
2400                var image = $(this),
2401                    imageSource = $(this).attr('data-lazy'),
2402                    imageToLoad = document.createElement('img');
2403
2404                imageToLoad.onload = function() {
2405
2406                    image
2407                        .animate({ opacity: 0 }, 100, function() {
2408                        image
2409                            .attr('src', imageSource)
2410                            .animate({ opacity: 1 }, 200, function() {
2411                            image
2412                                .removeAttr('data-lazy')
2413                                .removeClass('slick-loading');
2414                        });
2415                        _.$slider.trigger('lazyLoaded', [_, image, imageSource]);
2416                    });
2417
2418                };
2419
2420                imageToLoad.onerror = function() {
2421
2422                    image
2423                        .removeAttr( 'data-lazy' )
2424                        .removeClass( 'slick-loading' )
2425                        .addClass( 'slick-lazyload-error' );
2426
2427                    _.$slider.trigger('lazyLoadError', [ _, image, imageSource ]);
2428
2429                };
2430
2431                imageToLoad.src = imageSource;
2432
2433            });
2434
2435        }
2436
2437        if (_.options.centerMode === true) {
2438            if (_.options.infinite === true) {
2439                rangeStart = _.currentSlide + (_.options.slidesToShow / 2 + 1);
2440                rangeEnd = rangeStart + _.options.slidesToShow + 2;
2441            } else {
2442                rangeStart = Math.max(0, _.currentSlide - (_.options.slidesToShow / 2 + 1));
2443                rangeEnd = 2 + (_.options.slidesToShow / 2 + 1) + _.currentSlide;
2444            }
2445        } else {
2446            rangeStart = _.options.infinite ? _.options.slidesToShow + _.currentSlide : _.currentSlide;
2447            rangeEnd = Math.ceil(rangeStart + _.options.slidesToShow);
2448            if (_.options.fade === true) {
2449                if (rangeStart > 0) rangeStart--;
2450                if (rangeEnd <= _.slideCount) rangeEnd++;
2451            }
2452        }
2453
2454        loadRange = _.$slider.find('.slick-slide').slice(rangeStart, rangeEnd);
2455        loadImages(loadRange);
2456
2457        if (_.slideCount <= _.options.slidesToShow) {
2458            cloneRange = _.$slider.find('.slick-slide');
2459            loadImages(cloneRange);
2460        } else
2461            if (_.currentSlide >= _.slideCount - _.options.slidesToShow) {
2462                cloneRange = _.$slider.find('.slick-cloned').slice(0, _.options.slidesToShow);
2463                loadImages(cloneRange);
2464            } else if (_.currentSlide === 0) {
2465                cloneRange = _.$slider.find('.slick-cloned').slice(_.options.slidesToShow * -1);
2466                loadImages(cloneRange);
2467            }
2468
2469    };
2470
2471    Slick.prototype.loadSlider = function() {
2472
2473        var _ = this;
2474
2475        _.setPosition();
2476
2477        _.$slideTrack.css({
2478            opacity: 1
2479        });
2480
2481        _.$slider.removeClass('slick-loading');
2482
2483        _.initUI();
2484
2485        if (_.options.lazyLoad === 'progressive') {
2486            _.progressiveLazyLoad();
2487        }
2488
2489    };
2490
2491    Slick.prototype.next = Slick.prototype.slickNext = function() {
2492
2493        var _ = this;
2494
2495        _.changeSlide({
2496            data: {
2497                message: 'next'
2498            }
2499        });
2500
2501    };
2502
2503    Slick.prototype.orientationChange = function() {
2504
2505        var _ = this;
2506
2507        _.checkResponsive();
2508        _.setPosition();
2509
2510    };
2511
2512    Slick.prototype.pause = Slick.prototype.slickPause = function() {
2513
2514        var _ = this;
2515
2516        _.autoPlayClear();
2517        _.paused = true;
2518
2519    };
2520
2521    Slick.prototype.play = Slick.prototype.slickPlay = function() {
2522
2523        var _ = this;
2524
2525        _.autoPlay();
2526        _.options.autoplay = true;
2527        _.paused = false;
2528        _.focussed = false;
2529        _.interrupted = false;
2530
2531    };
2532
2533    Slick.prototype.postSlide = function(index) {
2534
2535        var _ = this;
2536
2537        if( !_.unslicked ) {
2538
2539            _.$slider.trigger('afterChange', [_, index]);
2540
2541            _.animating = false;
2542
2543            _.setPosition();
2544
2545            _.swipeLeft = null;
2546
2547            if ( _.options.autoplay ) {
2548                _.autoPlay();
2549            }
2550
2551            if (_.options.accessibility === true) {
2552                _.initADA();
2553            }
2554
2555        }
2556
2557    };
2558
2559    Slick.prototype.prev = Slick.prototype.slickPrev = function() {
2560
2561        var _ = this;
2562
2563        _.changeSlide({
2564            data: {
2565                message: 'previous'
2566            }
2567        });
2568
2569    };
2570
2571    Slick.prototype.preventDefault = function(event) {
2572
2573        event.preventDefault();
2574
2575    };
2576
2577    Slick.prototype.progressiveLazyLoad = function( tryCount ) {
2578
2579        tryCount = tryCount || 1;
2580
2581        var _ = this,
2582            $imgsToLoad = $( 'img[data-lazy]', _.$slider ),
2583            image,
2584            imageSource,
2585            imageToLoad;
2586
2587        if ( $imgsToLoad.length ) {
2588
2589            image = $imgsToLoad.first();
2590            imageSource = image.attr('data-lazy');
2591            imageToLoad = document.createElement('img');
2592
2593            imageToLoad.onload = function() {
2594
2595                image
2596                    .attr( 'src', imageSource )
2597                    .removeAttr('data-lazy')
2598                    .removeClass('slick-loading');
2599
2600                if ( _.options.adaptiveHeight === true ) {
2601                    _.setPosition();
2602                }
2603
2604                _.$slider.trigger('lazyLoaded', [ _, image, imageSource ]);
2605                _.progressiveLazyLoad();
2606
2607            };
2608
2609            imageToLoad.onerror = function() {
2610
2611                if ( tryCount < 3 ) {
2612
2613                    /**
2614                     * try to load the image 3 times,
2615                     * leave a slight delay so we don't get
2616                     * servers blocking the request.
2617                     */
2618                    setTimeout( function() {
2619                        _.progressiveLazyLoad( tryCount + 1 );
2620                    }, 500 );
2621
2622                } else {
2623
2624                    image
2625                        .removeAttr( 'data-lazy' )
2626                        .removeClass( 'slick-loading' )
2627                        .addClass( 'slick-lazyload-error' );
2628
2629                    _.$slider.trigger('lazyLoadError', [ _, image, imageSource ]);
2630
2631                    _.progressiveLazyLoad();
2632
2633                }
2634
2635            };
2636
2637            imageToLoad.src = imageSource;
2638
2639        } else {
2640
2641            _.$slider.trigger('allImagesLoaded', [ _ ]);
2642
2643        }
2644
2645    };
2646
2647    Slick.prototype.refresh = function( initializing ) {
2648
2649        var _ = this, currentSlide, lastVisibleIndex;
2650
2651        lastVisibleIndex = _.slideCount - _.options.slidesToShow;
2652
2653        // in non-infinite sliders, we don't want to go past the
2654        // last visible index.
2655        if( !_.options.infinite && ( _.currentSlide > lastVisibleIndex )) {
2656            _.currentSlide = lastVisibleIndex;
2657        }
2658
2659        // if less slides than to show, go to start.
2660        if ( _.slideCount <= _.options.slidesToShow ) {
2661            _.currentSlide = 0;
2662
2663        }
2664
2665        currentSlide = _.currentSlide;
2666
2667        _.destroy(true);
2668
2669        $.extend(_, _.initials, { currentSlide: currentSlide });
2670
2671        _.init();
2672
2673        if( !initializing ) {
2674
2675            _.changeSlide({
2676                data: {
2677                    message: 'index',
2678                    index: currentSlide
2679                }
2680            }, false);
2681
2682        }
2683
2684    };
2685
2686    Slick.prototype.registerBreakpoints = function() {
2687
2688        var _ = this, breakpoint, currentBreakpoint, l,
2689            responsiveSettings = _.options.responsive || null;
2690
2691        if ( $.type(responsiveSettings) === 'array' && responsiveSettings.length ) {
2692
2693            _.respondTo = _.options.respondTo || 'window';
2694
2695            for ( breakpoint in responsiveSettings ) {
2696
2697                l = _.breakpoints.length-1;
2698                currentBreakpoint = responsiveSettings[breakpoint].breakpoint;
2699
2700                if (responsiveSettings.hasOwnProperty(breakpoint)) {
2701
2702                    // loop through the breakpoints and cut out any existing
2703                    // ones with the same breakpoint number, we don't want dupes.
2704                    while( l >= 0 ) {
2705                        if( _.breakpoints[l] && _.breakpoints[l] === currentBreakpoint ) {
2706                            _.breakpoints.splice(l,1);
2707                        }
2708                        l--;
2709                    }
2710
2711                    _.breakpoints.push(currentBreakpoint);
2712                    _.breakpointSettings[currentBreakpoint] = responsiveSettings[breakpoint].settings;
2713
2714                }
2715
2716            }
2717
2718            _.breakpoints.sort(function(a, b) {
2719                return ( _.options.mobileFirst ) ? a-b : b-a;
2720            });
2721
2722        }
2723
2724    };
2725
2726    Slick.prototype.reinit = function() {
2727
2728        var _ = this;
2729
2730        _.$slides =
2731            _.$slideTrack
2732            .children(_.options.slide)
2733            .addClass('slick-slide');
2734
2735        _.slideCount = _.$slides.length;
2736
2737        if (_.currentSlide >= _.slideCount && _.currentSlide !== 0) {
2738            _.currentSlide = _.currentSlide - _.options.slidesToScroll;
2739        }
2740
2741        if (_.slideCount <= _.options.slidesToShow) {
2742            _.currentSlide = 0;
2743        }
2744
2745        _.registerBreakpoints();
2746
2747        _.setProps();
2748        _.setupInfinite();
2749        _.buildArrows();
2750        _.updateArrows();
2751        _.initArrowEvents();
2752        _.buildDots();
2753        _.updateDots();
2754        _.initDotEvents();
2755        _.cleanUpSlideEvents();
2756        _.initSlideEvents();
2757
2758        _.checkResponsive(false, true);
2759
2760        if (_.options.focusOnSelect === true) {
2761            $(_.$slideTrack).children().on('click.slick', _.selectHandler);
2762        }
2763
2764        _.setSlideClasses(typeof _.currentSlide === 'number' ? _.currentSlide : 0);
2765
2766        _.setPosition();
2767        _.focusHandler();
2768
2769        _.paused = !_.options.autoplay;
2770        _.autoPlay();
2771
2772        _.$slider.trigger('reInit', [_]);
2773
2774    };
2775
2776    Slick.prototype.resize = function() {
2777
2778        var _ = this;
2779
2780        if ($(window).width() !== _.windowWidth) {
2781            clearTimeout(_.windowDelay);
2782            _.windowDelay = window.setTimeout(function() {
2783                _.windowWidth = $(window).width();
2784                _.checkResponsive();
2785                if( !_.unslicked ) { _.setPosition(); }
2786            }, 50);
2787        }
2788    };
2789
2790    Slick.prototype.removeSlide = Slick.prototype.slickRemove = function(index, removeBefore, removeAll) {
2791
2792        var _ = this;
2793
2794        if (typeof(index) === 'boolean') {
2795            removeBefore = index;
2796            index = removeBefore === true ? 0 : _.slideCount - 1;
2797        } else {
2798            index = removeBefore === true ? --index : index;
2799        }
2800
2801        if (_.slideCount < 1 || index < 0 || index > _.slideCount - 1) {
2802            return false;
2803        }
2804
2805        _.unload();
2806
2807        if (removeAll === true) {
2808            _.$slideTrack.children().remove();
2809        } else {
2810            _.$slideTrack.children(this.options.slide).eq(index).remove();
2811        }
2812
2813        _.$slides = _.$slideTrack.children(this.options.slide);
2814
2815        _.$slideTrack.children(this.options.slide).detach();
2816
2817        _.$slideTrack.append(_.$slides);
2818
2819        _.$slidesCache = _.$slides;
2820
2821        _.reinit();
2822
2823    };
2824
2825    Slick.prototype.setCSS = function(position) {
2826
2827        var _ = this,
2828            positionProps = {},
2829            x, y;
2830
2831        if (_.options.rtl === true) {
2832            position = -position;
2833        }
2834        x = _.positionProp == 'left' ? Math.ceil(position) + 'px' : '0px';
2835        y = _.positionProp == 'top' ? Math.ceil(position) + 'px' : '0px';
2836
2837        positionProps[_.positionProp] = position;
2838
2839        if (_.transformsEnabled === false) {
2840            _.$slideTrack.css(positionProps);
2841        } else {
2842            positionProps = {};
2843            if (_.cssTransitions === false) {
2844                positionProps[_.animType] = 'translate(' + x + ', ' + y + ')';
2845                _.$slideTrack.css(positionProps);
2846            } else {
2847                positionProps[_.animType] = 'translate3d(' + x + ', ' + y + ', 0px)';
2848                _.$slideTrack.css(positionProps);
2849            }
2850        }
2851
2852    };
2853
2854    Slick.prototype.setDimensions = function() {
2855
2856        var _ = this;
2857
2858        if (_.options.vertical === false) {
2859            if (_.options.centerMode === true) {
2860                _.$list.css({
2861                    padding: ('0px ' + _.options.centerPadding)
2862                });
2863            }
2864        } else {
2865            _.$list.height(_.$slides.first().outerHeight(true) * _.options.slidesToShow);
2866            if (_.options.centerMode === true) {
2867                _.$list.css({
2868                    padding: (_.options.centerPadding + ' 0px')
2869                });
2870            }
2871        }
2872
2873        _.listWidth = _.$list.width();
2874        _.listHeight = _.$list.height();
2875
2876
2877        if (_.options.vertical === false && _.options.variableWidth === false) {
2878            _.slideWidth = Math.ceil(_.listWidth / _.options.slidesToShow);
2879            _.$slideTrack.width(Math.ceil((_.slideWidth * _.$slideTrack.children('.slick-slide').length)));
2880
2881        } else if (_.options.variableWidth === true) {
2882            _.$slideTrack.width(5000 * _.slideCount);
2883        } else {
2884            _.slideWidth = Math.ceil(_.listWidth);
2885            _.$slideTrack.height(Math.ceil((_.$slides.first().outerHeight(true) * _.$slideTrack.children('.slick-slide').length)));
2886        }
2887
2888        var offset = _.$slides.first().outerWidth(true) - _.$slides.first().width();
2889        if (_.options.variableWidth === false) _.$slideTrack.children('.slick-slide').width(_.slideWidth - offset);
2890
2891    };
2892
2893    Slick.prototype.setFade = function() {
2894
2895        var _ = this,
2896            targetLeft;
2897
2898        _.$slides.each(function(index, element) {
2899            targetLeft = (_.slideWidth * index) * -1;
2900            if (_.options.rtl === true) {
2901                $(element).css({
2902                    position: 'relative',
2903                    right: targetLeft,
2904                    top: 0,
2905                    zIndex: _.options.zIndex - 2,
2906                    opacity: 0
2907                });
2908            } else {
2909                $(element).css({
2910                    position: 'relative',
2911                    left: targetLeft,
2912                    top: 0,
2913                    zIndex: _.options.zIndex - 2,
2914                    opacity: 0
2915                });
2916            }
2917        });
2918
2919        _.$slides.eq(_.currentSlide).css({
2920            zIndex: _.options.zIndex - 1,
2921            opacity: 1
2922        });
2923
2924    };
2925
2926    Slick.prototype.setHeight = function() {
2927
2928        var _ = this;
2929
2930        if (_.options.slidesToShow === 1 && _.options.adaptiveHeight === true && _.options.vertical === false) {
2931            var targetHeight = _.$slides.eq(_.currentSlide).outerHeight(true);
2932            _.$list.css('height', targetHeight);
2933        }
2934
2935    };
2936
2937    Slick.prototype.setOption =
2938