From fad2495d22459c9d4a1218553d2dc42aedc831af Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Albin=20S=C3=B6derqvist?= Date: Thu, 19 Feb 2015 13:55:36 +0100 Subject: [PATCH 1/3] Add license information for LibreJS compatibility. --- gh-pages-files/index.css | 2 + index.html | 318 ++++++++++++++++++++------------------- jslicense.html | 64 ++++++++ 3 files changed, 233 insertions(+), 151 deletions(-) create mode 100644 jslicense.html diff --git a/gh-pages-files/index.css b/gh-pages-files/index.css index 60ad9d96c..ee3be6525 100755 --- a/gh-pages-files/index.css +++ b/gh-pages-files/index.css @@ -119,6 +119,7 @@ footer h5 { font-size:74px; margin-bottom:60px; color:#00bed5; text-transform:up footer p { font-family:amatic_scregular, sans-serif; font-size:32px; text-transform:uppercase; letter-spacing:2px; } footer img { display:inline-block; } footer a { text-decoration:underline; color:#000; } +footer small { display: inline-block; margin-top: 20px; font-family:roboto, sans-serif; font-size: 11px; text-transform: none; } @media screen and (max-width: 1199px) { @@ -158,3 +159,4 @@ footer a { text-decoration:underline; color:#000; } } } + diff --git a/index.html b/index.html index 5ace46529..915efa66e 100755 --- a/index.html +++ b/index.html @@ -1,14 +1,28 @@ - - + Angular Schema Form - - - - - + + + + + + + + + + + + + + + + + + + + @@ -73,7 +87,7 @@

What is it?

Bootstrap 3 ready forms from a JSON Schema.

-

+

@@ -154,7 +168,7 @@
Check out
the demo
page for more
examples
- Demo + Demo
@@ -209,161 +223,163 @@

{{::addon.name}}

- - - - - - - - - - - - - - - - + + + + + + + + + + + - - + + - - + + + // Filter for nice json output. + }).filter('prettyjson', function() { + return function(input) { + return JSON.stringify(input, undefined, 2); + }; + }); + // @license-end + diff --git a/jslicense.html b/jslicense.html new file mode 100644 index 000000000..079255df3 --- /dev/null +++ b/jslicense.html @@ -0,0 +1,64 @@ + + + + + textalk.github.io/angular-schema-form - JavaScript License Information + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
jquery-1.11.2.min.jsExpatjquery-1.11.2.js
jquery-migrate-1.2.1.min.jsExpatjquery-migrate-1.2.1.js
highlight.min.jsBSD 3 Clausehighlight.js
tv4.jsPublic Domaintv4.js
angular.min.jsExpatangular.js
angular-sanitize.min.jsExpatangular-sanitize.js
ObjectPath.jsExpatangular.js
schema-form.min.jsExpatschema-form.js
bootstrap-decorator.min.jsExpatbootstrap-decorator.js
slick.min.jsExpatslick.js
+ + + From c5eac1ecbcf798e847bb9bdcf964a2576332bee5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Albin=20S=C3=B6derqvist?= Date: Thu, 19 Feb 2015 14:31:31 +0100 Subject: [PATCH 2/3] Remove the title element. --- jslicense.html | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/jslicense.html b/jslicense.html index 079255df3..c00768e9c 100644 --- a/jslicense.html +++ b/jslicense.html @@ -9,12 +9,12 @@ - + - + @@ -30,32 +30,32 @@ - + - + - + - + - + - +
jquery-1.11.2.min.jsExpatExpat jquery-1.11.2.js
jquery-migrate-1.2.1.min.jsExpatExpat jquery-migrate-1.2.1.js
angular.min.jsExpatExpat angular.js
angular-sanitize.min.jsExpatExpat angular-sanitize.js
ObjectPath.jsExpatExpat angular.js
schema-form.min.jsExpatExpat schema-form.js
bootstrap-decorator.min.jsExpatExpat bootstrap-decorator.js
slick.min.jsExpatExpat slick.js
From 4d47246811954c4b41ce3526c1c000bf0161a8d5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Albin=20S=C3=B6derqvist?= Date: Fri, 20 Feb 2015 17:06:54 +0100 Subject: [PATCH 3/3] Add js source files. --- jslicense.html | 11 +- src/highlight.js | 656 +++++++++++++++++++ src/slick.js | 1580 ++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 2244 insertions(+), 3 deletions(-) create mode 100644 src/highlight.js create mode 100644 src/slick.js diff --git a/jslicense.html b/jslicense.html index 1930af872..4d466f2fd 100644 --- a/jslicense.html +++ b/jslicense.html @@ -21,7 +21,7 @@ highlight.min.js BSD 3 Clause - highlight.js + highlight.js tv4.js @@ -56,12 +56,17 @@ bootstrap-decorator.min.js Expat - bootstrap-decorator.js + bootstrap-decorator.js slick.min.js Expat - slick.js + slick.js + + + jquery-2.1.1.min.js + Expat + jquery-2.1.1.js 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(); +}); +}));