PowerPack Addons for Elementor (Instagram Feed, Pricing Table,

Version Description

December 10, 2020 =
Fixed: Instagram Feed - Masonry layout

Release Info

Developer	ideaboxcreations
Plugin	PowerPack Addons for Elementor (Instagram Feed, Pricing Table, Forms Stylers, Display Conditions, Free Elementor Widgets and Elementor Templates)
Version	2.2.2
Comparing to
See all releases

Code changes from version 2.2.1 to 2.2.2

Files changed (7) hide show

assets/lib/isotope/isotope.pkgd.js +3563 -0
assets/lib/isotope/isotope.pkgd.min.js +12 -0
changelog.txt +4 -0
package.json +1 -1
plugin.php +10 -0
powerpack-lite-elementor.php +2 -2
readme.txt +4 -1

assets/lib/isotope/isotope.pkgd.js ADDED Viewed

	@@ -0,0 +1,3563 @@


1	+ /*!
2	+ * Isotope PACKAGED v3.0.6
3	+ *
4	+ * Licensed GPLv3 for open source use
5	+ * or Isotope Commercial License for commercial use
6	+ *
7	+ * https://isotope.metafizzy.co
8	+ * Copyright 2010-2018 Metafizzy
9	+ */
10	+
11	+ /**
12	+ * Bridget makes jQuery widgets
13	+ * v2.0.1
14	+ * MIT license
15	+ */
16	+
17	+ /* jshint browser: true, strict: true, undef: true, unused: true */
18	+
19	+ ( function( window, factory ) {
20	+ // universal module definition
21	+ /jshint strict: false / /* globals define, module, require */
22	+ if ( typeof define == 'function' && define.amd ) {
23	+ // AMD
24	+ define( 'jquery-bridget/jquery-bridget',[ 'jquery' ], function( jQuery ) {
25	+ return factory( window, jQuery );
26	+ });
27	+ } else if ( typeof module == 'object' && module.exports ) {
28	+ // CommonJS
29	+ module.exports = factory(
30	+ window,
31	+ require('jquery')
32	+ );
33	+ } else {
34	+ // browser global
35	+ window.jQueryBridget = factory(
36	+ window,
37	+ window.jQuery
38	+ );
39	+ }
40	+
41	+ }( window, function factory( window, jQuery ) {
42	+ 'use strict';
43	+
44	+ // ----- utils ----- //
45	+
46	+ var arraySlice = Array.prototype.slice;
47	+
48	+ // helper function for logging errors
49	+ // $.error breaks jQuery chaining
50	+ var console = window.console;
51	+ var logError = typeof console == 'undefined' ? function() {} :
52	+ function( message ) {
53	+ console.error( message );
54	+ };
55	+
56	+ // ----- jQueryBridget ----- //
57	+
58	+ function jQueryBridget( namespace, PluginClass, $ ) {
59	+ $ = $ \|\| jQuery \|\| window.jQuery;
60	+ if ( !$ ) {
61	+ return;
62	+ }
63	+
64	+ // add option method -> $().plugin('option', {...})
65	+ if ( !PluginClass.prototype.option ) {
66	+ // option setter
67	+ PluginClass.prototype.option = function( opts ) {
68	+ // bail out if not an object
69	+ if ( !$.isPlainObject( opts ) ){
70	+ return;
71	+ }
72	+ this.options = $.extend( true, this.options, opts );
73	+ };
74	+ }
75	+
76	+ // make jQuery plugin
77	+ $.fn[ namespace ] = function( arg0 /, arg1 / ) {
78	+ if ( typeof arg0 == 'string' ) {
79	+ // method call $().plugin( 'methodName', { options } )
80	+ // shift arguments by 1
81	+ var args = arraySlice.call( arguments, 1 );
82	+ return methodCall( this, arg0, args );
83	+ }
84	+ // just $().plugin({ options })
85	+ plainCall( this, arg0 );
86	+ return this;
87	+ };
88	+
89	+ // $().plugin('methodName')
90	+ function methodCall( $elems, methodName, args ) {
91	+ var returnValue;
92	+ var pluginMethodStr = '$().' + namespace + '("' + methodName + '")';
93	+
94	+ $elems.each( function( i, elem ) {
95	+ // get instance
96	+ var instance = $.data( elem, namespace );
97	+ if ( !instance ) {
98	+ logError( namespace + ' not initialized. Cannot call methods, i.e. ' +
99	+ pluginMethodStr );
100	+ return;
101	+ }
102	+
103	+ var method = instance[ methodName ];
104	+ if ( !method \|\| methodName.charAt(0) == '_' ) {
105	+ logError( pluginMethodStr + ' is not a valid method' );
106	+ return;
107	+ }
108	+
109	+ // apply method, get return value
110	+ var value = method.apply( instance, args );
111	+ // set return value if value is returned, use only first value
112	+ returnValue = returnValue === undefined ? value : returnValue;
113	+ });
114	+
115	+ return returnValue !== undefined ? returnValue : $elems;
116	+ }
117	+
118	+ function plainCall( $elems, options ) {
119	+ $elems.each( function( i, elem ) {
120	+ var instance = $.data( elem, namespace );
121	+ if ( instance ) {
122	+ // set options & init
123	+ instance.option( options );
124	+ instance._init();
125	+ } else {
126	+ // initialize new instance
127	+ instance = new PluginClass( elem, options );
128	+ $.data( elem, namespace, instance );
129	+ }
130	+ });
131	+ }
132	+
133	+ updateJQuery( $ );
134	+
135	+ }
136	+
137	+ // ----- updateJQuery ----- //
138	+
139	+ // set $.bridget for v1 backwards compatibility
140	+ function updateJQuery( $ ) {
141	+ if ( !$ \|\| ( $ && $.bridget ) ) {
142	+ return;
143	+ }
144	+ $.bridget = jQueryBridget;
145	+ }
146	+
147	+ updateJQuery( jQuery \|\| window.jQuery );
148	+
149	+ // ----- ----- //
150	+
151	+ return jQueryBridget;
152	+
153	+ }));
154	+
155	+ /**
156	+ * EvEmitter v1.1.0
157	+ * Lil' event emitter
158	+ * MIT License
159	+ */
160	+
161	+ /* jshint unused: true, undef: true, strict: true */
162	+
163	+ ( function( global, factory ) {
164	+ // universal module definition
165	+ /* jshint strict: false / / globals define, module, window */
166	+ if ( typeof define == 'function' && define.amd ) {
167	+ // AMD - RequireJS
168	+ define( 'ev-emitter/ev-emitter',factory );
169	+ } else if ( typeof module == 'object' && module.exports ) {
170	+ // CommonJS - Browserify, Webpack
171	+ module.exports = factory();
172	+ } else {
173	+ // Browser globals
174	+ global.EvEmitter = factory();
175	+ }
176	+
177	+ }( typeof window != 'undefined' ? window : this, function() {
178	+
179	+
180	+
181	+ function EvEmitter() {}
182	+
183	+ var proto = EvEmitter.prototype;
184	+
185	+ proto.on = function( eventName, listener ) {
186	+ if ( !eventName \|\| !listener ) {
187	+ return;
188	+ }
189	+ // set events hash
190	+ var events = this._events = this._events \|\| {};
191	+ // set listeners array
192	+ var listeners = events[ eventName ] = events[ eventName ] \|\| [];
193	+ // only add once
194	+ if ( listeners.indexOf( listener ) == -1 ) {
195	+ listeners.push( listener );
196	+ }
197	+
198	+ return this;
199	+ };
200	+
201	+ proto.once = function( eventName, listener ) {
202	+ if ( !eventName \|\| !listener ) {
203	+ return;
204	+ }
205	+ // add event
206	+ this.on( eventName, listener );
207	+ // set once flag
208	+ // set onceEvents hash
209	+ var onceEvents = this._onceEvents = this._onceEvents \|\| {};
210	+ // set onceListeners object
211	+ var onceListeners = onceEvents[ eventName ] = onceEvents[ eventName ] \|\| {};
212	+ // set flag
213	+ onceListeners[ listener ] = true;
214	+
215	+ return this;
216	+ };
217	+
218	+ proto.off = function( eventName, listener ) {
219	+ var listeners = this._events && this._events[ eventName ];
220	+ if ( !listeners \|\| !listeners.length ) {
221	+ return;
222	+ }
223	+ var index = listeners.indexOf( listener );
224	+ if ( index != -1 ) {
225	+ listeners.splice( index, 1 );
226	+ }
227	+
228	+ return this;
229	+ };
230	+
231	+ proto.emitEvent = function( eventName, args ) {
232	+ var listeners = this._events && this._events[ eventName ];
233	+ if ( !listeners \|\| !listeners.length ) {
234	+ return;
235	+ }
236	+ // copy over to avoid interference if .off() in listener
237	+ listeners = listeners.slice(0);
238	+ args = args \|\| [];
239	+ // once stuff
240	+ var onceListeners = this._onceEvents && this._onceEvents[ eventName ];
241	+
242	+ for ( var i=0; i < listeners.length; i++ ) {
243	+ var listener = listeners[i]
244	+ var isOnce = onceListeners && onceListeners[ listener ];
245	+ if ( isOnce ) {
246	+ // remove listener
247	+ // remove before trigger to prevent recursion
248	+ this.off( eventName, listener );
249	+ // unset once flag
250	+ delete onceListeners[ listener ];
251	+ }
252	+ // trigger listener
253	+ listener.apply( this, args );
254	+ }
255	+
256	+ return this;
257	+ };
258	+
259	+ proto.allOff = function() {
260	+ delete this._events;
261	+ delete this._onceEvents;
262	+ };
263	+
264	+ return EvEmitter;
265	+
266	+ }));
267	+
268	+ /*!
269	+ * getSize v2.0.3
270	+ * measure size of elements
271	+ * MIT license
272	+ */
273	+
274	+ /* jshint browser: true, strict: true, undef: true, unused: true */
275	+ /* globals console: false */
276	+
277	+ ( function( window, factory ) {
278	+ /* jshint strict: false / / globals define, module */
279	+ if ( typeof define == 'function' && define.amd ) {
280	+ // AMD
281	+ define( 'get-size/get-size',factory );
282	+ } else if ( typeof module == 'object' && module.exports ) {
283	+ // CommonJS
284	+ module.exports = factory();
285	+ } else {
286	+ // browser global
287	+ window.getSize = factory();
288	+ }
289	+
290	+ })( window, function factory() {
291	+ 'use strict';
292	+
293	+ // -------------------------- helpers -------------------------- //
294	+
295	+ // get a number from a string, not a percentage
296	+ function getStyleSize( value ) {
297	+ var num = parseFloat( value );
298	+ // not a percent like '100%', and a number
299	+ var isValid = value.indexOf('%') == -1 && !isNaN( num );
300	+ return isValid && num;
301	+ }
302	+
303	+ function noop() {}
304	+
305	+ var logError = typeof console == 'undefined' ? noop :
306	+ function( message ) {
307	+ console.error( message );
308	+ };
309	+
310	+ // -------------------------- measurements -------------------------- //
311	+
312	+ var measurements = [
313	+ 'paddingLeft',
314	+ 'paddingRight',
315	+ 'paddingTop',
316	+ 'paddingBottom',
317	+ 'marginLeft',
318	+ 'marginRight',
319	+ 'marginTop',
320	+ 'marginBottom',
321	+ 'borderLeftWidth',
322	+ 'borderRightWidth',
323	+ 'borderTopWidth',
324	+ 'borderBottomWidth'
325	+ ];
326	+
327	+ var measurementsLength = measurements.length;
328	+
329	+ function getZeroSize() {
330	+ var size = {
331	+ width: 0,
332	+ height: 0,
333	+ innerWidth: 0,
334	+ innerHeight: 0,
335	+ outerWidth: 0,
336	+ outerHeight: 0
337	+ };
338	+ for ( var i=0; i < measurementsLength; i++ ) {
339	+ var measurement = measurements[i];
340	+ size[ measurement ] = 0;
341	+ }
342	+ return size;
343	+ }
344	+
345	+ // -------------------------- getStyle -------------------------- //
346	+
347	+ /**
348	+ * getStyle, get style of element, check for Firefox bug
349	+ * https://bugzilla.mozilla.org/show_bug.cgi?id=548397
350	+ */
351	+ function getStyle( elem ) {
352	+ var style = getComputedStyle( elem );
353	+ if ( !style ) {
354	+ logError( 'Style returned ' + style +
355	+ '. Are you running this code in a hidden iframe on Firefox? ' +
356	+ 'See https://bit.ly/getsizebug1' );
357	+ }
358	+ return style;
359	+ }
360	+
361	+ // -------------------------- setup -------------------------- //
362	+
363	+ var isSetup = false;
364	+
365	+ var isBoxSizeOuter;
366	+
367	+ /**
368	+ * setup
369	+ * check isBoxSizerOuter
370	+ * do on first getSize() rather than on page load for Firefox bug
371	+ */
372	+ function setup() {
373	+ // setup once
374	+ if ( isSetup ) {
375	+ return;
376	+ }
377	+ isSetup = true;
378	+
379	+ // -------------------------- box sizing -------------------------- //
380	+
381	+ /**
382	+ * Chrome & Safari measure the outer-width on style.width on border-box elems
383	+ * IE11 & Firefox<29 measures the inner-width
384	+ */
385	+ var div = document.createElement('div');
386	+ div.style.width = '200px';
387	+ div.style.padding = '1px 2px 3px 4px';
388	+ div.style.borderStyle = 'solid';
389	+ div.style.borderWidth = '1px 2px 3px 4px';
390	+ div.style.boxSizing = 'border-box';
391	+
392	+ var body = document.body \|\| document.documentElement;
393	+ body.appendChild( div );
394	+ var style = getStyle( div );
395	+ // round value for browser zoom. desandro/masonry#928
396	+ isBoxSizeOuter = Math.round( getStyleSize( style.width ) ) == 200;
397	+ getSize.isBoxSizeOuter = isBoxSizeOuter;
398	+
399	+ body.removeChild( div );
400	+ }
401	+
402	+ // -------------------------- getSize -------------------------- //
403	+
404	+ function getSize( elem ) {
405	+ setup();
406	+
407	+ // use querySeletor if elem is string
408	+ if ( typeof elem == 'string' ) {
409	+ elem = document.querySelector( elem );
410	+ }
411	+
412	+ // do not proceed on non-objects
413	+ if ( !elem \|\| typeof elem != 'object' \|\| !elem.nodeType ) {
414	+ return;
415	+ }
416	+
417	+ var style = getStyle( elem );
418	+
419	+ // if hidden, everything is 0
420	+ if ( style.display == 'none' ) {
421	+ return getZeroSize();
422	+ }
423	+
424	+ var size = {};
425	+ size.width = elem.offsetWidth;
426	+ size.height = elem.offsetHeight;
427	+
428	+ var isBorderBox = size.isBorderBox = style.boxSizing == 'border-box';
429	+
430	+ // get all measurements
431	+ for ( var i=0; i < measurementsLength; i++ ) {
432	+ var measurement = measurements[i];
433	+ var value = style[ measurement ];
434	+ var num = parseFloat( value );
435	+ // any 'auto', 'medium' value will be 0
436	+ size[ measurement ] = !isNaN( num ) ? num : 0;
437	+ }
438	+
439	+ var paddingWidth = size.paddingLeft + size.paddingRight;
440	+ var paddingHeight = size.paddingTop + size.paddingBottom;
441	+ var marginWidth = size.marginLeft + size.marginRight;
442	+ var marginHeight = size.marginTop + size.marginBottom;
443	+ var borderWidth = size.borderLeftWidth + size.borderRightWidth;
444	+ var borderHeight = size.borderTopWidth + size.borderBottomWidth;
445	+
446	+ var isBorderBoxSizeOuter = isBorderBox && isBoxSizeOuter;
447	+
448	+ // overwrite width and height if we can get it from style
449	+ var styleWidth = getStyleSize( style.width );
450	+ if ( styleWidth !== false ) {
451	+ size.width = styleWidth +
452	+ // add padding and border unless it's already including it
453	+ ( isBorderBoxSizeOuter ? 0 : paddingWidth + borderWidth );
454	+ }
455	+
456	+ var styleHeight = getStyleSize( style.height );
457	+ if ( styleHeight !== false ) {
458	+ size.height = styleHeight +
459	+ // add padding and border unless it's already including it
460	+ ( isBorderBoxSizeOuter ? 0 : paddingHeight + borderHeight );
461	+ }
462	+
463	+ size.innerWidth = size.width - ( paddingWidth + borderWidth );
464	+ size.innerHeight = size.height - ( paddingHeight + borderHeight );
465	+
466	+ size.outerWidth = size.width + marginWidth;
467	+ size.outerHeight = size.height + marginHeight;
468	+
469	+ return size;
470	+ }
471	+
472	+ return getSize;
473	+
474	+ });
475	+
476	+ /**
477	+ * matchesSelector v2.0.2
478	+ * matchesSelector( element, '.selector' )
479	+ * MIT license
480	+ */
481	+
482	+ /jshint browser: true, strict: true, undef: true, unused: true /
483	+
484	+ ( function( window, factory ) {
485	+ /global define: false, module: false /
486	+ 'use strict';
487	+ // universal module definition
488	+ if ( typeof define == 'function' && define.amd ) {
489	+ // AMD
490	+ define( 'desandro-matches-selector/matches-selector',factory );
491	+ } else if ( typeof module == 'object' && module.exports ) {
492	+ // CommonJS
493	+ module.exports = factory();
494	+ } else {
495	+ // browser global
496	+ window.matchesSelector = factory();
497	+ }
498	+
499	+ }( window, function factory() {
500	+ 'use strict';
501	+
502	+ var matchesMethod = ( function() {
503	+ var ElemProto = window.Element.prototype;
504	+ // check for the standard method name first
505	+ if ( ElemProto.matches ) {
506	+ return 'matches';
507	+ }
508	+ // check un-prefixed
509	+ if ( ElemProto.matchesSelector ) {
510	+ return 'matchesSelector';
511	+ }
512	+ // check vendor prefixes
513	+ var prefixes = [ 'webkit', 'moz', 'ms', 'o' ];
514	+
515	+ for ( var i=0; i < prefixes.length; i++ ) {
516	+ var prefix = prefixes[i];
517	+ var method = prefix + 'MatchesSelector';
518	+ if ( ElemProto[ method ] ) {
519	+ return method;
520	+ }
521	+ }
522	+ })();
523	+
524	+ return function matchesSelector( elem, selector ) {
525	+ return elem[ matchesMethod ]( selector );
526	+ };
527	+
528	+ }));
529	+
530	+ /**
531	+ * Fizzy UI utils v2.0.7
532	+ * MIT license
533	+ */
534	+
535	+ /jshint browser: true, undef: true, unused: true, strict: true /
536	+
537	+ ( function( window, factory ) {
538	+ // universal module definition
539	+ /jshint strict: false / /globals define, module, require /
540	+
541	+ if ( typeof define == 'function' && define.amd ) {
542	+ // AMD
543	+ define( 'fizzy-ui-utils/utils',[
544	+ 'desandro-matches-selector/matches-selector'
545	+ ], function( matchesSelector ) {
546	+ return factory( window, matchesSelector );
547	+ });
548	+ } else if ( typeof module == 'object' && module.exports ) {
549	+ // CommonJS
550	+ module.exports = factory(
551	+ window,
552	+ require('desandro-matches-selector')
553	+ );
554	+ } else {
555	+ // browser global
556	+ window.fizzyUIUtils = factory(
557	+ window,
558	+ window.matchesSelector
559	+ );
560	+ }
561	+
562	+ }( window, function factory( window, matchesSelector ) {
563	+
564	+
565	+
566	+ var utils = {};
567	+
568	+ // ----- extend ----- //
569	+
570	+ // extends objects
571	+ utils.extend = function( a, b ) {
572	+ for ( var prop in b ) {
573	+ a[ prop ] = b[ prop ];
574	+ }
575	+ return a;
576	+ };
577	+
578	+ // ----- modulo ----- //
579	+
580	+ utils.modulo = function( num, div ) {
581	+ return ( ( num % div ) + div ) % div;
582	+ };
583	+
584	+ // ----- makeArray ----- //
585	+
586	+ var arraySlice = Array.prototype.slice;
587	+
588	+ // turn element or nodeList into an array
589	+ utils.makeArray = function( obj ) {
590	+ if ( Array.isArray( obj ) ) {
591	+ // use object if already an array
592	+ return obj;
593	+ }
594	+ // return empty array if undefined or null. #6
595	+ if ( obj === null \|\| obj === undefined ) {
596	+ return [];
597	+ }
598	+
599	+ var isArrayLike = typeof obj == 'object' && typeof obj.length == 'number';
600	+ if ( isArrayLike ) {
601	+ // convert nodeList to array
602	+ return arraySlice.call( obj );
603	+ }
604	+
605	+ // array of single index
606	+ return [ obj ];
607	+ };
608	+
609	+ // ----- removeFrom ----- //
610	+
611	+ utils.removeFrom = function( ary, obj ) {
612	+ var index = ary.indexOf( obj );
613	+ if ( index != -1 ) {
614	+ ary.splice( index, 1 );
615	+ }
616	+ };
617	+
618	+ // ----- getParent ----- //
619	+
620	+ utils.getParent = function( elem, selector ) {
621	+ while ( elem.parentNode && elem != document.body ) {
622	+ elem = elem.parentNode;
623	+ if ( matchesSelector( elem, selector ) ) {
624	+ return elem;
625	+ }
626	+ }
627	+ };
628	+
629	+ // ----- getQueryElement ----- //
630	+
631	+ // use element as selector string
632	+ utils.getQueryElement = function( elem ) {
633	+ if ( typeof elem == 'string' ) {
634	+ return document.querySelector( elem );
635	+ }
636	+ return elem;
637	+ };
638	+
639	+ // ----- handleEvent ----- //
640	+
641	+ // enable .ontype to trigger from .addEventListener( elem, 'type' )
642	+ utils.handleEvent = function( event ) {
643	+ var method = 'on' + event.type;
644	+ if ( this[ method ] ) {
645	+ this[ method ]( event );
646	+ }
647	+ };
648	+
649	+ // ----- filterFindElements ----- //
650	+
651	+ utils.filterFindElements = function( elems, selector ) {
652	+ // make array of elems
653	+ elems = utils.makeArray( elems );
654	+ var ffElems = [];
655	+
656	+ elems.forEach( function( elem ) {
657	+ // check that elem is an actual element
658	+ if ( !( elem instanceof HTMLElement ) ) {
659	+ return;
660	+ }
661	+ // add elem if no selector
662	+ if ( !selector ) {
663	+ ffElems.push( elem );
664	+ return;
665	+ }
666	+ // filter & find items if we have a selector
667	+ // filter
668	+ if ( matchesSelector( elem, selector ) ) {
669	+ ffElems.push( elem );
670	+ }
671	+ // find children
672	+ var childElems = elem.querySelectorAll( selector );
673	+ // concat childElems to filterFound array
674	+ for ( var i=0; i < childElems.length; i++ ) {
675	+ ffElems.push( childElems[i] );
676	+ }
677	+ });
678	+
679	+ return ffElems;
680	+ };
681	+
682	+ // ----- debounceMethod ----- //
683	+
684	+ utils.debounceMethod = function( _class, methodName, threshold ) {
685	+ threshold = threshold \|\| 100;
686	+ // original method
687	+ var method = _class.prototype[ methodName ];
688	+ var timeoutName = methodName + 'Timeout';
689	+
690	+ _class.prototype[ methodName ] = function() {
691	+ var timeout = this[ timeoutName ];
692	+ clearTimeout( timeout );
693	+
694	+ var args = arguments;
695	+ var _this = this;
696	+ this[ timeoutName ] = setTimeout( function() {
697	+ method.apply( _this, args );
698	+ delete _this[ timeoutName ];
699	+ }, threshold );
700	+ };
701	+ };
702	+
703	+ // ----- docReady ----- //
704	+
705	+ utils.docReady = function( callback ) {
706	+ var readyState = document.readyState;
707	+ if ( readyState == 'complete' \|\| readyState == 'interactive' ) {
708	+ // do async to allow for other scripts to run. metafizzy/flickity#441
709	+ setTimeout( callback );
710	+ } else {
711	+ document.addEventListener( 'DOMContentLoaded', callback );
712	+ }
713	+ };
714	+
715	+ // ----- htmlInit ----- //
716	+
717	+ // http://jamesroberts.name/blog/2010/02/22/string-functions-for-javascript-trim-to-camel-case-to-dashed-and-to-underscore/
718	+ utils.toDashed = function( str ) {
719	+ return str.replace( /(.)([A-Z])/g, function( match, $1, $2 ) {
720	+ return $1 + '-' + $2;
721	+ }).toLowerCase();
722	+ };
723	+
724	+ var console = window.console;
725	+ /**
726	+ * allow user to initialize classes via [data-namespace] or .js-namespace class
727	+ * htmlInit( Widget, 'widgetName' )
728	+ * options are parsed from data-namespace-options
729	+ */
730	+ utils.htmlInit = function( WidgetClass, namespace ) {
731	+ utils.docReady( function() {
732	+ var dashedNamespace = utils.toDashed( namespace );
733	+ var dataAttr = 'data-' + dashedNamespace;
734	+ var dataAttrElems = document.querySelectorAll( '[' + dataAttr + ']' );
735	+ var jsDashElems = document.querySelectorAll( '.js-' + dashedNamespace );
736	+ var elems = utils.makeArray( dataAttrElems )
737	+ .concat( utils.makeArray( jsDashElems ) );
738	+ var dataOptionsAttr = dataAttr + '-options';
739	+ var jQuery = window.jQuery;
740	+
741	+ elems.forEach( function( elem ) {
742	+ var attr = elem.getAttribute( dataAttr ) \|\|
743	+ elem.getAttribute( dataOptionsAttr );
744	+ var options;
745	+ try {
746	+ options = attr && JSON.parse( attr );
747	+ } catch ( error ) {
748	+ // log error, do not initialize
749	+ if ( console ) {
750	+ console.error( 'Error parsing ' + dataAttr + ' on ' + elem.className +
751	+ ': ' + error );
752	+ }
753	+ return;
754	+ }
755	+ // initialize
756	+ var instance = new WidgetClass( elem, options );
757	+ // make available via $().data('namespace')
758	+ if ( jQuery ) {
759	+ jQuery.data( elem, namespace, instance );
760	+ }
761	+ });
762	+
763	+ });
764	+ };
765	+
766	+ // ----- ----- //
767	+
768	+ return utils;
769	+
770	+ }));
771	+
772	+ /**
773	+ * Outlayer Item
774	+ */
775	+
776	+ ( function( window, factory ) {
777	+ // universal module definition
778	+ /* jshint strict: false / / globals define, module, require */
779	+ if ( typeof define == 'function' && define.amd ) {
780	+ // AMD - RequireJS
781	+ define( 'outlayer/item',[
782	+ 'ev-emitter/ev-emitter',
783	+ 'get-size/get-size'
784	+ ],
785	+ factory
786	+ );
787	+ } else if ( typeof module == 'object' && module.exports ) {
788	+ // CommonJS - Browserify, Webpack
789	+ module.exports = factory(
790	+ require('ev-emitter'),
791	+ require('get-size')
792	+ );
793	+ } else {
794	+ // browser global
795	+ window.Outlayer = {};
796	+ window.Outlayer.Item = factory(
797	+ window.EvEmitter,
798	+ window.getSize
799	+ );
800	+ }
801	+
802	+ }( window, function factory( EvEmitter, getSize ) {
803	+ 'use strict';
804	+
805	+ // ----- helpers ----- //
806	+
807	+ function isEmptyObj( obj ) {
808	+ for ( var prop in obj ) {
809	+ return false;
810	+ }
811	+ prop = null;
812	+ return true;
813	+ }
814	+
815	+ // -------------------------- CSS3 support -------------------------- //
816	+
817	+
818	+ var docElemStyle = document.documentElement.style;
819	+
820	+ var transitionProperty = typeof docElemStyle.transition == 'string' ?
821	+ 'transition' : 'WebkitTransition';
822	+ var transformProperty = typeof docElemStyle.transform == 'string' ?
823	+ 'transform' : 'WebkitTransform';
824	+
825	+ var transitionEndEvent = {
826	+ WebkitTransition: 'webkitTransitionEnd',
827	+ transition: 'transitionend'
828	+ }[ transitionProperty ];
829	+
830	+ // cache all vendor properties that could have vendor prefix
831	+ var vendorProperties = {
832	+ transform: transformProperty,
833	+ transition: transitionProperty,
834	+ transitionDuration: transitionProperty + 'Duration',
835	+ transitionProperty: transitionProperty + 'Property',
836	+ transitionDelay: transitionProperty + 'Delay'
837	+ };
838	+
839	+ // -------------------------- Item -------------------------- //
840	+
841	+ function Item( element, layout ) {
842	+ if ( !element ) {
843	+ return;
844	+ }
845	+
846	+ this.element = element;
847	+ // parent layout class, i.e. Masonry, Isotope, or Packery
848	+ this.layout = layout;
849	+ this.position = {
850	+ x: 0,
851	+ y: 0
852	+ };
853	+
854	+ this._create();
855	+ }
856	+
857	+ // inherit EvEmitter
858	+ var proto = Item.prototype = Object.create( EvEmitter.prototype );
859	+ proto.constructor = Item;
860	+
861	+ proto._create = function() {
862	+ // transition objects
863	+ this._transn = {
864	+ ingProperties: {},
865	+ clean: {},
866	+ onEnd: {}
867	+ };
868	+
869	+ this.css({
870	+ position: 'absolute'
871	+ });
872	+ };
873	+
874	+ // trigger specified handler for event type
875	+ proto.handleEvent = function( event ) {
876	+ var method = 'on' + event.type;
877	+ if ( this[ method ] ) {
878	+ this[ method ]( event );
879	+ }
880	+ };
881	+
882	+ proto.getSize = function() {
883	+ this.size = getSize( this.element );
884	+ };
885	+
886	+ /**
887	+ * apply CSS styles to element
888	+ * @param {Object} style
889	+ */
890	+ proto.css = function( style ) {
891	+ var elemStyle = this.element.style;
892	+
893	+ for ( var prop in style ) {
894	+ // use vendor property if available
895	+ var supportedProp = vendorProperties[ prop ] \|\| prop;
896	+ elemStyle[ supportedProp ] = style[ prop ];
897	+ }
898	+ };
899	+
900	+ // measure position, and sets it
901	+ proto.getPosition = function() {
902	+ var style = getComputedStyle( this.element );
903	+ var isOriginLeft = this.layout._getOption('originLeft');
904	+ var isOriginTop = this.layout._getOption('originTop');
905	+ var xValue = style[ isOriginLeft ? 'left' : 'right' ];
906	+ var yValue = style[ isOriginTop ? 'top' : 'bottom' ];
907	+ var x = parseFloat( xValue );
908	+ var y = parseFloat( yValue );
909	+ // convert percent to pixels
910	+ var layoutSize = this.layout.size;
911	+ if ( xValue.indexOf('%') != -1 ) {
912	+ x = ( x / 100 ) * layoutSize.width;
913	+ }
914	+ if ( yValue.indexOf('%') != -1 ) {
915	+ y = ( y / 100 ) * layoutSize.height;
916	+ }
917	+ // clean up 'auto' or other non-integer values
918	+ x = isNaN( x ) ? 0 : x;
919	+ y = isNaN( y ) ? 0 : y;
920	+ // remove padding from measurement
921	+ x -= isOriginLeft ? layoutSize.paddingLeft : layoutSize.paddingRight;
922	+ y -= isOriginTop ? layoutSize.paddingTop : layoutSize.paddingBottom;
923	+
924	+ this.position.x = x;
925	+ this.position.y = y;
926	+ };
927	+
928	+ // set settled position, apply padding
929	+ proto.layoutPosition = function() {
930	+ var layoutSize = this.layout.size;
931	+ var style = {};
932	+ var isOriginLeft = this.layout._getOption('originLeft');
933	+ var isOriginTop = this.layout._getOption('originTop');
934	+
935	+ // x
936	+ var xPadding = isOriginLeft ? 'paddingLeft' : 'paddingRight';
937	+ var xProperty = isOriginLeft ? 'left' : 'right';
938	+ var xResetProperty = isOriginLeft ? 'right' : 'left';
939	+
940	+ var x = this.position.x + layoutSize[ xPadding ];
941	+ // set in percentage or pixels
942	+ style[ xProperty ] = this.getXValue( x );
943	+ // reset other property
944	+ style[ xResetProperty ] = '';
945	+
946	+ // y
947	+ var yPadding = isOriginTop ? 'paddingTop' : 'paddingBottom';
948	+ var yProperty = isOriginTop ? 'top' : 'bottom';
949	+ var yResetProperty = isOriginTop ? 'bottom' : 'top';
950	+
951	+ var y = this.position.y + layoutSize[ yPadding ];
952	+ // set in percentage or pixels
953	+ style[ yProperty ] = this.getYValue( y );
954	+ // reset other property
955	+ style[ yResetProperty ] = '';
956	+
957	+ this.css( style );
958	+ this.emitEvent( 'layout', [ this ] );
959	+ };
960	+
961	+ proto.getXValue = function( x ) {
962	+ var isHorizontal = this.layout._getOption('horizontal');
963	+ return this.layout.options.percentPosition && !isHorizontal ?
964	+ ( ( x / this.layout.size.width ) * 100 ) + '%' : x + 'px';
965	+ };
966	+
967	+ proto.getYValue = function( y ) {
968	+ var isHorizontal = this.layout._getOption('horizontal');
969	+ return this.layout.options.percentPosition && isHorizontal ?
970	+ ( ( y / this.layout.size.height ) * 100 ) + '%' : y + 'px';
971	+ };
972	+
973	+ proto._transitionTo = function( x, y ) {
974	+ this.getPosition();
975	+ // get current x & y from top/left
976	+ var curX = this.position.x;
977	+ var curY = this.position.y;
978	+
979	+ var didNotMove = x == this.position.x && y == this.position.y;
980	+
981	+ // save end position
982	+ this.setPosition( x, y );
983	+
984	+ // if did not move and not transitioning, just go to layout
985	+ if ( didNotMove && !this.isTransitioning ) {
986	+ this.layoutPosition();
987	+ return;
988	+ }
989	+
990	+ var transX = x - curX;
991	+ var transY = y - curY;
992	+ var transitionStyle = {};
993	+ transitionStyle.transform = this.getTranslate( transX, transY );
994	+
995	+ this.transition({
996	+ to: transitionStyle,
997	+ onTransitionEnd: {
998	+ transform: this.layoutPosition
999	+ },
1000	+ isCleaning: true
1001	+ });
1002	+ };
1003	+
1004	+ proto.getTranslate = function( x, y ) {
1005	+ // flip cooridinates if origin on right or bottom
1006	+ var isOriginLeft = this.layout._getOption('originLeft');
1007	+ var isOriginTop = this.layout._getOption('originTop');
1008	+ x = isOriginLeft ? x : -x;
1009	+ y = isOriginTop ? y : -y;
1010	+ return 'translate3d(' + x + 'px, ' + y + 'px, 0)';
1011	+ };
1012	+
1013	+ // non transition + transform support
1014	+ proto.goTo = function( x, y ) {
1015	+ this.setPosition( x, y );
1016	+ this.layoutPosition();
1017	+ };
1018	+
1019	+ proto.moveTo = proto._transitionTo;
1020	+
1021	+ proto.setPosition = function( x, y ) {
1022	+ this.position.x = parseFloat( x );
1023	+ this.position.y = parseFloat( y );
1024	+ };
1025	+
1026	+ // ----- transition ----- //
1027	+
1028	+ /**
1029	+ * @param {Object} style - CSS
1030	+ * @param {Function} onTransitionEnd
1031	+ */
1032	+
1033	+ // non transition, just trigger callback
1034	+ proto._nonTransition = function( args ) {
1035	+ this.css( args.to );
1036	+ if ( args.isCleaning ) {
1037	+ this._removeStyles( args.to );
1038	+ }
1039	+ for ( var prop in args.onTransitionEnd ) {
1040	+ args.onTransitionEnd[ prop ].call( this );
1041	+ }
1042	+ };
1043	+
1044	+ /**
1045	+ * proper transition
1046	+ * @param {Object} args - arguments
1047	+ * @param {Object} to - style to transition to
1048	+ * @param {Object} from - style to start transition from
1049	+ * @param {Boolean} isCleaning - removes transition styles after transition
1050	+ * @param {Function} onTransitionEnd - callback
1051	+ */
1052	+ proto.transition = function( args ) {
1053	+ // redirect to nonTransition if no transition duration
1054	+ if ( !parseFloat( this.layout.options.transitionDuration ) ) {
1055	+ this._nonTransition( args );
1056	+ return;
1057	+ }
1058	+
1059	+ var _transition = this._transn;
1060	+ // keep track of onTransitionEnd callback by css property
1061	+ for ( var prop in args.onTransitionEnd ) {
1062	+ _transition.onEnd[ prop ] = args.onTransitionEnd[ prop ];
1063	+ }
1064	+ // keep track of properties that are transitioning
1065	+ for ( prop in args.to ) {
1066	+ _transition.ingProperties[ prop ] = true;
1067	+ // keep track of properties to clean up when transition is done
1068	+ if ( args.isCleaning ) {
1069	+ _transition.clean[ prop ] = true;
1070	+ }
1071	+ }
1072	+
1073	+ // set from styles
1074	+ if ( args.from ) {
1075	+ this.css( args.from );
1076	+ // force redraw. http://blog.alexmaccaw.com/css-transitions
1077	+ var h = this.element.offsetHeight;
1078	+ // hack for JSHint to hush about unused var
1079	+ h = null;
1080	+ }
1081	+ // enable transition
1082	+ this.enableTransition( args.to );
1083	+ // set styles that are transitioning
1084	+ this.css( args.to );
1085	+
1086	+ this.isTransitioning = true;
1087	+
1088	+ };
1089	+
1090	+ // dash before all cap letters, including first for
1091	+ // WebkitTransform => -webkit-transform
1092	+ function toDashedAll( str ) {
1093	+ return str.replace( /([A-Z])/g, function( $1 ) {
1094	+ return '-' + $1.toLowerCase();
1095	+ });
1096	+ }
1097	+
1098	+ var transitionProps = 'opacity,' + toDashedAll( transformProperty );
1099	+
1100	+ proto.enableTransition = function(/* style */) {
1101	+ // HACK changing transitionProperty during a transition
1102	+ // will cause transition to jump
1103	+ if ( this.isTransitioning ) {
1104	+ return;
1105	+ }
1106	+
1107	+ // make `transition: foo, bar, baz` from style object
1108	+ // HACK un-comment this when enableTransition can work
1109	+ // while a transition is happening
1110	+ // var transitionValues = [];
1111	+ // for ( var prop in style ) {
1112	+ // // dash-ify camelCased properties like WebkitTransition
1113	+ // prop = vendorProperties[ prop ] \|\| prop;
1114	+ // transitionValues.push( toDashedAll( prop ) );
1115	+ // }
1116	+ // munge number to millisecond, to match stagger
1117	+ var duration = this.layout.options.transitionDuration;
1118	+ duration = typeof duration == 'number' ? duration + 'ms' : duration;
1119	+ // enable transition styles
1120	+ this.css({
1121	+ transitionProperty: transitionProps,
1122	+ transitionDuration: duration,
1123	+ transitionDelay: this.staggerDelay \|\| 0
1124	+ });
1125	+ // listen for transition end event
1126	+ this.element.addEventListener( transitionEndEvent, this, false );
1127	+ };
1128	+
1129	+ // ----- events ----- //
1130	+
1131	+ proto.onwebkitTransitionEnd = function( event ) {
1132	+ this.ontransitionend( event );
1133	+ };
1134	+
1135	+ proto.onotransitionend = function( event ) {
1136	+ this.ontransitionend( event );
1137	+ };
1138	+
1139	+ // properties that I munge to make my life easier
1140	+ var dashedVendorProperties = {
1141	+ '-webkit-transform': 'transform'
1142	+ };
1143	+
1144	+ proto.ontransitionend = function( event ) {
1145	+ // disregard bubbled events from children
1146	+ if ( event.target !== this.element ) {
1147	+ return;
1148	+ }
1149	+ var _transition = this._transn;
1150	+ // get property name of transitioned property, convert to prefix-free
1151	+ var propertyName = dashedVendorProperties[ event.propertyName ] \|\| event.propertyName;
1152	+
1153	+ // remove property that has completed transitioning
1154	+ delete _transition.ingProperties[ propertyName ];
1155	+ // check if any properties are still transitioning
1156	+ if ( isEmptyObj( _transition.ingProperties ) ) {
1157	+ // all properties have completed transitioning
1158	+ this.disableTransition();
1159	+ }
1160	+ // clean style
1161	+ if ( propertyName in _transition.clean ) {
1162	+ // clean up style
1163	+ this.element.style[ event.propertyName ] = '';
1164	+ delete _transition.clean[ propertyName ];
1165	+ }
1166	+ // trigger onTransitionEnd callback
1167	+ if ( propertyName in _transition.onEnd ) {
1168	+ var onTransitionEnd = _transition.onEnd[ propertyName ];
1169	+ onTransitionEnd.call( this );
1170	+ delete _transition.onEnd[ propertyName ];
1171	+ }
1172	+
1173	+ this.emitEvent( 'transitionEnd', [ this ] );
1174	+ };
1175	+
1176	+ proto.disableTransition = function() {
1177	+ this.removeTransitionStyles();
1178	+ this.element.removeEventListener( transitionEndEvent, this, false );
1179	+ this.isTransitioning = false;
1180	+ };
1181	+
1182	+ /**
1183	+ * removes style property from element
1184	+ * @param {Object} style
1185	+ **/
1186	+ proto._removeStyles = function( style ) {
1187	+ // clean up transition styles
1188	+ var cleanStyle = {};
1189	+ for ( var prop in style ) {
1190	+ cleanStyle[ prop ] = '';
1191	+ }
1192	+ this.css( cleanStyle );
1193	+ };
1194	+
1195	+ var cleanTransitionStyle = {
1196	+ transitionProperty: '',
1197	+ transitionDuration: '',
1198	+ transitionDelay: ''
1199	+ };
1200	+
1201	+ proto.removeTransitionStyles = function() {
1202	+ // remove transition
1203	+ this.css( cleanTransitionStyle );
1204	+ };
1205	+
1206	+ // ----- stagger ----- //
1207	+
1208	+ proto.stagger = function( delay ) {
1209	+ delay = isNaN( delay ) ? 0 : delay;
1210	+ this.staggerDelay = delay + 'ms';
1211	+ };
1212	+
1213	+ // ----- show/hide/remove ----- //
1214	+
1215	+ // remove element from DOM
1216	+ proto.removeElem = function() {
1217	+ this.element.parentNode.removeChild( this.element );
1218	+ // remove display: none
1219	+ this.css({ display: '' });
1220	+ this.emitEvent( 'remove', [ this ] );
1221	+ };
1222	+
1223	+ proto.remove = function() {
1224	+ // just remove element if no transition support or no transition
1225	+ if ( !transitionProperty \|\| !parseFloat( this.layout.options.transitionDuration ) ) {
1226	+ this.removeElem();
1227	+ return;
1228	+ }
1229	+
1230	+ // start transition
1231	+ this.once( 'transitionEnd', function() {
1232	+ this.removeElem();
1233	+ });
1234	+ this.hide();
1235	+ };
1236	+
1237	+ proto.reveal = function() {
1238	+ delete this.isHidden;
1239	+ // remove display: none
1240	+ this.css({ display: '' });
1241	+
1242	+ var options = this.layout.options;
1243	+
1244	+ var onTransitionEnd = {};
1245	+ var transitionEndProperty = this.getHideRevealTransitionEndProperty('visibleStyle');
1246	+ onTransitionEnd[ transitionEndProperty ] = this.onRevealTransitionEnd;
1247	+
1248	+ this.transition({
1249	+ from: options.hiddenStyle,
1250	+ to: options.visibleStyle,
1251	+ isCleaning: true,
1252	+ onTransitionEnd: onTransitionEnd
1253	+ });
1254	+ };
1255	+
1256	+ proto.onRevealTransitionEnd = function() {
1257	+ // check if still visible
1258	+ // during transition, item may have been hidden
1259	+ if ( !this.isHidden ) {
1260	+ this.emitEvent('reveal');
1261	+ }
1262	+ };
1263	+
1264	+ /**
1265	+ * get style property use for hide/reveal transition end
1266	+ * @param {String} styleProperty - hiddenStyle/visibleStyle
1267	+ * @returns {String}
1268	+ */
1269	+ proto.getHideRevealTransitionEndProperty = function( styleProperty ) {
1270	+ var optionStyle = this.layout.options[ styleProperty ];
1271	+ // use opacity
1272	+ if ( optionStyle.opacity ) {
1273	+ return 'opacity';
1274	+ }
1275	+ // get first property
1276	+ for ( var prop in optionStyle ) {
1277	+ return prop;
1278	+ }
1279	+ };
1280	+
1281	+ proto.hide = function() {
1282	+ // set flag
1283	+ this.isHidden = true;
1284	+ // remove display: none
1285	+ this.css({ display: '' });
1286	+
1287	+ var options = this.layout.options;
1288	+
1289	+ var onTransitionEnd = {};
1290	+ var transitionEndProperty = this.getHideRevealTransitionEndProperty('hiddenStyle');
1291	+ onTransitionEnd[ transitionEndProperty ] = this.onHideTransitionEnd;
1292	+
1293	+ this.transition({
1294	+ from: options.visibleStyle,
1295	+ to: options.hiddenStyle,
1296	+ // keep hidden stuff hidden
1297	+ isCleaning: true,
1298	+ onTransitionEnd: onTransitionEnd
1299	+ });
1300	+ };
1301	+
1302	+ proto.onHideTransitionEnd = function() {
1303	+ // check if still hidden
1304	+ // during transition, item may have been un-hidden
1305	+ if ( this.isHidden ) {
1306	+ this.css({ display: 'none' });
1307	+ this.emitEvent('hide');
1308	+ }
1309	+ };
1310	+
1311	+ proto.destroy = function() {
1312	+ this.css({
1313	+ position: '',
1314	+ left: '',
1315	+ right: '',
1316	+ top: '',
1317	+ bottom: '',
1318	+ transition: '',
1319	+ transform: ''
1320	+ });
1321	+ };
1322	+
1323	+ return Item;
1324	+
1325	+ }));
1326	+
1327	+ /*!
1328	+ * Outlayer v2.1.1
1329	+ * the brains and guts of a layout library
1330	+ * MIT license
1331	+ */
1332	+
1333	+ ( function( window, factory ) {
1334	+ 'use strict';
1335	+ // universal module definition
1336	+ /* jshint strict: false / / globals define, module, require */
1337	+ if ( typeof define == 'function' && define.amd ) {
1338	+ // AMD - RequireJS
1339	+ define( 'outlayer/outlayer',[
1340	+ 'ev-emitter/ev-emitter',
1341	+ 'get-size/get-size',
1342	+ 'fizzy-ui-utils/utils',
1343	+ './item'
1344	+ ],
1345	+ function( EvEmitter, getSize, utils, Item ) {
1346	+ return factory( window, EvEmitter, getSize, utils, Item);
1347	+ }
1348	+ );
1349	+ } else if ( typeof module == 'object' && module.exports ) {
1350	+ // CommonJS - Browserify, Webpack
1351	+ module.exports = factory(
1352	+ window,
1353	+ require('ev-emitter'),
1354	+ require('get-size'),
1355	+ require('fizzy-ui-utils'),
1356	+ require('./item')
1357	+ );
1358	+ } else {
1359	+ // browser global
1360	+ window.Outlayer = factory(
1361	+ window,
1362	+ window.EvEmitter,
1363	+ window.getSize,
1364	+ window.fizzyUIUtils,
1365	+ window.Outlayer.Item
1366	+ );
1367	+ }
1368	+
1369	+ }( window, function factory( window, EvEmitter, getSize, utils, Item ) {
1370	+ 'use strict';
1371	+
1372	+ // ----- vars ----- //
1373	+
1374	+ var console = window.console;
1375	+ var jQuery = window.jQuery;
1376	+ var noop = function() {};
1377	+
1378	+ // -------------------------- Outlayer -------------------------- //
1379	+
1380	+ // globally unique identifiers
1381	+ var GUID = 0;
1382	+ // internal store of all Outlayer intances
1383	+ var instances = {};
1384	+
1385	+
1386	+ /**
1387	+ * @param {Element, String} element
1388	+ * @param {Object} options
1389	+ * @constructor
1390	+ */
1391	+ function Outlayer( element, options ) {
1392	+ var queryElement = utils.getQueryElement( element );
1393	+ if ( !queryElement ) {
1394	+ if ( console ) {
1395	+ console.error( 'Bad element for ' + this.constructor.namespace +
1396	+ ': ' + ( queryElement \|\| element ) );
1397	+ }
1398	+ return;
1399	+ }
1400	+ this.element = queryElement;
1401	+ // add jQuery
1402	+ if ( jQuery ) {
1403	+ this.$element = jQuery( this.element );
1404	+ }
1405	+
1406	+ // options
1407	+ this.options = utils.extend( {}, this.constructor.defaults );
1408	+ this.option( options );
1409	+
1410	+ // add id for Outlayer.getFromElement
1411	+ var id = ++GUID;
1412	+ this.element.outlayerGUID = id; // expando
1413	+ instances[ id ] = this; // associate via id
1414	+
1415	+ // kick it off
1416	+ this._create();
1417	+
1418	+ var isInitLayout = this._getOption('initLayout');
1419	+ if ( isInitLayout ) {
1420	+ this.layout();
1421	+ }
1422	+ }
1423	+
1424	+ // settings are for internal use only
1425	+ Outlayer.namespace = 'outlayer';
1426	+ Outlayer.Item = Item;
1427	+
1428	+ // default options
1429	+ Outlayer.defaults = {
1430	+ containerStyle: {
1431	+ position: 'relative'
1432	+ },
1433	+ initLayout: true,
1434	+ originLeft: true,
1435	+ originTop: true,
1436	+ resize: true,
1437	+ resizeContainer: true,
1438	+ // item options
1439	+ transitionDuration: '0.4s',
1440	+ hiddenStyle: {
1441	+ opacity: 0,
1442	+ transform: 'scale(0.001)'
1443	+ },
1444	+ visibleStyle: {
1445	+ opacity: 1,
1446	+ transform: 'scale(1)'
1447	+ }
1448	+ };
1449	+
1450	+ var proto = Outlayer.prototype;
1451	+ // inherit EvEmitter
1452	+ utils.extend( proto, EvEmitter.prototype );
1453	+
1454	+ /**
1455	+ * set options
1456	+ * @param {Object} opts
1457	+ */
1458	+ proto.option = function( opts ) {
1459	+ utils.extend( this.options, opts );
1460	+ };
1461	+
1462	+ /**
1463	+ * get backwards compatible option value, check old name
1464	+ */
1465	+ proto._getOption = function( option ) {
1466	+ var oldOption = this.constructor.compatOptions[ option ];
1467	+ return oldOption && this.options[ oldOption ] !== undefined ?
1468	+ this.options[ oldOption ] : this.options[ option ];
1469	+ };
1470	+
1471	+ Outlayer.compatOptions = {
1472	+ // currentName: oldName
1473	+ initLayout: 'isInitLayout',
1474	+ horizontal: 'isHorizontal',
1475	+ layoutInstant: 'isLayoutInstant',
1476	+ originLeft: 'isOriginLeft',
1477	+ originTop: 'isOriginTop',
1478	+ resize: 'isResizeBound',
1479	+ resizeContainer: 'isResizingContainer'
1480	+ };
1481	+
1482	+ proto._create = function() {
1483	+ // get items from children
1484	+ this.reloadItems();
1485	+ // elements that affect layout, but are not laid out
1486	+ this.stamps = [];
1487	+ this.stamp( this.options.stamp );
1488	+ // set container style
1489	+ utils.extend( this.element.style, this.options.containerStyle );
1490	+
1491	+ // bind resize method
1492	+ var canBindResize = this._getOption('resize');
1493	+ if ( canBindResize ) {
1494	+ this.bindResize();
1495	+ }
1496	+ };
1497	+
1498	+ // goes through all children again and gets bricks in proper order
1499	+ proto.reloadItems = function() {
1500	+ // collection of item elements
1501	+ this.items = this._itemize( this.element.children );
1502	+ };
1503	+
1504	+
1505	+ /**
1506	+ * turn elements into Outlayer.Items to be used in layout
1507	+ * @param {Array or NodeList or HTMLElement} elems
1508	+ * @returns {Array} items - collection of new Outlayer Items
1509	+ */
1510	+ proto._itemize = function( elems ) {
1511	+
1512	+ var itemElems = this._filterFindItemElements( elems );
1513	+ var Item = this.constructor.Item;
1514	+
1515	+ // create new Outlayer Items for collection
1516	+ var items = [];
1517	+ for ( var i=0; i < itemElems.length; i++ ) {
1518	+ var elem = itemElems[i];
1519	+ var item = new Item( elem, this );
1520	+ items.push( item );
1521	+ }
1522	+
1523	+ return items;
1524	+ };
1525	+
1526	+ /**
1527	+ * get item elements to be used in layout
1528	+ * @param {Array or NodeList or HTMLElement} elems
1529	+ * @returns {Array} items - item elements
1530	+ */
1531	+ proto._filterFindItemElements = function( elems ) {
1532	+ return utils.filterFindElements( elems, this.options.itemSelector );
1533	+ };
1534	+
1535	+ /**
1536	+ * getter method for getting item elements
1537	+ * @returns {Array} elems - collection of item elements
1538	+ */
1539	+ proto.getItemElements = function() {
1540	+ return this.items.map( function( item ) {
1541	+ return item.element;
1542	+ });
1543	+ };
1544	+
1545	+ // ----- init & layout ----- //
1546	+
1547	+ /**
1548	+ * lays out all items
1549	+ */
1550	+ proto.layout = function() {
1551	+ this._resetLayout();
1552	+ this._manageStamps();
1553	+
1554	+ // don't animate first layout
1555	+ var layoutInstant = this._getOption('layoutInstant');
1556	+ var isInstant = layoutInstant !== undefined ?
1557	+ layoutInstant : !this._isLayoutInited;
1558	+ this.layoutItems( this.items, isInstant );
1559	+
1560	+ // flag for initalized
1561	+ this._isLayoutInited = true;
1562	+ };
1563	+
1564	+ // _init is alias for layout
1565	+ proto._init = proto.layout;
1566	+
1567	+ /**
1568	+ * logic before any new layout
1569	+ */
1570	+ proto._resetLayout = function() {
1571	+ this.getSize();
1572	+ };
1573	+
1574	+
1575	+ proto.getSize = function() {
1576	+ this.size = getSize( this.element );
1577	+ };
1578	+
1579	+ /**
1580	+ * get measurement from option, for columnWidth, rowHeight, gutter
1581	+ * if option is String -> get element from selector string, & get size of element
1582	+ * if option is Element -> get size of element
1583	+ * else use option as a number
1584	+ *
1585	+ * @param {String} measurement
1586	+ * @param {String} size - width or height
1587	+ * @private
1588	+ */
1589	+ proto._getMeasurement = function( measurement, size ) {
1590	+ var option = this.options[ measurement ];
1591	+ var elem;
1592	+ if ( !option ) {
1593	+ // default to 0
1594	+ this[ measurement ] = 0;
1595	+ } else {
1596	+ // use option as an element
1597	+ if ( typeof option == 'string' ) {
1598	+ elem = this.element.querySelector( option );
1599	+ } else if ( option instanceof HTMLElement ) {
1600	+ elem = option;
1601	+ }
1602	+ // use size of element, if element
1603	+ this[ measurement ] = elem ? getSize( elem )[ size ] : option;
1604	+ }
1605	+ };
1606	+
1607	+ /**
1608	+ * layout a collection of item elements
1609	+ * @api public
1610	+ */
1611	+ proto.layoutItems = function( items, isInstant ) {
1612	+ items = this._getItemsForLayout( items );
1613	+
1614	+ this._layoutItems( items, isInstant );
1615	+
1616	+ this._postLayout();
1617	+ };
1618	+
1619	+ /**
1620	+ * get the items to be laid out
1621	+ * you may want to skip over some items
1622	+ * @param {Array} items
1623	+ * @returns {Array} items
1624	+ */
1625	+ proto._getItemsForLayout = function( items ) {
1626	+ return items.filter( function( item ) {
1627	+ return !item.isIgnored;
1628	+ });
1629	+ };
1630	+
1631	+ /**
1632	+ * layout items
1633	+ * @param {Array} items
1634	+ * @param {Boolean} isInstant
1635	+ */
1636	+ proto._layoutItems = function( items, isInstant ) {
1637	+ this._emitCompleteOnItems( 'layout', items );
1638	+
1639	+ if ( !items \|\| !items.length ) {
1640	+ // no items, emit event with empty array
1641	+ return;
1642	+ }
1643	+
1644	+ var queue = [];
1645	+
1646	+ items.forEach( function( item ) {
1647	+ // get x/y object from method
1648	+ var position = this._getItemLayoutPosition( item );
1649	+ // enqueue
1650	+ position.item = item;
1651	+ position.isInstant = isInstant \|\| item.isLayoutInstant;
1652	+ queue.push( position );
1653	+ }, this );
1654	+
1655	+ this._processLayoutQueue( queue );
1656	+ };
1657	+
1658	+ /**
1659	+ * get item layout position
1660	+ * @param {Outlayer.Item} item
1661	+ * @returns {Object} x and y position
1662	+ */
1663	+ proto._getItemLayoutPosition = function( /* item */ ) {
1664	+ return {
1665	+ x: 0,
1666	+ y: 0
1667	+ };
1668	+ };
1669	+
1670	+ /**
1671	+ * iterate over array and position each item
1672	+ * Reason being - separating this logic prevents 'layout invalidation'
1673	+ * thx @paul_irish
1674	+ * @param {Array} queue
1675	+ */
1676	+ proto._processLayoutQueue = function( queue ) {
1677	+ this.updateStagger();
1678	+ queue.forEach( function( obj, i ) {
1679	+ this._positionItem( obj.item, obj.x, obj.y, obj.isInstant, i );
1680	+ }, this );
1681	+ };
1682	+
1683	+ // set stagger from option in milliseconds number
1684	+ proto.updateStagger = function() {
1685	+ var stagger = this.options.stagger;
1686	+ if ( stagger === null \|\| stagger === undefined ) {
1687	+ this.stagger = 0;
1688	+ return;
1689	+ }
1690	+ this.stagger = getMilliseconds( stagger );
1691	+ return this.stagger;
1692	+ };
1693	+
1694	+ /**
1695	+ * Sets position of item in DOM
1696	+ * @param {Outlayer.Item} item
1697	+ * @param {Number} x - horizontal position
1698	+ * @param {Number} y - vertical position
1699	+ * @param {Boolean} isInstant - disables transitions
1700	+ */
1701	+ proto._positionItem = function( item, x, y, isInstant, i ) {
1702	+ if ( isInstant ) {
1703	+ // if not transition, just set CSS
1704	+ item.goTo( x, y );
1705	+ } else {
1706	+ item.stagger( i * this.stagger );
1707	+ item.moveTo( x, y );
1708	+ }
1709	+ };
1710	+
1711	+ /**
1712	+ * Any logic you want to do after each layout,
1713	+ * i.e. size the container
1714	+ */
1715	+ proto._postLayout = function() {
1716	+ this.resizeContainer();
1717	+ };
1718	+
1719	+ proto.resizeContainer = function() {
1720	+ var isResizingContainer = this._getOption('resizeContainer');
1721	+ if ( !isResizingContainer ) {
1722	+ return;
1723	+ }
1724	+ var size = this._getContainerSize();
1725	+ if ( size ) {
1726	+ this._setContainerMeasure( size.width, true );
1727	+ this._setContainerMeasure( size.height, false );
1728	+ }
1729	+ };
1730	+
1731	+ /**
1732	+ * Sets width or height of container if returned
1733	+ * @returns {Object} size
1734	+ * @param {Number} width
1735	+ * @param {Number} height
1736	+ */
1737	+ proto._getContainerSize = noop;
1738	+
1739	+ /**
1740	+ * @param {Number} measure - size of width or height
1741	+ * @param {Boolean} isWidth
1742	+ */
1743	+ proto._setContainerMeasure = function( measure, isWidth ) {
1744	+ if ( measure === undefined ) {
1745	+ return;
1746	+ }
1747	+
1748	+ var elemSize = this.size;
1749	+ // add padding and border width if border box
1750	+ if ( elemSize.isBorderBox ) {
1751	+ measure += isWidth ? elemSize.paddingLeft + elemSize.paddingRight +
1752	+ elemSize.borderLeftWidth + elemSize.borderRightWidth :
1753	+ elemSize.paddingBottom + elemSize.paddingTop +
1754	+ elemSize.borderTopWidth + elemSize.borderBottomWidth;
1755	+ }
1756	+
1757	+ measure = Math.max( measure, 0 );
1758	+ this.element.style[ isWidth ? 'width' : 'height' ] = measure + 'px';
1759	+ };
1760	+
1761	+ /**
1762	+ * emit eventComplete on a collection of items events
1763	+ * @param {String} eventName
1764	+ * @param {Array} items - Outlayer.Items
1765	+ */
1766	+ proto._emitCompleteOnItems = function( eventName, items ) {
1767	+ var _this = this;
1768	+ function onComplete() {
1769	+ _this.dispatchEvent( eventName + 'Complete', null, [ items ] );
1770	+ }
1771	+
1772	+ var count = items.length;
1773	+ if ( !items \|\| !count ) {
1774	+ onComplete();
1775	+ return;
1776	+ }
1777	+
1778	+ var doneCount = 0;
1779	+ function tick() {
1780	+ doneCount++;
1781	+ if ( doneCount == count ) {
1782	+ onComplete();
1783	+ }
1784	+ }
1785	+
1786	+ // bind callback
1787	+ items.forEach( function( item ) {
1788	+ item.once( eventName, tick );
1789	+ });
1790	+ };
1791	+
1792	+ /**
1793	+ * emits events via EvEmitter and jQuery events
1794	+ * @param {String} type - name of event
1795	+ * @param {Event} event - original event
1796	+ * @param {Array} args - extra arguments
1797	+ */
1798	+ proto.dispatchEvent = function( type, event, args ) {
1799	+ // add original event to arguments
1800	+ var emitArgs = event ? [ event ].concat( args ) : args;
1801	+ this.emitEvent( type, emitArgs );
1802	+
1803	+ if ( jQuery ) {
1804	+ // set this.$element
1805	+ this.$element = this.$element \|\| jQuery( this.element );
1806	+ if ( event ) {
1807	+ // create jQuery event
1808	+ var $event = jQuery.Event( event );
1809	+ $event.type = type;
1810	+ this.$element.trigger( $event, args );
1811	+ } else {
1812	+ // just trigger with type if no event available
1813	+ this.$element.trigger( type, args );
1814	+ }
1815	+ }
1816	+ };
1817	+
1818	+ // -------------------------- ignore & stamps -------------------------- //
1819	+
1820	+
1821	+ /**
1822	+ * keep item in collection, but do not lay it out
1823	+ * ignored items do not get skipped in layout
1824	+ * @param {Element} elem
1825	+ */
1826	+ proto.ignore = function( elem ) {
1827	+ var item = this.getItem( elem );
1828	+ if ( item ) {
1829	+ item.isIgnored = true;
1830	+ }
1831	+ };
1832	+
1833	+ /**
1834	+ * return item to layout collection
1835	+ * @param {Element} elem
1836	+ */
1837	+ proto.unignore = function( elem ) {
1838	+ var item = this.getItem( elem );
1839	+ if ( item ) {
1840	+ delete item.isIgnored;
1841	+ }
1842	+ };
1843	+
1844	+ /**
1845	+ * adds elements to stamps
1846	+ * @param {NodeList, Array, Element, or String} elems
1847	+ */
1848	+ proto.stamp = function( elems ) {
1849	+ elems = this._find( elems );
1850	+ if ( !elems ) {
1851	+ return;
1852	+ }
1853	+
1854	+ this.stamps = this.stamps.concat( elems );
1855	+ // ignore
1856	+ elems.forEach( this.ignore, this );
1857	+ };
1858	+
1859	+ /**
1860	+ * removes elements to stamps
1861	+ * @param {NodeList, Array, or Element} elems
1862	+ */
1863	+ proto.unstamp = function( elems ) {
1864	+ elems = this._find( elems );
1865	+ if ( !elems ){
1866	+ return;
1867	+ }
1868	+
1869	+ elems.forEach( function( elem ) {
1870	+ // filter out removed stamp elements
1871	+ utils.removeFrom( this.stamps, elem );
1872	+ this.unignore( elem );
1873	+ }, this );
1874	+ };
1875	+
1876	+ /**
1877	+ * finds child elements
1878	+ * @param {NodeList, Array, Element, or String} elems
1879	+ * @returns {Array} elems
1880	+ */
1881	+ proto._find = function( elems ) {
1882	+ if ( !elems ) {
1883	+ return;
1884	+ }
1885	+ // if string, use argument as selector string
1886	+ if ( typeof elems == 'string' ) {
1887	+ elems = this.element.querySelectorAll( elems );
1888	+ }
1889	+ elems = utils.makeArray( elems );
1890	+ return elems;
1891	+ };
1892	+
1893	+ proto._manageStamps = function() {
1894	+ if ( !this.stamps \|\| !this.stamps.length ) {
1895	+ return;
1896	+ }
1897	+
1898	+ this._getBoundingRect();
1899	+
1900	+ this.stamps.forEach( this._manageStamp, this );
1901	+ };
1902	+
1903	+ // update boundingLeft / Top
1904	+ proto._getBoundingRect = function() {
1905	+ // get bounding rect for container element
1906	+ var boundingRect = this.element.getBoundingClientRect();
1907	+ var size = this.size;
1908	+ this._boundingRect = {
1909	+ left: boundingRect.left + size.paddingLeft + size.borderLeftWidth,
1910	+ top: boundingRect.top + size.paddingTop + size.borderTopWidth,
1911	+ right: boundingRect.right - ( size.paddingRight + size.borderRightWidth ),
1912	+ bottom: boundingRect.bottom - ( size.paddingBottom + size.borderBottomWidth )
1913	+ };
1914	+ };
1915	+
1916	+ /**
1917	+ * @param {Element} stamp
1918	+ **/
1919	+ proto._manageStamp = noop;
1920	+
1921	+ /**
1922	+ * get x/y position of element relative to container element
1923	+ * @param {Element} elem
1924	+ * @returns {Object} offset - has left, top, right, bottom
1925	+ */
1926	+ proto._getElementOffset = function( elem ) {
1927	+ var boundingRect = elem.getBoundingClientRect();
1928	+ var thisRect = this._boundingRect;
1929	+ var size = getSize( elem );
1930	+ var offset = {
1931	+ left: boundingRect.left - thisRect.left - size.marginLeft,
1932	+ top: boundingRect.top - thisRect.top - size.marginTop,
1933	+ right: thisRect.right - boundingRect.right - size.marginRight,
1934	+ bottom: thisRect.bottom - boundingRect.bottom - size.marginBottom
1935	+ };
1936	+ return offset;
1937	+ };
1938	+
1939	+ // -------------------------- resize -------------------------- //
1940	+
1941	+ // enable event handlers for listeners
1942	+ // i.e. resize -> onresize
1943	+ proto.handleEvent = utils.handleEvent;
1944	+
1945	+ /**
1946	+ * Bind layout to window resizing
1947	+ */
1948	+ proto.bindResize = function() {
1949	+ window.addEventListener( 'resize', this );
1950	+ this.isResizeBound = true;
1951	+ };
1952	+
1953	+ /**
1954	+ * Unbind layout to window resizing
1955	+ */
1956	+ proto.unbindResize = function() {
1957	+ window.removeEventListener( 'resize', this );
1958	+ this.isResizeBound = false;
1959	+ };
1960	+
1961	+ proto.onresize = function() {
1962	+ this.resize();
1963	+ };
1964	+
1965	+ utils.debounceMethod( Outlayer, 'onresize', 100 );
1966	+
1967	+ proto.resize = function() {
1968	+ // don't trigger if size did not change
1969	+ // or if resize was unbound. See #9
1970	+ if ( !this.isResizeBound \|\| !this.needsResizeLayout() ) {
1971	+ return;
1972	+ }
1973	+
1974	+ this.layout();
1975	+ };
1976	+
1977	+ /**
1978	+ * check if layout is needed post layout
1979	+ * @returns Boolean
1980	+ */
1981	+ proto.needsResizeLayout = function() {
1982	+ var size = getSize( this.element );
1983	+ // check that this.size and size are there
1984	+ // IE8 triggers resize on body size change, so they might not be
1985	+ var hasSizes = this.size && size;
1986	+ return hasSizes && size.innerWidth !== this.size.innerWidth;
1987	+ };
1988	+
1989	+ // -------------------------- methods -------------------------- //
1990	+
1991	+ /**
1992	+ * add items to Outlayer instance
1993	+ * @param {Array or NodeList or Element} elems
1994	+ * @returns {Array} items - Outlayer.Items
1995	+ **/
1996	+ proto.addItems = function( elems ) {
1997	+ var items = this._itemize( elems );
1998	+ // add items to collection
1999	+ if ( items.length ) {
2000	+ this.items = this.items.concat( items );
2001	+ }
2002	+ return items;
2003	+ };
2004	+
2005	+ /**
2006	+ * Layout newly-appended item elements
2007	+ * @param {Array or NodeList or Element} elems
2008	+ */
2009	+ proto.appended = function( elems ) {
2010	+ var items = this.addItems( elems );
2011	+ if ( !items.length ) {
2012	+ return;
2013	+ }
2014	+ // layout and reveal just the new items
2015	+ this.layoutItems( items, true );
2016	+ this.reveal( items );
2017	+ };
2018	+
2019	+ /**
2020	+ * Layout prepended elements
2021	+ * @param {Array or NodeList or Element} elems
2022	+ */
2023	+ proto.prepended = function( elems ) {
2024	+ var items = this._itemize( elems );
2025	+ if ( !items.length ) {
2026	+ return;
2027	+ }
2028	+ // add items to beginning of collection
2029	+ var previousItems = this.items.slice(0);
2030	+ this.items = items.concat( previousItems );
2031	+ // start new layout
2032	+ this._resetLayout();
2033	+ this._manageStamps();
2034	+ // layout new stuff without transition
2035	+ this.layoutItems( items, true );
2036	+ this.reveal( items );
2037	+ // layout previous items
2038	+ this.layoutItems( previousItems );
2039	+ };
2040	+
2041	+ /**
2042	+ * reveal a collection of items
2043	+ * @param {Array of Outlayer.Items} items
2044	+ */
2045	+ proto.reveal = function( items ) {
2046	+ this._emitCompleteOnItems( 'reveal', items );
2047	+ if ( !items \|\| !items.length ) {
2048	+ return;
2049	+ }
2050	+ var stagger = this.updateStagger();
2051	+ items.forEach( function( item, i ) {
2052	+ item.stagger( i * stagger );
2053	+ item.reveal();
2054	+ });
2055	+ };
2056	+
2057	+ /**
2058	+ * hide a collection of items
2059	+ * @param {Array of Outlayer.Items} items
2060	+ */
2061	+ proto.hide = function( items ) {
2062	+ this._emitCompleteOnItems( 'hide', items );
2063	+ if ( !items \|\| !items.length ) {
2064	+ return;
2065	+ }
2066	+ var stagger = this.updateStagger();
2067	+ items.forEach( function( item, i ) {
2068	+ item.stagger( i * stagger );
2069	+ item.hide();
2070	+ });
2071	+ };
2072	+
2073	+ /**
2074	+ * reveal item elements
2075	+ * @param {Array}, {Element}, {NodeList} items
2076	+ */
2077	+ proto.revealItemElements = function( elems ) {
2078	+ var items = this.getItems( elems );
2079	+ this.reveal( items );
2080	+ };
2081	+
2082	+ /**
2083	+ * hide item elements
2084	+ * @param {Array}, {Element}, {NodeList} items
2085	+ */
2086	+ proto.hideItemElements = function( elems ) {
2087	+ var items = this.getItems( elems );
2088	+ this.hide( items );
2089	+ };
2090	+
2091	+ /**
2092	+ * get Outlayer.Item, given an Element
2093	+ * @param {Element} elem
2094	+ * @param {Function} callback
2095	+ * @returns {Outlayer.Item} item
2096	+ */
2097	+ proto.getItem = function( elem ) {
2098	+ // loop through items to get the one that matches
2099	+ for ( var i=0; i < this.items.length; i++ ) {
2100	+ var item = this.items[i];
2101	+ if ( item.element == elem ) {
2102	+ // return item
2103	+ return item;
2104	+ }
2105	+ }
2106	+ };
2107	+
2108	+ /**
2109	+ * get collection of Outlayer.Items, given Elements
2110	+ * @param {Array} elems
2111	+ * @returns {Array} items - Outlayer.Items
2112	+ */
2113	+ proto.getItems = function( elems ) {
2114	+ elems = utils.makeArray( elems );
2115	+ var items = [];
2116	+ elems.forEach( function( elem ) {
2117	+ var item = this.getItem( elem );
2118	+ if ( item ) {
2119	+ items.push( item );
2120	+ }
2121	+ }, this );
2122	+
2123	+ return items;
2124	+ };
2125	+
2126	+ /**
2127	+ * remove element(s) from instance and DOM
2128	+ * @param {Array or NodeList or Element} elems
2129	+ */
2130	+ proto.remove = function( elems ) {
2131	+ var removeItems = this.getItems( elems );
2132	+
2133	+ this._emitCompleteOnItems( 'remove', removeItems );
2134	+
2135	+ // bail if no items to remove
2136	+ if ( !removeItems \|\| !removeItems.length ) {
2137	+ return;
2138	+ }
2139	+
2140	+ removeItems.forEach( function( item ) {
2141	+ item.remove();
2142	+ // remove item from collection
2143	+ utils.removeFrom( this.items, item );
2144	+ }, this );
2145	+ };
2146	+
2147	+ // ----- destroy ----- //
2148	+
2149	+ // remove and disable Outlayer instance
2150	+ proto.destroy = function() {
2151	+ // clean up dynamic styles
2152	+ var style = this.element.style;
2153	+ style.height = '';
2154	+ style.position = '';
2155	+ style.width = '';
2156	+ // destroy items
2157	+ this.items.forEach( function( item ) {
2158	+ item.destroy();
2159	+ });
2160	+
2161	+ this.unbindResize();
2162	+
2163	+ var id = this.element.outlayerGUID;
2164	+ delete instances[ id ]; // remove reference to instance by id
2165	+ delete this.element.outlayerGUID;
2166	+ // remove data for jQuery
2167	+ if ( jQuery ) {
2168	+ jQuery.removeData( this.element, this.constructor.namespace );
2169	+ }
2170	+
2171	+ };
2172	+
2173	+ // -------------------------- data -------------------------- //
2174	+
2175	+ /**
2176	+ * get Outlayer instance from element
2177	+ * @param {Element} elem
2178	+ * @returns {Outlayer}
2179	+ */
2180	+ Outlayer.data = function( elem ) {
2181	+ elem = utils.getQueryElement( elem );
2182	+ var id = elem && elem.outlayerGUID;
2183	+ return id && instances[ id ];
2184	+ };
2185	+
2186	+
2187	+ // -------------------------- create Outlayer class -------------------------- //
2188	+
2189	+ /**
2190	+ * create a layout class
2191	+ * @param {String} namespace
2192	+ */
2193	+ Outlayer.create = function( namespace, options ) {
2194	+ // sub-class Outlayer
2195	+ var Layout = subclass( Outlayer );
2196	+ // apply new options and compatOptions
2197	+ Layout.defaults = utils.extend( {}, Outlayer.defaults );
2198	+ utils.extend( Layout.defaults, options );
2199	+ Layout.compatOptions = utils.extend( {}, Outlayer.compatOptions );
2200	+
2201	+ Layout.namespace = namespace;
2202	+
2203	+ Layout.data = Outlayer.data;
2204	+
2205	+ // sub-class Item
2206	+ Layout.Item = subclass( Item );
2207	+
2208	+ // -------------------------- declarative -------------------------- //
2209	+
2210	+ utils.htmlInit( Layout, namespace );
2211	+
2212	+ // -------------------------- jQuery bridge -------------------------- //
2213	+
2214	+ // make into jQuery plugin
2215	+ if ( jQuery && jQuery.bridget ) {
2216	+ jQuery.bridget( namespace, Layout );
2217	+ }
2218	+
2219	+ return Layout;
2220	+ };
2221	+
2222	+ function subclass( Parent ) {
2223	+ function SubClass() {
2224	+ Parent.apply( this, arguments );
2225	+ }
2226	+
2227	+ SubClass.prototype = Object.create( Parent.prototype );
2228	+ SubClass.prototype.constructor = SubClass;
2229	+
2230	+ return SubClass;
2231	+ }
2232	+
2233	+ // ----- helpers ----- //
2234	+
2235	+ // how many milliseconds are in each unit
2236	+ var msUnits = {
2237	+ ms: 1,
2238	+ s: 1000
2239	+ };
2240	+
2241	+ // munge time-like parameter into millisecond number
2242	+ // '0.4s' -> 40
2243	+ function getMilliseconds( time ) {
2244	+ if ( typeof time == 'number' ) {
2245	+ return time;
2246	+ }
2247	+ var matches = time.match( /(^\d\.?\d)(\w*)/ );
2248	+ var num = matches && matches[1];
2249	+ var unit = matches && matches[2];
2250	+ if ( !num.length ) {
2251	+ return 0;
2252	+ }
2253	+ num = parseFloat( num );
2254	+ var mult = msUnits[ unit ] \|\| 1;
2255	+ return num * mult;
2256	+ }
2257	+
2258	+ // ----- fin ----- //
2259	+
2260	+ // back in global
2261	+ Outlayer.Item = Item;
2262	+
2263	+ return Outlayer;
2264	+
2265	+ }));
2266	+
2267	+ /**
2268	+ * Isotope Item
2269	+ **/
2270	+
2271	+ ( function( window, factory ) {
2272	+ // universal module definition
2273	+ /* jshint strict: false / /globals define, module, require */
2274	+ if ( typeof define == 'function' && define.amd ) {
2275	+ // AMD
2276	+ define( 'isotope-layout/js/item',[
2277	+ 'outlayer/outlayer'
2278	+ ],
2279	+ factory );
2280	+ } else if ( typeof module == 'object' && module.exports ) {
2281	+ // CommonJS
2282	+ module.exports = factory(
2283	+ require('outlayer')
2284	+ );
2285	+ } else {
2286	+ // browser global
2287	+ window.Isotope = window.Isotope \|\| {};
2288	+ window.Isotope.Item = factory(
2289	+ window.Outlayer
2290	+ );
2291	+ }
2292	+
2293	+ }( window, function factory( Outlayer ) {
2294	+ 'use strict';
2295	+
2296	+ // -------------------------- Item -------------------------- //
2297	+
2298	+ // sub-class Outlayer Item
2299	+ function Item() {
2300	+ Outlayer.Item.apply( this, arguments );
2301	+ }
2302	+
2303	+ var proto = Item.prototype = Object.create( Outlayer.Item.prototype );
2304	+
2305	+ var _create = proto._create;
2306	+ proto._create = function() {
2307	+ // assign id, used for original-order sorting
2308	+ this.id = this.layout.itemGUID++;
2309	+ _create.call( this );
2310	+ this.sortData = {};
2311	+ };
2312	+
2313	+ proto.updateSortData = function() {
2314	+ if ( this.isIgnored ) {
2315	+ return;
2316	+ }
2317	+ // default sorters
2318	+ this.sortData.id = this.id;
2319	+ // for backward compatibility
2320	+ this.sortData['original-order'] = this.id;
2321	+ this.sortData.random = Math.random();
2322	+ // go thru getSortData obj and apply the sorters
2323	+ var getSortData = this.layout.options.getSortData;
2324	+ var sorters = this.layout._sorters;
2325	+ for ( var key in getSortData ) {
2326	+ var sorter = sorters[ key ];
2327	+ this.sortData[ key ] = sorter( this.element, this );
2328	+ }
2329	+ };
2330	+
2331	+ var _destroy = proto.destroy;
2332	+ proto.destroy = function() {
2333	+ // call super
2334	+ _destroy.apply( this, arguments );
2335	+ // reset display, #741
2336	+ this.css({
2337	+ display: ''
2338	+ });
2339	+ };
2340	+
2341	+ return Item;
2342	+
2343	+ }));
2344	+
2345	+ /**
2346	+ * Isotope LayoutMode
2347	+ */
2348	+
2349	+ ( function( window, factory ) {
2350	+ // universal module definition
2351	+ /* jshint strict: false / /globals define, module, require */
2352	+ if ( typeof define == 'function' && define.amd ) {
2353	+ // AMD
2354	+ define( 'isotope-layout/js/layout-mode',[
2355	+ 'get-size/get-size',
2356	+ 'outlayer/outlayer'
2357	+ ],
2358	+ factory );
2359	+ } else if ( typeof module == 'object' && module.exports ) {
2360	+ // CommonJS
2361	+ module.exports = factory(
2362	+ require('get-size'),
2363	+ require('outlayer')
2364	+ );
2365	+ } else {
2366	+ // browser global
2367	+ window.Isotope = window.Isotope \|\| {};
2368	+ window.Isotope.LayoutMode = factory(
2369	+ window.getSize,
2370	+ window.Outlayer
2371	+ );
2372	+ }
2373	+
2374	+ }( window, function factory( getSize, Outlayer ) {
2375	+ 'use strict';
2376	+
2377	+ // layout mode class
2378	+ function LayoutMode( isotope ) {
2379	+ this.isotope = isotope;
2380	+ // link properties
2381	+ if ( isotope ) {
2382	+ this.options = isotope.options[ this.namespace ];
2383	+ this.element = isotope.element;
2384	+ this.items = isotope.filteredItems;
2385	+ this.size = isotope.size;
2386	+ }
2387	+ }
2388	+
2389	+ var proto = LayoutMode.prototype;
2390	+
2391	+ /**
2392	+ * some methods should just defer to default Outlayer method
2393	+ * and reference the Isotope instance as `this`
2394	+ **/
2395	+ var facadeMethods = [
2396	+ '_resetLayout',
2397	+ '_getItemLayoutPosition',
2398	+ '_manageStamp',
2399	+ '_getContainerSize',
2400	+ '_getElementOffset',
2401	+ 'needsResizeLayout',
2402	+ '_getOption'
2403	+ ];
2404	+
2405	+ facadeMethods.forEach( function( methodName ) {
2406	+ proto[ methodName ] = function() {
2407	+ return Outlayer.prototype[ methodName ].apply( this.isotope, arguments );
2408	+ };
2409	+ });
2410	+
2411	+ // ----- ----- //
2412	+
2413	+ // for horizontal layout modes, check vertical size
2414	+ proto.needsVerticalResizeLayout = function() {
2415	+ // don't trigger if size did not change
2416	+ var size = getSize( this.isotope.element );
2417	+ // check that this.size and size are there
2418	+ // IE8 triggers resize on body size change, so they might not be
2419	+ var hasSizes = this.isotope.size && size;
2420	+ return hasSizes && size.innerHeight != this.isotope.size.innerHeight;
2421	+ };
2422	+
2423	+ // ----- measurements ----- //
2424	+
2425	+ proto._getMeasurement = function() {
2426	+ this.isotope._getMeasurement.apply( this, arguments );
2427	+ };
2428	+
2429	+ proto.getColumnWidth = function() {
2430	+ this.getSegmentSize( 'column', 'Width' );
2431	+ };
2432	+
2433	+ proto.getRowHeight = function() {
2434	+ this.getSegmentSize( 'row', 'Height' );
2435	+ };
2436	+
2437	+ /**
2438	+ * get columnWidth or rowHeight
2439	+ * segment: 'column' or 'row'
2440	+ * size 'Width' or 'Height'
2441	+ **/
2442	+ proto.getSegmentSize = function( segment, size ) {
2443	+ var segmentName = segment + size;
2444	+ var outerSize = 'outer' + size;
2445	+ // columnWidth / outerWidth // rowHeight / outerHeight
2446	+ this._getMeasurement( segmentName, outerSize );
2447	+ // got rowHeight or columnWidth, we can chill
2448	+ if ( this[ segmentName ] ) {
2449	+ return;
2450	+ }
2451	+ // fall back to item of first element
2452	+ var firstItemSize = this.getFirstItemSize();
2453	+ this[ segmentName ] = firstItemSize && firstItemSize[ outerSize ] \|\|
2454	+ // or size of container
2455	+ this.isotope.size[ 'inner' + size ];
2456	+ };
2457	+
2458	+ proto.getFirstItemSize = function() {
2459	+ var firstItem = this.isotope.filteredItems[0];
2460	+ return firstItem && firstItem.element && getSize( firstItem.element );
2461	+ };
2462	+
2463	+ // ----- methods that should reference isotope ----- //
2464	+
2465	+ proto.layout = function() {
2466	+ this.isotope.layout.apply( this.isotope, arguments );
2467	+ };
2468	+
2469	+ proto.getSize = function() {
2470	+ this.isotope.getSize();
2471	+ this.size = this.isotope.size;
2472	+ };
2473	+
2474	+ // -------------------------- create -------------------------- //
2475	+
2476	+ LayoutMode.modes = {};
2477	+
2478	+ LayoutMode.create = function( namespace, options ) {
2479	+
2480	+ function Mode() {
2481	+ LayoutMode.apply( this, arguments );
2482	+ }
2483	+
2484	+ Mode.prototype = Object.create( proto );
2485	+ Mode.prototype.constructor = Mode;
2486	+
2487	+ // default options
2488	+ if ( options ) {
2489	+ Mode.options = options;
2490	+ }
2491	+
2492	+ Mode.prototype.namespace = namespace;
2493	+ // register in Isotope
2494	+ LayoutMode.modes[ namespace ] = Mode;
2495	+
2496	+ return Mode;
2497	+ };
2498	+
2499	+ return LayoutMode;
2500	+
2501	+ }));
2502	+
2503	+ /*!
2504	+ * Masonry v4.2.1
2505	+ * Cascading grid layout library
2506	+ * https://masonry.desandro.com
2507	+ * MIT License
2508	+ * by David DeSandro
2509	+ */
2510	+
2511	+ ( function( window, factory ) {
2512	+ // universal module definition
2513	+ /* jshint strict: false / /globals define, module, require */
2514	+ if ( typeof define == 'function' && define.amd ) {
2515	+ // AMD
2516	+ define( 'masonry-layout/masonry',[
2517	+ 'outlayer/outlayer',
2518	+ 'get-size/get-size'
2519	+ ],
2520	+ factory );
2521	+ } else if ( typeof module == 'object' && module.exports ) {
2522	+ // CommonJS
2523	+ module.exports = factory(
2524	+ require('outlayer'),
2525	+ require('get-size')
2526	+ );
2527	+ } else {
2528	+ // browser global
2529	+ window.Masonry = factory(
2530	+ window.Outlayer,
2531	+ window.getSize
2532	+ );
2533	+ }
2534	+
2535	+ }( window, function factory( Outlayer, getSize ) {
2536	+
2537	+
2538	+
2539	+ // -------------------------- masonryDefinition -------------------------- //
2540	+
2541	+ // create an Outlayer layout class
2542	+ var Masonry = Outlayer.create('masonry');
2543	+ // isFitWidth -> fitWidth
2544	+ Masonry.compatOptions.fitWidth = 'isFitWidth';
2545	+
2546	+ var proto = Masonry.prototype;
2547	+
2548	+ proto._resetLayout = function() {
2549	+ this.getSize();
2550	+ this._getMeasurement( 'columnWidth', 'outerWidth' );
2551	+ this._getMeasurement( 'gutter', 'outerWidth' );
2552	+ this.measureColumns();
2553	+
2554	+ // reset column Y
2555	+ this.colYs = [];
2556	+ for ( var i=0; i < this.cols; i++ ) {
2557	+ this.colYs.push( 0 );
2558	+ }
2559	+
2560	+ this.maxY = 0;
2561	+ this.horizontalColIndex = 0;
2562	+ };
2563	+
2564	+ proto.measureColumns = function() {
2565	+ this.getContainerWidth();
2566	+ // if columnWidth is 0, default to outerWidth of first item
2567	+ if ( !this.columnWidth ) {
2568	+ var firstItem = this.items[0];
2569	+ var firstItemElem = firstItem && firstItem.element;
2570	+ // columnWidth fall back to item of first element
2571	+ this.columnWidth = firstItemElem && getSize( firstItemElem ).outerWidth \|\|
2572	+ // if first elem has no width, default to size of container
2573	+ this.containerWidth;
2574	+ }
2575	+
2576	+ var columnWidth = this.columnWidth += this.gutter;
2577	+
2578	+ // calculate columns
2579	+ var containerWidth = this.containerWidth + this.gutter;
2580	+ var cols = containerWidth / columnWidth;
2581	+ // fix rounding errors, typically with gutters
2582	+ var excess = columnWidth - containerWidth % columnWidth;
2583	+ // if overshoot is less than a pixel, round up, otherwise floor it
2584	+ var mathMethod = excess && excess < 1 ? 'round' : 'floor';
2585	+ cols = Math[ mathMethod ]( cols );
2586	+ this.cols = Math.max( cols, 1 );
2587	+ };
2588	+
2589	+ proto.getContainerWidth = function() {
2590	+ // container is parent if fit width
2591	+ var isFitWidth = this._getOption('fitWidth');
2592	+ var container = isFitWidth ? this.element.parentNode : this.element;
2593	+ // check that this.size and size are there
2594	+ // IE8 triggers resize on body size change, so they might not be
2595	+ var size = getSize( container );
2596	+ this.containerWidth = size && size.innerWidth;
2597	+ };
2598	+
2599	+ proto._getItemLayoutPosition = function( item ) {
2600	+ item.getSize();
2601	+ // how many columns does this brick span
2602	+ var remainder = item.size.outerWidth % this.columnWidth;
2603	+ var mathMethod = remainder && remainder < 1 ? 'round' : 'ceil';
2604	+ // round if off by 1 pixel, otherwise use ceil
2605	+ var colSpan = Math[ mathMethod ]( item.size.outerWidth / this.columnWidth );
2606	+ colSpan = Math.min( colSpan, this.cols );
2607	+ // use horizontal or top column position
2608	+ var colPosMethod = this.options.horizontalOrder ?
2609	+ '_getHorizontalColPosition' : '_getTopColPosition';
2610	+ var colPosition = this[ colPosMethod ]( colSpan, item );
2611	+ // position the brick
2612	+ var position = {
2613	+ x: this.columnWidth * colPosition.col,
2614	+ y: colPosition.y
2615	+ };
2616	+ // apply setHeight to necessary columns
2617	+ var setHeight = colPosition.y + item.size.outerHeight;
2618	+ var setMax = colSpan + colPosition.col;
2619	+ for ( var i = colPosition.col; i < setMax; i++ ) {
2620	+ this.colYs[i] = setHeight;
2621	+ }
2622	+
2623	+ return position;
2624	+ };
2625	+
2626	+ proto._getTopColPosition = function( colSpan ) {
2627	+ var colGroup = this._getTopColGroup( colSpan );
2628	+ // get the minimum Y value from the columns
2629	+ var minimumY = Math.min.apply( Math, colGroup );
2630	+
2631	+ return {
2632	+ col: colGroup.indexOf( minimumY ),
2633	+ y: minimumY,
2634	+ };
2635	+ };
2636	+
2637	+ /**
2638	+ * @param {Number} colSpan - number of columns the element spans
2639	+ * @returns {Array} colGroup
2640	+ */
2641	+ proto._getTopColGroup = function( colSpan ) {
2642	+ if ( colSpan < 2 ) {
2643	+ // if brick spans only one column, use all the column Ys
2644	+ return this.colYs;
2645	+ }
2646	+
2647	+ var colGroup = [];
2648	+ // how many different places could this brick fit horizontally
2649	+ var groupCount = this.cols + 1 - colSpan;
2650	+ // for each group potential horizontal position
2651	+ for ( var i = 0; i < groupCount; i++ ) {
2652	+ colGroup[i] = this._getColGroupY( i, colSpan );
2653	+ }
2654	+ return colGroup;
2655	+ };
2656	+
2657	+ proto._getColGroupY = function( col, colSpan ) {
2658	+ if ( colSpan < 2 ) {
2659	+ return this.colYs[ col ];
2660	+ }
2661	+ // make an array of colY values for that one group
2662	+ var groupColYs = this.colYs.slice( col, col + colSpan );
2663	+ // and get the max value of the array
2664	+ return Math.max.apply( Math, groupColYs );
2665	+ };
2666	+
2667	+ // get column position based on horizontal index. #873
2668	+ proto._getHorizontalColPosition = function( colSpan, item ) {
2669	+ var col = this.horizontalColIndex % this.cols;
2670	+ var isOver = colSpan > 1 && col + colSpan > this.cols;
2671	+ // shift to next row if item can't fit on current row
2672	+ col = isOver ? 0 : col;
2673	+ // don't let zero-size items take up space
2674	+ var hasSize = item.size.outerWidth && item.size.outerHeight;
2675	+ this.horizontalColIndex = hasSize ? col + colSpan : this.horizontalColIndex;
2676	+
2677	+ return {
2678	+ col: col,
2679	+ y: this._getColGroupY( col, colSpan ),
2680	+ };
2681	+ };
2682	+
2683	+ proto._manageStamp = function( stamp ) {
2684	+ var stampSize = getSize( stamp );
2685	+ var offset = this._getElementOffset( stamp );
2686	+ // get the columns that this stamp affects
2687	+ var isOriginLeft = this._getOption('originLeft');
2688	+ var firstX = isOriginLeft ? offset.left : offset.right;
2689	+ var lastX = firstX + stampSize.outerWidth;
2690	+ var firstCol = Math.floor( firstX / this.columnWidth );
2691	+ firstCol = Math.max( 0, firstCol );
2692	+ var lastCol = Math.floor( lastX / this.columnWidth );
2693	+ // lastCol should not go over if multiple of columnWidth #425
2694	+ lastCol -= lastX % this.columnWidth ? 0 : 1;
2695	+ lastCol = Math.min( this.cols - 1, lastCol );
2696	+ // set colYs to bottom of the stamp
2697	+
2698	+ var isOriginTop = this._getOption('originTop');
2699	+ var stampMaxY = ( isOriginTop ? offset.top : offset.bottom ) +
2700	+ stampSize.outerHeight;
2701	+ for ( var i = firstCol; i <= lastCol; i++ ) {
2702	+ this.colYs[i] = Math.max( stampMaxY, this.colYs[i] );
2703	+ }
2704	+ };
2705	+
2706	+ proto._getContainerSize = function() {
2707	+ this.maxY = Math.max.apply( Math, this.colYs );
2708	+ var size = {
2709	+ height: this.maxY
2710	+ };
2711	+
2712	+ if ( this._getOption('fitWidth') ) {
2713	+ size.width = this._getContainerFitWidth();
2714	+ }
2715	+
2716	+ return size;
2717	+ };
2718	+
2719	+ proto._getContainerFitWidth = function() {
2720	+ var unusedCols = 0;
2721	+ // count unused columns
2722	+ var i = this.cols;
2723	+ while ( --i ) {
2724	+ if ( this.colYs[i] !== 0 ) {
2725	+ break;
2726	+ }
2727	+ unusedCols++;
2728	+ }
2729	+ // fit container to columns that have been used
2730	+ return ( this.cols - unusedCols ) * this.columnWidth - this.gutter;
2731	+ };
2732	+
2733	+ proto.needsResizeLayout = function() {
2734	+ var previousWidth = this.containerWidth;
2735	+ this.getContainerWidth();
2736	+ return previousWidth != this.containerWidth;
2737	+ };
2738	+
2739	+ return Masonry;
2740	+
2741	+ }));
2742	+
2743	+ /*!
2744	+ * Masonry layout mode
2745	+ * sub-classes Masonry
2746	+ * https://masonry.desandro.com
2747	+ */
2748	+
2749	+ ( function( window, factory ) {
2750	+ // universal module definition
2751	+ /* jshint strict: false / /globals define, module, require */
2752	+ if ( typeof define == 'function' && define.amd ) {
2753	+ // AMD
2754	+ define( 'isotope-layout/js/layout-modes/masonry',[
2755	+ '../layout-mode',
2756	+ 'masonry-layout/masonry'
2757	+ ],
2758	+ factory );
2759	+ } else if ( typeof module == 'object' && module.exports ) {
2760	+ // CommonJS
2761	+ module.exports = factory(
2762	+ require('../layout-mode'),
2763	+ require('masonry-layout')
2764	+ );
2765	+ } else {
2766	+ // browser global
2767	+ factory(
2768	+ window.Isotope.LayoutMode,
2769	+ window.Masonry
2770	+ );
2771	+ }
2772	+
2773	+ }( window, function factory( LayoutMode, Masonry ) {
2774	+ 'use strict';
2775	+
2776	+ // -------------------------- masonryDefinition -------------------------- //
2777	+
2778	+ // create an Outlayer layout class
2779	+ var MasonryMode = LayoutMode.create('masonry');
2780	+
2781	+ var proto = MasonryMode.prototype;
2782	+
2783	+ var keepModeMethods = {
2784	+ _getElementOffset: true,
2785	+ layout: true,
2786	+ _getMeasurement: true
2787	+ };
2788	+
2789	+ // inherit Masonry prototype
2790	+ for ( var method in Masonry.prototype ) {
2791	+ // do not inherit mode methods
2792	+ if ( !keepModeMethods[ method ] ) {
2793	+ proto[ method ] = Masonry.prototype[ method ];
2794	+ }
2795	+ }
2796	+
2797	+ var measureColumns = proto.measureColumns;
2798	+ proto.measureColumns = function() {
2799	+ // set items, used if measuring first item
2800	+ this.items = this.isotope.filteredItems;
2801	+ measureColumns.call( this );
2802	+ };
2803	+
2804	+ // point to mode options for fitWidth
2805	+ var _getOption = proto._getOption;
2806	+ proto._getOption = function( option ) {
2807	+ if ( option == 'fitWidth' ) {
2808	+ return this.options.isFitWidth !== undefined ?
2809	+ this.options.isFitWidth : this.options.fitWidth;
2810	+ }
2811	+ return _getOption.apply( this.isotope, arguments );
2812	+ };
2813	+
2814	+ return MasonryMode;
2815	+
2816	+ }));
2817	+
2818	+ /**
2819	+ * fitRows layout mode
2820	+ */
2821	+
2822	+ ( function( window, factory ) {
2823	+ // universal module definition
2824	+ /* jshint strict: false / /globals define, module, require */
2825	+ if ( typeof define == 'function' && define.amd ) {
2826	+ // AMD
2827	+ define( 'isotope-layout/js/layout-modes/fit-rows',[
2828	+ '../layout-mode'
2829	+ ],
2830	+ factory );
2831	+ } else if ( typeof exports == 'object' ) {
2832	+ // CommonJS
2833	+ module.exports = factory(
2834	+ require('../layout-mode')
2835	+ );
2836	+ } else {
2837	+ // browser global
2838	+ factory(
2839	+ window.Isotope.LayoutMode
2840	+ );
2841	+ }
2842	+
2843	+ }( window, function factory( LayoutMode ) {
2844	+ 'use strict';
2845	+
2846	+ var FitRows = LayoutMode.create('fitRows');
2847	+
2848	+ var proto = FitRows.prototype;
2849	+
2850	+ proto._resetLayout = function() {
2851	+ this.x = 0;
2852	+ this.y = 0;
2853	+ this.maxY = 0;
2854	+ this._getMeasurement( 'gutter', 'outerWidth' );
2855	+ };
2856	+
2857	+ proto._getItemLayoutPosition = function( item ) {
2858	+ item.getSize();
2859	+
2860	+ var itemWidth = item.size.outerWidth + this.gutter;
2861	+ // if this element cannot fit in the current row
2862	+ var containerWidth = this.isotope.size.innerWidth + this.gutter;
2863	+ if ( this.x !== 0 && itemWidth + this.x > containerWidth ) {
2864	+ this.x = 0;
2865	+ this.y = this.maxY;
2866	+ }
2867	+
2868	+ var position = {
2869	+ x: this.x,
2870	+ y: this.y
2871	+ };
2872	+
2873	+ this.maxY = Math.max( this.maxY, this.y + item.size.outerHeight );
2874	+ this.x += itemWidth;
2875	+
2876	+ return position;
2877	+ };
2878	+
2879	+ proto._getContainerSize = function() {
2880	+ return { height: this.maxY };
2881	+ };
2882	+
2883	+ return FitRows;
2884	+
2885	+ }));
2886	+
2887	+ /**
2888	+ * vertical layout mode
2889	+ */
2890	+
2891	+ ( function( window, factory ) {
2892	+ // universal module definition
2893	+ /* jshint strict: false / /globals define, module, require */
2894	+ if ( typeof define == 'function' && define.amd ) {
2895	+ // AMD
2896	+ define( 'isotope-layout/js/layout-modes/vertical',[
2897	+ '../layout-mode'
2898	+ ],
2899	+ factory );
2900	+ } else if ( typeof module == 'object' && module.exports ) {
2901	+ // CommonJS
2902	+ module.exports = factory(
2903	+ require('../layout-mode')
2904	+ );
2905	+ } else {
2906	+ // browser global
2907	+ factory(
2908	+ window.Isotope.LayoutMode
2909	+ );
2910	+ }
2911	+
2912	+ }( window, function factory( LayoutMode ) {
2913	+ 'use strict';
2914	+
2915	+ var Vertical = LayoutMode.create( 'vertical', {
2916	+ horizontalAlignment: 0
2917	+ });
2918	+
2919	+ var proto = Vertical.prototype;
2920	+
2921	+ proto._resetLayout = function() {
2922	+ this.y = 0;
2923	+ };
2924	+
2925	+ proto._getItemLayoutPosition = function( item ) {
2926	+ item.getSize();
2927	+ var x = ( this.isotope.size.innerWidth - item.size.outerWidth ) *
2928	+ this.options.horizontalAlignment;
2929	+ var y = this.y;
2930	+ this.y += item.size.outerHeight;
2931	+ return { x: x, y: y };
2932	+ };
2933	+
2934	+ proto._getContainerSize = function() {
2935	+ return { height: this.y };
2936	+ };
2937	+
2938	+ return Vertical;
2939	+
2940	+ }));
2941	+
2942	+ /*!
2943	+ * Isotope v3.0.6
2944	+ *
2945	+ * Licensed GPLv3 for open source use
2946	+ * or Isotope Commercial License for commercial use
2947	+ *
2948	+ * https://isotope.metafizzy.co
2949	+ * Copyright 2010-2018 Metafizzy
2950	+ */
2951	+
2952	+ ( function( window, factory ) {
2953	+ // universal module definition
2954	+ /* jshint strict: false / /globals define, module, require */
2955	+ if ( typeof define == 'function' && define.amd ) {
2956	+ // AMD
2957	+ define( [
2958	+ 'outlayer/outlayer',
2959	+ 'get-size/get-size',
2960	+ 'desandro-matches-selector/matches-selector',
2961	+ 'fizzy-ui-utils/utils',
2962	+ 'isotope-layout/js/item',
2963	+ 'isotope-layout/js/layout-mode',
2964	+ // include default layout modes
2965	+ 'isotope-layout/js/layout-modes/masonry',
2966	+ 'isotope-layout/js/layout-modes/fit-rows',
2967	+ 'isotope-layout/js/layout-modes/vertical'
2968	+ ],
2969	+ function( Outlayer, getSize, matchesSelector, utils, Item, LayoutMode ) {
2970	+ return factory( window, Outlayer, getSize, matchesSelector, utils, Item, LayoutMode );
2971	+ });
2972	+ } else if ( typeof module == 'object' && module.exports ) {
2973	+ // CommonJS
2974	+ module.exports = factory(
2975	+ window,
2976	+ require('outlayer'),
2977	+ require('get-size'),
2978	+ require('desandro-matches-selector'),
2979	+ require('fizzy-ui-utils'),
2980	+ require('isotope-layout/js/item'),
2981	+ require('isotope-layout/js/layout-mode'),
2982	+ // include default layout modes
2983	+ require('isotope-layout/js/layout-modes/masonry'),
2984	+ require('isotope-layout/js/layout-modes/fit-rows'),
2985	+ require('isotope-layout/js/layout-modes/vertical')
2986	+ );
2987	+ } else {
2988	+ // browser global
2989	+ window.Isotope = factory(
2990	+ window,
2991	+ window.Outlayer,
2992	+ window.getSize,
2993	+ window.matchesSelector,
2994	+ window.fizzyUIUtils,
2995	+ window.Isotope.Item,
2996	+ window.Isotope.LayoutMode
2997	+ );
2998	+ }
2999	+
3000	+ }( window, function factory( window, Outlayer, getSize, matchesSelector, utils,
3001	+ Item, LayoutMode ) {
3002	+
3003	+
3004	+
3005	+ // -------------------------- vars -------------------------- //
3006	+
3007	+ var jQuery = window.jQuery;
3008	+
3009	+ // -------------------------- helpers -------------------------- //
3010	+
3011	+ var trim = String.prototype.trim ?
3012	+ function( str ) {
3013	+ return str.trim();
3014	+ } :
3015	+ function( str ) {
3016	+ return str.replace( /^\s+\|\s+$/g, '' );
3017	+ };
3018	+
3019	+ // -------------------------- isotopeDefinition -------------------------- //
3020	+
3021	+ // create an Outlayer layout class
3022	+ var Isotope = Outlayer.create( 'isotope', {
3023	+ layoutMode: 'masonry',
3024	+ isJQueryFiltering: true,
3025	+ sortAscending: true
3026	+ });
3027	+
3028	+ Isotope.Item = Item;
3029	+ Isotope.LayoutMode = LayoutMode;
3030	+
3031	+ var proto = Isotope.prototype;
3032	+
3033	+ proto._create = function() {
3034	+ this.itemGUID = 0;
3035	+ // functions that sort items
3036	+ this._sorters = {};
3037	+ this._getSorters();
3038	+ // call super
3039	+ Outlayer.prototype._create.call( this );
3040	+
3041	+ // create layout modes
3042	+ this.modes = {};
3043	+ // start filteredItems with all items
3044	+ this.filteredItems = this.items;
3045	+ // keep of track of sortBys
3046	+ this.sortHistory = [ 'original-order' ];
3047	+ // create from registered layout modes
3048	+ for ( var name in LayoutMode.modes ) {
3049	+ this._initLayoutMode( name );
3050	+ }
3051	+ };
3052	+
3053	+ proto.reloadItems = function() {
3054	+ // reset item ID counter
3055	+ this.itemGUID = 0;
3056	+ // call super
3057	+ Outlayer.prototype.reloadItems.call( this );
3058	+ };
3059	+
3060	+ proto._itemize = function() {
3061	+ var items = Outlayer.prototype._itemize.apply( this, arguments );
3062	+ // assign ID for original-order
3063	+ for ( var i=0; i < items.length; i++ ) {
3064	+ var item = items[i];
3065	+ item.id = this.itemGUID++;
3066	+ }
3067	+ this._updateItemsSortData( items );
3068	+ return items;
3069	+ };
3070	+
3071	+
3072	+ // -------------------------- layout -------------------------- //
3073	+
3074	+ proto._initLayoutMode = function( name ) {
3075	+ var Mode = LayoutMode.modes[ name ];
3076	+ // set mode options
3077	+ // HACK extend initial options, back-fill in default options
3078	+ var initialOpts = this.options[ name ] \|\| {};
3079	+ this.options[ name ] = Mode.options ?
3080	+ utils.extend( Mode.options, initialOpts ) : initialOpts;
3081	+ // init layout mode instance
3082	+ this.modes[ name ] = new Mode( this );
3083	+ };
3084	+
3085	+
3086	+ proto.layout = function() {
3087	+ // if first time doing layout, do all magic
3088	+ if ( !this._isLayoutInited && this._getOption('initLayout') ) {
3089	+ this.arrange();
3090	+ return;
3091	+ }
3092	+ this._layout();
3093	+ };
3094	+
3095	+ // private method to be used in layout() & magic()
3096	+ proto._layout = function() {
3097	+ // don't animate first layout
3098	+ var isInstant = this._getIsInstant();
3099	+ // layout flow
3100	+ this._resetLayout();
3101	+ this._manageStamps();
3102	+ this.layoutItems( this.filteredItems, isInstant );
3103	+
3104	+ // flag for initalized
3105	+ this._isLayoutInited = true;
3106	+ };
3107	+
3108	+ // filter + sort + layout
3109	+ proto.arrange = function( opts ) {
3110	+ // set any options pass
3111	+ this.option( opts );
3112	+ this._getIsInstant();
3113	+ // filter, sort, and layout
3114	+
3115	+ // filter
3116	+ var filtered = this._filter( this.items );
3117	+ this.filteredItems = filtered.matches;
3118	+
3119	+ this._bindArrangeComplete();
3120	+
3121	+ if ( this._isInstant ) {
3122	+ this._noTransition( this._hideReveal, [ filtered ] );
3123	+ } else {
3124	+ this._hideReveal( filtered );
3125	+ }
3126	+
3127	+ this._sort();
3128	+ this._layout();
3129	+ };
3130	+ // alias to _init for main plugin method
3131	+ proto._init = proto.arrange;
3132	+
3133	+ proto._hideReveal = function( filtered ) {
3134	+ this.reveal( filtered.needReveal );
3135	+ this.hide( filtered.needHide );
3136	+ };
3137	+
3138	+ // HACK
3139	+ // Don't animate/transition first layout
3140	+ // Or don't animate/transition other layouts
3141	+ proto._getIsInstant = function() {
3142	+ var isLayoutInstant = this._getOption('layoutInstant');
3143	+ var isInstant = isLayoutInstant !== undefined ? isLayoutInstant :
3144	+ !this._isLayoutInited;
3145	+ this._isInstant = isInstant;
3146	+ return isInstant;
3147	+ };
3148	+
3149	+ // listen for layoutComplete, hideComplete and revealComplete
3150	+ // to trigger arrangeComplete
3151	+ proto._bindArrangeComplete = function() {
3152	+ // listen for 3 events to trigger arrangeComplete
3153	+ var isLayoutComplete, isHideComplete, isRevealComplete;
3154	+ var _this = this;
3155	+ function arrangeParallelCallback() {
3156	+ if ( isLayoutComplete && isHideComplete && isRevealComplete ) {
3157	+ _this.dispatchEvent( 'arrangeComplete', null, [ _this.filteredItems ] );
3158	+ }
3159	+ }
3160	+ this.once( 'layoutComplete', function() {
3161	+ isLayoutComplete = true;
3162	+ arrangeParallelCallback();
3163	+ });
3164	+ this.once( 'hideComplete', function() {
3165	+ isHideComplete = true;
3166	+ arrangeParallelCallback();
3167	+ });
3168	+ this.once( 'revealComplete', function() {
3169	+ isRevealComplete = true;
3170	+ arrangeParallelCallback();
3171	+ });
3172	+ };
3173	+
3174	+ // -------------------------- filter -------------------------- //
3175	+
3176	+ proto._filter = function( items ) {
3177	+ var filter = this.options.filter;
3178	+ filter = filter \|\| '*';
3179	+ var matches = [];
3180	+ var hiddenMatched = [];
3181	+ var visibleUnmatched = [];
3182	+
3183	+ var test = this._getFilterTest( filter );
3184	+
3185	+ // test each item
3186	+ for ( var i=0; i < items.length; i++ ) {
3187	+ var item = items[i];
3188	+ if ( item.isIgnored ) {
3189	+ continue;
3190	+ }
3191	+ // add item to either matched or unmatched group
3192	+ var isMatched = test( item );
3193	+ // item.isFilterMatched = isMatched;
3194	+ // add to matches if its a match
3195	+ if ( isMatched ) {
3196	+ matches.push( item );
3197	+ }
3198	+ // add to additional group if item needs to be hidden or revealed
3199	+ if ( isMatched && item.isHidden ) {
3200	+ hiddenMatched.push( item );
3201	+ } else if ( !isMatched && !item.isHidden ) {
3202	+ visibleUnmatched.push( item );
3203	+ }
3204	+ }
3205	+
3206	+ // return collections of items to be manipulated
3207	+ return {
3208	+ matches: matches,
3209	+ needReveal: hiddenMatched,
3210	+ needHide: visibleUnmatched
3211	+ };
3212	+ };
3213	+
3214	+ // get a jQuery, function, or a matchesSelector test given the filter
3215	+ proto._getFilterTest = function( filter ) {
3216	+ if ( jQuery && this.options.isJQueryFiltering ) {
3217	+ // use jQuery
3218	+ return function( item ) {
3219	+ return jQuery( item.element ).is( filter );
3220	+ };
3221	+ }
3222	+ if ( typeof filter == 'function' ) {
3223	+ // use filter as function
3224	+ return function( item ) {
3225	+ return filter( item.element );
3226	+ };
3227	+ }
3228	+ // default, use filter as selector string
3229	+ return function( item ) {
3230	+ return matchesSelector( item.element, filter );
3231	+ };
3232	+ };
3233	+
3234	+ // -------------------------- sorting -------------------------- //
3235	+
3236	+ /**
3237	+ * @params {Array} elems
3238	+ * @public
3239	+ */
3240	+ proto.updateSortData = function( elems ) {
3241	+ // get items
3242	+ var items;
3243	+ if ( elems ) {
3244	+ elems = utils.makeArray( elems );
3245	+ items = this.getItems( elems );
3246	+ } else {
3247	+ // update all items if no elems provided
3248	+ items = this.items;
3249	+ }
3250	+
3251	+ this._getSorters();
3252	+ this._updateItemsSortData( items );
3253	+ };
3254	+
3255	+ proto._getSorters = function() {
3256	+ var getSortData = this.options.getSortData;
3257	+ for ( var key in getSortData ) {
3258	+ var sorter = getSortData[ key ];
3259	+ this._sorters[ key ] = mungeSorter( sorter );
3260	+ }
3261	+ };
3262	+
3263	+ /**
3264	+ * @params {Array} items - of Isotope.Items
3265	+ * @private
3266	+ */
3267	+ proto._updateItemsSortData = function( items ) {
3268	+ // do not update if no items
3269	+ var len = items && items.length;
3270	+
3271	+ for ( var i=0; len && i < len; i++ ) {
3272	+ var item = items[i];
3273	+ item.updateSortData();
3274	+ }
3275	+ };
3276	+
3277	+ // ----- munge sorter ----- //
3278	+
3279	+ // encapsulate this, as we just need mungeSorter
3280	+ // other functions in here are just for munging
3281	+ var mungeSorter = ( function() {
3282	+ // add a magic layer to sorters for convienent shorthands
3283	+ // `.foo-bar` will use the text of .foo-bar querySelector
3284	+ // `[foo-bar]` will use attribute
3285	+ // you can also add parser
3286	+ // `.foo-bar parseInt` will parse that as a number
3287	+ function mungeSorter( sorter ) {
3288	+ // if not a string, return function or whatever it is
3289	+ if ( typeof sorter != 'string' ) {
3290	+ return sorter;
3291	+ }
3292	+ // parse the sorter string
3293	+ var args = trim( sorter ).split(' ');
3294	+ var query = args[0];
3295	+ // check if query looks like [an-attribute]
3296	+ var attrMatch = query.match( /^\[(.+)\]$/ );
3297	+ var attr = attrMatch && attrMatch[1];
3298	+ var getValue = getValueGetter( attr, query );
3299	+ // use second argument as a parser
3300	+ var parser = Isotope.sortDataParsers[ args[1] ];
3301	+ // parse the value, if there was a parser
3302	+ sorter = parser ? function( elem ) {
3303	+ return elem && parser( getValue( elem ) );
3304	+ } :
3305	+ // otherwise just return value
3306	+ function( elem ) {
3307	+ return elem && getValue( elem );
3308	+ };
3309	+
3310	+ return sorter;
3311	+ }
3312	+
3313	+ // get an attribute getter, or get text of the querySelector
3314	+ function getValueGetter( attr, query ) {
3315	+ // if query looks like [foo-bar], get attribute
3316	+ if ( attr ) {
3317	+ return function getAttribute( elem ) {
3318	+ return elem.getAttribute( attr );
3319	+ };
3320	+ }
3321	+
3322	+ // otherwise, assume its a querySelector, and get its text
3323	+ return function getChildText( elem ) {
3324	+ var child = elem.querySelector( query );
3325	+ return child && child.textContent;
3326	+ };
3327	+ }
3328	+
3329	+ return mungeSorter;
3330	+ })();
3331	+
3332	+ // parsers used in getSortData shortcut strings
3333	+ Isotope.sortDataParsers = {
3334	+ 'parseInt': function( val ) {
3335	+ return parseInt( val, 10 );
3336	+ },
3337	+ 'parseFloat': function( val ) {
3338	+ return parseFloat( val );
3339	+ }
3340	+ };
3341	+
3342	+ // ----- sort method ----- //
3343	+
3344	+ // sort filteredItem order
3345	+ proto._sort = function() {
3346	+ if ( !this.options.sortBy ) {
3347	+ return;
3348	+ }
3349	+ // keep track of sortBy History
3350	+ var sortBys = utils.makeArray( this.options.sortBy );
3351	+ if ( !this._getIsSameSortBy( sortBys ) ) {
3352	+ // concat all sortBy and sortHistory, add to front, oldest goes in last
3353	+ this.sortHistory = sortBys.concat( this.sortHistory );
3354	+ }
3355	+ // sort magic
3356	+ var itemSorter = getItemSorter( this.sortHistory, this.options.sortAscending );
3357	+ this.filteredItems.sort( itemSorter );
3358	+ };
3359	+
3360	+ // check if sortBys is same as start of sortHistory
3361	+ proto._getIsSameSortBy = function( sortBys ) {
3362	+ for ( var i=0; i < sortBys.length; i++ ) {
3363	+ if ( sortBys[i] != this.sortHistory[i] ) {
3364	+ return false;
3365	+ }
3366	+ }
3367	+ return true;
3368	+ };
3369	+
3370	+ // returns a function used for sorting
3371	+ function getItemSorter( sortBys, sortAsc ) {
3372	+ return function sorter( itemA, itemB ) {
3373	+ // cycle through all sortKeys
3374	+ for ( var i = 0; i < sortBys.length; i++ ) {
3375	+ var sortBy = sortBys[i];
3376	+ var a = itemA.sortData[ sortBy ];
3377	+ var b = itemB.sortData[ sortBy ];
3378	+ if ( a > b \|\| a < b ) {
3379	+ // if sortAsc is an object, use the value given the sortBy key
3380	+ var isAscending = sortAsc[ sortBy ] !== undefined ? sortAsc[ sortBy ] : sortAsc;
3381	+ var direction = isAscending ? 1 : -1;
3382	+ return ( a > b ? 1 : -1 ) * direction;
3383	+ }
3384	+ }
3385	+ return 0;
3386	+ };
3387	+ }
3388	+
3389	+ // -------------------------- methods -------------------------- //
3390	+
3391	+ // get layout mode
3392	+ proto._mode = function() {
3393	+ var layoutMode = this.options.layoutMode;
3394	+ var mode = this.modes[ layoutMode ];
3395	+ if ( !mode ) {
3396	+ // TODO console.error
3397	+ throw new Error( 'No layout mode: ' + layoutMode );
3398	+ }
3399	+ // HACK sync mode's options
3400	+ // any options set after init for layout mode need to be synced
3401	+ mode.options = this.options[ layoutMode ];
3402	+ return mode;
3403	+ };
3404	+
3405	+ proto._resetLayout = function() {
3406	+ // trigger original reset layout
3407	+ Outlayer.prototype._resetLayout.call( this );
3408	+ this._mode()._resetLayout();
3409	+ };
3410	+
3411	+ proto._getItemLayoutPosition = function( item ) {
3412	+ return this._mode()._getItemLayoutPosition( item );
3413	+ };
3414	+
3415	+ proto._manageStamp = function( stamp ) {
3416	+ this._mode()._manageStamp( stamp );
3417	+ };
3418	+
3419	+ proto._getContainerSize = function() {
3420	+ return this._mode()._getContainerSize();
3421	+ };
3422	+
3423	+ proto.needsResizeLayout = function() {
3424	+ return this._mode().needsResizeLayout();
3425	+ };
3426	+
3427	+ // -------------------------- adding & removing -------------------------- //
3428	+
3429	+ // HEADS UP overwrites default Outlayer appended
3430	+ proto.appended = function( elems ) {
3431	+ var items = this.addItems( elems );
3432	+ if ( !items.length ) {
3433	+ return;
3434	+ }
3435	+ // filter, layout, reveal new items
3436	+ var filteredItems = this._filterRevealAdded( items );
3437	+ // add to filteredItems
3438	+ this.filteredItems = this.filteredItems.concat( filteredItems );
3439	+ };
3440	+
3441	+ // HEADS UP overwrites default Outlayer prepended
3442	+ proto.prepended = function( elems ) {
3443	+ var items = this._itemize( elems );
3444	+ if ( !items.length ) {
3445	+ return;
3446	+ }
3447	+ // start new layout
3448	+ this._resetLayout();
3449	+ this._manageStamps();
3450	+ // filter, layout, reveal new items
3451	+ var filteredItems = this._filterRevealAdded( items );
3452	+ // layout previous items
3453	+ this.layoutItems( this.filteredItems );
3454	+ // add to items and filteredItems
3455	+ this.filteredItems = filteredItems.concat( this.filteredItems );
3456	+ this.items = items.concat( this.items );
3457	+ };
3458	+
3459	+ proto._filterRevealAdded = function( items ) {
3460	+ var filtered = this._filter( items );
3461	+ this.hide( filtered.needHide );
3462	+ // reveal all new items
3463	+ this.reveal( filtered.matches );
3464	+ // layout new items, no transition
3465	+ this.layoutItems( filtered.matches, true );
3466	+ return filtered.matches;
3467	+ };
3468	+
3469	+ /**
3470	+ * Filter, sort, and layout newly-appended item elements
3471	+ * @param {Array or NodeList or Element} elems
3472	+ */
3473	+ proto.insert = function( elems ) {
3474	+ var items = this.addItems( elems );
3475	+ if ( !items.length ) {
3476	+ return;
3477	+ }
3478	+ // append item elements
3479	+ var i, item;
3480	+ var len = items.length;
3481	+ for ( i=0; i < len; i++ ) {
3482	+ item = items[i];
3483	+ this.element.appendChild( item.element );
3484	+ }
3485	+ // filter new stuff
3486	+ var filteredInsertItems = this._filter( items ).matches;
3487	+ // set flag
3488	+ for ( i=0; i < len; i++ ) {
3489	+ items[i].isLayoutInstant = true;
3490	+ }
3491	+ this.arrange();
3492	+ // reset flag
3493	+ for ( i=0; i < len; i++ ) {
3494	+ delete items[i].isLayoutInstant;
3495	+ }
3496	+ this.reveal( filteredInsertItems );
3497	+ };
3498	+
3499	+ var _remove = proto.remove;
3500	+ proto.remove = function( elems ) {
3501	+ elems = utils.makeArray( elems );
3502	+ var removeItems = this.getItems( elems );
3503	+ // do regular thing
3504	+ _remove.call( this, elems );
3505	+ // bail if no items to remove
3506	+ var len = removeItems && removeItems.length;
3507	+ // remove elems from filteredItems
3508	+ for ( var i=0; len && i < len; i++ ) {
3509	+ var item = removeItems[i];
3510	+ // remove item from collection
3511	+ utils.removeFrom( this.filteredItems, item );
3512	+ }
3513	+ };
3514	+
3515	+ proto.shuffle = function() {
3516	+ // update random sortData
3517	+ for ( var i=0; i < this.items.length; i++ ) {
3518	+ var item = this.items[i];
3519	+ item.sortData.random = Math.random();
3520	+ }
3521	+ this.options.sortBy = 'random';
3522	+ this._sort();
3523	+ this._layout();
3524	+ };
3525	+
3526	+ /**
3527	+ * trigger fn without transition
3528	+ * kind of hacky to have this in the first place
3529	+ * @param {Function} fn
3530	+ * @param {Array} args
3531	+ * @returns ret
3532	+ * @private
3533	+ */
3534	+ proto._noTransition = function( fn, args ) {
3535	+ // save transitionDuration before disabling
3536	+ var transitionDuration = this.options.transitionDuration;
3537	+ // disable transition
3538	+ this.options.transitionDuration = 0;
3539	+ // do it
3540	+ var returnValue = fn.apply( this, args );
3541	+ // re-enable transition for reveal
3542	+ this.options.transitionDuration = transitionDuration;
3543	+ return returnValue;
3544	+ };
3545	+
3546	+ // ----- helper methods ----- //
3547	+
3548	+ /**
3549	+ * getter method for getting filtered item elements
3550	+ * @returns {Array} elems - collection of item elements
3551	+ */
3552	+ proto.getFilteredItemElements = function() {
3553	+ return this.filteredItems.map( function( item ) {
3554	+ return item.element;
3555	+ });
3556	+ };
3557	+
3558	+ // ----- ----- //
3559	+
3560	+ return Isotope;
3561	+
3562	+ }));
3563	+

assets/lib/isotope/isotope.pkgd.min.js ADDED Viewed

	@@ -0,0 +1,12 @@


1	+ /*!
2	+ * Isotope PACKAGED v3.0.6
3	+ *
4	+ * Licensed GPLv3 for open source use
5	+ * or Isotope Commercial License for commercial use
6	+ *
7	+ * https://isotope.metafizzy.co
8	+ * Copyright 2010-2018 Metafizzy
9	+ */
10	+
11	+ !function(t,e){"function"==typeof define&&define.amd?define("jquery-bridget/jquery-bridget",["jquery"],function(i){return e(t,i)}):"object"==typeof module&&module.exports?module.exports=e(t,require("jquery")):t.jQueryBridget=e(t,t.jQuery)}(window,function(t,e){"use strict";function i(i,s,a){function u(t,e,o){var n,s="$()."+i+'("'+e+'")';return t.each(function(t,u){var h=a.data(u,i);if(!h)return void r(i+" not initialized. Cannot call methods, i.e. "+s);var d=h[e];if(!d\|\|"_"==e.charAt(0))return void r(s+" is not a valid method");var l=d.apply(h,o);n=void 0===n?l:n}),void 0!==n?n:t}function h(t,e){t.each(function(t,o){var n=a.data(o,i);n?(n.option(e),n._init()):(n=new s(o,e),a.data(o,i,n))})}a=a\|\|e\|\|t.jQuery,a&&(s.prototype.option\|\|(s.prototype.option=function(t){a.isPlainObject(t)&&(this.options=a.extend(!0,this.options,t))}),a.fn[i]=function(t){if("string"==typeof t){var e=n.call(arguments,1);return u(this,t,e)}return h(this,t),this},o(a))}function o(t){!t\|\|t&&t.bridget\|\|(t.bridget=i)}var n=Array.prototype.slice,s=t.console,r="undefined"==typeof s?function(){}:function(t){s.error(t)};return o(e\|\|t.jQuery),i}),function(t,e){"function"==typeof define&&define.amd?define("ev-emitter/ev-emitter",e):"object"==typeof module&&module.exports?module.exports=e():t.EvEmitter=e()}("undefined"!=typeof window?window:this,function(){function t(){}var e=t.prototype;return e.on=function(t,e){if(t&&e){var i=this._events=this._events\|\|{},o=i[t]=i[t]\|\|[];return o.indexOf(e)==-1&&o.push(e),this}},e.once=function(t,e){if(t&&e){this.on(t,e);var i=this._onceEvents=this._onceEvents\|\|{},o=i[t]=i[t]\|\|{};return o[e]=!0,this}},e.off=function(t,e){var i=this._events&&this._events[t];if(i&&i.length){var o=i.indexOf(e);return o!=-1&&i.splice(o,1),this}},e.emitEvent=function(t,e){var i=this._events&&this._events[t];if(i&&i.length){i=i.slice(0),e=e\|\|[];for(var o=this._onceEvents&&this._onceEvents[t],n=0;n<i.length;n++){var s=i[n],r=o&&o[s];r&&(this.off(t,s),delete o[s]),s.apply(this,e)}return this}},e.allOff=function(){delete this._events,delete this._onceEvents},t}),function(t,e){"function"==typeof define&&define.amd?define("get-size/get-size",e):"object"==typeof module&&module.exports?module.exports=e():t.getSize=e()}(window,function(){"use strict";function t(t){var e=parseFloat(t),i=t.indexOf("%")==-1&&!isNaN(e);return i&&e}function e(){}function i(){for(var t={width:0,height:0,innerWidth:0,innerHeight:0,outerWidth:0,outerHeight:0},e=0;e<h;e++){var i=u[e];t[i]=0}return t}function o(t){var e=getComputedStyle(t);return e\|\|a("Style returned "+e+". Are you running this code in a hidden iframe on Firefox? See https://bit.ly/getsizebug1"),e}function n(){if(!d){d=!0;var e=document.createElement("div");e.style.width="200px",e.style.padding="1px 2px 3px 4px",e.style.borderStyle="solid",e.style.borderWidth="1px 2px 3px 4px",e.style.boxSizing="border-box";var i=document.body\|\|document.documentElement;i.appendChild(e);var n=o(e);r=200==Math.round(t(n.width)),s.isBoxSizeOuter=r,i.removeChild(e)}}function s(e){if(n(),"string"==typeof e&&(e=document.querySelector(e)),e&&"object"==typeof e&&e.nodeType){var s=o(e);if("none"==s.display)return i();var a={};a.width=e.offsetWidth,a.height=e.offsetHeight;for(var d=a.isBorderBox="border-box"==s.boxSizing,l=0;l<h;l++){var f=u[l],c=s[f],m=parseFloat(c);a[f]=isNaN(m)?0:m}var p=a.paddingLeft+a.paddingRight,y=a.paddingTop+a.paddingBottom,g=a.marginLeft+a.marginRight,v=a.marginTop+a.marginBottom,_=a.borderLeftWidth+a.borderRightWidth,z=a.borderTopWidth+a.borderBottomWidth,I=d&&r,x=t(s.width);x!==!1&&(a.width=x+(I?0:p+_));var S=t(s.height);return S!==!1&&(a.height=S+(I?0:y+z)),a.innerWidth=a.width-(p+_),a.innerHeight=a.height-(y+z),a.outerWidth=a.width+g,a.outerHeight=a.height+v,a}}var r,a="undefined"==typeof console?e:function(t){console.error(t)},u=["paddingLeft","paddingRight","paddingTop","paddingBottom","marginLeft","marginRight","marginTop","marginBottom","borderLeftWidth","borderRightWidth","borderTopWidth","borderBottomWidth"],h=u.length,d=!1;return s}),function(t,e){"use strict";"function"==typeof define&&define.amd?define("desandro-matches-selector/matches-selector",e):"object"==typeof module&&module.exports?module.exports=e():t.matchesSelector=e()}(window,function(){"use strict";var t=function(){var t=window.Element.prototype;if(t.matches)return"matches";if(t.matchesSelector)return"matchesSelector";for(var e=["webkit","moz","ms","o"],i=0;i<e.length;i++){var o=e[i],n=o+"MatchesSelector";if(t[n])return n}}();return function(e,i){return e[t](i)}}),function(t,e){"function"==typeof define&&define.amd?define("fizzy-ui-utils/utils",["desandro-matches-selector/matches-selector"],function(i){return e(t,i)}):"object"==typeof module&&module.exports?module.exports=e(t,require("desandro-matches-selector")):t.fizzyUIUtils=e(t,t.matchesSelector)}(window,function(t,e){var i={};i.extend=function(t,e){for(var i in e)t[i]=e[i];return t},i.modulo=function(t,e){return(t%e+e)%e};var o=Array.prototype.slice;i.makeArray=function(t){if(Array.isArray(t))return t;if(null===t\|\|void 0===t)return[];var e="object"==typeof t&&"number"==typeof t.length;return e?o.call(t):[t]},i.removeFrom=function(t,e){var i=t.indexOf(e);i!=-1&&t.splice(i,1)},i.getParent=function(t,i){for(;t.parentNode&&t!=document.body;)if(t=t.parentNode,e(t,i))return t},i.getQueryElement=function(t){return"string"==typeof t?document.querySelector(t):t},i.handleEvent=function(t){var e="on"+t.type;this[e]&&this[e](t)},i.filterFindElements=function(t,o){t=i.makeArray(t);var n=[];return t.forEach(function(t){if(t instanceof HTMLElement){if(!o)return void n.push(t);e(t,o)&&n.push(t);for(var i=t.querySelectorAll(o),s=0;s<i.length;s++)n.push(i[s])}}),n},i.debounceMethod=function(t,e,i){i=i\|\|100;var o=t.prototype[e],n=e+"Timeout";t.prototype[e]=function(){var t=this[n];clearTimeout(t);var e=arguments,s=this;this[n]=setTimeout(function(){o.apply(s,e),delete s[n]},i)}},i.docReady=function(t){var e=document.readyState;"complete"==e\|\|"interactive"==e?setTimeout(t):document.addEventListener("DOMContentLoaded",t)},i.toDashed=function(t){return t.replace(/(.)([A-Z])/g,function(t,e,i){return e+"-"+i}).toLowerCase()};var n=t.console;return i.htmlInit=function(e,o){i.docReady(function(){var s=i.toDashed(o),r="data-"+s,a=document.querySelectorAll("["+r+"]"),u=document.querySelectorAll(".js-"+s),h=i.makeArray(a).concat(i.makeArray(u)),d=r+"-options",l=t.jQuery;h.forEach(function(t){var i,s=t.getAttribute(r)\|\|t.getAttribute(d);try{i=s&&JSON.parse(s)}catch(a){return void(n&&n.error("Error parsing "+r+" on "+t.className+": "+a))}var u=new e(t,i);l&&l.data(t,o,u)})})},i}),function(t,e){"function"==typeof define&&define.amd?define("outlayer/item",["ev-emitter/ev-emitter","get-size/get-size"],e):"object"==typeof module&&module.exports?module.exports=e(require("ev-emitter"),require("get-size")):(t.Outlayer={},t.Outlayer.Item=e(t.EvEmitter,t.getSize))}(window,function(t,e){"use strict";function i(t){for(var e in t)return!1;return e=null,!0}function o(t,e){t&&(this.element=t,this.layout=e,this.position={x:0,y:0},this._create())}function n(t){return t.replace(/([A-Z])/g,function(t){return"-"+t.toLowerCase()})}var s=document.documentElement.style,r="string"==typeof s.transition?"transition":"WebkitTransition",a="string"==typeof s.transform?"transform":"WebkitTransform",u={WebkitTransition:"webkitTransitionEnd",transition:"transitionend"}[r],h={transform:a,transition:r,transitionDuration:r+"Duration",transitionProperty:r+"Property",transitionDelay:r+"Delay"},d=o.prototype=Object.create(t.prototype);d.constructor=o,d._create=function(){this._transn={ingProperties:{},clean:{},onEnd:{}},this.css({position:"absolute"})},d.handleEvent=function(t){var e="on"+t.type;this[e]&&this[e](t)},d.getSize=function(){this.size=e(this.element)},d.css=function(t){var e=this.element.style;for(var i in t){var o=h[i]\|\|i;e[o]=t[i]}},d.getPosition=function(){var t=getComputedStyle(this.element),e=this.layout._getOption("originLeft"),i=this.layout._getOption("originTop"),o=t[e?"left":"right"],n=t[i?"top":"bottom"],s=parseFloat(o),r=parseFloat(n),a=this.layout.size;o.indexOf("%")!=-1&&(s=s/100a.width),n.indexOf("%")!=-1&&(r=r/100a.height),s=isNaN(s)?0:s,r=isNaN(r)?0:r,s-=e?a.paddingLeft:a.paddingRight,r-=i?a.paddingTop:a.paddingBottom,this.position.x=s,this.position.y=r},d.layoutPosition=function(){var t=this.layout.size,e={},i=this.layout._getOption("originLeft"),o=this.layout._getOption("originTop"),n=i?"paddingLeft":"paddingRight",s=i?"left":"right",r=i?"right":"left",a=this.position.x+t[n];e[s]=this.getXValue(a),e[r]="";var u=o?"paddingTop":"paddingBottom",h=o?"top":"bottom",d=o?"bottom":"top",l=this.position.y+t[u];e[h]=this.getYValue(l),e[d]="",this.css(e),this.emitEvent("layout",[this])},d.getXValue=function(t){var e=this.layout._getOption("horizontal");return this.layout.options.percentPosition&&!e?t/this.layout.size.width100+"%":t+"px"},d.getYValue=function(t){var e=this.layout._getOption("horizontal");return this.layout.options.percentPosition&&e?t/this.layout.size.height100+"%":t+"px"},d._transitionTo=function(t,e){this.getPosition();var i=this.position.x,o=this.position.y,n=t==this.position.x&&e==this.position.y;if(this.setPosition(t,e),n&&!this.isTransitioning)return void this.layoutPosition();var s=t-i,r=e-o,a={};a.transform=this.getTranslate(s,r),this.transition({to:a,onTransitionEnd:{transform:this.layoutPosition},isCleaning:!0})},d.getTranslate=function(t,e){var i=this.layout._getOption("originLeft"),o=this.layout._getOption("originTop");return t=i?t:-t,e=o?e:-e,"translate3d("+t+"px, "+e+"px, 0)"},d.goTo=function(t,e){this.setPosition(t,e),this.layoutPosition()},d.moveTo=d._transitionTo,d.setPosition=function(t,e){this.position.x=parseFloat(t),this.position.y=parseFloat(e)},d._nonTransition=function(t){this.css(t.to),t.isCleaning&&this._removeStyles(t.to);for(var e in t.onTransitionEnd)t.onTransitionEnd[e].call(this)},d.transition=function(t){if(!parseFloat(this.layout.options.transitionDuration))return void this._nonTransition(t);var e=this._transn;for(var i in t.onTransitionEnd)e.onEnd[i]=t.onTransitionEnd[i];for(i in t.to)e.ingProperties[i]=!0,t.isCleaning&&(e.clean[i]=!0);if(t.from){this.css(t.from);var o=this.element.offsetHeight;o=null}this.enableTransition(t.to),this.css(t.to),this.isTransitioning=!0};var l="opacity,"+n(a);d.enableTransition=function(){if(!this.isTransitioning){var t=this.layout.options.transitionDuration;t="number"==typeof t?t+"ms":t,this.css({transitionProperty:l,transitionDuration:t,transitionDelay:this.staggerDelay\|\|0}),this.element.addEventListener(u,this,!1)}},d.onwebkitTransitionEnd=function(t){this.ontransitionend(t)},d.onotransitionend=function(t){this.ontransitionend(t)};var f={"-webkit-transform":"transform"};d.ontransitionend=function(t){if(t.target===this.element){var e=this._transn,o=f[t.propertyName]\|\|t.propertyName;if(delete e.ingProperties[o],i(e.ingProperties)&&this.disableTransition(),o in e.clean&&(this.element.style[t.propertyName]="",delete e.clean[o]),o in e.onEnd){var n=e.onEnd[o];n.call(this),delete e.onEnd[o]}this.emitEvent("transitionEnd",[this])}},d.disableTransition=function(){this.removeTransitionStyles(),this.element.removeEventListener(u,this,!1),this.isTransitioning=!1},d._removeStyles=function(t){var e={};for(var i in t)e[i]="";this.css(e)};var c={transitionProperty:"",transitionDuration:"",transitionDelay:""};return d.removeTransitionStyles=function(){this.css(c)},d.stagger=function(t){t=isNaN(t)?0:t,this.staggerDelay=t+"ms"},d.removeElem=function(){this.element.parentNode.removeChild(this.element),this.css({display:""}),this.emitEvent("remove",[this])},d.remove=function(){return r&&parseFloat(this.layout.options.transitionDuration)?(this.once("transitionEnd",function(){this.removeElem()}),void this.hide()):void this.removeElem()},d.reveal=function(){delete this.isHidden,this.css({display:""});var t=this.layout.options,e={},i=this.getHideRevealTransitionEndProperty("visibleStyle");e[i]=this.onRevealTransitionEnd,this.transition({from:t.hiddenStyle,to:t.visibleStyle,isCleaning:!0,onTransitionEnd:e})},d.onRevealTransitionEnd=function(){this.isHidden\|\|this.emitEvent("reveal")},d.getHideRevealTransitionEndProperty=function(t){var e=this.layout.options[t];if(e.opacity)return"opacity";for(var i in e)return i},d.hide=function(){this.isHidden=!0,this.css({display:""});var t=this.layout.options,e={},i=this.getHideRevealTransitionEndProperty("hiddenStyle");e[i]=this.onHideTransitionEnd,this.transition({from:t.visibleStyle,to:t.hiddenStyle,isCleaning:!0,onTransitionEnd:e})},d.onHideTransitionEnd=function(){this.isHidden&&(this.css({display:"none"}),this.emitEvent("hide"))},d.destroy=function(){this.css({position:"",left:"",right:"",top:"",bottom:"",transition:"",transform:""})},o}),function(t,e){"use strict";"function"==typeof define&&define.amd?define("outlayer/outlayer",["ev-emitter/ev-emitter","get-size/get-size","fizzy-ui-utils/utils","./item"],function(i,o,n,s){return e(t,i,o,n,s)}):"object"==typeof module&&module.exports?module.exports=e(t,require("ev-emitter"),require("get-size"),require("fizzy-ui-utils"),require("./item")):t.Outlayer=e(t,t.EvEmitter,t.getSize,t.fizzyUIUtils,t.Outlayer.Item)}(window,function(t,e,i,o,n){"use strict";function s(t,e){var i=o.getQueryElement(t);if(!i)return void(u&&u.error("Bad element for "+this.constructor.namespace+": "+(i\|\|t)));this.element=i,h&&(this.$element=h(this.element)),this.options=o.extend({},this.constructor.defaults),this.option(e);var n=++l;this.element.outlayerGUID=n,f[n]=this,this._create();var s=this._getOption("initLayout");s&&this.layout()}function r(t){function e(){t.apply(this,arguments)}return e.prototype=Object.create(t.prototype),e.prototype.constructor=e,e}function a(t){if("number"==typeof t)return t;var e=t.match(/(^\d\.?\d)(\w)/),i=e&&e[1],o=e&&e[2];if(!i.length)return 0;i=parseFloat(i);var n=m[o]\|\|1;return in}var u=t.console,h=t.jQuery,d=function(){},l=0,f={};s.namespace="outlayer",s.Item=n,s.defaults={containerStyle:{position:"relative"},initLayout:!0,originLeft:!0,originTop:!0,resize:!0,resizeContainer:!0,transitionDuration:"0.4s",hiddenStyle:{opacity:0,transform:"scale(0.001)"},visibleStyle:{opacity:1,transform:"scale(1)"}};var c=s.prototype;o.extend(c,e.prototype),c.option=function(t){o.extend(this.options,t)},c._getOption=function(t){var e=this.constructor.compatOptions[t];return e&&void 0!==this.options[e]?this.options[e]:this.options[t]},s.compatOptions={initLayout:"isInitLayout",horizontal:"isHorizontal",layoutInstant:"isLayoutInstant",originLeft:"isOriginLeft",originTop:"isOriginTop",resize:"isResizeBound",resizeContainer:"isResizingContainer"},c._create=function(){this.reloadItems(),this.stamps=[],this.stamp(this.options.stamp),o.extend(this.element.style,this.options.containerStyle);var t=this._getOption("resize");t&&this.bindResize()},c.reloadItems=function(){this.items=this._itemize(this.element.children)},c._itemize=function(t){for(var e=this._filterFindItemElements(t),i=this.constructor.Item,o=[],n=0;n<e.length;n++){var s=e[n],r=new i(s,this);o.push(r)}return o},c._filterFindItemElements=function(t){return o.filterFindElements(t,this.options.itemSelector)},c.getItemElements=function(){return this.items.map(function(t){return t.element})},c.layout=function(){this._resetLayout(),this._manageStamps();var t=this._getOption("layoutInstant"),e=void 0!==t?t:!this._isLayoutInited;this.layoutItems(this.items,e),this._isLayoutInited=!0},c._init=c.layout,c._resetLayout=function(){this.getSize()},c.getSize=function(){this.size=i(this.element)},c._getMeasurement=function(t,e){var o,n=this.options[t];n?("string"==typeof n?o=this.element.querySelector(n):n instanceof HTMLElement&&(o=n),this[t]=o?i(o)[e]:n):this[t]=0},c.layoutItems=function(t,e){t=this._getItemsForLayout(t),this._layoutItems(t,e),this._postLayout()},c._getItemsForLayout=function(t){return t.filter(function(t){return!t.isIgnored})},c._layoutItems=function(t,e){if(this._emitCompleteOnItems("layout",t),t&&t.length){var i=[];t.forEach(function(t){var o=this._getItemLayoutPosition(t);o.item=t,o.isInstant=e\|\|t.isLayoutInstant,i.push(o)},this),this._processLayoutQueue(i)}},c._getItemLayoutPosition=function(){return{x:0,y:0}},c._processLayoutQueue=function(t){this.updateStagger(),t.forEach(function(t,e){this._positionItem(t.item,t.x,t.y,t.isInstant,e)},this)},c.updateStagger=function(){var t=this.options.stagger;return null===t\|\|void 0===t?void(this.stagger=0):(this.stagger=a(t),this.stagger)},c._positionItem=function(t,e,i,o,n){o?t.goTo(e,i):(t.stagger(nthis.stagger),t.moveTo(e,i))},c._postLayout=function(){this.resizeContainer()},c.resizeContainer=function(){var t=this._getOption("resizeContainer");if(t){var e=this._getContainerSize();e&&(this._setContainerMeasure(e.width,!0),this._setContainerMeasure(e.height,!1))}},c._getContainerSize=d,c._setContainerMeasure=function(t,e){if(void 0!==t){var i=this.size;i.isBorderBox&&(t+=e?i.paddingLeft+i.paddingRight+i.borderLeftWidth+i.borderRightWidth:i.paddingBottom+i.paddingTop+i.borderTopWidth+i.borderBottomWidth),t=Math.max(t,0),this.element.style[e?"width":"height"]=t+"px"}},c._emitCompleteOnItems=function(t,e){function i(){n.dispatchEvent(t+"Complete",null,[e])}function o(){r++,r==s&&i()}var n=this,s=e.length;if(!e\|\|!s)return void i();var r=0;e.forEach(function(e){e.once(t,o)})},c.dispatchEvent=function(t,e,i){var o=e?[e].concat(i):i;if(this.emitEvent(t,o),h)if(this.$element=this.$element\|\|h(this.element),e){var n=h.Event(e);n.type=t,this.$element.trigger(n,i)}else this.$element.trigger(t,i)},c.ignore=function(t){var e=this.getItem(t);e&&(e.isIgnored=!0)},c.unignore=function(t){var e=this.getItem(t);e&&delete e.isIgnored},c.stamp=function(t){t=this._find(t),t&&(this.stamps=this.stamps.concat(t),t.forEach(this.ignore,this))},c.unstamp=function(t){t=this._find(t),t&&t.forEach(function(t){o.removeFrom(this.stamps,t),this.unignore(t)},this)},c._find=function(t){if(t)return"string"==typeof t&&(t=this.element.querySelectorAll(t)),t=o.makeArray(t)},c._manageStamps=function(){this.stamps&&this.stamps.length&&(this._getBoundingRect(),this.stamps.forEach(this._manageStamp,this))},c._getBoundingRect=function(){var t=this.element.getBoundingClientRect(),e=this.size;this._boundingRect={left:t.left+e.paddingLeft+e.borderLeftWidth,top:t.top+e.paddingTop+e.borderTopWidth,right:t.right-(e.paddingRight+e.borderRightWidth),bottom:t.bottom-(e.paddingBottom+e.borderBottomWidth)}},c._manageStamp=d,c._getElementOffset=function(t){var e=t.getBoundingClientRect(),o=this._boundingRect,n=i(t),s={left:e.left-o.left-n.marginLeft,top:e.top-o.top-n.marginTop,right:o.right-e.right-n.marginRight,bottom:o.bottom-e.bottom-n.marginBottom};return s},c.handleEvent=o.handleEvent,c.bindResize=function(){t.addEventListener("resize",this),this.isResizeBound=!0},c.unbindResize=function(){t.removeEventListener("resize",this),this.isResizeBound=!1},c.onresize=function(){this.resize()},o.debounceMethod(s,"onresize",100),c.resize=function(){this.isResizeBound&&this.needsResizeLayout()&&this.layout()},c.needsResizeLayout=function(){var t=i(this.element),e=this.size&&t;return e&&t.innerWidth!==this.size.innerWidth},c.addItems=function(t){var e=this._itemize(t);return e.length&&(this.items=this.items.concat(e)),e},c.appended=function(t){var e=this.addItems(t);e.length&&(this.layoutItems(e,!0),this.reveal(e))},c.prepended=function(t){var e=this._itemize(t);if(e.length){var i=this.items.slice(0);this.items=e.concat(i),this._resetLayout(),this._manageStamps(),this.layoutItems(e,!0),this.reveal(e),this.layoutItems(i)}},c.reveal=function(t){if(this._emitCompleteOnItems("reveal",t),t&&t.length){var e=this.updateStagger();t.forEach(function(t,i){t.stagger(ie),t.reveal()})}},c.hide=function(t){if(this._emitCompleteOnItems("hide",t),t&&t.length){var e=this.updateStagger();t.forEach(function(t,i){t.stagger(ie),t.hide()})}},c.revealItemElements=function(t){var e=this.getItems(t);this.reveal(e)},c.hideItemElements=function(t){var e=this.getItems(t);this.hide(e)},c.getItem=function(t){for(var e=0;e<this.items.length;e++){var i=this.items[e];if(i.element==t)return i}},c.getItems=function(t){t=o.makeArray(t);var e=[];return t.forEach(function(t){var i=this.getItem(t);i&&e.push(i)},this),e},c.remove=function(t){var e=this.getItems(t);this._emitCompleteOnItems("remove",e),e&&e.length&&e.forEach(function(t){t.remove(),o.removeFrom(this.items,t)},this)},c.destroy=function(){var t=this.element.style;t.height="",t.position="",t.width="",this.items.forEach(function(t){t.destroy()}),this.unbindResize();var e=this.element.outlayerGUID;delete f[e],delete this.element.outlayerGUID,h&&h.removeData(this.element,this.constructor.namespace)},s.data=function(t){t=o.getQueryElement(t);var e=t&&t.outlayerGUID;return e&&f[e]},s.create=function(t,e){var i=r(s);return i.defaults=o.extend({},s.defaults),o.extend(i.defaults,e),i.compatOptions=o.extend({},s.compatOptions),i.namespace=t,i.data=s.data,i.Item=r(n),o.htmlInit(i,t),h&&h.bridget&&h.bridget(t,i),i};var m={ms:1,s:1e3};return s.Item=n,s}),function(t,e){"function"==typeof define&&define.amd?define("isotope-layout/js/item",["outlayer/outlayer"],e):"object"==typeof module&&module.exports?module.exports=e(require("outlayer")):(t.Isotope=t.Isotope\|\|{},t.Isotope.Item=e(t.Outlayer))}(window,function(t){"use strict";function e(){t.Item.apply(this,arguments)}var i=e.prototype=Object.create(t.Item.prototype),o=i._create;i._create=function(){this.id=this.layout.itemGUID++,o.call(this),this.sortData={}},i.updateSortData=function(){if(!this.isIgnored){this.sortData.id=this.id,this.sortData["original-order"]=this.id,this.sortData.random=Math.random();var t=this.layout.options.getSortData,e=this.layout._sorters;for(var i in t){var o=e[i];this.sortData[i]=o(this.element,this)}}};var n=i.destroy;return i.destroy=function(){n.apply(this,arguments),this.css({display:""})},e}),function(t,e){"function"==typeof define&&define.amd?define("isotope-layout/js/layout-mode",["get-size/get-size","outlayer/outlayer"],e):"object"==typeof module&&module.exports?module.exports=e(require("get-size"),require("outlayer")):(t.Isotope=t.Isotope\|\|{},t.Isotope.LayoutMode=e(t.getSize,t.Outlayer))}(window,function(t,e){"use strict";function i(t){this.isotope=t,t&&(this.options=t.options[this.namespace],this.element=t.element,this.items=t.filteredItems,this.size=t.size)}var o=i.prototype,n=["_resetLayout","_getItemLayoutPosition","_manageStamp","_getContainerSize","_getElementOffset","needsResizeLayout","_getOption"];return n.forEach(function(t){o[t]=function(){return e.prototype[t].apply(this.isotope,arguments)}}),o.needsVerticalResizeLayout=function(){var e=t(this.isotope.element),i=this.isotope.size&&e;return i&&e.innerHeight!=this.isotope.size.innerHeight},o._getMeasurement=function(){this.isotope._getMeasurement.apply(this,arguments)},o.getColumnWidth=function(){this.getSegmentSize("column","Width")},o.getRowHeight=function(){this.getSegmentSize("row","Height")},o.getSegmentSize=function(t,e){var i=t+e,o="outer"+e;if(this._getMeasurement(i,o),!this[i]){var n=this.getFirstItemSize();this[i]=n&&n[o]\|\|this.isotope.size["inner"+e]}},o.getFirstItemSize=function(){var e=this.isotope.filteredItems[0];return e&&e.element&&t(e.element)},o.layout=function(){this.isotope.layout.apply(this.isotope,arguments)},o.getSize=function(){this.isotope.getSize(),this.size=this.isotope.size},i.modes={},i.create=function(t,e){function n(){i.apply(this,arguments)}return n.prototype=Object.create(o),n.prototype.constructor=n,e&&(n.options=e),n.prototype.namespace=t,i.modes[t]=n,n},i}),function(t,e){"function"==typeof define&&define.amd?define("masonry-layout/masonry",["outlayer/outlayer","get-size/get-size"],e):"object"==typeof module&&module.exports?module.exports=e(require("outlayer"),require("get-size")):t.Masonry=e(t.Outlayer,t.getSize)}(window,function(t,e){var i=t.create("masonry");i.compatOptions.fitWidth="isFitWidth";var o=i.prototype;return o._resetLayout=function(){this.getSize(),this._getMeasurement("columnWidth","outerWidth"),this._getMeasurement("gutter","outerWidth"),this.measureColumns(),this.colYs=[];for(var t=0;t<this.cols;t++)this.colYs.push(0);this.maxY=0,this.horizontalColIndex=0},o.measureColumns=function(){if(this.getContainerWidth(),!this.columnWidth){var t=this.items[0],i=t&&t.element;this.columnWidth=i&&e(i).outerWidth\|\|this.containerWidth}var o=this.columnWidth+=this.gutter,n=this.containerWidth+this.gutter,s=n/o,r=o-n%o,a=r&&r<1?"round":"floor";s=Math[a](s),this.cols=Math.max(s,1)},o.getContainerWidth=function(){var t=this._getOption("fitWidth"),i=t?this.element.parentNode:this.element,o=e(i);this.containerWidth=o&&o.innerWidth},o._getItemLayoutPosition=function(t){t.getSize();var e=t.size.outerWidth%this.columnWidth,i=e&&e<1?"round":"ceil",o=Math[i](t.size.outerWidth/this.columnWidth);o=Math.min(o,this.cols);for(var n=this.options.horizontalOrder?"_getHorizontalColPosition":"_getTopColPosition",s=this[n](o,t),r={x:this.columnWidths.col,y:s.y},a=s.y+t.size.outerHeight,u=o+s.col,h=s.col;h<u;h++)this.colYs[h]=a;return r},o._getTopColPosition=function(t){var e=this._getTopColGroup(t),i=Math.min.apply(Math,e);return{col:e.indexOf(i),y:i}},o._getTopColGroup=function(t){if(t<2)return this.colYs;for(var e=[],i=this.cols+1-t,o=0;o<i;o++)e[o]=this._getColGroupY(o,t);return e},o._getColGroupY=function(t,e){if(e<2)return this.colYs[t];var i=this.colYs.slice(t,t+e);return Math.max.apply(Math,i)},o._getHorizontalColPosition=function(t,e){var i=this.horizontalColIndex%this.cols,o=t>1&&i+t>this.cols;i=o?0:i;var n=e.size.outerWidth&&e.size.outerHeight;return this.horizontalColIndex=n?i+t:this.horizontalColIndex,{col:i,y:this._getColGroupY(i,t)}},o._manageStamp=function(t){var i=e(t),o=this._getElementOffset(t),n=this._getOption("originLeft"),s=n?o.left:o.right,r=s+i.outerWidth,a=Math.floor(s/this.columnWidth);a=Math.max(0,a);var u=Math.floor(r/this.columnWidth);u-=r%this.columnWidth?0:1,u=Math.min(this.cols-1,u);for(var h=this._getOption("originTop"),d=(h?o.top:o.bottom)+i.outerHeight,l=a;l<=u;l++)this.colYs[l]=Math.max(d,this.colYs[l])},o._getContainerSize=function(){this.maxY=Math.max.apply(Math,this.colYs);var t={height:this.maxY};return this._getOption("fitWidth")&&(t.width=this._getContainerFitWidth()),t},o._getContainerFitWidth=function(){for(var t=0,e=this.cols;--e&&0===this.colYs[e];)t++;return(this.cols-t)this.columnWidth-this.gutter},o.needsResizeLayout=function(){var t=this.containerWidth;return this.getContainerWidth(),t!=this.containerWidth},i}),function(t,e){"function"==typeof define&&define.amd?define("isotope-layout/js/layout-modes/masonry",["../layout-mode","masonry-layout/masonry"],e):"object"==typeof module&&module.exports?module.exports=e(require("../layout-mode"),require("masonry-layout")):e(t.Isotope.LayoutMode,t.Masonry)}(window,function(t,e){"use strict";var i=t.create("masonry"),o=i.prototype,n={_getElementOffset:!0,layout:!0,_getMeasurement:!0};for(var s in e.prototype)n[s]\|\|(o[s]=e.prototype[s]);var r=o.measureColumns;o.measureColumns=function(){this.items=this.isotope.filteredItems,r.call(this)};var a=o._getOption;return o._getOption=function(t){return"fitWidth"==t?void 0!==this.options.isFitWidth?this.options.isFitWidth:this.options.fitWidth:a.apply(this.isotope,arguments)},i}),function(t,e){"function"==typeof define&&define.amd?define("isotope-layout/js/layout-modes/fit-rows",["../layout-mode"],e):"object"==typeof exports?module.exports=e(require("../layout-mode")):e(t.Isotope.LayoutMode)}(window,function(t){"use strict";var e=t.create("fitRows"),i=e.prototype;return i._resetLayout=function(){this.x=0,this.y=0,this.maxY=0,this._getMeasurement("gutter","outerWidth")},i._getItemLayoutPosition=function(t){t.getSize();var e=t.size.outerWidth+this.gutter,i=this.isotope.size.innerWidth+this.gutter;0!==this.x&&e+this.x>i&&(this.x=0,this.y=this.maxY);var o={x:this.x,y:this.y};return this.maxY=Math.max(this.maxY,this.y+t.size.outerHeight),this.x+=e,o},i._getContainerSize=function(){return{height:this.maxY}},e}),function(t,e){"function"==typeof define&&define.amd?define("isotope-layout/js/layout-modes/vertical",["../layout-mode"],e):"object"==typeof module&&module.exports?module.exports=e(require("../layout-mode")):e(t.Isotope.LayoutMode)}(window,function(t){"use strict";var e=t.create("vertical",{horizontalAlignment:0}),i=e.prototype;return i._resetLayout=function(){this.y=0},i._getItemLayoutPosition=function(t){t.getSize();var e=(this.isotope.size.innerWidth-t.size.outerWidth)this.options.horizontalAlignment,i=this.y;return this.y+=t.size.outerHeight,{x:e,y:i}},i._getContainerSize=function(){return{height:this.y}},e}),function(t,e){"function"==typeof define&&define.amd?define(["outlayer/outlayer","get-size/get-size","desandro-matches-selector/matches-selector","fizzy-ui-utils/utils","isotope-layout/js/item","isotope-layout/js/layout-mode","isotope-layout/js/layout-modes/masonry","isotope-layout/js/layout-modes/fit-rows","isotope-layout/js/layout-modes/vertical"],function(i,o,n,s,r,a){return e(t,i,o,n,s,r,a)}):"object"==typeof module&&module.exports?module.exports=e(t,require("outlayer"),require("get-size"),require("desandro-matches-selector"),require("fizzy-ui-utils"),require("isotope-layout/js/item"),require("isotope-layout/js/layout-mode"),require("isotope-layout/js/layout-modes/masonry"),require("isotope-layout/js/layout-modes/fit-rows"),require("isotope-layout/js/layout-modes/vertical")):t.Isotope=e(t,t.Outlayer,t.getSize,t.matchesSelector,t.fizzyUIUtils,t.Isotope.Item,t.Isotope.LayoutMode)}(window,function(t,e,i,o,n,s,r){function a(t,e){return function(i,o){for(var n=0;n<t.length;n++){var s=t[n],r=i.sortData[s],a=o.sortData[s];if(r>a\|\|r<a){var u=void 0!==e[s]?e[s]:e,h=u?1:-1;return(r>a?1:-1)h}}return 0}}var u=t.jQuery,h=String.prototype.trim?function(t){return t.trim()}:function(t){return t.replace(/^\s+\|\s+$/g,"")},d=e.create("isotope",{layoutMode:"masonry",isJQueryFiltering:!0,sortAscending:!0});d.Item=s,d.LayoutMode=r;var l=d.prototype;l._create=function(){this.itemGUID=0,this._sorters={},this._getSorters(),e.prototype._create.call(this),this.modes={},this.filteredItems=this.items,this.sortHistory=["original-order"];for(var t in r.modes)this._initLayoutMode(t)},l.reloadItems=function(){this.itemGUID=0,e.prototype.reloadItems.call(this)},l._itemize=function(){for(var t=e.prototype._itemize.apply(this,arguments),i=0;i<t.length;i++){var o=t[i];o.id=this.itemGUID++}return this._updateItemsSortData(t),t},l._initLayoutMode=function(t){var e=r.modes[t],i=this.options[t]\|\|{};this.options[t]=e.options?n.extend(e.options,i):i,this.modes[t]=new e(this)},l.layout=function(){return!this._isLayoutInited&&this._getOption("initLayout")?void this.arrange():void this._layout()},l._layout=function(){var t=this._getIsInstant();this._resetLayout(),this._manageStamps(),this.layoutItems(this.filteredItems,t),this._isLayoutInited=!0},l.arrange=function(t){this.option(t),this._getIsInstant();var e=this._filter(this.items);this.filteredItems=e.matches,this._bindArrangeComplete(),this._isInstant?this._noTransition(this._hideReveal,[e]):this._hideReveal(e),this._sort(),this._layout()},l._init=l.arrange,l._hideReveal=function(t){this.reveal(t.needReveal),this.hide(t.needHide)},l._getIsInstant=function(){var t=this._getOption("layoutInstant"),e=void 0!==t?t:!this._isLayoutInited;return this._isInstant=e,e},l._bindArrangeComplete=function(){function t(){e&&i&&o&&n.dispatchEvent("arrangeComplete",null,[n.filteredItems])}var e,i,o,n=this;this.once("layoutComplete",function(){e=!0,t()}),this.once("hideComplete",function(){i=!0,t()}),this.once("revealComplete",function(){o=!0,t()})},l._filter=function(t){var e=this.options.filter;e=e\|\|"";for(var i=[],o=[],n=[],s=this._getFilterTest(e),r=0;r<t.length;r++){var a=t[r];if(!a.isIgnored){var u=s(a);u&&i.push(a),u&&a.isHidden?o.push(a):u\|\|a.isHidden\|\|n.push(a)}}return{matches:i,needReveal:o,needHide:n}},l._getFilterTest=function(t){return u&&this.options.isJQueryFiltering?function(e){return u(e.element).is(t);
12	+ }:"function"==typeof t?function(e){return t(e.element)}:function(e){return o(e.element,t)}},l.updateSortData=function(t){var e;t?(t=n.makeArray(t),e=this.getItems(t)):e=this.items,this._getSorters(),this._updateItemsSortData(e)},l._getSorters=function(){var t=this.options.getSortData;for(var e in t){var i=t[e];this._sorters[e]=f(i)}},l._updateItemsSortData=function(t){for(var e=t&&t.length,i=0;e&&i<e;i++){var o=t[i];o.updateSortData()}};var f=function(){function t(t){if("string"!=typeof t)return t;var i=h(t).split(" "),o=i[0],n=o.match(/^\[(.+)\]$/),s=n&&n[1],r=e(s,o),a=d.sortDataParsers[i[1]];return t=a?function(t){return t&&a(r(t))}:function(t){return t&&r(t)}}function e(t,e){return t?function(e){return e.getAttribute(t)}:function(t){var i=t.querySelector(e);return i&&i.textContent}}return t}();d.sortDataParsers={parseInt:function(t){return parseInt(t,10)},parseFloat:function(t){return parseFloat(t)}},l._sort=function(){if(this.options.sortBy){var t=n.makeArray(this.options.sortBy);this._getIsSameSortBy(t)\|\|(this.sortHistory=t.concat(this.sortHistory));var e=a(this.sortHistory,this.options.sortAscending);this.filteredItems.sort(e)}},l._getIsSameSortBy=function(t){for(var e=0;e<t.length;e++)if(t[e]!=this.sortHistory[e])return!1;return!0},l._mode=function(){var t=this.options.layoutMode,e=this.modes[t];if(!e)throw new Error("No layout mode: "+t);return e.options=this.options[t],e},l._resetLayout=function(){e.prototype._resetLayout.call(this),this._mode()._resetLayout()},l._getItemLayoutPosition=function(t){return this._mode()._getItemLayoutPosition(t)},l._manageStamp=function(t){this._mode()._manageStamp(t)},l._getContainerSize=function(){return this._mode()._getContainerSize()},l.needsResizeLayout=function(){return this._mode().needsResizeLayout()},l.appended=function(t){var e=this.addItems(t);if(e.length){var i=this._filterRevealAdded(e);this.filteredItems=this.filteredItems.concat(i)}},l.prepended=function(t){var e=this._itemize(t);if(e.length){this._resetLayout(),this._manageStamps();var i=this._filterRevealAdded(e);this.layoutItems(this.filteredItems),this.filteredItems=i.concat(this.filteredItems),this.items=e.concat(this.items)}},l._filterRevealAdded=function(t){var e=this._filter(t);return this.hide(e.needHide),this.reveal(e.matches),this.layoutItems(e.matches,!0),e.matches},l.insert=function(t){var e=this.addItems(t);if(e.length){var i,o,n=e.length;for(i=0;i<n;i++)o=e[i],this.element.appendChild(o.element);var s=this._filter(e).matches;for(i=0;i<n;i++)e[i].isLayoutInstant=!0;for(this.arrange(),i=0;i<n;i++)delete e[i].isLayoutInstant;this.reveal(s)}};var c=l.remove;return l.remove=function(t){t=n.makeArray(t);var e=this.getItems(t);c.call(this,t);for(var i=e&&e.length,o=0;i&&o<i;o++){var s=e[o];n.removeFrom(this.filteredItems,s)}},l.shuffle=function(){for(var t=0;t<this.items.length;t++){var e=this.items[t];e.sortData.random=Math.random()}this.options.sortBy="random",this._sort(),this._layout()},l._noTransition=function(t,e){var i=this.options.transitionDuration;this.options.transitionDuration=0;var o=t.apply(this,e);return this.options.transitionDuration=i,o},l.getFilteredItemElements=function(){return this.filteredItems.map(function(t){return t.element})},d});

changelog.txt CHANGED Viewed

	@@ -1,3 +1,7 @@




1	== 2.2.1 ==
2	Release date: November 2, 2020
3	* Fixed: Instagram Feed - Feed was not working


1	+ == 2.2.2 ==
2	+ Release date: December 10, 2020
3	+ * Fixed: Instagram Feed - Masonry layout
4	+
5	== 2.2.1 ==
6	Release date: November 2, 2020
7	* Fixed: Instagram Feed - Feed was not working

package.json CHANGED Viewed

	@@ -1,6 +1,6 @@
1	{
2	"name": "powerpack-lite-for-elementor",
3	- "version": "2.2.1",
4	"description": "Extend Elementor Page Builder with 50+ Creative Widgets.",
5	"keywords": [],
6	"author": "IdeaBox Creations",


1	{
2	"name": "powerpack-lite-for-elementor",
3	+ "version": "2.2.2",
4	"description": "Extend Elementor Page Builder with 50+ Creative Widgets.",
5	"keywords": [],
6	"author": "IdeaBox Creations",

plugin.php CHANGED Viewed

	@@ -204,6 +204,16 @@ class PowerpackLitePlugin {
204	)
205	);
206










207	wp_register_script(
208	'twentytwenty',
209	POWERPACK_ELEMENTS_LITE_URL . 'assets/lib/twentytwenty/jquery.twentytwenty.js',


204	)
205	);
206
207	+ wp_register_script(
208	+ 'isotope',
209	+ POWERPACK_ELEMENTS_LITE_URL . 'assets/lib/isotope/isotope.pkgd' . $suffix . '.js',
210	+ array(
211	+ 'jquery',
212	+ ),
213	+ '0.5.3',
214	+ true
215	+ );
216	+
217	wp_register_script(
218	'twentytwenty',
219	POWERPACK_ELEMENTS_LITE_URL . 'assets/lib/twentytwenty/jquery.twentytwenty.js',

powerpack-lite-elementor.php CHANGED Viewed

	@@ -3,7 +3,7 @@
3	* Plugin Name: PowerPack Lite for Elementor
4	* Plugin URI: https://powerpackelements.com
5	* Description: Custom addons for Elementor page builder.
6	- * Version: 2.2.1
7	* Author: IdeaBox Creations
8	* Author URI: http://ideabox.io/
9	* License: GNU General Public License v2.0
	@@ -14,7 +14,7 @@
14
15	if ( ! defined( 'ABSPATH' ) ) exit; // Exit if accessed directly
16
17	- define( 'POWERPACK_ELEMENTS_LITE_VER', '2.2.1' );
18	define( 'POWERPACK_ELEMENTS_LITE_PATH', plugin_dir_path( __FILE__ ) );
19	define( 'POWERPACK_ELEMENTS_LITE_BASE', plugin_basename( __FILE__ ) );
20	define( 'POWERPACK_ELEMENTS_LITE_URL', plugins_url( '/', __FILE__ ) );


3	* Plugin Name: PowerPack Lite for Elementor
4	* Plugin URI: https://powerpackelements.com
5	* Description: Custom addons for Elementor page builder.
6	+ * Version: 2.2.2
7	* Author: IdeaBox Creations
8	* Author URI: http://ideabox.io/
9	* License: GNU General Public License v2.0

14
15	if ( ! defined( 'ABSPATH' ) ) exit; // Exit if accessed directly
16
17	+ define( 'POWERPACK_ELEMENTS_LITE_VER', '2.2.2' );
18	define( 'POWERPACK_ELEMENTS_LITE_PATH', plugin_dir_path( __FILE__ ) );
19	define( 'POWERPACK_ELEMENTS_LITE_BASE', plugin_basename( __FILE__ ) );
20	define( 'POWERPACK_ELEMENTS_LITE_URL', plugins_url( '/', __FILE__ ) );

readme.txt CHANGED Viewed

	@@ -2,7 +2,7 @@
2	Contributors: ideaboxcreations, simrandeep, puneetsahalot, ibachal, jainnidhi, prash17, nirbhay18
3	Tags: elementor, addons, elementor addon, elementor widgets, elements, powerpack elementor addon, essential addons
4	Requires at least: 5.0
5	- Tested up to: 5.~~5.1~~
6	Stable tag: trunk
7	License: GPLv2 or later
8	License URI: http://www.gnu.org/licenses/gpl-2.0.html
	@@ -206,6 +206,9 @@ Not at all! All the widgets and settings are easy to use with drag & drop interf
206
207	== Changelog ==
208



209	= 2.2.1 - November 2, 2020 =
210	* Fixed: Instagram Feed - Feed was not working
211


2	Contributors: ideaboxcreations, simrandeep, puneetsahalot, ibachal, jainnidhi, prash17, nirbhay18
3	Tags: elementor, addons, elementor addon, elementor widgets, elements, powerpack elementor addon, essential addons
4	Requires at least: 5.0
5	+ Tested up to: 5.6
6	Stable tag: trunk
7	License: GPLv2 or later
8	License URI: http://www.gnu.org/licenses/gpl-2.0.html

206
207	== Changelog ==
208
209	+ = 2.2.2 - December 10, 2020 =
210	+ * Fixed: Instagram Feed - Masonry layout
211	+
212	= 2.2.1 - November 2, 2020 =
213	* Fixed: Instagram Feed - Feed was not working
214

PowerPack Addons for Elementor (Instagram Feed, Pricing Table, Forms Stylers, Display Conditions, Free Elementor Widgets and Elementor Templates) - Version 2.2.2

Version Description

Release Info

Code changes from version 2.2.1 to 2.2.2