//-------------------------------------------------------------------------------------------------
// zvents-mini.js
// Copyright 2007 Zvents, Inc. and other authors as noted
// $Revision: 23149 $ - $Date: 2007-11-02 09:59:11 -0700 (Fri, 02 Nov 2007) $
//-------------------------------------------------------------------------------------------------

ZventsMini = {
	widget: {}
};

//-------------------------------------------------------------------------------------------------
// Rename ZventsMini as Z for convenience - most of the rest of this file is inside this function
//-------------------------------------------------------------------------------------------------

(function( Z ) {

//-------------------------------------------------------------------------------------------------
// Browser detection
//-------------------------------------------------------------------------------------------------

(function() {
	var ua = navigator.userAgent.toLowerCase();
	var opera = ver('opera'),
		msie = ! opera && ver('msie'),
		webkit = ver('webkit'),
		mozilla = ! /(compatible|webkit)/.test(ua) && ver('mozilla');
		
	Z.browser = {
		msie: msie,
		opera: opera,
		webkit: webkit,
		mozilla: mozilla,
		iePngHack: msie >= 5.5 && msie < 7.0
	};
	
	function ver( name ) {
		var i = ua.indexOf( name );
		if( i < 0 ) return false;
		i += name.length + 1;
		var dots = 0;
		for( var j = i;  use(ua.charAt(j));  j++ ) {}
		return 0 + ua.substring( i, j );
		
		function use( c ) {
			return c == '.' ? dots++ == 0 : c >= '0' && c <= '9';
		}
	}
})();

//-------------------------------------------------------------------------------------------------
// Utility functions
//-------------------------------------------------------------------------------------------------

Z.Number = {
	randomString: function( length, base ) {
		return Math.floor( Math.random() * Math.pow(base,length) ).toString( base );
	}
};

//-------------------------------------------------------------------------------------------------

Z.Object = {
	combine: function() {
		return Z.Object.updateFromArray( {}, arguments, 0 );
	},
	
	copy: function( self ) {
		return Z.Object.combine( self )
	},
	
	update: function( self ) {
		return Z.Object.updateFromArray( self, arguments, 1 );
	},
	
	updateFromArray: function( self, array, start, stop ) {
		stop = stop || array.length;
		for( var i = start;  i < stop;  i++ ) {
			var obj = array[i];
			if( obj ) for( var prop in obj ) {
				if( typeof Object.prototype[prop] == 'undefined' ) {
					var a = self[prop], b = obj[prop];
					if( typeof a == 'object'  &&  typeof b == 'object' )
						Z.Object.update( a, b );
					else
						self[prop] = b;
				}
			}
		}
		return self;
	}
};

//-------------------------------------------------------------------------------------------------

Z.Array = {
	sort: function( input, key ) {
		
	  if(key !='name'){
		var sep = unescape('%uFFFF');
		
		var i = 0, n = input.length, sorted = [];
		// Numeric only, non-function
		for( ;  i < n;  ++i )
			sorted[i] = [ ( 1000000000000000 + input[i][key] + '' ).slice(-15), i ].join(sep);
		
		sorted.sort();
		
		var output = [];
		for( i = 0;  i < n;  ++i )
			output[i] = input[ sorted[i].split(sep)[1] ];
		
		return output;
		
	  }else{
		input.sort( function( a, b ) {
			if (a.name < b.name) return -1
			else if (a.name > b.name) return 1
			else return 0;
		});
		return input;
	  }

	}
};

//-------------------------------------------------------------------------------------------------

Z.extend = function( base, args1 ) {
	return function( args2 ) {
		return Z.call( base, args1, args2 );
	}
};

//-------------------------------------------------------------------------------------------------

Z.call = function( fn ) {
	return fn( Z.Object.updateFromArray( {}, arguments, 1 ) );
};

//-------------------------------------------------------------------------------------------------

Z.String = {
	trim: function( s ) {
		var m = s.match(/^\s*(.*)\s*$/);
		return m ? m[1] : '';
	},
	
	truncate: function( s, n ) {
		if( typeof s != 'string' ) return '';
		var len = s.length;
		if( typeof n == 'number'  &&  n < len ) {
			s = s.substring( 0, n + 1 ).replace( / +[^ ]+$/, '' ).replace( /[ ;,.]*$/, '&#8230;' );
		}
		return s;
	}
};

//-------------------------------------------------------------------------------------------------

Z.List = function( array, index ) {
	if( this == Z ) return new Z.List( array, index );
	this.byId = {};
	this.array = array || [];
	this.count = this.array.length;
	if( index ) this.index();
};

Z.List.prototype = {
	
	index: function() {
		var self = this;
		self.each( function( item ) {
			if( item.id ) self.byId[item.id] = item;
		});
	},
	
	push: function() {
		for( var i = 0, len = arguments.length;  i < len;  i++ ) {
			var item = arguments[i];
			if( item.id ) this.byId[item.id] = item;
			this.array[this.array.length] = item;
			this.count = this.array.length;
		}
	},
	
	join: function( sep ) {
		return this.array.join( sep != null ? sep : '' );
	},
	
	each: function( yields ) {
		var array = this.array, n = array.length, last = n - 1;
		var is = { first: true };
		for( var i = 0;  i < n;  ++i ) {
			
			is.index = i;
			if( i == last ) is.last = true;
			yields( array[i], is );
			delete is.first;
		}
		return n;
	},
	
	map: function( fn, that ) {
		var array = this.array, out = new Z.List;
		for( var i = 0, n = array.length;  i < n;  ++i ) {
			out.push( fn.call( that, array[i], i, n ) );
		}
		return out;
	},
	
	sort: function( key ) {
		this.array = Z.Array.sort( this.array, key );
	}
};

//-------------------------------------------------------------------------------------------------
// Zvents.Date - date/time utilities
//-------------------------------------------------------------------------------------------------
// We keep time in an unusual way: We pretend that UTC is our local time. For example, our
// "midnight" is midnight UTC, not midnight in your local time zone. This matches the server
// and lets us do time zone independent date searches.
//-------------------------------------------------------------------------------------------------

Z.Date = function( time ) {
	if( this === Z ) return new Z.Date( time );
	
	this.valid = Z.Date.dateStrict( time );
	this.date = this.valid  ||  Z.Date.dateNow();
};

Z.Date.prototype = {
	format: function( str ) {
		var self = this;
		return str.replace( /{(\w+)(:(\d+))?}/g,
			function( match, code, x, arg ) {
				return self[code] ? self[code](arg) : match;
			}
		);
	},

	// Formatters
	a: function() { return this.am().slice(0,1); },
	am: function() { return this.date.getUTCHours() < 12 ? 'am' : 'pm'; },
	D: function() { return this.date.getUTCDate(); },
	DD: function() { return Z.pad( this.D(), 2 ); },
	h: function() { return ( ( this.date.getUTCHours() + 11 ) % 12 + 1 ); }, 
	hh: function() { return Z.pad( this.h(), 2 ); },
	h24: function() { return this.date.getUTCHours(); }, 
	hh24: function() { return Z.pad( this.h24(), 2 ); },
	hmm: function() { return this.format( '{h}:{mm}&#160;{am}' ); },
	Jan: function() { return this.January().slice(0,3); },
	January: function() { return Z.Date.monthNames[ this.date.getUTCMonth() ]; },
	m: function() { return this.date.getUTCMinutes(); },
	mm: function() { return Z.pad( this.m(), 2 ); },
	M: function() { return this.date.getUTCMonth() + 1; },
	MM: function() { return Z.pad( this.M(), 2 ); },
	MDY: function() { return this.format( '{M}/{D}/{Y}' ); },
	s: function() { return this.date.getUTCSeconds(); },
	ss: function() { return Z.pad( this.s(), 2 ); },
	Sun: function() { return this.Sunday().slice(0,3); },
	Sunday: function() { return Z.Date.dayNames[ this.date.getUTCDay() ]; },
	Y: function() { return this.date.getUTCFullYear() },
	YMD: function() { return this.format( '{Y}-{MM}-{DD}' ); } //,

};

Z.Object.update( Z.Date, {
	oneSecond: 1000,
	oneMinute: 1000 * 60,
	oneHour:   1000 * 60 * 60,
	oneDay:    1000 * 60 * 60 * 24,
	oneWeek:   1000 * 60 * 60 * 24 * 7,
	
	dayNames: [
		'Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'
	],
	
	monthNames: [
			'January', 'February', 'March', 'April', 'May', 'June',
			'July', 'August', 'September', 'October', 'November', 'December'
	],
	
	// Create a Date object from a numeric or string time
	// Pass a numeric time straight through.
	// String time can be '20061231', '2006-12-31', or "Sun Dec 31 12:01:00 PDT 2006"
	// Always returns a Date object, defaulting to now if a string time can't be parsed
	date: function( time ) {
		return Z.Date.dateStrict( time )  ||  Z.Date.dateNow();
	},
	
	// Same as Z.Date.date, but returns null for a bad string time value
	dateStrict: function( time ) {
		var date = (function( time ) {
			try {
				if( ! time ) return;
				
				if( typeof time == 'number' ) {
					if( time < 100000000000 ) time *= 1000;  // handle time in seconds or milliseconds
					return new Date( time );
				}
				
				if( typeof time == 'object' ) {
					if( time.getTime ) return new Date( time.getTime() );  // Date
					if( time.date && time.valid ) return new Date( time.date.getTime() );  // Zvents.Date
				}
				
				if( typeof time != 'string' ) return;
				time = Z.String.trim( time );
				
				// Wed Jan 31 12:30:45 GMT 2007
				var m = time.match( /^[a-z]{3} ([a-z]{3}) (\d{2}) (\d{2}):(\d{2}):(\d{2}) \w{3} (\d{4})$/i );
				if( m ) return new Date( Date.UTC( +m[6], Z.Date.numberFromShortMonth(m[1]), +m[2], +m[3], +m[4], +m[5] ) );
				
				// Jan 2, 2007
				var m = time.match( /^([a-z]+)\s*(\d+)\s*,?\s*(\d+)$/i );
				if( m ) {
					var mon = Z.Date.numberFromShortMonth( m[1] );
					if( mon != null )
						return new Date( Date.UTC( +m[3], mon, +m[2] ) );
				}
				
				// 2007-01
				// 2007-01-31 
				// 2007-01-31 12:30
				// 2007-01-31 12:30:45
				var m = time.match( /^(\d{4})-(\d{2})(-(\d{2})( (\d{2}):(\d{2})(:(\d{2}))?)?)?$/ );
				if( m ) return new Date( Date.UTC( +m[1], m[2]-1, +m[4] || 1, +m[6] || 0, +m[7] || 0, +m[9] || 0 ) );
				
				// 20070131
				var m = time.match( /^(\d{4})(\d{2})(\d{2})$/ );
				if( m ) return new Date( Date.UTC( m[1], m[2]-1, m[3] ) );
			}
			catch( e ) {
			}
		})( time );
		
		return date && ! isNaN( date.getTime() ) ? date : null;
	},
	
	// Do the same as "new Date()", but treat time as local/UTC
	dateNow: function() {
		var date = new Date;
		return new Date( date.getTime() - date.getTimezoneOffset() * Z.Date.oneMinute );
	},
	
	time: function( time ) {
		return Z.Date.date(time).getTime();
	},
	
	now: function() {
		return Z.Date.dateNow().getTime();
	},
	
	midnight: function( time ) {
		return Z.Date.date(time).setUTCHours( 0, 0, 0, 0 );
	},
		
	today: function() {
		return Z.Date.midnight( Z.Date.now() );
	},
	
	isToday: function( time ) {
		return Z.Date.midnight(time) == Z.Date.today();
	},
	
	formatNumberDate: function( time, sep ) {
		return Z.Date(time).format( [ '{Y}', '{MM}', '{DD}' ].join( sep != null ? sep : '-' ) );
	},
	
	formatMdyDate: function( time, sep ) {
		return Z.Date(time).format( [ '{M}', '{D}', '{Y}' ].join( sep != null ? sep : '/' ) );
	},
	
	formatNumberMonth: function( time, sep ) {
		return Z.Date(time).format( [ '{Y}', '{MM}' ].join( sep != null ? sep : '-' ) );
	},
	
	formatLongDate: function( time, weekDay ) {
		return Z.Date(time).format(
			( weekDay ? '{Sunday}, ' : '' ) +
			'{January} {D}, {Y}'
		);
	},

	formatMonthYear: function( time ) {
		return Z.Date(time).format( '{January} {Y}' );
	},
	
	formatCalendarDate: function( time ) {
		return Z.Date(time).format( '{Jan} {D}' );
	},
	
	formatWeekDay: function( time ) {
		return Z.Date(time).format( '{Sunday}' );
	},
	
	formatShortTime: function( time ) {
		return Z.Date(time).hmm();
	},
	
	formatTimeRange: function( first, last ) {
		first = Z.Date.formatShortTime( first );
		if( ! last ) return first;
		last = Z.Date.formatShortTime( last );
		return first + '&#8211;' + last;
	},

	numberFromShortMonth: function( shortMonth ) {
		var months = {
			Jan:0, Feb:1, Mar:2, Apr:3, May:4, Jun:5,
			Jul:6, Aug:7, Sep:8, Oct:9, Nov:10, Dec:11
		};
		return months[shortMonth.slice(0,3)];
	}
});

//-------------------------------------------------------------------------------------------------

Z.unescape = function( str ) {
	return unescape( str || '' ).replace( /\+/g, ' ' );
};

Z.urlEscape = function( str ) {
	return str.replace( /&/g, "&amp;" );
};

Z.htmlEscape = function( str ) {
	return str/*.replace( /&/g, "&amp;" )*/
		.replace( /\"/g, "&quot;" )
		.replace( />/g, "&gt;" )
		.replace( /</g, "&lt;" );
};

Z.htmlFix = function( str ) {
	return Z.htmlEscape( Z.unescape(str) );
};

Z.pad = function( v, n ) {
	return n == null ? v : ( 1000000000000000 + v + '' ).slice( -n );
},

Z.addScript = function( url ) {
	var script = document.createElement( 'script' );
	script.type = 'text/javascript';
	script.charset = 'utf-8';
	script.src = url;
	document.body.appendChild( script );
	return script;
};

function valueOfId() {
	return this.id;
}

Z.url = function( base, params ) {
	var p = Z.joinProps( params, '=', '&' );
	return p ? [ base, p ].join('?') : base;
};

Z.joinProps = function( params, pair, delim ) {
	var a = [];
	for( var p in params ) {
		if( typeof Object.prototype[p] == 'undefined' ) {
			var v = params[p];
			if( v != null ) a[a.length] = [ p, v ].join(pair);
		}
	}
	return a.sort().join(delim);
};


Z.linkParams = function( base, params ) {
	return Z.url( ( base || '' ).replace( /\?[^\?]*$|$/, '' ), params );
};

function argtime( time ) {
	return Z.Date.time(time) / 1000 + '';
}

// Temp hack to add _thumb
Z.imgThumb = function( url ) {
	return url.replace( /_thumb\./, '.' ).replace( /\.([^.]+)$/, '_thumb.$1' );
};

Z.imgUrl = function ( file ) {
	return [ Z.imageBaseUrl, 'images/', file ].join('');
};

Z.imgTag = function( attrs ) {
	var src = attrs.src;
	if( Z.useIePng(src) ) {
		attrs.src = Z.imgUrl('spacer.png');
		attrs.style = [ ( attrs.style || '' ), 'filter:', Z.ieImgFilter(src) ].join('');
	}
	return Z.tag( 'img', attrs );
};

Z.setImg = function( img, src ) {
	if( Z.useIePng(src) ) img.style.filter = Z.ieImgFilter( src );
	else img.src = src;
};

Z.ieImgFilter = function( src ) {
	return [
		"progid:DXImageTransform.Microsoft.AlphaImageLoader(src='", src, "', sizingMethod=scale);"
	].join('');
};

Z.useIePng = function( src ) {
	return Z.browser.iePngHack  &&  src.search(/\.png$/i) > 0;
};

Z.tag = function( tag, attrs ) {
	var html = [ '<' + tag ];
	for( var name in attrs ) {
		if( typeof Object.prototype[name] == 'undefined' ) {
			var value = attrs[name];
			name = { Class:'class' }[name] || name;
			html[html.length] = [ name, '="', value, '"' ].join('');
		}
	}
	html[html.length] = '/>';
	return html.join(' ');
};

function capitalize( text ) {
	return text.charAt(0).toUpperCase() + text.substr(1);
}

//-------------------------------------------------------------------------------------------------

Z.Dom = {};

Z.Dom.on =
	document.addEventListener ?
		function( e, type, handler ) { e.addEventListener( type, handler, false ) } :
		function( e, type, handler ) { e.attachEvent( 'on' + type, handler ); };

Z.Dom.off =
	document.removeEventListener ?
		function( e, type, handler ) { e.removeEventListener( type, handler, false ) } :
		function( e, type, handler ) { e.detachEvent( 'on' + type, handler ); };

(function() {
	var waiting  = [];
	var listen = Z.browser.mozilla || Z.browser.opera;
	if( listen )
		document.addEventListener( 'DOMContentLoaded', go, false );
	else
		poll();
	
	Z.Dom.on( window, 'load', go );
	
	function go() {
		Z.Dom.off( window, 'load', go );
		if( listen )
			document.removeEventListener( 'DOMContentLoaded', go, false );
		for( var i = 0;  i < waiting.length;  ++i )
			waiting[i]();
		waiting = null;
	}
	
	function poll() {

	}
	
	Z.Dom.ready = function( yields ) {
		waiting ? waiting.push(yields) : yields();
	};
})();

//-------------------------------------------------------------------------------------------------

Z.Cookie = {
	read: function( name ) {
		var match = document.cookie.match( new RegExp( name + '=([^;]+)' ) );
		return match && unescape( match[1] );
	},
	
	write: function( name, value ) {
		document.cookie = name + '=' + escape( value );
	}
};

//-------------------------------------------------------------------------------------------------

Z.session = ( function() {
	var name = 'Zvents';
	var value = Z.Cookie.read( name );
	if( ! value ) {
		value = Z.Number.randomString( 10, 36 );
		Z.Cookie.write( name, value );
	}
	return value;
})();

//-------------------------------------------------------------------------------------------------

Z.jsons = {};

Z.jsonUrl = function( name, a ) {
	if( a.cat || a.what || a.when || a.where ) a.search = 'true';
	a.jsonsp = name;
	
	return [ Z.url( 'http://www.zvents.com/json', a ), '&sid=', Z.session ].join('');
};

Z.loadJson = function( a ) {
	var url = Z.jsonUrl( a.name, a.load );
	var json = Z.jsons[url];

	if( json ) return a.yields( json );
	
	Z.Dom.ready( function() {
			
		window[a.name] = function( json ) {
			function callback( j ) { json = j; }
			eval( json );
			Z.jsons[url] = json;
			a.yields( json );
			window[a.name] = null;
		};
		
		var script = Z.addScript( url );
	});
};

//-------------------------------------------------------------------------------------------------

Z.EventList = function( args ) {
	var events = new Z.List;
	var venues = new Z.List;
	var movies = new Z.List;
	
	Z.loadJson({
		name: 'Zvents_load_' + args.id,
		load: args.load,
		yields: ready
	});
	

	var mySearchIs ='';
	function ready( json ) {

		try {
			var rsp = json.rsp;
			switch( rsp.status ) {
			case 'error':
				var error = events.error = venues.error = rsp.msg;
				break;
			case 'ok':
				var content = rsp.content;
				
				var eventArray = events.array = content.events || [];
				var venueArray = venues.array = content.venues || [];
				var movieArray = movies.array = content.movies || [];
				
				
				events.repeats = 0;
				events.total = content.event_count;
				venues.total = content.venue_count;
				movies.total = content.movies_count;
				
				for( var m = 0, n = movieArray.length;  m < n;  m++ ) {
					
					var movie = movieArray[m];
					movie.valueOf = valueOfId;
					
					if (movie.zurl.substring(0,4)!= 'http'){
					}else{
					}
	
				}
				movies.count = movieArray.length;
				
				
		
				for( var v = 0, n = venueArray.length;  v < n;  v++ ) {
					var venue = venueArray[v];
					venue.valueOf = valueOfId;
					venue.events = [];
					venues.byId[venue.id] = venue;
				}
				venues.count = venueArray.length;
				
								
				for( var e = 0, n = eventArray.length;  e < n;  e++ ) {
					var event = eventArray[e];
					event.valueOf = valueOfId;
					events.byId[event.id] = event;
					var venue = event.venue = venues.byId[event.vid];
					if( venue ) {
						if( venue.parent_id ) venue = event.venue = venues.byId[venue.parent_id];
						if( venue ) {
							venue.events[venue.events.length] = event;
						}
					}
					event.starttime = Z.Date.time( event.startTime );
					event.date = Z.Date.midnight( event.starttime );
					if( event.endTime ) event.endtime = Z.Date.time( event.endTime );
					
					if (event.zurl.substring(0,4)!= 'http'){
					}else{
					}
				}
				events.count = eventArray.length;
				
				if(movies.count != 0){
					mySearchIs = 'movies';
					args.yields( movies );
				}else if(events.count != 0){
					mySearchIs = 'events';
					args.yields( events );
				}else{
					mySearchIs = 'venues';
					args.yields( venues );
				}

				break;
			}
		}
		catch( e ) {
		}
		finally {
		}
	}
};

//-------------------------------------------------------------------------------------------------
// End of ZventsMini --> Z renaming function
//-------------------------------------------------------------------------------------------------

	
	var today = Z.Date.today();
	
	// Default settings and render functions for all widgets
	var base = {
		// Render the event date as tomorrow, or Friday, or 1/31
		date: function( event ) {
			if( this.showDate === false ) return '';
			if( event.date == today ) return this.showDate === true ? 'today' : '';
			if( event.date == today + Z.Date.oneDay ) return 'tomorrow';
			return Z.Date(event.date).format(
				event.date < today + Z.Date.oneDay*7 ? '{Sunday}' :
				'{M}/{DD}' );
		},
		
		// Render the list of events
		events: function( events ) {
			return [
				'<div class="ZventsEventList">',
					events.map(this.event,this).join(''),
				'</div>'
			].join('');
		},
		
		// Render a single event
		event: function( event ) {
			var date = this.date( event );
			if( date ) {
				date = [
					'<span class="ZventsEventDate">',
						this.date( event ),
					'</span>',
					' '
				].join('');
			}
			
			return [
				'<div class="ZventsEvent">',
					'<div class="zArrow"></div>',
					this.images ? this.image( event ) : '',
					'<a class="ZventsEventName" href="', Z.site,  event.zurl, '">',
						Z.String.truncate( event.name, this.maxTitle || 36 ),
					'</a><br />',
					'<span class="ZventsEventTime">',
						this.time( event ),
					'</span>',
					' ',
					date,
				'</div>',
				'<div class="zEventStripe" style="margin: 0 8px;"></div>'
			].join('');
		},
		
		// Render the image(s) for an event
		image: function( event ) {
			var image = event.images[0];
			return ! image ? '' : [
				'<a class="ZventsImageLink" href="', Z.site, event.zurl, '">',
					'<img class="ZventsImage" alt="Image" border="0" align="left" ',
						'src="', Z.imgThumb(image.url), '" ',
						//'width="', image.width, '" height="', image.height, '" ',
					'/>',
				'</a>'
			].join('');
		},
		
		// Render the "Loading" indicator
		loading: function() {
			return [
				'<div class="ZventsLoading">',
					'<img src="http://images.zvents.com/images/spinner16.gif" />',
					'<span> Loading events&#8230;</span>',
				'</div>'
			].join('');
		},
		
		// Render the event time as Noon, Midnight, 2 pm, or 2:30 pm
		time: function( event ) {
			var start = Z.Date(event.startTime), date = start.date;
			var hours = date.getUTCHours(), minutes = date.getUTCMinutes();
			return start.format(
				minutes ? '{h}:{mm} {am}' :
				{ 0:'Midnight', 12:'Noon' }[hours] || '{h} {am}'
			);
		}
	};
	
	function Widget( args ) {
		Z.Object.update( this, base, args /*(temp:*/, args.render/*:temp)*/ );
	}
	
	// The base event list widget - custom widgets extend this one
	var idNext = 1;
	Z.widget.eventList = function( args ) {
		// Combine the settings, write the container and spinner
		var widget = new Widget( args );
		if( ! args.id ) {
			args.id = 'ZventsWidget' + idNext++;
			$(args.container).html([
				'<div id="', args.id, '">',
					widget.loading(),
				'</div>'
			].join(''));
		}
		
		if( args.load ) {
			// Call the core event list function with our partner ID
			Z.call( Z.EventList, {
				yields: function( events ) {
					// The event data is ready, sort it if requested
					if( widget.sort !== false )
						events.sort( 'starttime' );
					// Now render and display it
					var div = document.getElementById( args.id );
					div.innerHTML = widget.events( events );
				}
			}, args );
		}
		
		return args.id;
	};
	


//-------------------------------------------------------------------------------------------------

})( ZventsMini );