Thank you & good bye!
-
Made with 
by Textalk.
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
-
-
+
+
-
-
+
+
+ /*
+ Function for displaying addons. Takes both data types.
+ */
+ var setData = function(data) {
+ if (typeof(data) === 'string') { data = JSON.parse(data); }
+ angular.forEach(data, function(addon) {
+ addon.name = addon.name.split('angular-schema-form-').pop();
+ });
+ $scope.addons = data;
+ };
+ // Filter for nice json output.
+ }).filter('prettyjson', function() {
+ return function(input) {
+ return JSON.stringify(input, undefined, 2);
+ };
+ }).filter('momentify', function() {
+ return function(input) {
+ return moment(input).fromNow();
+ };
+ });
+ // @license-end
+
diff --git a/jslicense.html b/jslicense.html
new file mode 100644
index 000000000..4d466f2fd
--- /dev/null
+++ b/jslicense.html
@@ -0,0 +1,74 @@
+
+
+
+
+
textalk.github.io/angular-schema-form - JavaScript License Information
+
+
+
+
+
+
+
diff --git a/src/highlight.js b/src/highlight.js
new file mode 100644
index 000000000..6b9bb256a
--- /dev/null
+++ b/src/highlight.js
@@ -0,0 +1,656 @@
+/*
+Syntax highlighting with language autodetection.
+https://highlightjs.org/
+*/
+(function(factory) {
+// Setup highlight.js for different environments. First is Node.js or
+// CommonJS.
+if(typeof exports !== 'undefined') {
+factory(exports);
+} else {
+// Export hljs globally even when using AMD for cases when this script
+// is loaded with others that may still expect a global hljs.
+window.hljs = factory({});
+// Finally register the global hljs with AMD.
+if(typeof define === 'function' && define.amd) {
+define([], function() {
+return window.hljs;
+});
+}
+}
+}(function(hljs) {
+/* Utility functions */
+function escape(value) {
+return value.replace(/&/gm, '&').replace(//gm, '>');
+}
+function tag(node) {
+return node.nodeName.toLowerCase();
+}
+function testRe(re, lexeme) {
+var match = re && re.exec(lexeme);
+return match && match.index == 0;
+}
+function blockLanguage(block) {
+var classes = (block.className + ' ' + (block.parentNode ? block.parentNode.className : '')).split(/\s+/);
+classes = classes.map(function(c) {return c.replace(/^lang(uage)?-/, '');});
+return classes.filter(function(c) {return getLanguage(c) || /no(-?)highlight/.test(c);})[0];
+}
+function inherit(parent, obj) {
+var result = {};
+for (var key in parent)
+result[key] = parent[key];
+if (obj)
+for (var key in obj)
+result[key] = obj[key];
+return result;
+};
+/* Stream merging */
+function nodeStream(node) {
+var result = [];
+(function _nodeStream(node, offset) {
+for (var child = node.firstChild; child; child = child.nextSibling) {
+if (child.nodeType == 3)
+offset += child.nodeValue.length;
+else if (child.nodeType == 1) {
+result.push({
+event: 'start',
+offset: offset,
+node: child
+});
+offset = _nodeStream(child, offset);
+// Prevent void elements from having an end tag that would actually
+// double them in the output. There are more void elements in HTML
+// but we list only those realistically expected in code display.
+if (!tag(child).match(/br|hr|img|input/)) {
+result.push({
+event: 'stop',
+offset: offset,
+node: child
+});
+}
+}
+}
+return offset;
+})(node, 0);
+return result;
+}
+function mergeStreams(original, highlighted, value) {
+var processed = 0;
+var result = '';
+var nodeStack = [];
+function selectStream() {
+if (!original.length || !highlighted.length) {
+return original.length ? original : highlighted;
+}
+if (original[0].offset != highlighted[0].offset) {
+return (original[0].offset < highlighted[0].offset) ? original : highlighted;
+}
+/*
+To avoid starting the stream just before it should stop the order is
+ensured that original always starts first and closes last:
+if (event1 == 'start' && event2 == 'start')
+return original;
+if (event1 == 'start' && event2 == 'stop')
+return highlighted;
+if (event1 == 'stop' && event2 == 'start')
+return original;
+if (event1 == 'stop' && event2 == 'stop')
+return highlighted;
+... which is collapsed to:
+*/
+return highlighted[0].event == 'start' ? original : highlighted;
+}
+function open(node) {
+function attr_str(a) {return ' ' + a.nodeName + '="' + escape(a.value) + '"';}
+result += '<' + tag(node) + Array.prototype.map.call(node.attributes, attr_str).join('') + '>';
+}
+function close(node) {
+result += '';
+}
+function render(event) {
+(event.event == 'start' ? open : close)(event.node);
+}
+while (original.length || highlighted.length) {
+var stream = selectStream();
+result += escape(value.substr(processed, stream[0].offset - processed));
+processed = stream[0].offset;
+if (stream == original) {
+/*
+On any opening or closing tag of the original markup we first close
+the entire highlighted node stack, then render the original tag along
+with all the following original tags at the same offset and then
+reopen all the tags on the highlighted stack.
+*/
+nodeStack.reverse().forEach(close);
+do {
+render(stream.splice(0, 1)[0]);
+stream = selectStream();
+} while (stream == original && stream.length && stream[0].offset == processed);
+nodeStack.reverse().forEach(open);
+} else {
+if (stream[0].event == 'start') {
+nodeStack.push(stream[0].node);
+} else {
+nodeStack.pop();
+}
+render(stream.splice(0, 1)[0]);
+}
+}
+return result + escape(value.substr(processed));
+}
+/* Initialization */
+function compileLanguage(language) {
+function reStr(re) {
+return (re && re.source) || re;
+}
+function langRe(value, global) {
+return RegExp(
+reStr(value),
+'m' + (language.case_insensitive ? 'i' : '') + (global ? 'g' : '')
+);
+}
+function compileMode(mode, parent) {
+if (mode.compiled)
+return;
+mode.compiled = true;
+mode.keywords = mode.keywords || mode.beginKeywords;
+if (mode.keywords) {
+var compiled_keywords = {};
+var flatten = function(className, str) {
+if (language.case_insensitive) {
+str = str.toLowerCase();
+}
+str.split(' ').forEach(function(kw) {
+var pair = kw.split('|');
+compiled_keywords[pair[0]] = [className, pair[1] ? Number(pair[1]) : 1];
+});
+};
+if (typeof mode.keywords == 'string') { // string
+flatten('keyword', mode.keywords);
+} else {
+Object.keys(mode.keywords).forEach(function (className) {
+flatten(className, mode.keywords[className]);
+});
+}
+mode.keywords = compiled_keywords;
+}
+mode.lexemesRe = langRe(mode.lexemes || /\b[A-Za-z0-9_]+\b/, true);
+if (parent) {
+if (mode.beginKeywords) {
+mode.begin = '\\b(' + mode.beginKeywords.split(' ').join('|') + ')\\b';
+}
+if (!mode.begin)
+mode.begin = /\B|\b/;
+mode.beginRe = langRe(mode.begin);
+if (!mode.end && !mode.endsWithParent)
+mode.end = /\B|\b/;
+if (mode.end)
+mode.endRe = langRe(mode.end);
+mode.terminator_end = reStr(mode.end) || '';
+if (mode.endsWithParent && parent.terminator_end)
+mode.terminator_end += (mode.end ? '|' : '') + parent.terminator_end;
+}
+if (mode.illegal)
+mode.illegalRe = langRe(mode.illegal);
+if (mode.relevance === undefined)
+mode.relevance = 1;
+if (!mode.contains) {
+mode.contains = [];
+}
+var expanded_contains = [];
+mode.contains.forEach(function(c) {
+if (c.variants) {
+c.variants.forEach(function(v) {expanded_contains.push(inherit(c, v));});
+} else {
+expanded_contains.push(c == 'self' ? mode : c);
+}
+});
+mode.contains = expanded_contains;
+mode.contains.forEach(function(c) {compileMode(c, mode);});
+if (mode.starts) {
+compileMode(mode.starts, parent);
+}
+var terminators =
+mode.contains.map(function(c) {
+return c.beginKeywords ? '\\.?(' + c.begin + ')\\.?' : c.begin;
+})
+.concat([mode.terminator_end, mode.illegal])
+.map(reStr)
+.filter(Boolean);
+mode.terminators = terminators.length ? langRe(terminators.join('|'), true) : {exec: function(s) {return null;}};
+}
+compileMode(language);
+}
+/*
+Core highlighting function. Accepts a language name, or an alias, and a
+string with the code to highlight. Returns an object with the following
+properties:
+- relevance (int)
+- value (an HTML string with highlighting markup)
+*/
+function highlight(name, value, ignore_illegals, continuation) {
+function subMode(lexeme, mode) {
+for (var i = 0; i < mode.contains.length; i++) {
+if (testRe(mode.contains[i].beginRe, lexeme)) {
+return mode.contains[i];
+}
+}
+}
+function endOfMode(mode, lexeme) {
+if (testRe(mode.endRe, lexeme)) {
+return mode;
+}
+if (mode.endsWithParent) {
+return endOfMode(mode.parent, lexeme);
+}
+}
+function isIllegal(lexeme, mode) {
+return !ignore_illegals && testRe(mode.illegalRe, lexeme);
+}
+function keywordMatch(mode, match) {
+var match_str = language.case_insensitive ? match[0].toLowerCase() : match[0];
+return mode.keywords.hasOwnProperty(match_str) && mode.keywords[match_str];
+}
+function buildSpan(classname, insideSpan, leaveOpen, noPrefix) {
+var classPrefix = noPrefix ? '' : options.classPrefix,
+openSpan = '
';
+return openSpan + insideSpan + closeSpan;
+}
+function processKeywords() {
+if (!top.keywords)
+return escape(mode_buffer);
+var result = '';
+var last_index = 0;
+top.lexemesRe.lastIndex = 0;
+var match = top.lexemesRe.exec(mode_buffer);
+while (match) {
+result += escape(mode_buffer.substr(last_index, match.index - last_index));
+var keyword_match = keywordMatch(top, match);
+if (keyword_match) {
+relevance += keyword_match[1];
+result += buildSpan(keyword_match[0], escape(match[0]));
+} else {
+result += escape(match[0]);
+}
+last_index = top.lexemesRe.lastIndex;
+match = top.lexemesRe.exec(mode_buffer);
+}
+return result + escape(mode_buffer.substr(last_index));
+}
+function processSubLanguage() {
+if (top.subLanguage && !languages[top.subLanguage]) {
+return escape(mode_buffer);
+}
+var result = top.subLanguage ? highlight(top.subLanguage, mode_buffer, true, continuations[top.subLanguage]) : highlightAuto(mode_buffer);
+// Counting embedded language score towards the host language may be disabled
+// with zeroing the containing mode relevance. Usecase in point is Markdown that
+// allows XML everywhere and makes every XML snippet to have a much larger Markdown
+// score.
+if (top.relevance > 0) {
+relevance += result.relevance;
+}
+if (top.subLanguageMode == 'continuous') {
+continuations[top.subLanguage] = result.top;
+}
+return buildSpan(result.language, result.value, false, true);
+}
+function processBuffer() {
+return top.subLanguage !== undefined ? processSubLanguage() : processKeywords();
+}
+function startNewMode(mode, lexeme) {
+var markup = mode.className? buildSpan(mode.className, '', true): '';
+if (mode.returnBegin) {
+result += markup;
+mode_buffer = '';
+} else if (mode.excludeBegin) {
+result += escape(lexeme) + markup;
+mode_buffer = '';
+} else {
+result += markup;
+mode_buffer = lexeme;
+}
+top = Object.create(mode, {parent: {value: top}});
+}
+function processLexeme(buffer, lexeme) {
+mode_buffer += buffer;
+if (lexeme === undefined) {
+result += processBuffer();
+return 0;
+}
+var new_mode = subMode(lexeme, top);
+if (new_mode) {
+result += processBuffer();
+startNewMode(new_mode, lexeme);
+return new_mode.returnBegin ? 0 : lexeme.length;
+}
+var end_mode = endOfMode(top, lexeme);
+if (end_mode) {
+var origin = top;
+if (!(origin.returnEnd || origin.excludeEnd)) {
+mode_buffer += lexeme;
+}
+result += processBuffer();
+do {
+if (top.className) {
+result += '';
+}
+relevance += top.relevance;
+top = top.parent;
+} while (top != end_mode.parent);
+if (origin.excludeEnd) {
+result += escape(lexeme);
+}
+mode_buffer = '';
+if (end_mode.starts) {
+startNewMode(end_mode.starts, '');
+}
+return origin.returnEnd ? 0 : lexeme.length;
+}
+if (isIllegal(lexeme, top))
+throw new Error('Illegal lexeme "' + lexeme + '" for mode "' + (top.className || '
') + '"');
+/*
+Parser should not reach this point as all types of lexemes should be caught
+earlier, but if it does due to some bug make sure it advances at least one
+character forward to prevent infinite looping.
+*/
+mode_buffer += lexeme;
+return lexeme.length || 1;
+}
+var language = getLanguage(name);
+if (!language) {
+throw new Error('Unknown language: "' + name + '"');
+}
+compileLanguage(language);
+var top = continuation || language;
+var continuations = {}; // keep continuations for sub-languages
+var result = '';
+for(var current = top; current != language; current = current.parent) {
+if (current.className) {
+result = buildSpan(current.className, '', true) + result;
+}
+}
+var mode_buffer = '';
+var relevance = 0;
+try {
+var match, count, index = 0;
+while (true) {
+top.terminators.lastIndex = index;
+match = top.terminators.exec(value);
+if (!match)
+break;
+count = processLexeme(value.substr(index, match.index - index), match[0]);
+index = match.index + count;
+}
+processLexeme(value.substr(index));
+for(var current = top; current.parent; current = current.parent) { // close dangling modes
+if (current.className) {
+result += '';
+}
+};
+return {
+relevance: relevance,
+value: result,
+language: name,
+top: top
+};
+} catch (e) {
+if (e.message.indexOf('Illegal') != -1) {
+return {
+relevance: 0,
+value: escape(value)
+};
+} else {
+throw e;
+}
+}
+}
+/*
+Highlighting with language detection. Accepts a string with the code to
+highlight. Returns an object with the following properties:
+- language (detected language)
+- relevance (int)
+- value (an HTML string with highlighting markup)
+- second_best (object with the same structure for second-best heuristically
+detected language, may be absent)
+*/
+function highlightAuto(text, languageSubset) {
+languageSubset = languageSubset || options.languages || Object.keys(languages);
+var result = {
+relevance: 0,
+value: escape(text)
+};
+var second_best = result;
+languageSubset.forEach(function(name) {
+if (!getLanguage(name)) {
+return;
+}
+var current = highlight(name, text, false);
+current.language = name;
+if (current.relevance > second_best.relevance) {
+second_best = current;
+}
+if (current.relevance > result.relevance) {
+second_best = result;
+result = current;
+}
+});
+if (second_best.language) {
+result.second_best = second_best;
+}
+return result;
+}
+/*
+Post-processing of the highlighted markup:
+- replace TABs with something more useful
+- replace real line-breaks with '
' for non-pre containers
+*/
+function fixMarkup(value) {
+if (options.tabReplace) {
+value = value.replace(/^((<[^>]+>|\t)+)/gm, function(match, p1, offset, s) {
+return p1.replace(/\t/g, options.tabReplace);
+});
+}
+if (options.useBR) {
+value = value.replace(/\n/g, '
');
+}
+return value;
+}
+function buildClassName(prevClassName, currentLang, resultLang) {
+var language = currentLang ? aliases[currentLang] : resultLang,
+result = [prevClassName.trim()];
+if (!prevClassName.match(/(\s|^)hljs(\s|$)/)) {
+result.push('hljs');
+}
+if (language) {
+result.push(language);
+}
+return result.join(' ').trim();
+}
+/*
+Applies highlighting to a DOM node containing code. Accepts a DOM node and
+two optional parameters for fixMarkup.
+*/
+function highlightBlock(block) {
+var language = blockLanguage(block);
+if (/no(-?)highlight/.test(language))
+return;
+var node;
+if (options.useBR) {
+node = document.createElementNS('http://www.w3.org/1999/xhtml', 'div');
+node.innerHTML = block.innerHTML.replace(/\n/g, '').replace(//g, '\n');
+} else {
+node = block;
+}
+var text = node.textContent;
+var result = language ? highlight(language, text, true) : highlightAuto(text);
+var originalStream = nodeStream(node);
+if (originalStream.length) {
+var resultNode = document.createElementNS('http://www.w3.org/1999/xhtml', 'div');
+resultNode.innerHTML = result.value;
+result.value = mergeStreams(originalStream, nodeStream(resultNode), text);
+}
+result.value = fixMarkup(result.value);
+block.innerHTML = result.value;
+block.className = buildClassName(block.className, language, result.language);
+block.result = {
+language: result.language,
+re: result.relevance
+};
+if (result.second_best) {
+block.second_best = {
+language: result.second_best.language,
+re: result.second_best.relevance
+};
+}
+}
+var options = {
+classPrefix: 'hljs-',
+tabReplace: null,
+useBR: false,
+languages: undefined
+};
+/*
+Updates highlight.js global options with values passed in the form of an object
+*/
+function configure(user_options) {
+options = inherit(options, user_options);
+}
+/*
+Applies highlighting to all ..
blocks on a page.
+*/
+function initHighlighting() {
+if (initHighlighting.called)
+return;
+initHighlighting.called = true;
+var blocks = document.querySelectorAll('pre code');
+Array.prototype.forEach.call(blocks, highlightBlock);
+}
+/*
+Attaches highlighting to the page load event.
+*/
+function initHighlightingOnLoad() {
+addEventListener('DOMContentLoaded', initHighlighting, false);
+addEventListener('load', initHighlighting, false);
+}
+var languages = {};
+var aliases = {};
+function registerLanguage(name, language) {
+var lang = languages[name] = language(hljs);
+if (lang.aliases) {
+lang.aliases.forEach(function(alias) {aliases[alias] = name;});
+}
+}
+function listLanguages() {
+return Object.keys(languages);
+}
+function getLanguage(name) {
+return languages[name] || languages[aliases[name]];
+}
+/* Interface definition */
+hljs.highlight = highlight;
+hljs.highlightAuto = highlightAuto;
+hljs.fixMarkup = fixMarkup;
+hljs.highlightBlock = highlightBlock;
+hljs.configure = configure;
+hljs.initHighlighting = initHighlighting;
+hljs.initHighlightingOnLoad = initHighlightingOnLoad;
+hljs.registerLanguage = registerLanguage;
+hljs.listLanguages = listLanguages;
+hljs.getLanguage = getLanguage;
+hljs.inherit = inherit;
+// Common regexps
+hljs.IDENT_RE = '[a-zA-Z][a-zA-Z0-9_]*';
+hljs.UNDERSCORE_IDENT_RE = '[a-zA-Z_][a-zA-Z0-9_]*';
+hljs.NUMBER_RE = '\\b\\d+(\\.\\d+)?';
+hljs.C_NUMBER_RE = '(\\b0[xX][a-fA-F0-9]+|(\\b\\d+(\\.\\d*)?|\\.\\d+)([eE][-+]?\\d+)?)'; // 0x..., 0..., decimal, float
+hljs.BINARY_NUMBER_RE = '\\b(0b[01]+)'; // 0b...
+hljs.RE_STARTERS_RE = '!|!=|!==|%|%=|&|&&|&=|\\*|\\*=|\\+|\\+=|,|-|-=|/=|/|:|;|<<|<<=|<=|<|===|==|=|>>>=|>>=|>=|>>>|>>|>|\\?|\\[|\\{|\\(|\\^|\\^=|\\||\\|=|\\|\\||~';
+// Common modes
+hljs.BACKSLASH_ESCAPE = {
+begin: '\\\\[\\s\\S]', relevance: 0
+};
+hljs.APOS_STRING_MODE = {
+className: 'string',
+begin: '\'', end: '\'',
+illegal: '\\n',
+contains: [hljs.BACKSLASH_ESCAPE]
+};
+hljs.QUOTE_STRING_MODE = {
+className: 'string',
+begin: '"', end: '"',
+illegal: '\\n',
+contains: [hljs.BACKSLASH_ESCAPE]
+};
+hljs.PHRASAL_WORDS_MODE = {
+begin: /\b(a|an|the|are|I|I'm|isn't|don't|doesn't|won't|but|just|should|pretty|simply|enough|gonna|going|wtf|so|such)\b/
+};
+hljs.C_LINE_COMMENT_MODE = {
+className: 'comment',
+begin: '//', end: '$',
+contains: [hljs.PHRASAL_WORDS_MODE]
+};
+hljs.C_BLOCK_COMMENT_MODE = {
+className: 'comment',
+begin: '/\\*', end: '\\*/',
+contains: [hljs.PHRASAL_WORDS_MODE]
+};
+hljs.HASH_COMMENT_MODE = {
+className: 'comment',
+begin: '#', end: '$',
+contains: [hljs.PHRASAL_WORDS_MODE]
+};
+hljs.NUMBER_MODE = {
+className: 'number',
+begin: hljs.NUMBER_RE,
+relevance: 0
+};
+hljs.C_NUMBER_MODE = {
+className: 'number',
+begin: hljs.C_NUMBER_RE,
+relevance: 0
+};
+hljs.BINARY_NUMBER_MODE = {
+className: 'number',
+begin: hljs.BINARY_NUMBER_RE,
+relevance: 0
+};
+hljs.CSS_NUMBER_MODE = {
+className: 'number',
+begin: hljs.NUMBER_RE + '(' +
+'%|em|ex|ch|rem' +
+'|vw|vh|vmin|vmax' +
+'|cm|mm|in|pt|pc|px' +
+'|deg|grad|rad|turn' +
+'|s|ms' +
+'|Hz|kHz' +
+'|dpi|dpcm|dppx' +
+')?',
+relevance: 0
+};
+hljs.REGEXP_MODE = {
+className: 'regexp',
+begin: /\//, end: /\/[gimuy]*/,
+illegal: /\n/,
+contains: [
+hljs.BACKSLASH_ESCAPE,
+{
+begin: /\[/, end: /\]/,
+relevance: 0,
+contains: [hljs.BACKSLASH_ESCAPE]
+}
+]
+};
+hljs.TITLE_MODE = {
+className: 'title',
+begin: hljs.IDENT_RE,
+relevance: 0
+};
+hljs.UNDERSCORE_TITLE_MODE = {
+className: 'title',
+begin: hljs.UNDERSCORE_IDENT_RE,
+relevance: 0
+};
+return hljs;
+}));
diff --git a/src/slick.js b/src/slick.js
new file mode 100644
index 000000000..2e1a6ff7c
--- /dev/null
+++ b/src/slick.js
@@ -0,0 +1,1580 @@
+/*
+_ _ _ _
+___| (_) ___| | __ (_)___
+/ __| | |/ __| |/ / | / __|
+\__ \ | | (__| < _ | \__ \
+|___/_|_|\___|_|\_(_)/ |___/
+|__/
+Version: 1.4.0
+Author: Ken Wheeler
+Website: http://kenwheeler.github.io
+Docs: http://kenwheeler.github.io/slick
+Repo: http://github.com/kenwheeler/slick
+Issues: http://github.com/kenwheeler/slick/issues
+*/
+/* global window, document, define, jQuery, setInterval, clearInterval */
+(function(factory) {
+'use strict';
+if (typeof define === 'function' && define.amd) {
+define(['jquery'], factory);
+} else if (typeof exports !== 'undefined') {
+module.exports = factory(require('jquery'));
+} else {
+factory(jQuery);
+}
+}(function($) {
+'use strict';
+var Slick = window.Slick || {};
+Slick = (function() {
+var instanceUid = 0;
+function Slick(element, settings) {
+var _ = this,
+dataSettings, responsiveSettings, breakpoint;
+_.defaults = {
+accessibility: true,
+adaptiveHeight: false,
+appendArrows: $(element),
+appendDots: $(element),
+arrows: true,
+asNavFor: null,
+prevArrow: '',
+nextArrow: '',
+autoplay: false,
+autoplaySpeed: 3000,
+centerMode: false,
+centerPadding: '50px',
+cssEase: 'ease',
+customPaging: function(slider, i) {
+return '';
+},
+dots: false,
+dotsClass: 'slick-dots',
+draggable: true,
+easing: 'linear',
+edgeFriction: 0.35,
+fade: false,
+focusOnSelect: false,
+infinite: true,
+initialSlide: 0,
+lazyLoad: 'ondemand',
+mobileFirst: false,
+pauseOnHover: true,
+pauseOnDotsHover: false,
+respondTo: 'window',
+responsive: null,
+rtl: false,
+slide: '',
+slidesToShow: 1,
+slidesToScroll: 1,
+speed: 500,
+swipe: true,
+swipeToSlide: false,
+touchMove: true,
+touchThreshold: 5,
+useCSS: true,
+variableWidth: false,
+vertical: false,
+waitForAnimate: true
+};
+_.initials = {
+animating: false,
+dragging: false,
+autoPlayTimer: null,
+currentDirection: 0,
+currentLeft: null,
+currentSlide: 0,
+direction: 1,
+$dots: null,
+listWidth: null,
+listHeight: null,
+loadIndex: 0,
+$nextArrow: null,
+$prevArrow: null,
+slideCount: null,
+slideWidth: null,
+$slideTrack: null,
+$slides: null,
+sliding: false,
+slideOffset: 0,
+swipeLeft: null,
+$list: null,
+touchObject: {},
+transformsEnabled: false
+};
+$.extend(_, _.initials);
+_.activeBreakpoint = null;
+_.animType = null;
+_.animProp = null;
+_.breakpoints = [];
+_.breakpointSettings = [];
+_.cssTransitions = false;
+_.hidden = "hidden";
+_.paused = false;
+_.positionProp = null;
+_.respondTo = null;
+_.shouldClick = true;
+_.$slider = $(element);
+_.$slidesCache = null;
+_.transformType = null;
+_.transitionType = null;
+_.visibilityChange = "visibilitychange";
+_.windowWidth = 0;
+_.windowTimer = null;
+dataSettings = $(element).data('slick') || {};
+_.options = $.extend({}, _.defaults, dataSettings, settings);
+_.currentSlide = _.options.initialSlide;
+_.originalSettings = _.options;
+responsiveSettings = _.options.responsive || null;
+if (responsiveSettings && responsiveSettings.length > -1) {
+_.respondTo = _.options.respondTo || "window";
+for (breakpoint in responsiveSettings) {
+if (responsiveSettings.hasOwnProperty(breakpoint)) {
+_.breakpoints.push(responsiveSettings[
+breakpoint].breakpoint);
+_.breakpointSettings[responsiveSettings[
+breakpoint].breakpoint] =
+responsiveSettings[breakpoint].settings;
+}
+}
+_.breakpoints.sort(function(a, b) {
+if(_.options.mobileFirst === true) {
+return a - b;
+} else {
+return b - a;
+}
+});
+}
+if (typeof document.mozHidden !== "undefined") {
+_.hidden = "mozHidden";
+_.visibilityChange = "mozvisibilitychange";
+} else if (typeof document.msHidden !== "undefined") {
+_.hidden = "msHidden";
+_.visibilityChange = "msvisibilitychange";
+} else if (typeof document.webkitHidden !== "undefined") {
+_.hidden = "webkitHidden";
+_.visibilityChange = "webkitvisibilitychange";
+}
+_.autoPlay = $.proxy(_.autoPlay, _);
+_.autoPlayClear = $.proxy(_.autoPlayClear, _);
+_.changeSlide = $.proxy(_.changeSlide, _);
+_.clickHandler = $.proxy(_.clickHandler, _);
+_.selectHandler = $.proxy(_.selectHandler, _);
+_.setPosition = $.proxy(_.setPosition, _);
+_.swipeHandler = $.proxy(_.swipeHandler, _);
+_.dragHandler = $.proxy(_.dragHandler, _);
+_.keyHandler = $.proxy(_.keyHandler, _);
+_.autoPlayIterator = $.proxy(_.autoPlayIterator, _);
+_.instanceUid = instanceUid++;
+// A simple way to check for HTML strings
+// Strict HTML recognition (must start with <)
+// Extracted from jQuery v1.11 source
+_.htmlExpr = /^(?:\s*(<[\w\W]+>)[^>]*)$/;
+_.init();
+_.checkResponsive();
+}
+return Slick;
+}());
+Slick.prototype.addSlide = Slick.prototype.slickAdd = function(markup, index, addBefore) {
+var _ = this;
+if (typeof(index) === 'boolean') {
+addBefore = index;
+index = null;
+} else if (index < 0 || (index >= _.slideCount)) {
+return false;
+}
+_.unload();
+if (typeof(index) === 'number') {
+if (index === 0 && _.$slides.length === 0) {
+$(markup).appendTo(_.$slideTrack);
+} else if (addBefore) {
+$(markup).insertBefore(_.$slides.eq(index));
+} else {
+$(markup).insertAfter(_.$slides.eq(index));
+}
+} else {
+if (addBefore === true) {
+$(markup).prependTo(_.$slideTrack);
+} else {
+$(markup).appendTo(_.$slideTrack);
+}
+}
+_.$slides = _.$slideTrack.children(this.options.slide);
+_.$slideTrack.children(this.options.slide).detach();
+_.$slideTrack.append(_.$slides);
+_.$slides.each(function(index, element) {
+$(element).attr("data-slick-index",index);
+});
+_.$slidesCache = _.$slides;
+_.reinit();
+};
+Slick.prototype.animateHeight = function(){
+var _ = this;
+if(_.options.slidesToShow === 1 && _.options.adaptiveHeight === true && _.options.vertical === false) {
+var targetHeight = _.$slides.eq(_.currentSlide).outerHeight(true);
+_.$list.animate({height: targetHeight},_.options.speed);
+}
+};
+Slick.prototype.animateSlide = function(targetLeft, callback) {
+var animProps = {}, _ = this;
+_.animateHeight();
+if (_.options.rtl === true && _.options.vertical === false) {
+targetLeft = -targetLeft;
+}
+if (_.transformsEnabled === false) {
+if (_.options.vertical === false) {
+_.$slideTrack.animate({
+left: targetLeft
+}, _.options.speed, _.options.easing, callback);
+} else {
+_.$slideTrack.animate({
+top: targetLeft
+}, _.options.speed, _.options.easing, callback);
+}
+} else {
+if (_.cssTransitions === false) {
+if (_.options.rtl === true) {
+_.currentLeft = -(_.currentLeft);
+}
+$({
+animStart: _.currentLeft
+}).animate({
+animStart: targetLeft
+}, {
+duration: _.options.speed,
+easing: _.options.easing,
+step: function(now) {
+now = Math.ceil(now);
+if (_.options.vertical === false) {
+animProps[_.animType] = 'translate(' +
+now + 'px, 0px)';
+_.$slideTrack.css(animProps);
+} else {
+animProps[_.animType] = 'translate(0px,' +
+now + 'px)';
+_.$slideTrack.css(animProps);
+}
+},
+complete: function() {
+if (callback) {
+callback.call();
+}
+}
+});
+} else {
+_.applyTransition();
+targetLeft = Math.ceil(targetLeft);
+if (_.options.vertical === false) {
+animProps[_.animType] = 'translate3d(' + targetLeft + 'px, 0px, 0px)';
+} else {
+animProps[_.animType] = 'translate3d(0px,' + targetLeft + 'px, 0px)';
+}
+_.$slideTrack.css(animProps);
+if (callback) {
+setTimeout(function() {
+_.disableTransition();
+callback.call();
+}, _.options.speed);
+}
+}
+}
+};
+Slick.prototype.asNavFor = function(index) {
+var _ = this, asNavFor = _.options.asNavFor !== null ? $(_.options.asNavFor).slick('getSlick') : null;
+if(asNavFor !== null) asNavFor.slideHandler(index, true);
+};
+Slick.prototype.applyTransition = function(slide) {
+var _ = this,
+transition = {};
+if (_.options.fade === false) {
+transition[_.transitionType] = _.transformType + ' ' + _.options.speed + 'ms ' + _.options.cssEase;
+} else {
+transition[_.transitionType] = 'opacity ' + _.options.speed + 'ms ' + _.options.cssEase;
+}
+if (_.options.fade === false) {
+_.$slideTrack.css(transition);
+} else {
+_.$slides.eq(slide).css(transition);
+}
+};
+Slick.prototype.autoPlay = function() {
+var _ = this;
+if (_.autoPlayTimer) {
+clearInterval(_.autoPlayTimer);
+}
+if (_.slideCount > _.options.slidesToShow && _.paused !== true) {
+_.autoPlayTimer = setInterval(_.autoPlayIterator,
+_.options.autoplaySpeed);
+}
+};
+Slick.prototype.autoPlayClear = function() {
+var _ = this;
+if (_.autoPlayTimer) {
+clearInterval(_.autoPlayTimer);
+}
+};
+Slick.prototype.autoPlayIterator = function() {
+var _ = this;
+if (_.options.infinite === false) {
+if (_.direction === 1) {
+if ((_.currentSlide + 1) === _.slideCount -
+1) {
+_.direction = 0;
+}
+_.slideHandler(_.currentSlide + _.options.slidesToScroll);
+} else {
+if ((_.currentSlide - 1 === 0)) {
+_.direction = 1;
+}
+_.slideHandler(_.currentSlide - _.options.slidesToScroll);
+}
+} else {
+_.slideHandler(_.currentSlide + _.options.slidesToScroll);
+}
+};
+Slick.prototype.buildArrows = function() {
+var _ = this;
+if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {
+_.$prevArrow = $(_.options.prevArrow);
+_.$nextArrow = $(_.options.nextArrow);
+if (_.htmlExpr.test(_.options.prevArrow)) {
+_.$prevArrow.appendTo(_.options.appendArrows);
+}
+if (_.htmlExpr.test(_.options.nextArrow)) {
+_.$nextArrow.appendTo(_.options.appendArrows);
+}
+if (_.options.infinite !== true) {
+_.$prevArrow.addClass('slick-disabled');
+}
+}
+};
+Slick.prototype.buildDots = function() {
+var _ = this,
+i, dotString;
+if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {
+dotString = '';
+for (i = 0; i <= _.getDotCount(); i += 1) {
+dotString += '- ' + _.options.customPaging.call(this, _, i) + '
';
+}
+dotString += '
';
+_.$dots = $(dotString).appendTo(
+_.options.appendDots);
+_.$dots.find('li').first().addClass(
+'slick-active');
+}
+};
+Slick.prototype.buildOut = function() {
+var _ = this;
+_.$slides = _.$slider.children(_.options.slide +
+':not(.slick-cloned)').addClass(
+'slick-slide');
+_.slideCount = _.$slides.length;
+_.$slides.each(function(index, element) {
+$(element).attr("data-slick-index",index);
+});
+_.$slidesCache = _.$slides;
+_.$slider.addClass('slick-slider');
+_.$slideTrack = (_.slideCount === 0) ?
+$('').appendTo(_.$slider) :
+_.$slides.wrapAll('').parent();
+_.$list = _.$slideTrack.wrap(
+'').parent();
+_.$slideTrack.css('opacity', 0);
+if (_.options.centerMode === true) {
+_.options.slidesToScroll = 1;
+}
+$('img[data-lazy]', _.$slider).not('[src]').addClass('slick-loading');
+_.setupInfinite();
+_.buildArrows();
+_.buildDots();
+_.updateDots();
+if (_.options.accessibility === true) {
+_.$list.prop('tabIndex', 0);
+}
+_.setSlideClasses(typeof this.currentSlide === 'number' ? this.currentSlide : 0);
+if (_.options.draggable === true) {
+_.$list.addClass('draggable');
+}
+};
+Slick.prototype.checkResponsive = function() {
+var _ = this,
+breakpoint, targetBreakpoint, respondToWidth;
+var sliderWidth = _.$slider.width();
+var windowWidth = window.innerWidth || $(window).width();
+if (_.respondTo === "window") {
+respondToWidth = windowWidth;
+} else if (_.respondTo === "slider") {
+respondToWidth = sliderWidth;
+} else if (_.respondTo === "min") {
+respondToWidth = Math.min(windowWidth, sliderWidth);
+}
+if (_.originalSettings.responsive && _.originalSettings
+.responsive.length > -1 && _.originalSettings.responsive !== null) {
+targetBreakpoint = null;
+for (breakpoint in _.breakpoints) {
+if (_.breakpoints.hasOwnProperty(breakpoint)) {
+if (_.originalSettings.mobileFirst === false) {
+if (respondToWidth < _.breakpoints[breakpoint]) {
+targetBreakpoint = _.breakpoints[breakpoint];
+}
+} else {
+if (respondToWidth > _.breakpoints[breakpoint]) {
+targetBreakpoint = _.breakpoints[breakpoint];
+}
+}
+}
+}
+if (targetBreakpoint !== null) {
+if (_.activeBreakpoint !== null) {
+if (targetBreakpoint !== _.activeBreakpoint) {
+_.activeBreakpoint =
+targetBreakpoint;
+if(_.breakpointSettings[targetBreakpoint] === "unslick") {
+_.unslick();
+} else {
+_.options = $.extend({}, _.originalSettings,
+_.breakpointSettings[
+targetBreakpoint]);
+_.refresh();
+}
+}
+} else {
+_.activeBreakpoint = targetBreakpoint;
+if(_.breakpointSettings[targetBreakpoint] === "unslick") {
+_.unslick();
+} else {
+_.options = $.extend({}, _.originalSettings,
+_.breakpointSettings[
+targetBreakpoint]);
+_.refresh();
+}
+}
+} else {
+if (_.activeBreakpoint !== null) {
+_.activeBreakpoint = null;
+_.options = _.originalSettings;
+_.refresh();
+}
+}
+}
+};
+Slick.prototype.changeSlide = function(event, dontAnimate) {
+var _ = this,
+$target = $(event.target),
+indexOffset, slideOffset, unevenOffset;
+// If target is a link, prevent default action.
+$target.is('a') && event.preventDefault();
+unevenOffset = (_.slideCount % _.options.slidesToScroll !== 0);
+indexOffset = unevenOffset ? 0 : (_.slideCount - _.currentSlide) % _.options.slidesToScroll;
+switch (event.data.message) {
+case 'previous':
+slideOffset = indexOffset === 0 ? _.options.slidesToScroll : _.options.slidesToShow - indexOffset;
+if (_.slideCount > _.options.slidesToShow) {
+_.slideHandler(_.currentSlide - slideOffset, false, dontAnimate);
+}
+break;
+case 'next':
+slideOffset = indexOffset === 0 ? _.options.slidesToScroll : indexOffset;
+if (_.slideCount > _.options.slidesToShow) {
+_.slideHandler(_.currentSlide + slideOffset, false, dontAnimate);
+}
+break;
+case 'index':
+var index = event.data.index === 0 ? 0 :
+event.data.index || $(event.target).parent().index() * _.options.slidesToScroll;
+_.slideHandler(_.checkNavigable(index), false, dontAnimate);
+break;
+default:
+return;
+}
+};
+Slick.prototype.checkNavigable = function(index) {
+var _ = this, navigables, prevNavigable;
+navigables = _.getNavigableIndexes();
+prevNavigable = 0;
+if(index > navigables[navigables.length -1]){
+index = navigables[navigables.length -1];
+} else {
+for(var n in navigables) {
+if(index < navigables[n]) {
+index = prevNavigable;
+break;
+}
+prevNavigable = navigables[n];
+}
+}
+return index;
+};
+Slick.prototype.clickHandler = function(event) {
+var _ = this;
+if(_.shouldClick === false) {
+event.stopImmediatePropagation();
+event.stopPropagation();
+event.preventDefault();
+}
+};
+Slick.prototype.destroy = function() {
+var _ = this;
+_.autoPlayClear();
+_.touchObject = {};
+$('.slick-cloned', _.$slider).remove();
+if (_.$dots) {
+_.$dots.remove();
+}
+if (_.$prevArrow && (typeof _.options.prevArrow !== 'object')) {
+_.$prevArrow.remove();
+}
+if (_.$nextArrow && (typeof _.options.nextArrow !== 'object')) {
+_.$nextArrow.remove();
+}
+_.$slides.removeClass(
+'slick-slide slick-active slick-center slick-visible')
+.removeAttr('data-slick-index')
+.css({
+position: '',
+left: '',
+top: '',
+zIndex: '',
+opacity: '',
+width: ''
+});
+_.$slider.removeClass('slick-slider');
+_.$slider.removeClass('slick-initialized');
+_.$list.off('.slick');
+$(window).off('.slick-' + _.instanceUid);
+$(document).off('.slick-' + _.instanceUid);
+_.$slider.html(_.$slides);
+};
+Slick.prototype.disableTransition = function(slide) {
+var _ = this,
+transition = {};
+transition[_.transitionType] = "";
+if (_.options.fade === false) {
+_.$slideTrack.css(transition);
+} else {
+_.$slides.eq(slide).css(transition);
+}
+};
+Slick.prototype.fadeSlide = function(slideIndex, callback) {
+var _ = this;
+if (_.cssTransitions === false) {
+_.$slides.eq(slideIndex).css({
+zIndex: 1000
+});
+_.$slides.eq(slideIndex).animate({
+opacity: 1
+}, _.options.speed, _.options.easing, callback);
+} else {
+_.applyTransition(slideIndex);
+_.$slides.eq(slideIndex).css({
+opacity: 1,
+zIndex: 1000
+});
+if (callback) {
+setTimeout(function() {
+_.disableTransition(slideIndex);
+callback.call();
+}, _.options.speed);
+}
+}
+};
+Slick.prototype.filterSlides = Slick.prototype.slickFilter = function(filter) {
+var _ = this;
+if (filter !== null) {
+_.unload();
+_.$slideTrack.children(this.options.slide).detach();
+_.$slidesCache.filter(filter).appendTo(_.$slideTrack);
+_.reinit();
+}
+};
+Slick.prototype.getCurrent = Slick.prototype.slickCurrentSlide = function() {
+var _ = this;
+return _.currentSlide;
+};
+Slick.prototype.getDotCount = function() {
+var _ = this;
+var breakPoint = 0;
+var counter = 0;
+var pagerQty = 0;
+if(_.options.infinite === true) {
+pagerQty = Math.ceil(_.slideCount / _.options.slidesToScroll);
+} else if (_.options.centerMode === true) {
+pagerQty = _.slideCount;
+} else {
+while (breakPoint < _.slideCount){
+++pagerQty;
+breakPoint = counter + _.options.slidesToShow;
+counter += _.options.slidesToScroll <= _.options.slidesToShow ? _.options.slidesToScroll : _.options.slidesToShow;
+}
+}
+return pagerQty - 1;
+};
+Slick.prototype.getLeft = function(slideIndex) {
+var _ = this,
+targetLeft,
+verticalHeight,
+verticalOffset = 0,
+targetSlide;
+_.slideOffset = 0;
+verticalHeight = _.$slides.first().outerHeight();
+if (_.options.infinite === true) {
+if (_.slideCount > _.options.slidesToShow) {
+_.slideOffset = (_.slideWidth * _.options.slidesToShow) * -1;
+verticalOffset = (verticalHeight * _.options.slidesToShow) * -1;
+}
+if (_.slideCount % _.options.slidesToScroll !== 0) {
+if (slideIndex + _.options.slidesToScroll > _.slideCount && _.slideCount > _.options.slidesToShow) {
+if(slideIndex > _.slideCount) {
+_.slideOffset = ((_.options.slidesToShow - (slideIndex - _.slideCount)) * _.slideWidth) * -1;
+verticalOffset = ((_.options.slidesToShow - (slideIndex - _.slideCount)) * verticalHeight) * -1;
+} else {
+_.slideOffset = ((_.slideCount % _.options.slidesToScroll) * _.slideWidth) * -1;
+verticalOffset = ((_.slideCount % _.options.slidesToScroll) * verticalHeight) * -1;
+}
+}
+}
+} else {
+if(slideIndex + _.options.slidesToShow > _.slideCount) {
+_.slideOffset = ((slideIndex + _.options.slidesToShow) - _.slideCount) * _.slideWidth;
+verticalOffset = ((slideIndex + _.options.slidesToShow) - _.slideCount) * verticalHeight;
+}
+}
+if (_.slideCount <= _.options.slidesToShow){
+_.slideOffset = 0;
+verticalOffset = 0;
+}
+if (_.options.centerMode === true && _.options.infinite === true) {
+_.slideOffset += _.slideWidth * Math.floor(_.options.slidesToShow / 2) - _.slideWidth;
+} else if (_.options.centerMode === true) {
+_.slideOffset = 0;
+_.slideOffset += _.slideWidth * Math.floor(_.options.slidesToShow / 2);
+}
+if (_.options.vertical === false) {
+targetLeft = ((slideIndex * _.slideWidth) * -1) + _.slideOffset;
+} else {
+targetLeft = ((slideIndex * verticalHeight) * -1) + verticalOffset;
+}
+if (_.options.variableWidth === true) {
+if (_.slideCount <= _.options.slidesToShow || _.options.infinite === false) {
+targetSlide = _.$slideTrack.children('.slick-slide').eq(slideIndex);
+} else {
+targetSlide = _.$slideTrack.children('.slick-slide').eq(slideIndex + _.options.slidesToShow);
+}
+targetLeft = targetSlide[0] ? targetSlide[0].offsetLeft * -1 : 0;
+if (_.options.centerMode === true) {
+if(_.options.infinite === false) {
+targetSlide = _.$slideTrack.children('.slick-slide').eq(slideIndex);
+} else {
+targetSlide = _.$slideTrack.children('.slick-slide').eq(slideIndex + _.options.slidesToShow + 1);
+}
+targetLeft = targetSlide[0] ? targetSlide[0].offsetLeft * -1 : 0;
+targetLeft += (_.$list.width() - targetSlide.outerWidth()) / 2;
+}
+}
+return targetLeft;
+};
+Slick.prototype.getOption = Slick.prototype.slickGetOption = function(option) {
+var _ = this;
+return _.options[option];
+};
+Slick.prototype.getNavigableIndexes = function() {
+var _ = this;
+var breakPoint = 0;
+var counter = 0;
+var indexes = [];
+var max = _.options.infinite === false ? _.slideCount - _.options.slidesToShow + 1 : _.slideCount;
+if (_.options.centerMode === true) max = _.slideCount;
+while (breakPoint < max){
+indexes.push(breakPoint);
+breakPoint = counter + _.options.slidesToScroll;
+counter += _.options.slidesToScroll <= _.options.slidesToShow ? _.options.slidesToScroll : _.options.slidesToShow;
+}
+return indexes;
+};
+Slick.prototype.getSlick = function() {
+return this;
+};
+Slick.prototype.getSlideCount = function() {
+var _ = this, slidesTraversed, swipedSlide, centerOffset;
+centerOffset = _.options.centerMode === true ? _.slideWidth * Math.floor(_.options.slidesToShow / 2) : 0;
+if(_.options.swipeToSlide === true) {
+_.$slideTrack.find('.slick-slide').each(function(index, slide){
+if (slide.offsetLeft - centerOffset + ($(slide).outerWidth() / 2) > (_.swipeLeft * -1)) {
+swipedSlide = slide;
+return false;
+}
+});
+slidesTraversed = Math.abs($(swipedSlide).attr('data-slick-index') - _.currentSlide) || 1;
+return slidesTraversed;
+} else {
+return _.options.slidesToScroll;
+}
+};
+Slick.prototype.goTo = Slick.prototype.slickGoTo = function(slide, dontAnimate) {
+var _ = this;
+_.changeSlide({
+data: {
+message: 'index',
+index: parseInt(slide)
+}
+}, dontAnimate);
+};
+Slick.prototype.init = function() {
+var _ = this;
+if (!$(_.$slider).hasClass('slick-initialized')) {
+$(_.$slider).addClass('slick-initialized');
+_.buildOut();
+_.setProps();
+_.startLoad();
+_.loadSlider();
+_.initializeEvents();
+_.updateArrows();
+_.updateDots();
+}
+_.$slider.trigger("init", [ _ ]);
+};
+Slick.prototype.initArrowEvents = function() {
+var _ = this;
+if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {
+_.$prevArrow.on('click.slick', {
+message: 'previous'
+}, _.changeSlide);
+_.$nextArrow.on('click.slick', {
+message: 'next'
+}, _.changeSlide);
+}
+};
+Slick.prototype.initDotEvents = function() {
+var _ = this;
+if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {
+$('li', _.$dots).on('click.slick', {
+message: 'index'
+}, _.changeSlide);
+}
+if (_.options.dots === true && _.options.pauseOnDotsHover === true && _.options.autoplay === true) {
+$('li', _.$dots)
+.on('mouseenter.slick', function(){
+_.paused = true;
+_.autoPlayClear();
+})
+.on('mouseleave.slick', function(){
+_.paused = false;
+_.autoPlay();
+});
+}
+};
+Slick.prototype.initializeEvents = function() {
+var _ = this;
+_.initArrowEvents();
+_.initDotEvents();
+_.$list.on('touchstart.slick mousedown.slick', {
+action: 'start'
+}, _.swipeHandler);
+_.$list.on('touchmove.slick mousemove.slick', {
+action: 'move'
+}, _.swipeHandler);
+_.$list.on('touchend.slick mouseup.slick', {
+action: 'end'
+}, _.swipeHandler);
+_.$list.on('touchcancel.slick mouseleave.slick', {
+action: 'end'
+}, _.swipeHandler);
+_.$list.on('click.slick', _.clickHandler);
+if (_.options.autoplay === true) {
+$(document).on(_.visibilityChange, function(){
+_.visibility();
+});
+if( _.options.pauseOnHover === true ) {
+_.$list.on('mouseenter.slick', function(){
+_.paused = true;
+_.autoPlayClear();
+});
+_.$list.on('mouseleave.slick', function(){
+_.paused = false;
+_.autoPlay();
+});
+}
+}
+if(_.options.accessibility === true) {
+_.$list.on('keydown.slick', _.keyHandler);
+}
+if(_.options.focusOnSelect === true) {
+$(_.options.slide, _.$slideTrack).on('click.slick', _.selectHandler);
+}
+$(window).on('orientationchange.slick.slick-' + _.instanceUid, function() {
+_.checkResponsive();
+_.setPosition();
+});
+$(window).on('resize.slick.slick-' + _.instanceUid, function() {
+if ($(window).width() !== _.windowWidth) {
+clearTimeout(_.windowDelay);
+_.windowDelay = window.setTimeout(function() {
+_.windowWidth = $(window).width();
+_.checkResponsive();
+_.setPosition();
+}, 50);
+}
+});
+$('*[draggable!=true]', _.$slideTrack).on('dragstart', function(e){ e.preventDefault(); });
+$(window).on('load.slick.slick-' + _.instanceUid, _.setPosition);
+$(document).on('ready.slick.slick-' + _.instanceUid, _.setPosition);
+};
+Slick.prototype.initUI = function() {
+var _ = this;
+if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {
+_.$prevArrow.show();
+_.$nextArrow.show();
+}
+if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {
+_.$dots.show();
+}
+if (_.options.autoplay === true) {
+_.autoPlay();
+}
+};
+Slick.prototype.keyHandler = function(event) {
+var _ = this;
+if (event.keyCode === 37 && _.options.accessibility === true) {
+_.changeSlide({
+data: {
+message: 'previous'
+}
+});
+} else if (event.keyCode === 39 && _.options.accessibility === true) {
+_.changeSlide({
+data: {
+message: 'next'
+}
+});
+}
+};
+Slick.prototype.lazyLoad = function() {
+var _ = this,
+loadRange, cloneRange, rangeStart, rangeEnd;
+function loadImages(imagesScope) {
+$('img[data-lazy]', imagesScope).each(function() {
+var image = $(this),
+imageSource = $(this).attr('data-lazy');
+image
+.load(function() { image.animate({ opacity: 1 }, 200); })
+.css({ opacity: 0 })
+.attr('src', imageSource)
+.removeAttr('data-lazy')
+.removeClass('slick-loading');
+});
+}
+if (_.options.centerMode === true) {
+if (_.options.infinite === true) {
+rangeStart = _.currentSlide + (_.options.slidesToShow/2 + 1);
+rangeEnd = rangeStart + _.options.slidesToShow + 2;
+} else {
+rangeStart = Math.max(0, _.currentSlide - (_.options.slidesToShow/2 + 1));
+rangeEnd = 2 + (_.options.slidesToShow/2 + 1) + _.currentSlide;
+}
+} else {
+rangeStart = _.options.infinite ? _.options.slidesToShow + _.currentSlide : _.currentSlide;
+rangeEnd = rangeStart + _.options.slidesToShow;
+if (_.options.fade === true ) {
+if(rangeStart > 0) rangeStart--;
+if(rangeEnd <= _.slideCount) rangeEnd++;
+}
+}
+loadRange = _.$slider.find('.slick-slide').slice(rangeStart, rangeEnd);
+loadImages(loadRange);
+if (_.slideCount <= _.options.slidesToShow){
+cloneRange = _.$slider.find('.slick-slide');
+loadImages(cloneRange);
+}else
+if (_.currentSlide >= _.slideCount - _.options.slidesToShow) {
+cloneRange = _.$slider.find('.slick-cloned').slice(0, _.options.slidesToShow);
+loadImages(cloneRange);
+} else if (_.currentSlide === 0) {
+cloneRange = _.$slider.find('.slick-cloned').slice(_.options.slidesToShow * -1);
+loadImages(cloneRange);
+}
+};
+Slick.prototype.loadSlider = function() {
+var _ = this;
+_.setPosition();
+_.$slideTrack.css({
+opacity: 1
+});
+_.$slider.removeClass('slick-loading');
+_.initUI();
+if (_.options.lazyLoad === 'progressive') {
+_.progressiveLazyLoad();
+}
+};
+Slick.prototype.next = Slick.prototype.slickNext = function() {
+var _ = this;
+_.changeSlide({
+data: {
+message: 'next'
+}
+});
+};
+Slick.prototype.pause = Slick.prototype.slickPause = function() {
+var _ = this;
+_.autoPlayClear();
+_.paused = true;
+};
+Slick.prototype.play = Slick.prototype.slickPlay = function() {
+var _ = this;
+_.paused = false;
+_.autoPlay();
+};
+Slick.prototype.postSlide = function(index) {
+var _ = this;
+_.$slider.trigger("afterChange", [ _, index]);
+_.animating = false;
+_.setPosition();
+_.swipeLeft = null;
+if (_.options.autoplay === true && _.paused === false) {
+_.autoPlay();
+}
+};
+Slick.prototype.prev = Slick.prototype.slickPrev = function() {
+var _ = this;
+_.changeSlide({
+data: {
+message: 'previous'
+}
+});
+};
+Slick.prototype.progressiveLazyLoad = function() {
+var _ = this,
+imgCount, targetImage;
+imgCount = $('img[data-lazy]', _.$slider).length;
+if (imgCount > 0) {
+targetImage = $('img[data-lazy]', _.$slider).first();
+targetImage.attr('src', targetImage.attr('data-lazy')).removeClass('slick-loading').load(function() {
+targetImage.removeAttr('data-lazy');
+_.progressiveLazyLoad();
+})
+.error(function () {
+targetImage.removeAttr('data-lazy');
+_.progressiveLazyLoad();
+});
+}
+};
+Slick.prototype.refresh = function() {
+var _ = this,
+currentSlide = _.currentSlide;
+_.destroy();
+$.extend(_, _.initials);
+_.init();
+_.changeSlide({
+data: {
+message: 'index',
+index: currentSlide
+}
+}, true);
+};
+Slick.prototype.reinit = function() {
+var _ = this;
+_.$slides = _.$slideTrack.children(_.options.slide).addClass(
+'slick-slide');
+_.slideCount = _.$slides.length;
+if (_.currentSlide >= _.slideCount && _.currentSlide !== 0) {
+_.currentSlide = _.currentSlide - _.options.slidesToScroll;
+}
+if (_.slideCount <= _.options.slidesToShow) {
+_.currentSlide = 0;
+}
+_.setProps();
+_.setupInfinite();
+_.buildArrows();
+_.updateArrows();
+_.initArrowEvents();
+_.buildDots();
+_.updateDots();
+_.initDotEvents();
+if(_.options.focusOnSelect === true) {
+$(_.options.slide, _.$slideTrack).on('click.slick', _.selectHandler);
+}
+_.setSlideClasses(0);
+_.setPosition();
+_.$slider.trigger("reInit", [ _ ]);
+};
+Slick.prototype.removeSlide = Slick.prototype.slickRemove = function(index, removeBefore, removeAll) {
+var _ = this;
+if (typeof(index) === 'boolean') {
+removeBefore = index;
+index = removeBefore === true ? 0 : _.slideCount - 1;
+} else {
+index = removeBefore === true ? --index : index;
+}
+if (_.slideCount < 1 || index < 0 || index > _.slideCount - 1) {
+return false;
+}
+_.unload();
+if(removeAll === true) {
+_.$slideTrack.children().remove();
+} else {
+_.$slideTrack.children(this.options.slide).eq(index).remove();
+}
+_.$slides = _.$slideTrack.children(this.options.slide);
+_.$slideTrack.children(this.options.slide).detach();
+_.$slideTrack.append(_.$slides);
+_.$slidesCache = _.$slides;
+_.reinit();
+};
+Slick.prototype.setCSS = function(position) {
+var _ = this,
+positionProps = {}, x, y;
+if (_.options.rtl === true) {
+position = -position;
+}
+x = _.positionProp == 'left' ? Math.ceil(position) + 'px' : '0px';
+y = _.positionProp == 'top' ? Math.ceil(position) + 'px' : '0px';
+positionProps[_.positionProp] = position;
+if (_.transformsEnabled === false) {
+_.$slideTrack.css(positionProps);
+} else {
+positionProps = {};
+if (_.cssTransitions === false) {
+positionProps[_.animType] = 'translate(' + x + ', ' + y + ')';
+_.$slideTrack.css(positionProps);
+} else {
+positionProps[_.animType] = 'translate3d(' + x + ', ' + y + ', 0px)';
+_.$slideTrack.css(positionProps);
+}
+}
+};
+Slick.prototype.setDimensions = function() {
+var _ = this;
+if (_.options.vertical === false) {
+if (_.options.centerMode === true) {
+_.$list.css({
+padding: ('0px ' + _.options.centerPadding)
+});
+}
+} else {
+_.$list.height(_.$slides.first().outerHeight(true) * _.options.slidesToShow);
+if (_.options.centerMode === true) {
+_.$list.css({
+padding: (_.options.centerPadding + ' 0px')
+});
+}
+}
+_.listWidth = _.$list.width();
+_.listHeight = _.$list.height();
+if(_.options.vertical === false && _.options.variableWidth === false) {
+_.slideWidth = Math.ceil(_.listWidth / _.options.slidesToShow);
+_.$slideTrack.width(Math.ceil((_.slideWidth * _.$slideTrack.children('.slick-slide').length)));
+} else if (_.options.variableWidth === true) {
+var trackWidth = 0;
+_.slideWidth = Math.ceil(_.listWidth / _.options.slidesToShow);
+_.$slideTrack.children('.slick-slide').each(function(){
+trackWidth += _.listWidth;
+});
+_.$slideTrack.width(Math.ceil(trackWidth) + 1);
+} else {
+_.slideWidth = Math.ceil(_.listWidth);
+_.$slideTrack.height(Math.ceil((_.$slides.first().outerHeight(true) * _.$slideTrack.children('.slick-slide').length)));
+}
+var offset = _.$slides.first().outerWidth(true) - _.$slides.first().width();
+if (_.options.variableWidth === false) _.$slideTrack.children('.slick-slide').width(_.slideWidth - offset);
+};
+Slick.prototype.setFade = function() {
+var _ = this,
+targetLeft;
+_.$slides.each(function(index, element) {
+targetLeft = (_.slideWidth * index) * -1;
+if (_.options.rtl === true) {
+$(element).css({
+position: 'relative',
+right: targetLeft,
+top: 0,
+zIndex: 800,
+opacity: 0
+});
+} else {
+$(element).css({
+position: 'relative',
+left: targetLeft,
+top: 0,
+zIndex: 800,
+opacity: 0
+});
+}
+});
+_.$slides.eq(_.currentSlide).css({
+zIndex: 900,
+opacity: 1
+});
+};
+Slick.prototype.setHeight = function() {
+var _ = this;
+if(_.options.slidesToShow === 1 && _.options.adaptiveHeight === true && _.options.vertical === false) {
+var targetHeight = _.$slides.eq(_.currentSlide).outerHeight(true);
+_.$list.css('height', targetHeight);
+}
+};
+Slick.prototype.setOption = Slick.prototype.slickSetOption = function(option, value, refresh) {
+var _ = this;
+_.options[option] = value;
+if (refresh === true) {
+_.unload();
+_.reinit();
+}
+};
+Slick.prototype.setPosition = function() {
+var _ = this;
+_.setDimensions();
+_.setHeight();
+if (_.options.fade === false) {
+_.setCSS(_.getLeft(_.currentSlide));
+} else {
+_.setFade();
+}
+_.$slider.trigger("setPosition", [ _ ]);
+};
+Slick.prototype.setProps = function() {
+var _ = this,
+bodyStyle = document.body.style;
+_.positionProp = _.options.vertical === true ? 'top' : 'left';
+if (_.positionProp === 'top') {
+_.$slider.addClass('slick-vertical');
+} else {
+_.$slider.removeClass('slick-vertical');
+}
+if (bodyStyle.WebkitTransition !== undefined ||
+bodyStyle.MozTransition !== undefined ||
+bodyStyle.msTransition !== undefined) {
+if(_.options.useCSS === true) {
+_.cssTransitions = true;
+}
+}
+if (bodyStyle.OTransform !== undefined) {
+_.animType = 'OTransform';
+_.transformType = "-o-transform";
+_.transitionType = 'OTransition';
+if (bodyStyle.perspectiveProperty === undefined && bodyStyle.webkitPerspective === undefined) _.animType = false;
+}
+if (bodyStyle.MozTransform !== undefined) {
+_.animType = 'MozTransform';
+_.transformType = "-moz-transform";
+_.transitionType = 'MozTransition';
+if (bodyStyle.perspectiveProperty === undefined && bodyStyle.MozPerspective === undefined) _.animType = false;
+}
+if (bodyStyle.webkitTransform !== undefined) {
+_.animType = 'webkitTransform';
+_.transformType = "-webkit-transform";
+_.transitionType = 'webkitTransition';
+if (bodyStyle.perspectiveProperty === undefined && bodyStyle.webkitPerspective === undefined) _.animType = false;
+}
+if (bodyStyle.msTransform !== undefined) {
+_.animType = 'msTransform';
+_.transformType = "-ms-transform";
+_.transitionType = 'msTransition';
+if (bodyStyle.msTransform === undefined) _.animType = false;
+}
+if (bodyStyle.transform !== undefined && _.animType !== false) {
+_.animType = 'transform';
+_.transformType = "transform";
+_.transitionType = 'transition';
+}
+_.transformsEnabled = (_.animType !== null && _.animType !== false);
+};
+Slick.prototype.setSlideClasses = function(index) {
+var _ = this,
+centerOffset, allSlides, indexOffset, remainder;
+_.$slider.find('.slick-slide').removeClass('slick-active').removeClass('slick-center');
+allSlides = _.$slider.find('.slick-slide');
+if (_.options.centerMode === true) {
+centerOffset = Math.floor(_.options.slidesToShow / 2);
+if(_.options.infinite === true) {
+if (index >= centerOffset && index <= (_.slideCount - 1) - centerOffset) {
+_.$slides.slice(index - centerOffset, index + centerOffset + 1).addClass('slick-active');
+} else {
+indexOffset = _.options.slidesToShow + index;
+allSlides.slice(indexOffset - centerOffset + 1, indexOffset + centerOffset + 2).addClass('slick-active');
+}
+if (index === 0) {
+allSlides.eq(allSlides.length - 1 - _.options.slidesToShow).addClass('slick-center');
+} else if (index === _.slideCount - 1) {
+allSlides.eq(_.options.slidesToShow).addClass('slick-center');
+}
+}
+_.$slides.eq(index).addClass('slick-center');
+} else {
+if (index >= 0 && index <= (_.slideCount - _.options.slidesToShow)) {
+_.$slides.slice(index, index + _.options.slidesToShow).addClass('slick-active');
+} else if ( allSlides.length <= _.options.slidesToShow ) {
+allSlides.addClass('slick-active');
+} else {
+remainder = _.slideCount%_.options.slidesToShow;
+indexOffset = _.options.infinite === true ? _.options.slidesToShow + index : index;
+if(_.options.slidesToShow == _.options.slidesToScroll && (_.slideCount - index) < _.options.slidesToShow) {
+allSlides.slice(indexOffset-(_.options.slidesToShow-remainder), indexOffset + remainder).addClass('slick-active');
+} else {
+allSlides.slice(indexOffset, indexOffset + _.options.slidesToShow).addClass('slick-active');
+}
+}
+}
+if (_.options.lazyLoad === 'ondemand') {
+_.lazyLoad();
+}
+};
+Slick.prototype.setupInfinite = function() {
+var _ = this,
+i, slideIndex, infiniteCount;
+if (_.options.fade === true) {
+_.options.centerMode = false;
+}
+if (_.options.infinite === true && _.options.fade === false) {
+slideIndex = null;
+if (_.slideCount > _.options.slidesToShow) {
+if (_.options.centerMode === true) {
+infiniteCount = _.options.slidesToShow + 1;
+} else {
+infiniteCount = _.options.slidesToShow;
+}
+for (i = _.slideCount; i > (_.slideCount -
+infiniteCount); i -= 1) {
+slideIndex = i - 1;
+$(_.$slides[slideIndex]).clone(true).attr('id', '')
+.attr('data-slick-index', slideIndex-_.slideCount)
+.prependTo(_.$slideTrack).addClass('slick-cloned');
+}
+for (i = 0; i < infiniteCount; i += 1) {
+slideIndex = i;
+$(_.$slides[slideIndex]).clone(true).attr('id', '')
+.attr('data-slick-index', slideIndex+_.slideCount)
+.appendTo(_.$slideTrack).addClass('slick-cloned');
+}
+_.$slideTrack.find('.slick-cloned').find('[id]').each(function() {
+$(this).attr('id', '');
+});
+}
+}
+};
+Slick.prototype.selectHandler = function(event) {
+var _ = this;
+var index = parseInt($(event.target).parents('.slick-slide').attr("data-slick-index"));
+if(!index) index = 0;
+if(_.slideCount <= _.options.slidesToShow){
+_.$slider.find('.slick-slide').removeClass('slick-active');
+_.$slides.eq(index).addClass('slick-active');
+if(_.options.centerMode === true) {
+_.$slider.find('.slick-slide').removeClass('slick-center');
+_.$slides.eq(index).addClass('slick-center');
+}
+_.asNavFor(index);
+return;
+}
+_.slideHandler(index);
+};
+Slick.prototype.slideHandler = function(index,sync,dontAnimate) {
+var targetSlide, animSlide, oldSlide, slideLeft, targetLeft = null,
+_ = this;
+sync = sync || false;
+if (_.animating === true && _.options.waitForAnimate === true) {
+return;
+}
+if (_.options.fade === true && _.currentSlide === index) {
+return;
+}
+if (_.slideCount <= _.options.slidesToShow) {
+return;
+}
+if (sync === false) {
+_.asNavFor(index);
+}
+targetSlide = index;
+targetLeft = _.getLeft(targetSlide);
+slideLeft = _.getLeft(_.currentSlide);
+_.currentLeft = _.swipeLeft === null ? slideLeft : _.swipeLeft;
+if (_.options.infinite === false && _.options.centerMode === false && (index < 0 || index > _.getDotCount() * _.options.slidesToScroll)) {
+if(_.options.fade === false) {
+targetSlide = _.currentSlide;
+if(dontAnimate!==true) {
+_.animateSlide(slideLeft, function() {
+_.postSlide(targetSlide);
+});
+} else {
+_.postSlide(targetSlide);
+}
+}
+return;
+} else if (_.options.infinite === false && _.options.centerMode === true && (index < 0 || index > (_.slideCount - _.options.slidesToScroll))) {
+if(_.options.fade === false) {
+targetSlide = _.currentSlide;
+if(dontAnimate!==true) {
+_.animateSlide(slideLeft, function() {
+_.postSlide(targetSlide);
+});
+} else {
+_.postSlide(targetSlide);
+}
+}
+return;
+}
+if (_.options.autoplay === true) {
+clearInterval(_.autoPlayTimer);
+}
+if (targetSlide < 0) {
+if (_.slideCount % _.options.slidesToScroll !== 0) {
+animSlide = _.slideCount - (_.slideCount % _.options.slidesToScroll);
+} else {
+animSlide = _.slideCount + targetSlide;
+}
+} else if (targetSlide >= _.slideCount) {
+if (_.slideCount % _.options.slidesToScroll !== 0) {
+animSlide = 0;
+} else {
+animSlide = targetSlide - _.slideCount;
+}
+} else {
+animSlide = targetSlide;
+}
+_.animating = true;
+_.$slider.trigger("beforeChange", [ _ , _.currentSlide, animSlide]);
+oldSlide = _.currentSlide;
+_.currentSlide = animSlide;
+_.setSlideClasses(_.currentSlide);
+_.updateDots();
+_.updateArrows();
+if (_.options.fade === true) {
+if(dontAnimate!==true) {
+_.fadeSlide(animSlide, function() {
+_.postSlide(animSlide);
+});
+} else {
+_.postSlide(animSlide);
+}
+_.animateHeight();
+return;
+}
+if(dontAnimate!==true) {
+_.animateSlide(targetLeft, function() {
+_.postSlide(animSlide);
+});
+} else {
+_.postSlide(animSlide);
+}
+};
+Slick.prototype.startLoad = function() {
+var _ = this;
+if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {
+_.$prevArrow.hide();
+_.$nextArrow.hide();
+}
+if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {
+_.$dots.hide();
+}
+_.$slider.addClass('slick-loading');
+};
+Slick.prototype.swipeDirection = function() {
+var xDist, yDist, r, swipeAngle, _ = this;
+xDist = _.touchObject.startX - _.touchObject.curX;
+yDist = _.touchObject.startY - _.touchObject.curY;
+r = Math.atan2(yDist, xDist);
+swipeAngle = Math.round(r * 180 / Math.PI);
+if (swipeAngle < 0) {
+swipeAngle = 360 - Math.abs(swipeAngle);
+}
+if ((swipeAngle <= 45) && (swipeAngle >= 0)) {
+return (_.options.rtl === false ? 'left' : 'right');
+}
+if ((swipeAngle <= 360) && (swipeAngle >= 315)) {
+return (_.options.rtl === false ? 'left' : 'right');
+}
+if ((swipeAngle >= 135) && (swipeAngle <= 225)) {
+return (_.options.rtl === false ? 'right' : 'left');
+}
+return 'vertical';
+};
+Slick.prototype.swipeEnd = function(event) {
+var _ = this, slideCount;
+_.dragging = false;
+_.shouldClick = (_.touchObject.swipeLength > 10) ? false : true;
+if (_.touchObject.curX === undefined) {
+return false;
+}
+if (_.touchObject.edgeHit === true) {
+_.$slider.trigger("edge", [ _, _.swipeDirection()]);
+}
+if (_.touchObject.swipeLength >= _.touchObject.minSwipe) {
+switch (_.swipeDirection()) {
+case 'left':
+slideCount = _.options.swipeToSlide ? _.checkNavigable(_.currentSlide + _.getSlideCount()) : _.currentSlide + _.getSlideCount();
+_.slideHandler(slideCount);
+_.currentDirection = 0;
+_.touchObject = {};
+_.$slider.trigger("swipe", [ _, "left"]);
+break;
+case 'right':
+slideCount = _.options.swipeToSlide ? _.checkNavigable(_.currentSlide - _.getSlideCount()) : _.currentSlide - _.getSlideCount();
+_.slideHandler(slideCount);
+_.currentDirection = 1;
+_.touchObject = {};
+_.$slider.trigger("swipe", [ _, "right"]);
+break;
+}
+} else {
+if(_.touchObject.startX !== _.touchObject.curX) {
+_.slideHandler(_.currentSlide);
+_.touchObject = {};
+}
+}
+};
+Slick.prototype.swipeHandler = function(event) {
+var _ = this;
+if ((_.options.swipe === false) || ('ontouchend' in document && _.options.swipe === false)) {
+return;
+} else if (_.options.draggable === false && event.type.indexOf('mouse') !== -1) {
+return;
+}
+_.touchObject.fingerCount = event.originalEvent && event.originalEvent.touches !== undefined ?
+event.originalEvent.touches.length : 1;
+_.touchObject.minSwipe = _.listWidth / _.options
+.touchThreshold;
+switch (event.data.action) {
+case 'start':
+_.swipeStart(event);
+break;
+case 'move':
+_.swipeMove(event);
+break;
+case 'end':
+_.swipeEnd(event);
+break;
+}
+};
+Slick.prototype.swipeMove = function(event) {
+var _ = this,
+edgeWasHit = false,
+curLeft, swipeDirection, swipeLength, positionOffset, touches;
+touches = event.originalEvent !== undefined ? event.originalEvent.touches : null;
+if (!_.dragging || touches && touches.length !== 1) {
+return false;
+}
+curLeft = _.getLeft(_.currentSlide);
+_.touchObject.curX = touches !== undefined ? touches[0].pageX : event.clientX;
+_.touchObject.curY = touches !== undefined ? touches[0].pageY : event.clientY;
+_.touchObject.swipeLength = Math.round(Math.sqrt(
+Math.pow(_.touchObject.curX - _.touchObject.startX, 2)));
+swipeDirection = _.swipeDirection();
+if (swipeDirection === 'vertical') {
+return;
+}
+if (event.originalEvent !== undefined && _.touchObject.swipeLength > 4) {
+event.preventDefault();
+}
+positionOffset = (_.options.rtl === false ? 1 : -1) * (_.touchObject.curX > _.touchObject.startX ? 1 : -1);
+swipeLength = _.touchObject.swipeLength;
+_.touchObject.edgeHit = false;
+if (_.options.infinite === false) {
+if ((_.currentSlide === 0 && swipeDirection === "right") || (_.currentSlide >= _.getDotCount() && swipeDirection === "left")) {
+swipeLength = _.touchObject.swipeLength * _.options.edgeFriction;
+_.touchObject.edgeHit = true;
+}
+}
+if (_.options.vertical === false) {
+_.swipeLeft = curLeft + swipeLength * positionOffset;
+} else {
+_.swipeLeft = curLeft + (swipeLength * (_.$list.height() / _.listWidth)) * positionOffset;
+}
+if (_.options.fade === true || _.options.touchMove === false) {
+return false;
+}
+if (_.animating === true) {
+_.swipeLeft = null;
+return false;
+}
+_.setCSS(_.swipeLeft);
+};
+Slick.prototype.swipeStart = function(event) {
+var _ = this,
+touches;
+if (_.touchObject.fingerCount !== 1 || _.slideCount <= _.options.slidesToShow) {
+_.touchObject = {};
+return false;
+}
+if (event.originalEvent !== undefined && event.originalEvent.touches !== undefined) {
+touches = event.originalEvent.touches[0];
+}
+_.touchObject.startX = _.touchObject.curX = touches !== undefined ? touches.pageX : event.clientX;
+_.touchObject.startY = _.touchObject.curY = touches !== undefined ? touches.pageY : event.clientY;
+_.dragging = true;
+};
+Slick.prototype.unfilterSlides = Slick.prototype.slickUnfilter = function() {
+var _ = this;
+if (_.$slidesCache !== null) {
+_.unload();
+_.$slideTrack.children(this.options.slide).detach();
+_.$slidesCache.appendTo(_.$slideTrack);
+_.reinit();
+}
+};
+Slick.prototype.unload = function() {
+var _ = this;
+$('.slick-cloned', _.$slider).remove();
+if (_.$dots) {
+_.$dots.remove();
+}
+if (_.$prevArrow && (typeof _.options.prevArrow !== 'object')) {
+_.$prevArrow.remove();
+}
+if (_.$nextArrow && (typeof _.options.nextArrow !== 'object')) {
+_.$nextArrow.remove();
+}
+_.$slides.removeClass(
+'slick-slide slick-active slick-visible').css('width', '');
+};
+Slick.prototype.unslick = function() {
+var _ = this;
+_.destroy();
+};
+Slick.prototype.updateArrows = function() {
+var _ = this, centerOffset;
+centerOffset = Math.floor(_.options.slidesToShow / 2);
+if (_.options.arrows === true && _.options.infinite !==
+true && _.slideCount > _.options.slidesToShow) {
+_.$prevArrow.removeClass('slick-disabled');
+_.$nextArrow.removeClass('slick-disabled');
+if (_.currentSlide === 0) {
+_.$prevArrow.addClass('slick-disabled');
+_.$nextArrow.removeClass('slick-disabled');
+} else if (_.currentSlide >= _.slideCount - _.options.slidesToShow && _.options.centerMode === false) {
+_.$nextArrow.addClass('slick-disabled');
+_.$prevArrow.removeClass('slick-disabled');
+} else if (_.currentSlide >= _.slideCount - 1 && _.options.centerMode === true) {
+_.$nextArrow.addClass('slick-disabled');
+_.$prevArrow.removeClass('slick-disabled');
+}
+}
+};
+Slick.prototype.updateDots = function() {
+var _ = this;
+if (_.$dots !== null) {
+_.$dots.find('li').removeClass('slick-active');
+_.$dots.find('li').eq(Math.floor(_.currentSlide / _.options.slidesToScroll)).addClass('slick-active');
+}
+};
+Slick.prototype.visibility = function() {
+var _ = this;
+if( document[ _.hidden ] ) {
+_.paused = true;
+_.autoPlayClear();
+} else {
+_.paused = false;
+_.autoPlay();
+}
+};
+$.fn.slick = function() {
+var _ = this, opt = arguments[0], args = Array.prototype.slice.call(arguments,1), l = _.length, i = 0, ret;
+for(i; i < l; i++) {
+if (typeof opt == 'object' || typeof opt == 'undefined')
+_[i].slick = new Slick(_[i], opt);
+else
+ret = _[i].slick[opt].apply(_[i].slick, args);
+if (typeof ret != 'undefined') return ret;
+}
+return _;
+};
+$(function(){
+$('[data-slick]').slick();
+});
+}));
@@ -205,8 +219,8 @@