https://britlitblog.com/script/ZghxzrJKuXWUIqI/kJulVb-VP4jbzUTf1u8…1vcRkUoCO2-IzUJl3t3bS9sej8-vh0NrvgDvkB8T.js

1/* Detect-zoom
2 * -----------
3 * Cross Browser Zoom and Pixel Ratio Detector
4 * Version 1.0.4 | Apr 1 2013
5 * dual-licensed under the WTFPL and MIT license
6 * Maintained by https://github/tombigel
7 * Original developer https://github.com/yonran
8 */
9
10//AMD and CommonJS initialization copied from https://github.com/zohararad/audio5js
11(function (root, ns, factory) {
12    "use strict";
13
14    if (typeof (module) !== 'undefined' && module.exports) { // CommonJS
15        module.exports = factory(ns, root);
16    } else if (typeof (define) === 'function' && define.amd) { // AMD
17        define("factory", function () {
18            return factory(ns, root);
19        });
20    } else {
21        root[ns] = factory(ns, root);
22    }
23
24}(window, 'detectZoom', function () {
25
26    /**
27     * Use devicePixelRatio if supported by the browser
28     * @return {Number}
29     * @private
30     */
31    var devicePixelRatio = function () {
32        return window.devicePixelRatio || 1;
33    };
34
35    /**
36     * Fallback function to set default values
37     * @return {Object}
38     * @private
39     */
40    var fallback = function () {
41        return {
42            zoom: 1,
43            devicePxPerCssPx: 1
44        };
45    };
46    /**
47     * IE 8 and 9: no trick needed!
48     * TODO: Test on IE10 and Windows 8 RT
49     * @return {Object}
50     * @private
51     **/
52    var ie8 = function () {
53        var zoom = Math.round((screen.deviceXDPI / screen.logicalXDPI) * 100) / 100;
54        return {
55            zoom: zoom,
56            devicePxPerCssPx: zoom * devicePixelRatio()
57        };
58    };
59
60    /**
61     * For IE10 we need to change our technique again...
62     * thanks https://github.com/stefanvanburen
63     * @return {Object}
64     * @private
65     */
66    var ie10 = function () {
67        var zoom = Math.round((document.documentElement.offsetHeight / window.innerHeight) * 100) / 100;
68        return {
69            zoom: zoom,
70            devicePxPerCssPx: zoom * devicePixelRatio()
71        };
72    };
73
74    /**
75     * Mobile WebKit
76     * the trick: window.innerWIdth is in CSS pixels, while
77     * screen.width and screen.height are in system pixels.
78     * And there are no scrollbars to mess up the measurement.
79     * @return {Object}
80     * @private
81     */
82    var webkitMobile = function () {
83        var deviceWidth = (Math.abs(window.orientation) == 90) ? screen.height : screen.width;
84        var zoom = deviceWidth / window.innerWidth;
85        return {
86            zoom: zoom,
87            devicePxPerCssPx: zoom * devicePixelRatio()
88        };
89    };
90
91    /**
92     * Desktop Webkit
93     * the trick: an element's clientHeight is in CSS pixels, while you can
94     * set its line-height in system pixels using font-size and
95     * -webkit-text-size-adjust:none.
96     * device-pixel-ratio: https://www.webkit.org/blog/55/high-dpi-web-sites/
97     *
98     * Previous trick (used before https://trac.webkit.org/changeset/100847):
99     * documentElement.scrollWidth is in CSS pixels, while
100     * document.width was in system pixels. Note that this is the
101     * layout width of the document, which is slightly different from viewport
102     * because document width does not include scrollbars and might be wider
103     * due to big elements.
104     * @return {Object}
105     * @private
106     */
107    var webkit = function () {
108        var important = function (str) {
109            return str.replace(/;/g, " !important;");
110        };
111
112        var div = document.createElement('div');
113        div.innerHTML = "1<br>2<br>3<br>4<br>5<br>6<br>7<br>8<br>9<br>0";
114        div.setAttribute('style', important('font: 100px/1em sans-serif; -webkit-text-size-adjust: none; text-size-adjust: none; height: auto; width: 1em; padding: 0; overflow: visible;'));
115
116        // The container exists so that the div will be laid out in its own flow
117        // while not impacting the layout, viewport size, or display of the
118        // webpage as a whole.
119        // Add !important and relevant CSS rule resets
120        // so that other rules cannot affect the results.
121        var container = document.createElement('div');
122        container.setAttribute('style', important('width:0; height:0; overflow:hidden; visibility:hidden; position: absolute;'));
123        container.appendChild(div);
124
125        document.body.appendChild(container);
126        var zoom = 1000 / div.clientHeight;
127        zoom = Math.round(zoom * 100) / 100;
128        document.body.removeChild(container);
129
130        return{
131            zoom: zoom,
132            devicePxPerCssPx: zoom * devicePixelRatio()
133        };
134    };
135
136    /**
137     * no real trick; device-pixel-ratio is the ratio of device dpi / css dpi.
138     * (Note that this is a different interpretation than Webkit's device
139     * pixel ratio, which is the ratio device dpi / system dpi).
140     *
141     * Also, for Mozilla, there is no difference between the zoom factor and the device ratio.
142     *
143     * @return {Object}
144     * @private
145     */
146    var firefox4 = function () {
147        var zoom = mediaQueryBinarySearch('min--moz-device-pixel-ratio', '', 0, 10, 20, 0.0001);
148        zoom = Math.round(zoom * 100) / 100;
149        return {
150            zoom: zoom,
151            devicePxPerCssPx: zoom
152        };
153    };
154
155    /**
156     * Firefox 18.x

157     * Mozilla added support for devicePixelRatio to Firefox 18,
158     * but it is affected by the zoom level, so, like in older
159     * Firefox we can't tell if we are in zoom mode or in a device
160     * with a different pixel ratio
161     * @return {Object}
162     * @private
163     */
164    var firefox18 = function () {
165        return {
166            zoom: firefox4().zoom,
167            devicePxPerCssPx: devicePixelRatio()
168        };
169    };
170
171    /**
172     * works starting Opera 11.11
173     * the trick: outerWidth is the viewport width including scrollbars in
174     * system px, while innerWidth is the viewport width including scrollbars
175     * in CSS px
176     * @return {Object}
177     * @private
178     */
179    var opera11 = function () {
180        var zoom = window.top.outerWidth / window.top.innerWidth;
181        zoom = Math.round(zoom * 100) / 100;
182        return {
183            zoom: zoom,
184            devicePxPerCssPx: zoom * devicePixelRatio()
185        };
186    };
187
188    /**
189     * Use a binary search through media queries to find zoom level in Firefox
190     * @param property
191     * @param unit
192     * @param a
193     * @param b
194     * @param maxIter
195     * @param epsilon
196     * @return {Number}
197     */
198    var mediaQueryBinarySearch = function (property, unit, a, b, maxIter, epsilon) {
199        var matchMedia;
200        var head, style, div;
201        if (window.matchMedia) {
202            matchMedia = window.matchMedia;
203        } else {
204            head = document.getElementsByTagName('head')[0];
205            style = document.createElement('style');
206            head.appendChild(style);
207
208            div = document.createElement('div');
209            div.className = 'mediaQueryBinarySearch';
210            div.style.display = 'none';
211            document.body.appendChild(div);
212
213            matchMedia = function (query) {
214                style.sheet.insertRule('@media ' + query + '{.mediaQueryBinarySearch ' + '{text-decoration: underline} }', 0);
215                var matched = getComputedStyle(div, null).textDecoration == 'underline';
216                style.sheet.deleteRule(0);
217                return {matches: matched};
218            };
219        }
220        var ratio = binarySearch(a, b, maxIter);
221        if (div) {
222            head.removeChild(style);
223            document.body.removeChild(div);
224        }
225        return ratio;
226
227        function binarySearch(a, b, maxIter) {
228            var mid = (a + b) / 2;
229            if (maxIter <= 0 || b - a < epsilon) {
230                return mid;
231            }
232            var query = "(" + property + ":" + mid + unit + ")";
233            if (matchMedia(query).matches) {
234                return binarySearch(mid, b, maxIter - 1);
235            } else {
236                return binarySearch(a, mid, maxIter - 1);
237            }
238        }
239    };
240
241    /**
242     * Generate detection function
243     * @private
244     */
245    var detectFunction = (function () {
246        var func = fallback;
247        //IE8+
248        if (!isNaN(screen.logicalXDPI) && !isNaN(screen.systemXDPI)) {
249            func = ie8;
250        }
251        // IE10+ / Touch
252        else if (window.navigator.msMaxTouchPoints) {
253            func = ie10;
254        }
255        //Mobile Webkit
256        else if ('orientation' in window && typeof document.body.style.webkitMarquee === 'string') {
257            func = webkitMobile;
258        }
259        //WebKit
260        else if (typeof document.body.style.webkitMarquee === 'string') {
261            func = webkit;
262        }
263        //Opera
264        else if (navigator.userAgent.indexOf('Opera') >= 0) {
265            func = opera11;
266        }
267        //Last one is Firefox
268        //FF 18.x
269        else if (window.devicePixelRatio) {
270            func = firefox18;
271        }
272        //FF 4.0 - 17.x
273        else if (firefox4().zoom > 0.001) {
274            func = firefox4;
275        }
276
277        return func;
278    }());
279
280
281    return ({
282
283        /**
284         * Ratios.zoom shorthand
285         * @return {Number} Zoom level
286         */
287        zoom: function () {
288            return detectFunction().zoom;
289        },
290
291        /**
292         * Ratios.devicePxPerCssPx shorthand
293         * @return {Number} devicePxPerCssPx level
294         */
295        device: function () {
296            return detectFunction().devicePxPerCssPx;
297        }
298    });
299}));
300
301var wpcom_img_zoomer = {
302        clientHintSupport: {
303                gravatar: false,
304                files: false,
305                photon: false,
306                mshots: false,
307                staticAssets: false,
308                latex: false,
309                imgpress: false,
310        },
311	useHints: false,
312	zoomed: false,
313	timer: null,
314	interval: 1000, // zoom polling interval in millisecond
315
316	// Should we apply width/height attributes to control the image size?
317	imgNeedsSizeAtts: function( img ) {

318		// Do not overwrite existing width/height attributes.
319		if ( img.getAttribute('width') !== null || img.getAttribute('height') !== null )
320			return false;
321		// Do not apply the attributes if the image is already constrained by a parent element.
322		if ( img.width < img.naturalWidth || img.height < img.naturalHeight )
323			return false;
324		return true;
325	},
326
327        hintsFor: function( service ) {
328                if ( this.useHints === false ) {
329                        return false;
330                }
331                if ( this.hints() === false ) {
332                        return false;
333                }
334                if ( typeof this.clientHintSupport[service] === "undefined" ) {
335                        return false;
336                }
337                if ( this.clientHintSupport[service] === true ) {
338                        return true;
339                }
340                return false;
341        },
342
343	hints: function() {
344		try {
345			var chrome = window.navigator.userAgent.match(/\sChrome\/([0-9]+)\.[.0-9]+\s/)
346			if (chrome !== null) {
347				var version = parseInt(chrome[1], 10)
348				if (isNaN(version) === false && version >= 46) {
349					return true
350				}
351			}
352		} catch (e) {
353			return false
354		}
355		return false
356	},
357
358	init: function() {
359		var t = this;
360		try{
361			t.zoomImages();
362			t.timer = setInterval( function() { t.zoomImages(); }, t.interval );
363		}
364		catch(e){
365		}
366	},
367
368	stop: function() {
369		if ( this.timer )
370			clearInterval( this.timer );
371	},
372
373	getScale: function() {
374		var scale = detectZoom.device();
375		// Round up to 1.5 or the next integer below the cap.
376		if      ( scale <= 1.0 ) scale = 1.0;
377		else if ( scale <= 1.5 ) scale = 1.5;
378		else if ( scale <= 2.0 ) scale = 2.0;
379		else if ( scale <= 3.0 ) scale = 3.0;
380		else if ( scale <= 4.0 ) scale = 4.0;
381		else                     scale = 5.0;
382		return scale;
383	},
384
385	shouldZoom: function( scale ) {
386		var t = this;
387		// Do not operate on hidden frames.
388		if ( "innerWidth" in window && !window.innerWidth )
389			return false;
390		// Don't do anything until scale > 1
391		if ( scale == 1.0 && t.zoomed == false )
392			return false;
393		return true;
394	},
395
396	zoomImages: function() {
397		var t = this;
398		var scale = t.getScale();
399		if ( ! t.shouldZoom( scale ) ){
400			return;
401		}
402		t.zoomed = true;
403		// Loop through all the <img> elements on the page.
404		var imgs = document.getElementsByTagName("img");
405
406		for ( var i = 0; i < imgs.length; i++ ) {
407			// Wait for original images to load
408			if ( "complete" in imgs[i] && ! imgs[i].complete )
409				continue;
410
411			// Skip images that have srcset attributes.
412			if ( imgs[i].hasAttribute('srcset') ) {
413				continue;
414			}
415
416			// Skip images that don't need processing.
417			var imgScale = imgs[i].getAttribute("scale");
418			if ( imgScale == scale || imgScale == "0" )
419				continue;
420
421			// Skip images that have already failed at this scale
422			var scaleFail = imgs[i].getAttribute("scale-fail");
423			if ( scaleFail && scaleFail <= scale )
424				continue;
425
426			// Skip images that have no dimensions yet.
427			if ( ! ( imgs[i].width && imgs[i].height ) )
428				continue;
429
430			// Skip images from Lazy Load plugins
431			if ( ! imgScale && imgs[i].getAttribute("data-lazy-src") && (imgs[i].getAttribute("data-lazy-src") !== imgs[i].getAttribute("src")))
432				continue;
433
434			if ( t.scaleImage( imgs[i], scale ) ) {
435				// Mark the img as having been processed at this scale.
436				imgs[i].setAttribute("scale", scale);
437			}
438			else {
439				// Set the flag to skip this image.
440				imgs[i].setAttribute("scale", "0");
441			}
442		}
443	},
444
445	scaleImage: function( img, scale ) {
446		var t = this;
447		var newSrc = img.src;
448
449                var isFiles = false;
450                var isLatex = false;
451                var isPhoton = false;
452
453		// Skip slideshow images
454		if ( img.parentNode.className.match(/slideshow-slide/) )
455			return false;
456
457		// Scale gravatars that have ?s= or ?size=
458		if ( img.src.match( /^https?:\/\/([^\/]*\.)?gravatar\.com\/.+[?&](s|size)=/ ) ) {
459                        if ( this.hintsFor( "gravatar" ) === true ) {
460                                return false;
461                        }
462			newSrc = img.src.replace( /([?&](s|size)=)(\d+)/, function( $0, $1, $2, $3 ) {
463				// Stash the original size
464				var originalAtt = "originals",
465				originalSize = img.getAttribute(originalAtt);
466				if ( originalSize === null ) {
467					originalSize = $3;
468					img.setAttribute(originalAtt, originalSize);
469					if ( t.imgNeedsSizeAtts( img ) ) {
470						// Fix width and height attributes to rendered dimensions.
471						img.width = img.width;

472						img.height = img.height;
473					}
474				}
475				// Get the width/height of the image in CSS pixels
476				var size = img.clientWidth;
477				// Convert CSS pixels to device pixels
478				var targetSize = Math.ceil(img.clientWidth * scale);
479				// Don't go smaller than the original size
480				targetSize = Math.max( targetSize, originalSize );
481				// Don't go larger than the service supports
482				targetSize = Math.min( targetSize, 512 );
483				return $1 + targetSize;
484			});
485		}
486
487		// Scale mshots that have width
488		else if ( img.src.match(/^https?:\/\/([^\/]+\.)*(wordpress|wp)\.com\/mshots\/.+[?&]w=\d+/) ) {
489                        if ( this.hintsFor( "mshots" ) === true ) {
490                                return false;
491                        }
492			newSrc = img.src.replace( /([?&]w=)(\d+)/, function($0, $1, $2) {
493				// Stash the original size
494				var originalAtt = 'originalw', originalSize = img.getAttribute(originalAtt);
495				if ( originalSize === null ) {
496					originalSize = $2;
497					img.setAttribute(originalAtt, originalSize);
498					if ( t.imgNeedsSizeAtts( img ) ) {
499						// Fix width and height attributes to rendered dimensions.
500						img.width = img.width;
501						img.height = img.height;
502					}
503				}
504				// Get the width of the image in CSS pixels
505				var size = img.clientWidth;
506				// Convert CSS pixels to device pixels
507				var targetSize = Math.ceil(size * scale);
508				// Don't go smaller than the original size
509				targetSize = Math.max( targetSize, originalSize );
510				// Don't go bigger unless the current one is actually lacking
511				if ( scale > img.getAttribute("scale") && targetSize <= img.naturalWidth )
512					targetSize = $2;
513				if ( $2 != targetSize )
514					return $1 + targetSize;
515				return $0;
516			});
517
518			// Update height attribute to match width
519			newSrc = newSrc.replace( /([?&]h=)(\d+)/, function($0, $1, $2) {
520				if ( newSrc == img.src ) {
521					return $0;
522				}
523				// Stash the original size
524				var originalAtt = 'originalh', originalSize = img.getAttribute(originalAtt);
525				if ( originalSize === null ) {
526					originalSize = $2;
527					img.setAttribute(originalAtt, originalSize);
528				}
529				// Get the height of the image in CSS pixels
530				var size = img.clientHeight;
531				// Convert CSS pixels to device pixels
532				var targetSize = Math.ceil(size * scale);
533				// Don't go smaller than the original size
534				targetSize = Math.max( targetSize, originalSize );
535				// Don't go bigger unless the current one is actually lacking
536				if ( scale > img.getAttribute("scale") && targetSize <= img.naturalHeight )
537					targetSize = $2;
538				if ( $2 != targetSize )
539					return $1 + targetSize;
540				return $0;
541			});
542		}
543
544		// Scale simple imgpress queries (s0.wp.com) that only specify w/h/fit
545		else if ( img.src.match(/^https?:\/\/([^\/.]+\.)*(wp|wordpress)\.com\/imgpress\?(.+)/) ) {
546                        if ( this.hintsFor( "imgpress" ) === true ) {
547                                return false; 
548                        }
549			var imgpressSafeFunctions = ["zoom", "url", "h", "w", "fit", "filter", "brightness", "contrast", "colorize", "smooth", "unsharpmask"];
550			// Search the query string for unsupported functions.
551			var qs = RegExp.$3.split('&');
552			for ( var q in qs ) {
553				q = qs[q].split('=')[0];
554				if ( imgpressSafeFunctions.indexOf(q) == -1 ) {
555					return false;
556				}
557			}
558			// Fix width and height attributes to rendered dimensions.
559			img.width = img.width;
560			img.height = img.height;
561			// Compute new src
562			if ( scale == 1 )
563				newSrc = img.src.replace(/\?(zoom=[^&]+&)?/, '?');
564			else
565				newSrc = img.src.replace(/\?(zoom=[^&]+&)?/, '?zoom=' + scale + '&');
566		}
567
568		// Scale files.wordpress.com, LaTeX, or Photon images (i#.wp.com)
569		else if (
570			( isFiles = img.src.match(/^https?:\/\/([^\/]+)\.files\.wordpress\.com\/.+[?&][wh]=/) ) ||
571			( isLatex = img.src.match(/^https?:\/\/([^\/.]+\.)*(wp|wordpress)\.com\/latex\.php\?(latex|zoom)=(.+)/) ) ||
572			( isPhoton = img.src.match(/^https?:\/\/i[\d]{1}\.wp\.com\/(.+)/) )
573		) {
574                        if ( false !== isFiles && this.hintsFor( "files" ) === true ) {
575                                return false
576                        }
577                        if ( false !== isLatex && this.hintsFor( "latex" ) === true ) {
578                                return false
579                        }
580                        if ( false !== isPhoton && this.hintsFor( "photon" ) === true ) {
581                                return false
582                        }
583			// Fix width and height attributes to rendered dimensions.
584			img.width = img.width;

585			img.height = img.height;
586			// Compute new src
587			if ( scale == 1 ) {
588				newSrc = img.src.replace(/\?(zoom=[^&]+&)?/, '?');
589			} else {
590				newSrc = img.src;
591
592				var url_var = newSrc.match( /([?&]w=)(\d+)/ );
593				if ( url_var !== null && url_var[2] ) {
594					newSrc = newSrc.replace( url_var[0], url_var[1] + img.width );
595				}
596
597				url_var = newSrc.match( /([?&]h=)(\d+)/ );
598				if ( url_var !== null && url_var[2] ) {
599					newSrc = newSrc.replace( url_var[0], url_var[1] + img.height );
600				}
601
602				var zoom_arg = '&zoom=2';
603				if ( !newSrc.match( /\?/ ) ) {
604					zoom_arg = '?zoom=2';
605				}
606				img.setAttribute( 'srcset', newSrc + zoom_arg + ' ' + scale + 'x' );
607			}
608		}
609
610		// Scale static assets that have a name matching *-1x.png or *@1x.png
611		else if ( img.src.match(/^https?:\/\/[^\/]+\/.*[-@]([12])x\.(gif|jpeg|jpg|png)(\?|$)/) ) {
612                        if ( this.hintsFor( "staticAssets" ) === true ) {
613                                return false; 
614                        }
615			// Fix width and height attributes to rendered dimensions.
616			img.width = img.width;
617			img.height = img.height;
618			var currentSize = RegExp.$1, newSize = currentSize;
619			if ( scale <= 1 )
620				newSize = 1;
621			else
622				newSize = 2;
623			if ( currentSize != newSize )
624				newSrc = img.src.replace(/([-@])[12]x\.(gif|jpeg|jpg|png)(\?|$)/, '$1'+newSize+'x.$2$3');
625		}
626
627		else {
628			return false;
629		}
630
631		// Don't set img.src unless it has changed. This avoids unnecessary reloads.
632		if ( newSrc != img.src ) {
633			// Store the original img.src
634			var prevSrc, origSrc = img.getAttribute("src-orig");
635			if ( !origSrc ) {
636				origSrc = img.src;
637				img.setAttribute("src-orig", origSrc);
638			}
639			// In case of error, revert img.src
640			prevSrc = img.src;
641			img.onerror = function(){
642				img.src = prevSrc;
643				if ( img.getAttribute("scale-fail") < scale )
644					img.setAttribute("scale-fail", scale);
645				img.onerror = null;
646			};
647			// Finally load the new image
648			img.src = newSrc;
649		}
650
651		return true;
652	}
653};
654
655wpcom_img_zoomer.init();
656;
657/* global pm, wpcom_reblog */
658
659var jetpackLikesWidgetQueue = [];
660var jetpackLikesWidgetBatch = [];
661var jetpackLikesMasterReady = false;
662
663function JetpackLikespostMessage( message, target ) {
664	if ( 'string' === typeof message ){
665		try {
666			message = JSON.parse( message );
667		} catch(e) {
668			return;
669		}
670	}
671
672	pm( {
673		target: target,
674		type: 'likesMessage',
675		data: message,
676		origin: '*'
677	} );
678}
679
680function JetpackLikesBatchHandler() {
681	var requests = [];
682	jQuery( 'div.jetpack-likes-widget-unloaded' ).each( function() {
683		if ( jetpackLikesWidgetBatch.indexOf( this.id ) > -1 ) {
684			return;
685		}
686		jetpackLikesWidgetBatch.push( this.id );
687		var regex = /like-(post|comment)-wrapper-(\d+)-(\d+)-(\w+)/,
688			match = regex.exec( this.id ),
689			info;
690
691		if ( ! match || match.length !== 5 ) {
692			return;
693		}
694
695		info = {
696			blog_id: match[2],
697			width:   this.width
698		};
699
700		if ( 'post' === match[1] ) {
701			info.post_id = match[3];
702		} else if ( 'comment' === match[1] ) {
703			info.comment_id = match[3];
704		}
705
706		info.obj_id = match[4];
707
708		requests.push( info );
709	});
710
711	if ( requests.length > 0 ) {
712		JetpackLikespostMessage( { event: 'initialBatch', requests: requests }, window.frames['likes-master'] );
713	}
714}
715
716function JetpackLikesMessageListener( event, message ) {
717	var allowedOrigin, $container, $list, offset, rowLength, height, scrollbarWidth;
718
719	if ( 'undefined' === typeof event.event ) {
720		return;
721	}
722
723	// We only allow messages from one origin
724	allowedOrigin = window.location.protocol + 'https://widgets.wp.com';
725	if ( allowedOrigin !== message.origin ) {
726		return;
727	}
728
729	if ( 'masterReady' === event.event ) {
730		jQuery( document ).ready( function() {
731			jetpackLikesMasterReady = true;
732
733			var stylesData = {
734					event: 'injectStyles'
735				},
736				$sdTextColor = jQuery( '.sd-text-color' ),
737				$sdLinkColor = jQuery( '.sd-link-color' );
738
739			if ( jQuery( 'iframe.admin-bar-likes-widget' ).length > 0 ) {
740				JetpackLikespostMessage( { event: 'adminBarEnabled' }, window.frames[ 'likes-master' ] );
741
742				stylesData.adminBarStyles = {
743					background: jQuery( '#wpadminbar .quicklinks li#wp-admin-bar-wpl-like > a' ).css( 'background' ),

744					isRtl: ( 'rtl' === jQuery( '#wpadminbar' ).css( 'direction' ) )
745				};
746			}
747
748			// enable reblogs if we're on a single post page
749			if ( jQuery( 'body' ).hasClass( 'single' ) ) {
750				JetpackLikespostMessage( { event: 'reblogsEnabled' }, window.frames[ 'likes-master' ] );
751			}
752
753			if ( ! window.addEventListener ) {
754				jQuery( '#wp-admin-bar-admin-bar-likes-widget' ).hide();
755			}
756
757			stylesData.textStyles = {
758				color:          $sdTextColor.css( 'color' ),
759				fontFamily:     $sdTextColor.css( 'font-family' ),
760				fontSize:       $sdTextColor.css( 'font-size' ),
761				direction:      $sdTextColor.css( 'direction' ),
762				fontWeight:     $sdTextColor.css( 'font-weight' ),
763				fontStyle:      $sdTextColor.css( 'font-style' ),
764				textDecoration: $sdTextColor.css('text-decoration')
765			};
766
767			stylesData.linkStyles = {
768				color:          $sdLinkColor.css('color'),
769				fontFamily:     $sdLinkColor.css('font-family'),
770				fontSize:       $sdLinkColor.css('font-size'),
771				textDecoration: $sdLinkColor.css('text-decoration'),
772				fontWeight:     $sdLinkColor.css( 'font-weight' ),
773				fontStyle:      $sdLinkColor.css( 'font-style' )
774			};
775
776			JetpackLikespostMessage( stylesData, window.frames[ 'likes-master' ] );
777
778			JetpackLikesBatchHandler();
779
780			jQuery( document ).on( 'inview', 'div.jetpack-likes-widget-unloaded', function() {
781				jetpackLikesWidgetQueue.push( this.id );
782			});
783		});
784	}
785
786	if ( 'showLikeWidget' === event.event ) {
787		jQuery( '#' + event.id + ' .post-likes-widget-placeholder'  ).fadeOut( 'fast', function() {
788			jQuery( '#' + event.id + ' .post-likes-widget' ).fadeIn( 'fast', function() {
789				JetpackLikespostMessage( { event: 'likeWidgetDisplayed', blog_id: event.blog_id, post_id: event.post_id, obj_id: event.obj_id }, window.frames['likes-master'] );
790			});
791		});
792	}
793
794	if ( 'clickReblogFlair' === event.event ) {
795		wpcom_reblog.toggle_reblog_box_flair( event.obj_id );
796	}
797
798	if ( 'showOtherGravatars' === event.event ) {
799		$container = jQuery( '#likes-other-gravatars' );
800		$list = $container.find( 'ul' );
801
802		$container.hide();
803		$list.html( '' );
804
805		$container.find( '.likes-text span' ).text( event.total );
806
807		jQuery.each( event.likers, function( i, liker ) {
808			var element = jQuery( '<li><a><img /></a></li>' );
809			element.addClass( liker.css_class );
810
811			element.find( 'a' ).
812				attr({
813					href: liker.profile_URL,
814					rel: 'nofollow',
815					target: '_parent'
816				}).
817				addClass( 'wpl-liker' );
818
819			element.find( 'img' ).
820				attr({
821					src: liker.avatar_URL,
822					alt: liker.name
823				}).
824				css({
825					width: '30px',
826					height: '30px',
827					paddingRight: '3px'
828				});
829
830			$list.append( element );
831		} );
832
833		offset = jQuery( '[name=\'' + event.parent + '\']' ).offset();
834
835		$container.css( 'left', offset.left + event.position.left - 10 + 'px' );
836		$container.css( 'top', offset.top + event.position.top - 33 + 'px' );
837
838		rowLength = Math.floor( event.width / 37 );
839		height = ( Math.ceil( event.likers.length / rowLength ) * 37 ) + 13;
840		if ( height > 204 ) {
841			height = 204;
842		}
843
844		$container.css( 'height', height + 'px' );
845		$container.css( 'width', rowLength * 37 - 7 + 'px' );
846
847		$list.css( 'width', rowLength * 37 + 'px' );
848
849		$container.fadeIn( 'slow' );
850
851		scrollbarWidth = $list[0].offsetWidth - $list[0].clientWidth;
852		if ( scrollbarWidth > 0 ) {
853			$container.width( $container.width() + scrollbarWidth );
854			$list.width( $list.width() + scrollbarWidth );
855		}
856	}
857}
858
859pm.bind( 'likesMessage', JetpackLikesMessageListener );
860
861jQuery( document ).click( function( e ) {
862	var $container = jQuery( '#likes-other-gravatars' );
863
864	if ( $container.has( e.target ).length === 0 ) {
865		$container.fadeOut( 'slow' );
866	}
867});
868
869function JetpackLikesWidgetQueueHandler() {
870	var $wrapper, wrapperID, found;
871	if ( ! jetpackLikesMasterReady ) {
872		setTimeout( JetpackLikesWidgetQueueHandler, 500 );
873		return;
874	}
875
876	if ( jetpackLikesWidgetQueue.length > 0 ) {
877		// We may have a widget that needs creating now
878		found = false;
879		while( jetpackLikesWidgetQueue.length > 0 ) {
880			// Grab the first member of the queue that isn't already loading.
881			wrapperID = jetpackLikesWidgetQueue.splice( 0, 1 )[0];
882			if ( jQuery( '#' + wrapperID ).hasClass( 'jetpack-likes-widget-unloaded' ) ) {
883				found = true;
884				break;
885			}
886		}
887		if ( ! found ) {
888			setTimeout( JetpackLikesWidgetQueueHandler, 500 );
889			return;
890		}
891	} else if ( jQuery( 'div.jetpack-likes-widget-unloaded' ).length > 0 ) {
892		// Grab any unloaded widgets for a batch request
893		JetpackLikesBatchHandler();
894
895		// Get the next unloaded widget
896		wrapperID = jQuery( 'div.jetpack-likes-widget-unloaded' ).first()[0].id;
897		if ( ! wrapperID ) {
898			// Everything is currently loaded
899			setTimeout( JetpackLikesWidgetQueueHandler, 500 );
900			return;
901		}
902	}
903
904	if ( 'undefined' === typeof wrapperID ) {
905		setTimeout( JetpackLikesWidgetQueueHandler, 500 );
906		return;
907	}
908
909	$wrapper = jQuery( '#' + wrapperID );

910	$wrapper.find( 'iframe' ).remove();
911
912	if ( $wrapper.hasClass( 'slim-likes-widget' ) ) {
913		$wrapper.find( '.post-likes-widget-placeholder' ).after( '<iframe class="post-likes-widget jetpack-likes-widget" name="' + $wrapper.data( 'name' ) + '" height="22px" width="68px" frameBorder="0" scrolling="no" src="' + $wrapper.data( 'src' ) + '"></iframe>' );
914	} else {
915		$wrapper.find( '.post-likes-widget-placeholder' ).after( '<iframe class="post-likes-widget jetpack-likes-widget" name="' + $wrapper.data( 'name' ) + '" height="55px" width="100%" frameBorder="0" src="' + $wrapper.data( 'src' ) + '"></iframe>' );
916	}
917
918	$wrapper.removeClass( 'jetpack-likes-widget-unloaded' ).addClass( 'jetpack-likes-widget-loading' );
919
920	$wrapper.find( 'iframe' ).load( function( e ) {
921		var $iframe = jQuery( e.target );
922		$wrapper.removeClass( 'jetpack-likes-widget-loading' ).addClass( 'jetpack-likes-widget-loaded' );
923
924		JetpackLikespostMessage( { event: 'loadLikeWidget', name: $iframe.attr( 'name' ), width: $iframe.width(), domain: window.location.hostname }, window.frames[ 'likes-master' ] );
925
926		if ( $wrapper.hasClass( 'slim-likes-widget' ) ) {
927			$wrapper.find( 'iframe' ).Jetpack( 'resizeable' );
928		}
929	});
930	setTimeout( JetpackLikesWidgetQueueHandler, 250 );
931}
932JetpackLikesWidgetQueueHandler();
933;
934/*
935 * Swipe 2.0
936 *
937 * Brad Birdsall
938 * Copyright 2013, MIT License
939 *
940*/
941
942function Swipe(container, options) {
943
944  "use strict";
945
946  // utilities
947  var noop = function() {}; // simple no operation function
948  var offloadFn = function(fn) { setTimeout(fn || noop, 0) }; // offload a functions execution
949  
950  // check browser capabilities
951  var browser = {
952    addEventListener: !!window.addEventListener,
953    touch: ('ontouchstart' in window) || window.DocumentTouch && document instanceof DocumentTouch,
954    transitions: (function(temp) {
955      var props = ['transitionProperty', 'WebkitTransition', 'MozTransition', 'OTransition', 'msTransition'];
956      for ( var i in props ) if (temp.style[ props[i] ] !== undefined) return true;
957      return false;
958    })(document.createElement('swipe'))
959  };
960
961  // quit if no root element
962  if (!container) return;
963  var element = container.children[0];
964  var slides, slidePos, width, length;
965  options = options || {};
966  var index = parseInt(options.startSlide, 10) || 0;
967  var speed = options.speed || 300;
968  options.continuous = options.continuous !== undefined ? options.continuous : true;
969
970  function setup() {
971
972    // cache slides
973    slides = element.children;
974    length = slides.length;
975
976    // set continuous to false if only one slide
977    if (slides.length < 2) options.continuous = false;
978
979    //special case if two slides
980    if (browser.transitions && options.continuous && slides.length < 3) {
981      element.appendChild(slides[0].cloneNode(true));
982      element.appendChild(element.children[1].cloneNode(true));
983      slides = element.children;
984    }
985
986    // create an array to store current positions of each slide
987    slidePos = new Array(slides.length);
988
989    // determine width of each slide
990    width = container.getBoundingClientRect().width || container.offsetWidth;
991
992    element.style.width = (slides.length * width) + 'px';
993
994    // stack elements
995    var pos = slides.length;
996    while(pos--) {
997
998      var slide = slides[pos];
999
1000      slide.style.width = width + 'px';
1001      slide.setAttribute('data-index', pos);
1002
1003      if (browser.transitions) {
1004        slide.style.left = (pos * -width) + 'px';
1005        move(pos, index > pos ? -width : (index < pos ? width : 0), 0);
1006      }
1007
1008    }
1009
1010    // reposition elements before and after index
1011    if (options.continuous && browser.transitions) {
1012      move(circle(index-1), -width, 0);
1013      move(circle(index+1), width, 0);
1014    }
1015
1016    if (!browser.transitions) element.style.left = (index * -width) + 'px';
1017
1018    container.style.visibility = 'visible';
1019
1020  }
1021
1022  function prev() {
1023
1024    if (options.continuous) slide(index-1);
1025    else if (index) slide(index-1);
1026
1027  }
1028
1029  function next() {
1030
1031    if (options.continuous) slide(index+1);
1032    else if (index < slides.length - 1) slide(index+1);
1033
1034  }
1035
1036  function circle(index) {
1037
1038    // a simple positive modulo using slides.length
1039    return (slides.length + (index % slides.length)) % slides.length;
1040
1041  }
1042
1043  function slide(to, slideSpeed) {
1044
1045    // do nothing if already on requested slide
1046    if (index == to) return;
1047    
1048    if (browser.transitions) {
1049
1050      var direction = Math.abs(index-to) / (index-to); // 1: backward, -1: forward
1051
1052      // get the actual position of the slide
1053      if (options.continuous) {
1054        var natural_direction = direction;
1055        direction = -slidePos[circle(to)] / width;
1056
1057        // if going forward but to < index, use to = slides.length + to
1058        // if going backward but to > index, use to = -slides.length + to
1059        if (direction !== natural_direction) to =  -direction * slides.length + to;
1060
1061      }
1062
1063      var diff = Math.abs(index-to) - 1;
1064
1065      // move all the slides between index and to in the right direction
1066      while (diff--) move( circle((to > index ? to : index) - diff - 1), width * direction, 0);
1067            
1068      to = circle(to);
1069
1070      move(index, width * direction, slideSpeed || speed);
1071      move(to, 0, slideSpeed || speed);
1072
1073      if (options.continuous) move(circle(to - direction), -(width * direction), 0); // we need to get the next in place
1074      
1075    } else {     
1076      
1077      to = circle(to);
1078      animate(index * -width, to * -width, slideSpeed || speed);
1079      //no fallback for a circular continuous if the browser does not accept transitions
1080    }
1081
1082    index = to;
1083    offloadFn(options.callback && options.callback(index, slides[index]));
1084  }
1085
1086  function move(index, dist, speed) {
1087
1088    translate(index, dist, speed);
1089    slidePos[index] = dist;
1090
1091  }
1092
1093  function translate(index, dist, speed) {
1094
1095    var slide = slides[index];
1096    var style = slide && slide.style;
1097
1098    if (!style) return;
1099
1100    style.webkitTransitionDuration = 
1101    style.MozTransitionDuration = 
1102    style.msTransitionDuration = 
1103    style.OTransitionDuration = 
1104    style.transitionDuration = speed + 'ms';
1105
1106    style.webkitTransform = 'translate(' + dist + 'px,0)' + 'translateZ(0)';
1107    style.msTransform = 
1108    style.MozTransform = 
1109    style.OTransform = 'translateX(' + dist + 'px)';
1110
1111  }
1112
1113  function animate(from, to, speed) {
1114
1115    // if not an animation, just reposition
1116    if (!speed) {
1117
1118      element.style.left = to + 'px';
1119      return;
1120
1121    }
1122    
1123    var start = +new Date;
1124    
1125    var timer = setInterval(function() {
1126
1127      var timeElap = +new Date - start;
1128      
1129      if (timeElap > speed) {
1130
1131        element.style.left = to + 'px';
1132
1133        if (delay) begin();
1134
1135        options.transitionEnd && options.transitionEnd.call(event, index, slides[index]);
1136
1137        clearInterval(timer);
1138        return;
1139
1140      }
1141
1142      element.style.left = (( (to - from) * (Math.floor((timeElap / speed) * 100) / 100) ) + from) + 'px';
1143
1144    }, 4);
1145
1146  }
1147
1148  // setup auto slideshow

1149  var delay = options.auto || 0;
1150  var interval;
1151
1152  function begin() {
1153
1154    interval = setTimeout(next, delay);
1155
1156  }
1157
1158  function stop() {
1159
1160    delay = 0;
1161    clearTimeout(interval);
1162
1163  }
1164
1165
1166  // setup initial vars
1167  var start = {};
1168  var delta = {};
1169  var isScrolling;      
1170
1171  // setup event capturing
1172  var events = {
1173
1174    handleEvent: function(event) {
1175
1176      switch (event.type) {
1177        case 'touchstart': this.start(event); break;
1178        case 'touchmove': this.move(event); break;
1179        case 'touchend': offloadFn(this.end(event)); break;
1180        case 'webkitTransitionEnd':
1181        case 'msTransitionEnd':
1182        case 'oTransitionEnd':
1183        case 'otransitionend':
1184        case 'transitionend': offloadFn(this.transitionEnd(event)); break;
1185        case 'resize': offloadFn(setup.call()); break;
1186      }
1187
1188      if (options.stopPropagation) event.stopPropagation();
1189
1190    },
1191    start: function(event) {
1192
1193      var touches = event.touches[0];
1194
1195      // measure start values
1196      start = {
1197
1198        // get initial touch coords
1199        x: touches.pageX,
1200        y: touches.pageY,
1201
1202        // store time to determine touch duration
1203        time: +new Date
1204
1205      };
1206      
1207      // used for testing first move event
1208      isScrolling = undefined;
1209
1210      // reset delta and end measurements
1211      delta = {};
1212
1213      // attach touchmove and touchend listeners
1214      element.addEventListener('touchmove', this, false);
1215      element.addEventListener('touchend', this, false);
1216
1217    },
1218    move: function(event) {
1219
1220      // ensure swiping with one touch and not pinching
1221      if ( event.touches.length > 1 || event.scale && event.scale !== 1) return
1222
1223      if (options.disableScroll) event.preventDefault();
1224
1225      var touches = event.touches[0];
1226
1227      // measure change in x and y
1228      delta = {
1229        x: touches.pageX - start.x,
1230        y: touches.pageY - start.y
1231      }
1232
1233      // determine if scrolling test has run - one time test
1234      if ( typeof isScrolling == 'undefined') {
1235        isScrolling = !!( isScrolling || Math.abs(delta.x) < Math.abs(delta.y) );
1236      }
1237
1238      // if user is not trying to scroll vertically
1239      if (!isScrolling) {
1240
1241        // prevent native scrolling 
1242        event.preventDefault();
1243
1244        // stop slideshow
1245        stop();
1246
1247        // increase resistance if first or last slide
1248        if (options.continuous) { // we don't add resistance at the end
1249
1250          translate(circle(index-1), delta.x + slidePos[circle(index-1)], 0);
1251          translate(index, delta.x + slidePos[index], 0);
1252          translate(circle(index+1), delta.x + slidePos[circle(index+1)], 0);
1253
1254        } else {
1255
1256          delta.x = 
1257            delta.x / 
1258              ( (!index && delta.x > 0               // if first slide and sliding left
1259                || index == slides.length - 1        // or if last slide and sliding right
1260                && delta.x < 0                       // and if sliding at all
1261              ) ?                      
1262              ( Math.abs(delta.x) / width + 1 )      // determine resistance level
1263              : 1 );                                 // no resistance if false
1264          
1265          // translate 1:1
1266          translate(index-1, delta.x + slidePos[index-1], 0);
1267          translate(index, delta.x + slidePos[index], 0);
1268          translate(index+1, delta.x + slidePos[index+1], 0);
1269        }
1270
1271      }
1272
1273    },
1274    end: function(event) {
1275
1276      // measure duration
1277      var duration = +new Date - start.time;
1278
1279      // determine if slide attempt triggers next/prev slide
1280      var isValidSlide = 
1281            Number(duration) < 250               // if slide duration is less than 250ms
1282            && Math.abs(delta.x) > 20            // and if slide amt is greater than 20px
1283            || Math.abs(delta.x) > width/2;      // or if slide amt is greater than half the width
1284
1285      // determine if slide attempt is past start and end
1286      var isPastBounds = 
1287            !index && delta.x > 0                            // if first slide and slide amt is greater than 0
1288            || index == slides.length - 1 && delta.x < 0;    // or if last slide and slide amt is less than 0
1289
1290      if (options.continuous) isPastBounds = false;

1291      
1292      // determine direction of swipe (true:right, false:left)
1293      var direction = delta.x < 0;
1294
1295      // if not scrolling vertically
1296      if (!isScrolling) {
1297
1298        if (isValidSlide && !isPastBounds) {
1299
1300          if (direction) {
1301
1302            if (options.continuous) { // we need to get the next in this direction in place
1303
1304              move(circle(index-1), -width, 0);
1305              move(circle(index+2), width, 0);
1306
1307            } else {
1308              move(index-1, -width, 0);
1309            }
1310
1311            move(index, slidePos[index]-width, speed);
1312            move(circle(index+1), slidePos[circle(index+1)]-width, speed);
1313            index = circle(index+1);  
1314                      
1315          } else {
1316            if (options.continuous) { // we need to get the next in this direction in place
1317
1318              move(circle(index+1), width, 0);
1319              move(circle(index-2), -width, 0);
1320
1321            } else {
1322              move(index+1, width, 0);
1323            }
1324
1325            move(index, slidePos[index]+width, speed);
1326            move(circle(index-1), slidePos[circle(index-1)]+width, speed);
1327            index = circle(index-1);
1328
1329          }
1330
1331          options.callback && options.callback(index, slides[index]);
1332
1333        } else {
1334
1335          if (options.continuous) {
1336
1337            move(circle(index-1), -width, speed);
1338            move(index, 0, speed);
1339            move(circle(index+1), width, speed);
1340
1341          } else {
1342
1343            move(index-1, -width, speed);
1344            move(index, 0, speed);
1345            move(index+1, width, speed);
1346          }
1347
1348        }
1349
1350      }
1351
1352      // kill touchmove and touchend event listeners until touchstart called again
1353      element.removeEventListener('touchmove', events, false)
1354      element.removeEventListener('touchend', events, false)
1355
1356    },
1357    transitionEnd: function(event) {
1358
1359      if (parseInt(event.target.getAttribute('data-index'), 10) == index) {
1360        
1361        if (delay) begin();
1362
1363        options.transitionEnd && options.transitionEnd.call(event, index, slides[index]);
1364
1365      }
1366
1367    }
1368
1369  }
1370
1371  // trigger setup
1372  setup();
1373
1374  // start auto slideshow if applicable
1375  if (delay) begin();
1376
1377
1378  // add event listeners
1379  if (browser.addEventListener) {
1380    
1381    // set touchstart event on element    
1382    if (browser.touch) element.addEventListener('touchstart', events, false);
1383
1384    if (browser.transitions) {
1385      element.addEventListener('webkitTransitionEnd', events, false);
1386      element.addEventListener('msTransitionEnd', events, false);
1387      element.addEventListener('oTransitionEnd', events, false);
1388      element.addEventListener('otransitionend', events, false);
1389      element.addEventListener('transitionend', events, false);
1390    }
1391
1392    // set resize event on window
1393    window.addEventListener('resize', events, false);
1394
1395  } else {
1396
1397    window.onresize = function () { setup() }; // to play nice with old IE
1398
1399  }
1400
1401  // expose the Swipe API
1402  return {
1403    setup: function() {
1404
1405      setup();
1406
1407    },
1408    slide: function(to, speed) {
1409      
1410      // cancel slideshow
1411      stop();
1412      
1413      slide(to, speed);
1414
1415    },
1416    prev: function() {
1417
1418      // cancel slideshow
1419      stop();
1420
1421      prev();
1422
1423    },
1424    next: function() {
1425
1426      // cancel slideshow
1427      stop();
1428
1429      next();
1430
1431    },
1432    getPos: function() {
1433
1434      // return current index position
1435      return index;
1436
1437    },
1438    getNumSlides: function() {
1439      
1440      // return total number of slides
1441      return length;
1442    },
1443    kill: function() {
1444
1445      // cancel slideshow
1446      stop();
1447
1448      // reset element
1449      element.style.width = 'auto';
1450      element.style.left = 0;
1451
1452      // reset slides
1453      var pos = slides.length;
1454      while(pos--) {
1455
1456        var slide = slides[pos];
1457        slide.style.width = '100%';
1458        slide.style.left = 0;
1459
1460        if (browser.transitions) translate(pos, 0, 0);
1461
1462      }
1463
1464      // removed event listeners
1465      if (browser.addEventListener) {
1466
1467        // remove current event listeners
1468        element.removeEventListener('touchstart', events, false);
1469        element.removeEventListener('webkitTransitionEnd', events, false);
1470        element.removeEventListener('msTransitionEnd', events, false);
1471        element.removeEventListener('oTransitionEnd', events, false);
1472        element.removeEventListener('otransitionend', events, false);
1473        element.removeEventListener('transitionend', events, false);
1474        window.removeEventListener('resize', events, false);
1475
1476      }
1477      else {
1478
1479        window.onresize = null;
1480
1481      }
1482
1483    }
1484  }
1485
1486}
1487
1488
1489if ( window.jQuery || window.Zepto ) {
1490  (function($) {
1491    $.fn.Swipe = function(params) {
1492      return this.each(function() {
1493        $(this).data('Swipe', new Swipe($(this)[0], params));
1494      });
1495    }
1496  })( window.jQuery || window.Zepto )
1497}
1498;
1499/**
1500 * Comment Likes - JavaScript
1501 *
1502 * This handles liking and unliking comments, as well as viewing who has
1503 * liked a particular comment.
1504 *
1505 * @dependency  jQuery
1506 * @dependency  Swipe
1507 *
1508 * @package     Comment_Likes
1509 * @subpackage  JavaScript
1510 */
1511jQuery( function() {
1512	var $ = jQuery;
1513	var extWin;
1514	var extWinCheck;
1515	var commentLikeEvent;
1516
1517	// The O2 theme re-injects this script into the DOM when somebody
1518	// creates a new thread and the page is already open, but we don't
1519	// want to run this script a second time.
1520	if ( window.comment_likes_loaded ) return;
1521	window.comment_likes_loaded = true;
1522
1523	// Client-side cache of who liked a particular comment to avoid
1524	// having to hit the server multiple times for the same data.
1525	var comment_like_cache = {};
1526
1527	/**
1528	 * Parse the comment ID from a comment like link.
1529	 */
1530	var get_comment_id = function( $link ) {
1531		var comment_id = $link.attr( 'href' ).split( 'like_comment=' );
1532		return comment_id[1].split( '&_wpnonce=' )[0];
1533	};
1534
1535	/**
1536	 * Handle an ajax action on the comment like link.
1537	 */
1538	var handle_link_action = function( $link, action, comment_id, callback ) {
1539		var nonce = $link.attr( 'href' ).split( '_wpnonce=' )[1];
1540
1541		$.post( '/wp-admin/admin-ajax.php', {
1542			'action': action,
1543			'_wpnonce': nonce,
1544			'like_comment': comment_id,
1545			'blog_id': Number( $link.data( 'blog' ) )
1546		}, callback, 'json' );
1547	};
1548
1549	// Overlay used for displaying comment like info.

1550	var overlay = {
1551
1552		// Overlay element.
1553		$el: $( '<div/>' )
1554			.appendTo( 'body' )
1555			.addClass( 'comment-likes-overlay' )
1556			.hide()
1557			.mouseenter( function() {
1558				// Don't hide the overlay if the user is mousing over it.
1559				overlay.cancel_hide();
1560			} ).mouseleave( function() {
1561				overlay.request_hide();
1562			} ),
1563
1564		// Inner contents of overlay.
1565		$inner: null,
1566
1567		// Instance of the Swipe library.
1568		swipe: null,
1569
1570		// Initialise the overlay for use, removing any old content.
1571		clear: function() {
1572			// Unload any previous instance of Swipe (to avoid leaking a global
1573			// event handler). This is done before clearing the contents of the
1574			// overlay because Swipe expects the slides to still be present.
1575			if ( this.swipe ) {
1576				this.swipe.kill();
1577				this.swipe = null;
1578			}
1579			this.$el.html( '' );
1580			this.$inner = $( '<div/>' ).addClass( 'inner' ).appendTo( this.$el );
1581		},
1582
1583		/**
1584		 * Construct a list (<ul>) of user (gravatar, name) details.
1585		 *
1586		 * @param  data     liker data returned from the server
1587		 * @param  klass    CSS class to apply to the <ul> element
1588		 * @param  start    index of user to start at
1589		 * @param  length   number of users to include in the list
1590		 *
1591		 * @return          HTML for the list
1592		 */
1593		get_user_bits: function( data, klass, start, length ) {
1594			start = start || 0;
1595			var last = start + ( length || data.length );
1596			last = ( last > data.length ) ? data.length : last;
1597			var html = '<div class="liker-list"><ul class="' + ( klass || '' ) + '">';
1598			for ( var i = start; i < last; ++i ) {
1599				var user = data[ i ];
1600				html += '<li>';
1601				html += '<a rel="nofollow" title="' + user.display_name_esc + '" href="' + user.profile_url_esc + '"><img src="' + user.avatar_url_esc + '" alt="' + user.display_name_esc + '"  /> <span class="user-name">' + user.display_name_esc + '</span></a>';
1602				html += '</li>';
1603			}
1604			html += '</ul></div>';
1605			return html;
1606		},
1607
1608		/**
1609		 * Render the display of who has liked this comment. The type of
1610		 * display depends on how many people have liked the comment.
1611		 * If more than 10 people have liked the comment, this function
1612		 * renders navigation controls and sets up the Swipe library for
1613		 * changing between pages.
1614		 *
1615		 * @param link  the element over which the user is hovering
1616		 * @param data  the results retrieved from the server
1617		 */
1618		show_likes: function( $link, data ) {
1619			this.clear();
1620
1621			$link.data( 'likeCount', data.length );
1622			if ( 0 === data.length ) {
1623				// No likers after all.
1624				return this.$el.hide();
1625			}
1626
1627			this.$inner.css( 'padding', 12 );
1628
1629			if ( data.length < 6 ) {
1630				// Only one column needed.
1631				this.$inner.css( 'max-width', 200 );
1632				this.$inner.html( this.get_user_bits( data, 'single' ) );
1633
1634			} else if ( data.length < 11 ) {
1635				// Two columns, but only one page.
1636				this.$inner.html( this.get_user_bits( data, 'double' ) );
1637
1638			} else {
1639				// Multiple pages.
1640				this.render_likes_with_pagination( data );
1641			}
1642
1643			// Move the overlay into the correct position and then show it.
1644			this.set_position( $link );
1645		},
1646
1647		/**
1648		 * Render multiple pages of likes with pagination controls.
1649		 * This function is intended to be called by `show_likes` above.
1650		 *
1651		 * @param data  the results retrieved from the server
1652		 */
1653		render_likes_with_pagination: function( data ) {
1654			var page_count = Math.ceil( data.length / 10 );
1655			// Swipe requires two nested containers.
1656			var $swipe = $( '<div/>' ).addClass( 'swipe' ).appendTo( this.$inner );
1657			var $div = $( '<div/>' ).addClass( 'swipe-wrap' ).appendTo( $swipe );
1658			for ( var i = 0; i < page_count; ++i ) {
1659				$( this.get_user_bits( data, 'double', i * 10, 10 ) ).appendTo( $div );
1660			}
1661
1662			/** Navigation controls.
1663			 *  This is based on the Newdash controls found in
1664			 *    reader/recommendations-templates.php
1665			 */
1666			var nav_html = '<nav class="slider-nav"><a href="#" class="prev"><span class="noticon noticon-previous" title="Previous" alt="<"></span></a><span class="position">';
1667			for ( var i = 0; i < page_count; ++i ) {
1668				nav_html += '<em data-page="' + i + '" class="' + ( ( i === 0 ) ? 'on' : '' ) + '">&bull;</em>';
1669			}
1670			nav_html += '</span><a href="#" class="next"><span class="noticon noticon-next" title="Next" alt=">"></span></a></nav>';

1671			var $nav = $( nav_html ).appendTo( this.$inner );
1672
1673			/** Set up Swipe. **/
1674
1675			// Swipe cannot be set up successfully unless its container
1676			// is visible, so we show it now.
1677			this.$el.show();
1678
1679			var swipe = this.swipe = new Swipe( $swipe[0], {
1680				callback: function( pos ) {
1681					// Update the pagination indicators.
1682					//
1683					// If there are exactly two pages, Swipe has a weird
1684					// special case where it duplicates both pages and
1685					// can return index 2 and 3 even though those aren't
1686					// real pages (see swipe.js, line 47). To deal with
1687					// this, we use the expression `pos % page_count`.
1688					pos = pos % page_count;
1689					$nav.find( 'em' ).each( function() {
1690						var page = Number( $( this ).data( 'page' ) );
1691						$( this ).attr( 'class', ( pos === page ) ? 'on' : '' );
1692					} );
1693				}
1694			} );
1695			$nav.find( 'em' ).on( 'click', function( $e ) {
1696				// Go to the page corresponding to the indicator clicked.
1697				swipe.slide( Number( $( this ).data( 'page' ) ) );
1698				$e.preventDefault();
1699			} );
1700			// Previous and next buttons.
1701			$nav.find( '.prev' ).on( 'click', function( $e ) {
1702				swipe.prev();
1703				$e.preventDefault();
1704			} );
1705			$nav.find( '.next' ).on( 'click', function( $e ) {
1706				swipe.next();
1707				$e.preventDefault();
1708			} );
1709		},
1710
1711		/**
1712		 * Open the overlay and show a loading message.
1713		 */
1714		show_loading_message: function( $link ) {
1715			this.clear();
1716			this.$inner.text( comment_like_text.loading );
1717			this.set_position( $link );
1718		},
1719
1720		/**
1721		 * Position the overlay near the current comment.
1722		 *
1723		 * @param $link  element near which to position the overlay
1724		 */
1725		set_position: function( $link ) {
1726			// Prepare a down arrow icon for the bottom of the overlay.
1727			var $icon = $( '<span/>' )
1728				.appendTo( this.$el )
1729				.addClass( 'icon noticon noticon-downarrow' )
1730				.css( 'text-shadow', '0px 1px 1px rgb(223, 223, 223)' );
1731
1732			var offset = $link.offset();
1733			var left = offset.left - ( this.$el.width() - $link.width() ) / 2;
1734			left = left < 5 ? 5 : left;
1735			var top = offset.top - this.$el.height() + 5;
1736
1737			// Check if the overlay would appear off the screen.
1738			if ( top < ( $( window ).scrollTop() + ( $( '#wpadminbar' ).height() || 0 ) ) ) {
1739				// We'll display the overlay beneath the link instead.
1740				top = offset.top + $link.height();
1741				// Instead of using the down arrow icon, use an up arrow.
1742				$icon.remove().prependTo( this.$el )
1743					.removeClass( 'noticon-downarrow')
1744					.addClass( 'noticon-uparrow' )
1745					.css( {
1746						'text-shadow': '0px -1px 1px rgb(223, 223, 223)',
1747						'vertical-align': 'bottom'
1748					} );
1749			}
1750
1751			this.$el.css( { 'left': left, 'top': top } ).show();
1752
1753			$icon.css( {
1754				// The height of the arrow icon differs slightly between browsers,
1755				// so we compute the margin here to make sure it isn't disjointed
1756				// from the overlay.
1757				'margin-top': $icon[0].scrollHeight - 26,
1758				'margin-bottom': 20 - $icon[0].scrollHeight,
1759
1760				// Position the arrow to be horizontally centred on the link.
1761				'padding-left': offset.left - left + ( $link.width() - $icon[0].scrollWidth ) / 2
1762			} );
1763		},
1764
1765		/**
1766		 * Return whether the overlay is visible.
1767		 */
1768		is_visible: function() {
1769			return ( 'none' !== this.$el.css( 'display' ) );
1770		},
1771
1772		// Timeout used for hiding the overlay.
1773		hide_timeout: null,
1774
1775		/**
1776		 * Request that the overlay be hidden after a short delay.
1777		 */
1778		request_hide: function() {
1779			if ( null !== this.hide_timeout ) {
1780				return;
1781			}
1782			var self = this;
1783			this.hide_timeout = setTimeout( function() {
1784				self.$el.hide();
1785				self.clear();
1786			}, 300 );
1787		},
1788
1789		/**
1790		 * Cancel a request to hide the overlay.
1791		 */
1792		cancel_hide: function() {
1793			if ( null !== this.hide_timeout ) {
1794				clearTimeout( this.hide_timeout );
1795				this.hide_timeout = null;
1796			}
1797		}
1798	};
1799
1800	// The most recent comment for which the user has requested to see
1801	// who liked it.
1802	var relevant_comment;
1803
1804	// Precache after this timeout.
1805	var precache_timeout = null;
1806
1807	/**
1808	 * Fetch the like data for a particular comment.
1809	 */
1810	var fetch_like_data = function( $link, comment_id ) {
1811		comment_like_cache[ comment_id ] = null;
1812
1813		var $star = $link.parent().parent().find( 'a.comment-like-link' );
1814		handle_link_action( $star, 'view_comment_likes', comment_id, function( data ) {
1815			// Populate the cache.
1816			comment_like_cache[ comment_id ] = data;
1817
1818			// Only show the overlay if the user is interested.
1819			if ( overlay.is_visible() && ( relevant_comment === comment_id ) ) {
1820				overlay.show_likes( $link, data );
1821			}
1822		} );
1823	};
1824
1825	function readCookie( c ) {
1826		var nameEQ = c + '=',
1827			cookieStrings = document.cookie.split( ';' ),
1828			i, cookieString, num, chunk, pairs, pair, cookie_data;
1829		for ( i = 0; i < cookieStrings.length; i++ ) {
1830			cookieString = cookieStrings[ i ];
1831			while ( cookieString.charAt( 0 ) === ' ' ) {
1832				cookieString = cookieString.substring( 1, cookieString.length );
1833			}
1834			if ( cookieString.indexOf( nameEQ ) === 0 ) {
1835				chunk = cookieString.substring( nameEQ.length, cookieString.length );
1836				pairs = chunk.split( '&' );
1837				cookie_data = {};
1838				for ( num = pairs.length - 1; num >= 0; num-- ) {
1839					pair = pairs[ num ].split( '=' );
1840					cookie_data[ pair[0] ] = decodeURIComponent( pair[1] );
1841				}
1842				return cookie_data;
1843			}
1844		}
1845		return null;
1846	}
1847
1848	function getServiceData() {
1849		var data = readCookie( 'wpc_wpc' );
1850		if ( null === data || 'undefined' === typeof data.access_token || ! data.access_token ) {
1851			return false;

1852		}
1853		return data;
1854	}
1855
1856	function readMessage( event ) {
1857		if ( 'undefined' == typeof event.event ) {
1858			return;
1859		}
1860
1861		if ( 'login' == event.event && event.success ) {
1862			extWinCheck = setInterval( function() {
1863				if ( ! extWin || extWin.closed ) {
1864					clearInterval( extWinCheck );
1865					if ( getServiceData() ) {
1866
1867						// Load page in an iframe to get the current comment nonce
1868						var nonceIframe = document.createElement( 'iframe' );
1869						nonceIframe.id = 'wp-login-comment-nonce-iframe';
1870						nonceIframe.style.display = 'none';
1871						nonceIframe.src = commentLikeEvent + '';
1872						document.body.appendChild( nonceIframe );
1873
1874						var commentLikeId = ( commentLikeEvent + '' ).split( 'like_comment=' )[1].split( '&_wpnonce=' )[0];
1875						var c = false;
1876
1877						// Set a 5 second timeout to redirect to the comment page without doing the Like as a fallback
1878						var commentLikeTimeout = setTimeout( function() {
1879							window.location = commentLikeEvent;
1880						}, 5000 );
1881
1882						// Check for a new nonced redirect and use that if available before timing out
1883						var commentLikeCheck = setInterval( function() {
1884							c = $( '#wp-login-comment-nonce-iframe' ).contents().find( '#comment-like-' + commentLikeId + ' .comment-like-link' );
1885							if ( 'undefined' !== typeof c && 'undefined' !== typeof c[0] && 'undefined' !== typeof c[0].href ) {
1886								clearTimeout( commentLikeTimeout );
1887								clearInterval( commentLikeCheck );
1888								window.location = c[0].href;
1889							}
1890						}, 100 );
1891					}
1892				}
1893			}, 100 );
1894
1895			if ( extWin ) {
1896				if ( ! extWin.closed ) {
1897					extWin.close();
1898				}
1899				extWin = false;
1900			}
1901
1902			$( '#wp-login-polling-iframe' ).remove();
1903		}
1904	}
1905
1906	if ( 'undefined' != typeof window.pm ) {
1907		pm.bind( 'loginMessage', function( e ) { readMessage( e ); } );
1908	}
1909
1910	$( 'body' ).on( 'click', 'a.comment-like-link', function( $e ) {
1911		if ( $( $e.target ).hasClass( 'needs-login' ) ) {
1912			$e.preventDefault();
1913			commentLikeEvent = $e.target;
1914			if ( extWin ) {
1915				if ( ! extWin.closed ) {
1916					extWin.close();
1917				}
1918				extWin = false;
1919			}
1920
1921			$( '#wp-login-polling-iframe' ).remove();
1922
1923			var url = 'https://wordpress.com/public.api/connect/?action=request&service=wordpress';
1924			extWin = window.open( url, 'likeconn', 'status=0,toolbar=0,location=1,menubar=0,directories=0,resizable=1,scrollbars=1,height=560,width=500' );
1925
1926			// Append cookie polling login iframe to this window to wait for user to finish logging in (or cancel)
1927			var loginIframe = $( "<iframe id='wp-login-polling-iframe'></iframe>" );
1928			loginIframe.attr( "src", "https://wordpress.com/public.api/connect/?iframe=true" );
1929			loginIframe.css( "display", "none" );
1930			$( document.body ).append( loginIframe );
1931
1932			return false;
1933		}
1934
1935		// Record that the user likes or does not like this comment.
1936		var $star = $( this );
1937		var comment_id = get_comment_id( $star );
1938		$star.addClass( 'loading' );
1939		// Determine whether to like or unlike based on whether the comment is
1940		// currently liked.
1941		var action = ( $( 'p#comment-like-' + comment_id ).data( 'liked' ) === 'comment-liked' ) ? 'unlike_comment' : 'like_comment';
1942		handle_link_action( $star, action, comment_id, function( data ) {
1943			// Invalidate the like cache for this comment.
1944			delete comment_like_cache[ comment_id ];
1945
1946			$( '#comment-like-count-' + data.context ).html( data.display );
1947
1948			if ( 'like_comment' === action ) {
1949				$( 'p#comment-like-' + data.context ).removeClass( 'comment-not-liked' )
1950					.addClass( 'comment-liked' )
1951					.data( 'liked', 'comment-liked' );
1952			} else {
1953				$( 'p#comment-like-' + data.context ).removeClass( 'comment-liked' )
1954					.addClass( 'comment-not-liked' )
1955					.data( 'liked', 'comment-not-liked' );
1956			}
1957
1958			// Prefetch new data for this comment (if there are likers left).
1959			var $link = $star.parent().find( 'a.view-likers' );
1960			if ( 0 !== $link.length ) {
1961				fetch_like_data( $link, comment_id );
1962			}
1963
1964			$star.removeClass( 'loading' );
1965		} );
1966		$e.preventDefault();
1967		$e.stopPropagation();
1968
1969	} ).on( 'click', 'p.comment-not-liked', function() {
1970		// When a comment hasn't been liked, make the text clickable, too
1971		$( this ).find( 'a.comment-like-link' ).click();
1972
1973	} ).on( 'mouseenter', 'p.comment-likes a.view-likers', function() {
1974		// Show the user a list of who has liked this comment.
1975
1976		var $link = $( this );
1977		if ( 0 === Number( $link.data( 'likeCount' ) || 0 ) ) {
1978			// No one has liked this comment.
1979			return;
1980		}
1981
1982		// Don't hide the overlay.
1983		overlay.cancel_hide();
1984
1985		// Get the comment ID.
1986		var $star = $link.parent().parent().find( 'a.comment-like-link' );
1987		var comment_id = relevant_comment = get_comment_id( $star );
1988
1989		// Check if the list of likes for this comment is already in
1990		// the cache.
1991		if ( comment_id in comment_like_cache ) {
1992			var entry = comment_like_cache[ comment_id ];

1993			// Only display the likes if the ajax request is
1994			// actually done.
1995			if ( null !== entry ) {
1996				overlay.show_likes( $link, entry );
1997			} else {
1998				// Make sure the overlay is visible (in case
1999				// the user moved the mouse away while loading
2000				// but then came back before it finished
2001				// loading).
2002				overlay.show_loading_message( $link );
2003			}
2004			return;
2005		}
2006
2007		// Position the "Loading..." overlay.
2008		overlay.show_loading_message( $link );
2009
2010		// Fetch the data.
2011		fetch_like_data( $link, comment_id );
2012
2013	} ).on( 'mouseleave', 'p.comment-likes a.view-likers', function() {
2014		// User has moved cursor away - hide the overlay.
2015		overlay.request_hide();
2016
2017	} ).on( 'click', 'p.comment-likes a.view-likers', function( $e ) {
2018		// Don't do anything when clicking on the text.
2019		$e.preventDefault();
2020
2021	} ).on( 'mouseenter', '.comment:has(a.comment-like-link)', function() {
2022		// User is moving over a comment - precache the comment like data.
2023		if ( null !== precache_timeout ) {
2024			clearTimeout( precache_timeout );
2025			precache_timeout = null;
2026		}
2027
2028		var $star = $( this ).find( 'a.comment-like-link' );
2029		var $link = $star.parent().find( 'a.view-likers' );
2030		if ( 0 === Number( $link.data( 'likeCount' ) || 0 ) ) {
2031			// No likes.
2032			return;
2033		}
2034		var comment_id = get_comment_id( $star );
2035		if ( comment_id in comment_like_cache ) {
2036			// Already in cache.
2037			return;
2038		}
2039
2040		precache_timeout = setTimeout( function() {
2041			precache_timeout = null;
2042			if ( comment_id in comment_like_cache ) {
2043				// Was cached in the interim.
2044				return;
2045			}
2046			fetch_like_data( $link, comment_id );
2047		}, 1000 );
2048	} );
2049} );
2050;
2051/**
2052 * File skip-link-focus-fix.js.
2053 *
2054 * Helps with accessibility for keyboard only users.
2055 *
2056 * Learn more: https://git.io/vWdr2
2057 */
2058( function() {
2059	var isWebkit = navigator.userAgent.toLowerCase().indexOf( 'webkit' ) > -1,
2060	    isOpera  = navigator.userAgent.toLowerCase().indexOf( 'opera' )  > -1,
2061	    isIe     = navigator.userAgent.toLowerCase().indexOf( 'msie' )   > -1;
2062
2063	if ( ( isWebkit || isOpera || isIe ) && document.getElementById && window.addEventListener ) {
2064		window.addEventListener( 'hashchange', function() {
2065			var id = location.hash.substring( 1 ),
2066				element;
2067
2068			if ( ! ( /^[A-z0-9_-]+$/.test( id ) ) ) {
2069				return;
2070			}
2071
2072			element = document.getElementById( id );
2073
2074			if ( element ) {
2075				if ( ! ( /^(?:a|select|input|button|textarea)$/i.test( element.tagName ) ) ) {
2076					element.tabIndex = -1;
2077				}
2078
2079				element.focus();
2080			}
2081		}, false );
2082	}
2083})();;
2084/*
2085 * jQuery FlexSlider v2.4.0
2086 * Copyright 2012 WooThemes
2087 * Contributing Author: Tyler Smith
2088 */
2089;
2090(function ($) {
2091
2092  //FlexSlider: Object Instance
2093  $.flexslider = function(el, options) {
2094    var slider = $(el);
2095
2096    // making variables public
2097    slider.vars = $.extend({}, $.flexslider.defaults, options);
2098
2099    var namespace = slider.vars.namespace,
2100        msGesture = window.navigator && window.navigator.msPointerEnabled && window.MSGesture,
2101        touch = (( "ontouchstart" in window ) || msGesture || window.DocumentTouch && document instanceof DocumentTouch) && slider.vars.touch,
2102        // depricating this idea, as devices are being released with both of these events
2103        //eventType = (touch) ? "touchend" : "click",
2104        eventType = "click touchend MSPointerUp keyup",
2105        watchedEvent = "",
2106        watchedEventClearTimer,
2107        vertical = slider.vars.direction === "vertical",
2108        reverse = slider.vars.reverse,
2109        carousel = (slider.vars.itemWidth > 0),
2110        fade = slider.vars.animation === "fade",
2111        asNav = slider.vars.asNavFor !== "",
2112        methods = {},
2113        focused = true;
2114
2115    // Store a reference to the slider object
2116    $.data(el, "flexslider", slider);
2117
2118    // Private slider methods
2119    methods = {
2120      init: function() {
2121        slider.animating = false;
2122        // Get current slide and make sure it is a number
2123        slider.currentSlide = parseInt( ( slider.vars.startAt ? slider.vars.startAt : 0), 10 );
2124        if ( isNaN( slider.currentSlide ) ) { slider.currentSlide = 0; }
2125        slider.animatingTo = slider.currentSlide;
2126        slider.atEnd = (slider.currentSlide === 0 || slider.currentSlide === slider.last);
2127        slider.containerSelector = slider.vars.selector.substr(0,slider.vars.selector.search(' '));
2128        slider.slides = $(slider.vars.selector, slider);
2129        slider.container = $(slider.containerSelector, slider);
2130        slider.count = slider.slides.length;
2131        // SYNC:
2132        slider.syncExists = $(slider.vars.sync).length > 0;
2133        // SLIDE:
2134        if (slider.vars.animation === "slide") { slider.vars.animation = "swing"; }
2135        slider.prop = (vertical) ? "top" : "marginLeft";
2136        slider.args = {};
2137        // SLIDESHOW:
2138        slider.manualPause = false;

2139        slider.stopped = false;
2140        //PAUSE WHEN INVISIBLE
2141        slider.started = false;
2142        slider.startTimeout = null;
2143        // TOUCH/USECSS:
2144        slider.transitions = !slider.vars.video && !fade && slider.vars.useCSS && (function() {
2145          var obj = document.createElement('div'),
2146              props = ['perspectiveProperty', 'WebkitPerspective', 'MozPerspective', 'OPerspective', 'msPerspective'];
2147          for (var i in props) {
2148            if ( obj.style[ props[i] ] !== undefined ) {
2149              slider.pfx = props[i].replace('Perspective','').toLowerCase();
2150              slider.prop = "-" + slider.pfx + "-transform";
2151              return true;
2152            }
2153          }
2154          return false;
2155        }());
2156        slider.ensureAnimationEnd = '';
2157        // CONTROLSCONTAINER:
2158        if (slider.vars.controlsContainer !== "") slider.controlsContainer = $(slider.vars.controlsContainer).length > 0 && $(slider.vars.controlsContainer);
2159        // MANUAL:
2160        if (slider.vars.manualControls !== "") slider.manualControls = $(slider.vars.manualControls).length > 0 && $(slider.vars.manualControls);
2161
2162        // RANDOMIZE:
2163        if (slider.vars.randomize) {
2164          slider.slides.sort(function() { return (Math.round(Math.random())-0.5); });
2165          slider.container.empty().append(slider.slides);
2166        }
2167
2168        slider.doMath();
2169
2170        // INIT
2171        slider.setup("init");
2172
2173        // CONTROLNAV:
2174        if (slider.vars.controlNav) { methods.controlNav.setup(); }
2175
2176        // DIRECTIONNAV:
2177        if (slider.vars.directionNav) { methods.directionNav.setup(); }
2178
2179        // KEYBOARD:
2180        if (slider.vars.keyboard && ($(slider.containerSelector).length === 1 || slider.vars.multipleKeyboard)) {
2181          $(document).bind('keyup', function(event) {
2182            var keycode = event.keyCode;
2183            if (!slider.animating && (keycode === 39 || keycode === 37)) {
2184              var target = (keycode === 39) ? slider.getTarget('next') :
2185                           (keycode === 37) ? slider.getTarget('prev') : false;
2186              slider.flexAnimate(target, slider.vars.pauseOnAction);
2187            }
2188          });
2189        }
2190        // MOUSEWHEEL:
2191        if (slider.vars.mousewheel) {
2192          slider.bind('mousewheel', function(event, delta, deltaX, deltaY) {
2193            event.preventDefault();
2194            var target = (delta < 0) ? slider.getTarget('next') : slider.getTarget('prev');
2195            slider.flexAnimate(target, slider.vars.pauseOnAction);
2196          });
2197        }
2198
2199        // PAUSEPLAY
2200        if (slider.vars.pausePlay) { methods.pausePlay.setup(); }
2201
2202        //PAUSE WHEN INVISIBLE
2203        if (slider.vars.slideshow && slider.vars.pauseInvisible) { methods.pauseInvisible.init(); }
2204
2205        // SLIDSESHOW
2206        if (slider.vars.slideshow) {
2207          if (slider.vars.pauseOnHover) {
2208            slider.hover(function() {
2209              if (!slider.manualPlay && !slider.manualPause) { slider.pause(); }
2210            }, function() {
2211              if (!slider.manualPause && !slider.manualPlay && !slider.stopped) { slider.play(); }
2212            });
2213          }
2214          // initialize animation
2215          //If we're visible, or we don't use PageVisibility API
2216          if(!slider.vars.pauseInvisible || !methods.pauseInvisible.isHidden()) {
2217            (slider.vars.initDelay > 0) ? slider.startTimeout = setTimeout(slider.play, slider.vars.initDelay) : slider.play();
2218          }
2219        }
2220
2221        // ASNAV:
2222        if (asNav) { methods.asNav.setup(); }
2223
2224        // TOUCH
2225        if (touch && slider.vars.touch) { methods.touch(); }
2226
2227        // FADE&&SMOOTHHEIGHT || SLIDE:
2228        if (!fade || (fade && slider.vars.smoothHeight)) { $(window).bind("resize orientationchange focus", methods.resize); }
2229
2230        slider.find("img").attr("draggable", "false");
2231
2232        // API: start() Callback
2233        setTimeout(function(){
2234          slider.vars.start(slider);
2235        }, 200);
2236      },
2237      asNav: {
2238        setup: function() {
2239          slider.asNav = true;
2240          slider.animatingTo = Math.floor(slider.currentSlide/slider.move);
2241          slider.currentItem = slider.currentSlide;
2242          slider.slides.removeClass(namespace + "active-slide").eq(slider.currentItem).addClass(namespace + "active-slide");
2243          if(!msGesture){
2244              slider.slides.on(eventType, function(e){
2245                e.preventDefault();
2246                var $slide = $(this),
2247                    target = $slide.index();
2248                var posFromLeft = $slide.offset().left - $(slider).scrollLeft(); // Find position of slide relative to left of slider container
2249                if( posFromLeft <= 0 && $slide.hasClass( namespace + 'active-slide' ) ) {
2250                  slider.flexAnimate(slider.getTarget("prev"), true);
2251                } else if (!$(slider.vars.asNavFor).data('flexslider').animating && !$slide.hasClass(namespace + "active-slide")) {
2252                  slider.direction = (slider.currentItem < target) ? "next" : "prev";
2253                  slider.flexAnimate(target, slider.vars.pauseOnAction, false, true, true);
2254                }
2255              });
2256          }else{
2257              el._slider = slider;
2258              slider.slides.each(function (){
2259                  var that = this;
2260                  that._gesture = new MSGesture();
2261                  that._gesture.target = that;
2262                  that.addEventListener("MSPointerDown", function (e){
2263                      e.preventDefault();
2264                      if(e.currentTarget._gesture) {
2265                        e.currentTarget._gesture.addPointer(e.pointerId);
2266                      }
2267                  }, false);
2268                  that.addEventListener("MSGestureTap", function (e){
2269                      e.preventDefault();
2270                      var $slide = $(this),
2271                          target = $slide.index();
2272                      if (!$(slider.vars.asNavFor).data('flexslider').animating && !$slide.hasClass('active')) {
2273                          slider.direction = (slider.currentItem < target) ? "next" : "prev";
2274                          slider.flexAnimate(target, slider.vars.pauseOnAction, false, true, true);
2275                      }
2276                  });
2277              });
2278          }
2279        }
2280      },
2281      controlNav: {
2282        setup: function() {
2283          if (!slider.manualControls) {
2284            methods.controlNav.setupPaging();
2285          } else { // MANUALCONTROLS:
2286            methods.controlNav.setupManual();
2287          }
2288        },
2289        setupPaging: function() {
2290          var type = (slider.vars.controlNav === "thumbnails") ? 'control-thumbs' : 'control-paging',
2291              j = 1,
2292              item,
2293              slide;
2294
2295          slider.controlNavScaffold = $('<ol class="'+ namespace + 'control-nav ' + namespace + type + '"></ol>');
2296
2297          if (slider.pagingCount > 1) {
2298            for (var i = 0; i < slider.pagingCount; i++) {
2299              slide = slider.slides.eq(i);
2300
2301              if ( undefined === slide.attr( 'data-thumb-alt' ) ) { 
2302                slide.attr( 'data-thumb-alt', '' ); 
2303              }
2304              
2305              item = $( '<a></a>' ).attr( 'href', '#' ).text( j );
2306              if ( slider.vars.controlNav === "thumbnails" ) {
2307                item = $( '<img/>' ).attr( 'src', slide.attr( 'data-thumb' ) );
2308              }
2309              
2310              if ( '' !== slide.attr( 'data-thumb-alt' ) ) {
2311                item.attr( 'alt', slide.attr( 'data-thumb-alt' ) );
2312              }
2313
2314              if ( 'thumbnails' === slider.vars.controlNav && true === slider.vars.thumbCaptions ) {
2315                var captn = slide.attr( 'data-thumbcaption' );
2316                if ( '' !== captn && undefined !== captn ) { 
2317                  var caption = $('<span></span>' ).addClass( namespace + 'caption' ).text( captn );
2318                  item.append( caption );
2319                }
2320              }
2321              
2322              var liElement = $( '<li>' );
2323              item.appendTo( liElement );
2324              liElement.append( '</li>' );
2325
2326              slider.controlNavScaffold.append(liElement);
2327              j++;
2328            }
2329          }
2330
2331          // CONTROLSCONTAINER:
2332          (slider.controlsContainer) ? $(slider.controlsContainer).append(slider.controlNavScaffold) : slider.append(slider.controlNavScaffold);
2333          methods.controlNav.set();
2334
2335          methods.controlNav.active();
2336
2337          slider.controlNavScaffold.delegate('a, img', eventType, function(event) {
2338            event.preventDefault();
2339
2340            if (watchedEvent === "" || watchedEvent === event.type) {
2341              var $this = $(this),
2342                  target = slider.controlNav.index($this);
2343
2344              if (!$this.hasClass(namespace + 'active')) {
2345                slider.direction = (target > slider.currentSlide) ? "next" : "prev";
2346                slider.flexAnimate(target, slider.vars.pauseOnAction);
2347              }
2348            }
2349
2350            // setup flags to prevent event duplication
2351            if (watchedEvent === "") {
2352              watchedEvent = event.type;
2353            }
2354            methods.setToClearWatchedEvent();
2355
2356          });
2357        },
2358        setupManual: function() {
2359          slider.controlNav = slider.manualControls;
2360          methods.controlNav.active();
2361
2362          slider.controlNav.bind(eventType, function(event) {
2363            event.preventDefault();
2364
2365            if (watchedEvent === "" || watchedEvent === event.type) {
2366              var $this = $(this),
2367                  target = slider.controlNav.index($this);
2368
2369              if (!$this.hasClass(namespace + 'active')) {
2370                (target > slider.currentSlide) ? slider.direction = "next" : slider.direction = "prev";
2371                slider.flexAnimate(target, slider.vars.pauseOnAction);
2372              }
2373            }
2374
2375            // setup flags to prevent event duplication
2376            if (watchedEvent === "") {
2377              watchedEvent = event.type;
2378            }
2379            methods.setToClearWatchedEvent();
2380          });
2381        },
2382        set: function() {
2383          var selector = (slider.vars.controlNav === "thumbnails") ? 'img' : 'a';
2384          slider.controlNav = $('.' + namespace + 'control-nav li ' + selector, (slider.controlsContainer) ? slider.controlsContainer : slider);
2385        },
2386        active: function() {
2387          slider.controlNav.removeClass(namespace + "active").eq(slider.animatingTo).addClass(namespace + "active");
2388        },
2389        update: function(action, pos) {
2390          if (slider.pagingCount > 1 && action === "add") {
2391            slider.controlNavScaffold.append($('<li><a>' + slider.count + '</a></li>'));
2392          } else if (slider.pagingCount === 1) {
2393            slider.controlNavScaffold.find('li').remove();
2394          } else {
2395            slider.controlNav.eq(pos).closest('li').remove();
2396          }
2397          methods.controlNav.set();
2398          (slider.pagingCount > 1 && slider.pagingCount !== slider.controlNav.length) ? slider.update(pos, action) : methods.controlNav.active();
2399        }
2400      },
2401      directionNav: {
2402        setup: function() {
2403          var directionNavScaffold = $('<ul class="' + namespace + 'direction-nav"><li class="' + namespace + 'nav-prev"><a class="' + namespace + 'prev" href="#">' + slider.vars.prevText + '</a></li><li class="' + namespace + 'nav-next"><a class="' + namespace + 'next" href="#">' + slider.vars.nextText + '</a></li></ul>');
2404
2405          // CONTROLSCONTAINER:
2406          if (slider.controlsContainer) {
2407            $(slider.controlsContainer).append(directionNavScaffold);
2408            slider.directionNav = $('.' + namespace + 'direction-nav li a', slider.controlsContainer);
2409          } else {
2410            slider.append(directionNavScaffold);
2411            slider.directionNav = $('.' + namespace + 'direction-nav li a', slider);
2412          }
2413
2414          methods.directionNav.update();
2415
2416          slider.directionNav.bind(eventType, function(event) {
2417            event.preventDefault();
2418            var target;
2419
2420            if (watchedEvent === "" || watchedEvent === event.type) {
2421              target = ($(this).hasClass(namespace + 'next')) ? slider.getTarget('next') : slider.getTarget('prev');
2422              slider.flexAnimate(target, slider.vars.pauseOnAction);
2423            }
2424
2425            // setup flags to prevent event duplication
2426            if (watchedEvent === "") {
2427              watchedEvent = event.type;
2428            }
2429            methods.setToClearWatchedEvent();
2430          });
2431        },
2432        update: function() {
2433          var disabledClass = namespace + 'disabled';
2434          if (slider.pagingCount === 1) {
2435            slider.directionNav.addClass(disabledClass).attr('tabindex', '-1');
2436          } else if (!slider.vars.animationLoop) {
2437            if (slider.animatingTo === 0) {
2438              slider.directionNav.removeClass(disabledClass).filter('.' + namespace + "prev").addClass(disabledClass).attr('tabindex', '-1');
2439            } else if (slider.animatingTo === slider.last) {
2440              slider.directionNav.removeClass(disabledClass).filter('.' + namespace + "next").addClass(disabledClass).attr('tabindex', '-1');
2441            } else {
2442              slider.directionNav.removeClass(disabledClass).removeAttr('tabindex');
2443            }
2444          } else {
2445            slider.directionNav.removeClass(disabledClass).removeAttr('tabindex');
2446          }
2447        }
2448      },
2449      pausePlay: {
2450        setup: function() {
2451          var pausePlayScaffold = $('<div class="' + namespace + 'pauseplay"><a></a></div>');
2452
2453          // CONTROLSCONTAINER:
2454          if (slider.controlsContainer) {
2455            slider.controlsContainer.append(pausePlayScaffold);
2456            slider.pausePlay = $('.' + namespace + 'pauseplay a', slider.controlsContainer);
2457          } else {
2458            slider.append(pausePlayScaffold);
2459            slider.pausePlay = $('.' + namespace + 'pauseplay a', slider);
2460          }
2461
2462          methods.pausePlay.update((slider.vars.slideshow) ? namespace + 'pause' : namespace + 'play');
2463
2464          slider.pausePlay.bind(eventType, function(event) {
2465            event.preventDefault();
2466
2467            if (watchedEvent === "" || watchedEvent === event.type) {
2468              if ($(this).hasClass(namespace + 'pause')) {
2469                slider.manualPause = true;
2470                slider.manualPlay = false;
2471                slider.pause();
2472              } else {
2473                slider.manualPause = false;
2474                slider.manualPlay = true;
2475                slider.play();
2476              }
2477            }
2478
2479            // setup flags to prevent event duplication
2480            if (watchedEvent === "") {
2481              watchedEvent = event.type;
2482            }
2483            methods.setToClearWatchedEvent();
2484          });
2485        },
2486        update: function(state) {
2487          (state === "play") ? slider.pausePlay.removeClass(namespace + 'pause').addClass(namespace + 'play').html(slider.vars.playText) : slider.pausePlay.removeClass(namespace + 'play').addClass(namespace + 'pause').html(slider.vars.pauseText);
2488        }
2489      },
2490      touch: function() {
2491        var startX,
2492          startY,
2493          offset,
2494          cwidth,
2495          dx,
2496          startT,
2497          scrolling = false,
2498          localX = 0,
2499          localY = 0,
2500          accDx = 0;
2501
2502        if(!msGesture){
2503            el.addEventListener('touchstart', onTouchStart, false);
2504
2505            function onTouchStart(e) {
2506              if (slider.animating) {
2507                e.preventDefault();
2508              } else if ( ( window.navigator.msPointerEnabled ) || e.touches.length === 1 ) {
2509                slider.pause();
2510                // CAROUSEL:
2511                cwidth = (vertical) ? slider.h : slider. w;
2512                startT = Number(new Date());
2513                // CAROUSEL:
2514
2515                // Local vars for X and Y points.
2516                localX = e.touches[0].pageX;
2517                localY = e.touches[0].pageY;
2518
2519                offset = (carousel && reverse && slider.animatingTo === slider.last) ? 0 :
2520                         (carousel && reverse) ? slider.limit - (((slider.itemW + slider.vars.itemMargin) * slider.move) * slider.animatingTo) :
2521                         (carousel && slider.currentSlide === slider.last) ? slider.limit :
2522                         (carousel) ? ((slider.itemW + slider.vars.itemMargin) * slider.move) * slider.currentSlide :
2523                         (reverse) ? (slider.last - slider.currentSlide + slider.cloneOffset) * cwidth : (slider.currentSlide + slider.cloneOffset) * cwidth;
2524                startX = (vertical) ? localY : localX;
2525                startY = (vertical) ? localX : localY;
2526
2527                el.addEventListener('touchmove', onTouchMove, false);
2528                el.addEventListener('touchend', onTouchEnd, false);
2529              }
2530            }
2531
2532            function onTouchMove(e) {
2533              // Local vars for X and Y points.
2534
2535              localX = e.touches[0].pageX;
2536              localY = e.touches[0].pageY;
2537
2538              dx = (vertical) ? startX - localY : startX - localX;
2539              scrolling = (vertical) ? (Math.abs(dx) < Math.abs(localX - startY)) : (Math.abs(dx) < Math.abs(localY - startY));
2540
2541              var fxms = 500;
2542
2543              if ( ! scrolling || Number( new Date() ) - startT > fxms ) {
2544                e.preventDefault();
2545                if (!fade && slider.transitions) {
2546                  if (!slider.vars.animationLoop) {
2547                    dx = dx/((slider.currentSlide === 0 && dx < 0 || slider.currentSlide === slider.last && dx > 0) ? (Math.abs(dx)/cwidth+2) : 1);
2548                  }
2549                  slider.setProps(offset + dx, "setTouch");
2550                }
2551              }
2552            }
2553
2554            function onTouchEnd(e) {
2555              // finish the touch by undoing the touch session
2556              el.removeEventListener('touchmove', onTouchMove, false);
2557
2558              if (slider.animatingTo === slider.currentSlide && !scrolling && !(dx === null)) {
2559                var updateDx = (reverse) ? -dx : dx,
2560                    target = (updateDx > 0) ? slider.getTarget('next') : slider.getTarget('prev');
2561
2562                if (slider.canAdvance(target) && (Number(new Date()) - startT < 550 && Math.abs(updateDx) > 50 || Math.abs(updateDx) > cwidth/2)) {
2563                  slider.flexAnimate(target, slider.vars.pauseOnAction);
2564                } else {
2565                  if (!fade) { slider.flexAnimate(slider.currentSlide, slider.vars.pauseOnAction, true); }
2566                }
2567              }
2568              el.removeEventListener('touchend', onTouchEnd, false);
2569
2570              startX = null;
2571              startY = null;
2572              dx = null;
2573              offset = null;
2574            }
2575        }else{
2576            el.style.msTouchAction = "none";
2577            el._gesture = new MSGesture();
2578            el._gesture.target = el;
2579            el.addEventListener("MSPointerDown", onMSPointerDown, false);
2580            el._slider = slider;
2581            el.addEventListener("MSGestureChange", onMSGestureChange, false);
2582            el.addEventListener("MSGestureEnd", onMSGestureEnd, false);
2583
2584            function onMSPointerDown(e){
2585                e.stopPropagation();
2586                if (slider.animating) {
2587                    e.preventDefault();
2588                }else{
2589                    slider.pause();
2590                    el._gesture.addPointer(e.pointerId);
2591                    accDx = 0;
2592                    cwidth = (vertical) ? slider.h : slider. w;
2593                    startT = Number(new Date());
2594                    // CAROUSEL:
2595
2596                    offset = (carousel && reverse && slider.animatingTo === slider.last) ? 0 :
2597                        (carousel && reverse) ? slider.limit - (((slider.itemW + slider.vars.itemMargin) * slider.move) * slider.animatingTo) :
2598                            (carousel && slider.currentSlide === slider.last) ? slider.limit :
2599                                (carousel) ? ((slider.itemW + slider.vars.itemMargin) * slider.move) * slider.currentSlide :
2600                                    (reverse) ? (slider.last - slider.currentSlide + slider.cloneOffset) * cwidth : (slider.currentSlide + slider.cloneOffset) * cwidth;
2601                }
2602            }
2603
2604            function onMSGestureChange(e) {
2605                e.stopPropagation();
2606                var slider = e.target._slider;
2607                if(!slider){
2608                    return;
2609                }
2610                var transX = -e.translationX,
2611                    transY = -e.translationY;
2612
2613                //Accumulate translations.
2614                accDx = accDx + ((vertical) ? transY : transX);
2615                dx = accDx;
2616                scrolling = (vertical) ? (Math.abs(accDx) < Math.abs(-transX)) : (Math.abs(accDx) < Math.abs(-transY));
2617
2618                if(e.detail === e.MSGESTURE_FLAG_INERTIA){
2619                    setImmediate(function (){
2620                        el._gesture.stop();
2621                    });
2622
2623                    return;
2624                }
2625
2626                if (!scrolling || Number(new Date()) - startT > 500) {
2627                    e.preventDefault();
2628                    if (!fade && slider.transitions) {
2629                        if (!slider.vars.animationLoop) {
2630                            dx = accDx / ((slider.currentSlide === 0 && accDx < 0 || slider.currentSlide === slider.last && accDx > 0) ? (Math.abs(accDx) / cwidth + 2) : 1);
2631                        }
2632                        slider.setProps(offset + dx, "setTouch");
2633                    }
2634                }
2635            }
2636
2637            function onMSGestureEnd(e) {
2638                e.stopPropagation();
2639                var slider = e.target._slider;
2640                if(!slider){
2641                    return;
2642                }
2643                if (slider.animatingTo === slider.currentSlide && !scrolling && !(dx === null)) {
2644                    var updateDx = (reverse) ? -dx : dx,
2645                        target = (updateDx > 0) ? slider.getTarget('next') : slider.getTarget('prev');
2646
2647                    if (slider.canAdvance(target) && (Number(new Date()) - startT < 550 && Math.abs(updateDx) > 50 || Math.abs(updateDx) > cwidth/2)) {
2648                        slider.flexAnimate(target, slider.vars.pauseOnAction);
2649                    } else {
2650                        if (!fade) { slider.flexAnimate(slider.currentSlide, slider.vars.pauseOnAction, true); }
2651                    }
2652                }
2653
2654                startX = null;
2655                startY = null;
2656                dx = null;
2657                offset = null;
2658                accDx = 0;
2659            }
2660        }
2661      },
2662      resize: function() {
2663        if (!slider.animating && slider.is(':visible')) {
2664          if (!carousel) { slider.doMath(); }
2665
2666          if (fade) {
2667            // SMOOTH HEIGHT:
2668            methods.smoothHeight();
2669          } else if (carousel) { //CAROUSEL:
2670            slider.slides.width(slider.computedW);
2671            slider.update(slider.pagingCount);
2672            slider.setProps();
2673          }
2674          else if (vertical) { //VERTICAL:
2675            slider.viewport.height(slider.h);
2676            slider.setProps(slider.h, "setTotal");
2677          } else {
2678            // SMOOTH HEIGHT:
2679            if (slider.vars.smoothHeight) { methods.smoothHeight(); }
2680            slider.newSlides.width(slider.computedW);
2681            slider.setProps(slider.computedW, "setTotal");
2682          }
2683        }
2684      },
2685      smoothHeight: function(dur) {
2686        if (!vertical || fade) {
2687          var $obj = (fade) ? slider : slider.viewport;
2688          (dur) ? $obj.animate({"height": slider.slides.eq(slider.animatingTo).height()}, dur) : $obj.height(slider.slides.eq(slider.animatingTo).height());
2689        }
2690      },
2691      sync: function(action) {
2692        var $obj = $(slider.vars.sync).data("flexslider"),
2693            target = slider.animatingTo;
2694
2695        switch (action) {
2696          case "animate": $obj.flexAnimate(target, slider.vars.pauseOnAction, false, true); break;
2697          case "play": if (!$obj.playing && !$obj.asNav) { $obj.play(); } break;
2698          case "pause": $obj.pause(); break;
2699        }
2700      },
2701      uniqueID: function($clone) {
2702        // Append _clone to current level and children elements with id attributes
2703        $clone.filter( '[id]' ).add($clone.find( '[id]' )).each(function() {
2704          var $this = $(this);
2705          $this.attr( 'id', $this.attr( 'id' ) + '_clone' );
2706        });
2707        return $clone;
2708      },
2709      pauseInvisible: {
2710        visProp: null,
2711        init: function() {
2712          var visProp = methods.pauseInvisible.getHiddenProp();
2713          if (visProp) {
2714            var evtname = visProp.replace(/[H|h]idden/,'') + 'visibilitychange';
2715            document.addEventListener(evtname, function() {
2716              if (methods.pauseInvisible.isHidden()) {
2717                if(slider.startTimeout) {
2718                  clearTimeout(slider.startTimeout); //If clock is ticking, stop timer and prevent from starting while invisible
2719                } else { 
2720                  slider.pause(); //Or just pause
2721                }
2722              }
2723              else {
2724                if(slider.started) {
2725                  slider.play(); //Initiated before, just play
2726                } else { 
2727                  if (slider.vars.initDelay > 0) { 
2728                    setTimeout(slider.play, slider.vars.initDelay);
2729                  } else {
2730                    slider.play(); //Didn't init before: simply init or wait for it
2731                  } 
2732                }
2733              }
2734            });
2735          }
2736        },
2737        isHidden: function() {
2738          var prop = methods.pauseInvisible.getHiddenProp();
2739          if (!prop) {
2740            return false;
2741          }
2742          return document[prop];
2743        },
2744        getHiddenProp: function() {
2745          var prefixes = ['webkit','moz','ms','o'];
2746          // if 'hidden' is natively supported just return it
2747          if ('hidden' in document) {
2748            return 'hidden';
2749          }
2750          // otherwise loop over all the known prefixes until we find one
2751          for ( var i = 0; i < prefixes.length; i++ ) {
2752              if ((prefixes[i] + 'Hidden') in document) {
2753                return prefixes[i] + 'Hidden';
2754              }
2755          }
2756          // otherwise it's not supported
2757          return null;
2758        }
2759      },
2760      setToClearWatchedEvent: function() {
2761        clearTimeout(watchedEventClearTimer);
2762        watchedEventClearTimer = setTimeout(function() {
2763          watchedEvent = "";
2764        }, 3000);
2765      }
2766    };
2767
2768    // public methods
2769    slider.flexAnimate = function(target, pause, override, withSync, fromNav) {
2770      if (!slider.vars.animationLoop && target !== slider.currentSlide) {
2771        slider.direction = (target > slider.currentSlide) ? "next" : "prev";
2772      }
2773
2774      if (asNav && slider.pagingCount === 1) slider.direction = (slider.currentItem < target) ? "next" : "prev";
2775
2776      if (!slider.animating && (slider.canAdvance(target, fromNav) || override) && slider.is(":visible")) {
2777        if (asNav && withSync) {
2778          var master = $(slider.vars.asNavFor).data('flexslider');
2779          slider.atEnd = target === 0 || target === slider.count - 1;
2780          master.flexAnimate(target, true, false, true, fromNav);
2781          slider.direction = (slider.currentItem < target) ? "next" : "prev";
2782          master.direction = slider.direction;
2783
2784          if (Math.ceil((target + 1)/slider.visible) - 1 !== slider.currentSlide && target !== 0) {
2785            slider.currentItem = target;
2786            slider.slides.removeClass(namespace + "active-slide").eq(target).addClass(namespace + "active-slide");
2787            target = Math.floor(target/slider.visible);
2788          } else {
2789            slider.currentItem = target;
2790            slider.slides.removeClass(namespace + "active-slide").eq(target).addClass(namespace + "active-slide");
2791            return false;
2792          }
2793        }
2794
2795        slider.animating = true;
2796        slider.animatingTo = target;
2797
2798        // SLIDESHOW:
2799        if (pause) { slider.pause(); }
2800
2801        // API: before() animation Callback
2802        slider.vars.before(slider);
2803
2804        // SYNC:
2805        if (slider.syncExists && !fromNav) { methods.sync("animate"); }
2806
2807        // CONTROLNAV
2808        if (slider.vars.controlNav) { methods.controlNav.active(); }
2809
2810        // !CAROUSEL:
2811        // CANDIDATE: slide active class (for add/remove slide)
2812        if (!carousel) { slider.slides.removeClass(namespace + 'active-slide').eq(target).addClass(namespace + 'active-slide'); }
2813
2814        // INFINITE LOOP:
2815        // CANDIDATE: atEnd
2816        slider.atEnd = target === 0 || target === slider.last;
2817
2818        // DIRECTIONNAV:
2819        if (slider.vars.directionNav) { methods.directionNav.update(); }
2820
2821        if (target === slider.last) {
2822          // API: end() of cycle Callback
2823          slider.vars.end(slider);
2824          // SLIDESHOW && !INFINITE LOOP:
2825          if (!slider.vars.animationLoop) { slider.pause(); }
2826        }
2827
2828        // SLIDE:
2829        if (!fade) {
2830          var dimension = (vertical) ? slider.slides.filter(':first').height() : slider.computedW,
2831              margin, slideString, calcNext;
2832
2833          // INFINITE LOOP / REVERSE:
2834          if (carousel) {
2835            //margin = (slider.vars.itemWidth > slider.w) ? slider.vars.itemMargin * 2 : slider.vars.itemMargin;
2836            margin = slider.vars.itemMargin;
2837            calcNext = ((slider.itemW + margin) * slider.move) * slider.animatingTo;
2838            slideString = (calcNext > slider.limit && slider.visible !== 1) ? slider.limit : calcNext;
2839          } else if (slider.currentSlide === 0 && target === slider.count - 1 && slider.vars.animationLoop && slider.direction !== "next") {
2840            slideString = (reverse) ? (slider.count + slider.cloneOffset) * dimension : 0;
2841          } else if (slider.currentSlide === slider.last && target === 0 && slider.vars.animationLoop && slider.direction !== "prev") {
2842            slideString = (reverse) ? 0 : (slider.count + 1) * dimension;
2843          } else {
2844            slideString = (reverse) ? ((slider.count - 1) - target + slider.cloneOffset) * dimension : (target + slider.cloneOffset) * dimension;
2845          }
2846          slider.setProps(slideString, "", slider.vars.animationSpeed);
2847          if (slider.transitions) {
2848            if (!slider.vars.animationLoop || !slider.atEnd) {
2849              slider.animating = false;
2850              slider.currentSlide = slider.animatingTo;
2851            }
2852            
2853            // Unbind previous transitionEnd events and re-bind new transitionEnd event
2854            slider.container.unbind("webkitTransitionEnd transitionend");
2855            slider.container.bind("webkitTransitionEnd transitionend", function() {
2856              clearTimeout(slider.ensureAnimationEnd);
2857              slider.wrapup(dimension);
2858            });
2859
2860            // Insurance for the ever-so-fickle transitionEnd event
2861            clearTimeout(slider.ensureAnimationEnd);
2862            slider.ensureAnimationEnd = setTimeout(function() {
2863              slider.wrapup(dimension);
2864            }, slider.vars.animationSpeed + 100);
2865
2866          } else {
2867            slider.container.animate(slider.args, slider.vars.animationSpeed, slider.vars.easing, function(){
2868              slider.wrapup(dimension);
2869            });
2870          }
2871        } else { // FADE:
2872          if (!touch) {
2873            //slider.slides.eq(slider.currentSlide).fadeOut(slider.vars.animationSpeed, slider.vars.easing);
2874            //slider.slides.eq(target).fadeIn(slider.vars.animationSpeed, slider.vars.easing, slider.wrapup);
2875
2876            slider.slides.eq(slider.currentSlide).css({"zIndex": 1}).animate({"opacity": 0}, slider.vars.animationSpeed, slider.vars.easing);
2877            slider.slides.eq(target).css({"zIndex": 2}).animate({"opacity": 1}, slider.vars.animationSpeed, slider.vars.easing, slider.wrapup);
2878
2879          } else {
2880            slider.slides.eq(slider.currentSlide).css({ "opacity": 0, "zIndex": 1 });
2881            slider.slides.eq(target).css({ "opacity": 1, "zIndex": 2 });
2882            slider.wrapup(dimension);
2883          }
2884        }
2885        // SMOOTH HEIGHT:
2886        if (slider.vars.smoothHeight) { methods.smoothHeight(slider.vars.animationSpeed); }
2887      }
2888    };
2889    slider.wrapup = function(dimension) {
2890      // SLIDE:
2891      if (!fade && !carousel) {
2892        if (slider.currentSlide === 0 && slider.animatingTo === slider.last && slider.vars.animationLoop) {
2893          slider.setProps(dimension, "jumpEnd");
2894        } else if (slider.currentSlide === slider.last && slider.animatingTo === 0 && slider.vars.animationLoop) {
2895          slider.setProps(dimension, "jumpStart");
2896        }
2897      }
2898      slider.animating = false;
2899      slider.currentSlide = slider.animatingTo;
2900      // API: after() animation Callback
2901      slider.vars.after(slider);
2902    };
2903
2904    // SLIDESHOW:
2905    slider.animateSlides = function() {
2906      if (!slider.animating && focused ) { slider.flexAnimate(slider.getTarget("next")); }
2907    };
2908    // SLIDESHOW:
2909    slider.pause = function() {
2910      clearInterval(slider.animatedSlides);
2911      slider.animatedSlides = null;
2912      slider.playing = false;
2913      // PAUSEPLAY:
2914      if (slider.vars.pausePlay) { methods.pausePlay.update("play"); }
2915      // SYNC:
2916      if (slider.syncExists) { methods.sync("pause"); }
2917    };
2918    // SLIDESHOW:
2919    slider.play = function() {
2920      if (slider.playing) { clearInterval(slider.animatedSlides); }
2921      slider.animatedSlides = slider.animatedSlides || setInterval(slider.animateSlides, slider.vars.slideshowSpeed);
2922      slider.started = slider.playing = true;
2923      // PAUSEPLAY:
2924      if (slider.vars.pausePlay) { methods.pausePlay.update("pause"); }
2925      // SYNC:
2926      if (slider.syncExists) { methods.sync("play"); }
2927    };
2928    // STOP:
2929    slider.stop = function () {
2930      slider.pause();
2931      slider.stopped = true;
2932    };
2933    slider.canAdvance = function(target, fromNav) {
2934      // ASNAV:
2935      var last = (asNav) ? slider.pagingCount - 1 : slider.last;
2936      return (fromNav) ? true :
2937             (asNav && slider.currentItem === slider.count - 1 && target === 0 && slider.direction === "prev") ? true :
2938             (asNav && slider.currentItem === 0 && target === slider.pagingCount - 1 && slider.direction !== "next") ? false :
2939             (target === slider.currentSlide && !asNav) ? false :
2940             (slider.vars.animationLoop) ? true :
2941             (slider.atEnd && slider.currentSlide === 0 && target === last && slider.direction !== "next") ? false :
2942             (slider.atEnd && slider.currentSlide === last && target === 0 && slider.direction === "next") ? false :
2943             true;
2944    };
2945    slider.getTarget = function(dir) {
2946      slider.direction = dir;
2947      if (dir === "next") {
2948        return (slider.currentSlide === slider.last) ? 0 : slider.currentSlide + 1;
2949      } else {
2950        return (slider.currentSlide === 0) ? slider.last : slider.currentSlide - 1;
2951      }
2952    };
2953
2954    // SLIDE:
2955    slider.setProps = function(pos, special, dur) {
2956      var target = (function() {
2957        var posCheck = (pos) ? pos : ((slider.itemW + slider.vars.itemMargin) * slider.move) * slider.animatingTo,
2958            posCalc = (function() {
2959              if (carousel) {
2960                return (special === "setTouch") ? pos :
2961                       (reverse && slider.animatingTo === slider.last) ? 0 :
2962                       (reverse) ? slider.limit - (((slider.itemW + slider.vars.itemMargin) * slider.move) * slider.animatingTo) :
2963                       (slider.animatingTo === slider.last) ? slider.limit : posCheck;
2964              } else {
2965                switch (special) {
2966                  case "setTotal": return (reverse) ? ((slider.count - 1) - slider.currentSlide + slider.cloneOffset) * pos : (slider.currentSlide + slider.cloneOffset) * pos;
2967                  case "setTouch": return (reverse) ? pos : pos;
2968                  case "jumpEnd": return (reverse) ? pos : slider.count * pos;
2969                  case "jumpStart": return (reverse) ? slider.count * pos : pos;
2970                  default: return pos;
2971                }
2972              }
2973            }());
2974
2975            return (posCalc * -1) + "px";
2976          }());
2977
2978      if (slider.transitions) {
2979        target = (vertical) ? "translate3d(0," + target + ",0)" : "translate3d(" + target + ",0,0)";
2980        dur = (dur !== undefined) ? (dur/1000) + "s" : "0s";
2981        slider.container.css("-" + slider.pfx + "-transition-duration", dur);
2982         slider.container.css("transition-duration", dur);
2983      }
2984
2985      slider.args[slider.prop] = target;
2986      if (slider.transitions || dur === undefined) { slider.container.css(slider.args); }
2987
2988      slider.container.css('transform',target);
2989    };
2990
2991    slider.setup = function(type) {
2992      // SLIDE:
2993      if (!fade) {
2994        var sliderOffset, arr;
2995
2996        if (type === "init") {
2997          slider.viewport = $('<div class="' + namespace + 'viewport"></div>').css({"overflow": "hidden", "position": "relative"}).appendTo(slider).append(slider.container);
2998          // INFINITE LOOP:
2999          slider.cloneCount = 0;
3000          slider.cloneOffset = 0;
3001          // REVERSE:
3002          if (reverse) {
3003            arr = $.makeArray(slider.slides).reverse();
3004            slider.slides = $(arr);
3005            slider.container.empty().append(slider.slides);
3006          }
3007        }
3008        // INFINITE LOOP && !CAROUSEL:
3009        if (slider.vars.animationLoop && !carousel) {
3010          slider.cloneCount = 2;
3011          slider.cloneOffset = 1;
3012          // clear out old clones
3013          if (type !== "init") { slider.container.find('.clone').remove(); }
3014          slider.container.append(methods.uniqueID(slider.slides.first().clone().addClass('clone')).attr('aria-hidden', 'true'))
3015                          .prepend(methods.uniqueID(slider.slides.last().clone().addClass('clone')).attr('aria-hidden', 'true'));
3016        }
3017        slider.newSlides = $(slider.vars.selector, slider);
3018
3019        sliderOffset = (reverse) ? slider.count - 1 - slider.currentSlide + slider.cloneOffset : slider.currentSlide + slider.cloneOffset;
3020        // VERTICAL:
3021        if (vertical && !carousel) {
3022          slider.container.height((slider.count + slider.cloneCount) * 200 + "%").css("position", "absolute").width("100%");
3023          setTimeout(function(){
3024            slider.newSlides.css({"display": "block"});
3025            slider.doMath();
3026            slider.viewport.height(slider.h);
3027            slider.setProps(sliderOffset * slider.h, "init");
3028          }, (type === "init") ? 100 : 0);
3029        } else {
3030          slider.container.width((slider.count + slider.cloneCount) * 200 + "%");
3031          slider.setProps(sliderOffset * slider.computedW, "init");
3032          setTimeout(function(){
3033            slider.doMath();
3034            slider.newSlides.css({"width": slider.computedW, "float": "left", "display": "block"});
3035            // SMOOTH HEIGHT:
3036            if (slider.vars.smoothHeight) { methods.smoothHeight(); }
3037          }, (type === "init") ? 100 : 0);
3038        }
3039      } else { // FADE:
3040        slider.slides.css({"width": "100%", "float": "left", "marginRight": "-100%", "position": "relative"});
3041        if (type === "init") {
3042          if (!touch) {
3043            //slider.slides.eq(slider.currentSlide).fadeIn(slider.vars.animationSpeed, slider.vars.easing);
3044            if (slider.vars.fadeFirstSlide == false) {
3045              slider.slides.css({ "opacity": 0, "display": "block", "zIndex": 1 }).eq(slider.currentSlide).css({"zIndex": 2}).css({"opacity": 1});
3046            } else {
3047              slider.slides.css({ "opacity": 0, "display": "block", "zIndex": 1 }).eq(slider.currentSlide).css({"zIndex": 2}).animate({"opacity": 1},slider.vars.animationSpeed,slider.vars.easing);
3048            }
3049          } else {
3050            slider.slides.css({ "opacity": 0, "display": "block", "webkitTransition": "opacity " + slider.vars.animationSpeed / 1000 + "s ease", "zIndex": 1 }).eq(slider.currentSlide).css({ "opacity": 1, "zIndex": 2});
3051          }
3052        }
3053        // SMOOTH HEIGHT:
3054        if (slider.vars.smoothHeight) { methods.smoothHeight(); }
3055      }
3056      // !CAROUSEL:
3057      // CANDIDATE: active slide
3058      if (!carousel) { slider.slides.removeClass(namespace + "active-slide").eq(slider.currentSlide).addClass(namespace + "active-slide"); }
3059
3060      //FlexSlider: init() Callback
3061      slider.vars.init(slider);
3062    };
3063
3064    slider.doMath = function() {
3065      var slide = slider.slides.first(),
3066          slideMargin = slider.vars.itemMargin,
3067          minItems = slider.vars.minItems,
3068          maxItems = slider.vars.maxItems;
3069
3070      slider.w = (slider.viewport===undefined) ? slider.width() : slider.viewport.width();
3071      slider.h = slide.height();
3072      slider.boxPadding = slide.outerWidth() - slide.width();
3073
3074      // CAROUSEL:
3075      if (carousel) {
3076        slider.itemT = slider.vars.itemWidth + slideMargin;
3077        slider.minW = (minItems) ? minItems * slider.itemT : slider.w;
3078        slider.maxW = (maxItems) ? (maxItems * slider.itemT) - slideMargin : slider.w;
3079        slider.itemW = (slider.minW > slider.w) ? (slider.w - (slideMargin * (minItems - 1)))/minItems :
3080                       (slider.maxW < slider.w) ? (slider.w - (slideMargin * (maxItems - 1)))/maxItems :
3081                       (slider.vars.itemWidth > slider.w) ? slider.w : slider.vars.itemWidth;
3082
3083        slider.visible = Math.floor(slider.w/(slider.itemW));
3084        slider.move = (slider.vars.move > 0 && slider.vars.move < slider.visible ) ? slider.vars.move : slider.visible;
3085        slider.pagingCount = Math.ceil(((slider.count - slider.visible)/slider.move) + 1);
3086        slider.last =  slider.pagingCount - 1;
3087        slider.limit = (slider.pagingCount === 1) ? 0 :
3088                       (slider.vars.itemWidth > slider.w) ? (slider.itemW * (slider.count - 1)) + (slideMargin * (slider.count - 1)) : ((slider.itemW + slideMargin) * slider.count) - slider.w - slideMargin;
3089      } else {
3090        slider.itemW = slider.w;
3091        slider.pagingCount = slider.count;
3092        slider.last = slider.count - 1;
3093      }
3094      slider.computedW = slider.itemW - slider.boxPadding;
3095    };
3096
3097    slider.update = function(pos, action) {
3098      slider.doMath();
3099
3100      // update currentSlide and slider.animatingTo if necessary
3101      if (!carousel) {
3102        if (pos < slider.currentSlide) {
3103          slider.currentSlide += 1;
3104        } else if (pos <= slider.currentSlide && pos !== 0) {
3105          slider.currentSlide -= 1;
3106        }
3107        slider.animatingTo = slider.currentSlide;
3108      }
3109
3110      // update controlNav
3111      if (slider.vars.controlNav && !slider.manualControls) {
3112        if ((action === "add" && !carousel) || slider.pagingCount > slider.controlNav.length) {
3113          methods.controlNav.update("add");
3114        } else if ((action === "remove" && !carousel) || slider.pagingCount < slider.controlNav.length) {
3115          if (carousel && slider.currentSlide > slider.last) {
3116            slider.currentSlide -= 1;
3117            slider.animatingTo -= 1;
3118          }
3119          methods.controlNav.update("remove", slider.last);
3120        }
3121      }
3122      // update directionNav
3123      if (slider.vars.directionNav) { methods.directionNav.update(); }
3124
3125    };
3126
3127    slider.addSlide = function(obj, pos) {
3128      var $obj = $(obj);
3129
3130      slider.count += 1;
3131      slider.last = slider.count - 1;
3132
3133      // append new slide
3134      if (vertical && reverse) {
3135        (pos !== undefined) ? slider.slides.eq(slider.count - pos).after($obj) : slider.container.prepend($obj);
3136      } else {
3137        (pos !== undefined) ? slider.slides.eq(pos).before($obj) : slider.container.append($obj);
3138      }
3139
3140      // update currentSlide, animatingTo, controlNav, and directionNav
3141      slider.update(pos, "add");
3142
3143      // update slider.slides
3144      slider.slides = $(slider.vars.selector + ':not(.clone)', slider);
3145      // re-setup the slider to accomdate new slide
3146      slider.setup();
3147
3148      //FlexSlider: added() Callback
3149      slider.vars.added(slider);
3150    };
3151    slider.removeSlide = function(obj) {
3152      var pos = (isNaN(obj)) ? slider.slides.index($(obj)) : obj;
3153
3154      // update count
3155      slider.count -= 1;
3156      slider.last = slider.count - 1;
3157
3158      // remove slide
3159      if (isNaN(obj)) {
3160        $(obj, slider.slides).remove();
3161      } else {
3162        (vertical && reverse) ? slider.slides.eq(slider.last).remove() : slider.slides.eq(obj).remove();
3163      }
3164
3165      // update currentSlide, animatingTo, controlNav, and directionNav
3166      slider.doMath();
3167      slider.update(pos, "remove");
3168
3169      // update slider.slides
3170      slider.slides = $(slider.vars.selector + ':not(.clone)', slider);
3171      // re-setup the slider to accomdate new slide
3172      slider.setup();
3173
3174      // FlexSlider: removed() Callback
3175      slider.vars.removed(slider);
3176    };
3177
3178    //FlexSlider: Initialize
3179    methods.init();
3180  };
3181
3182  // Ensure the slider isn't focussed if the window loses focus.
3183  $( window ).blur( function ( e ) {
3184    focused = false;