a:29:{s:9:"#provides";s:16:"dojo.date.locale";s:9:"#resource";s:14:"date/locale.js";s:9:"#requires";a:5:{i:0;a:2:{i:0;s:6:"common";i:1;s:9:"dojo.date";}i:1;a:2:{i:0;s:6:"common";i:1;s:22:"dojo.cldr.supplemental";}i:2;a:2:{i:0;s:6:"common";i:1;s:11:"dojo.regexp";}i:3;a:2:{i:0;s:6:"common";i:1;s:11:"dojo.string";}i:4;a:2:{i:0;s:6:"common";i:1;s:9:"dojo.i18n";}}s:25:"dojo.date.locale.getNames";a:5:{s:4:"type";s:8:"Function";s:10:"parameters";a:4:{s:4:"item";a:2:{s:4:"type";s:6:"String";s:7:"summary";s:18:"'months' || 'days'";}s:4:"type";a:2:{s:4:"type";s:6:"String";s:7:"summary";s:114:"'wide' || 'narrow' || 'abbr' (e.g. "Monday", "Mon", or "M" respectively, in English)";}s:7:"context";a:3:{s:8:"optional";b:1;s:4:"type";s:6:"String";s:7:"summary";s:34:"'standAlone' || 'format' (default)";}s:6:"locale";a:3:{s:8:"optional";b:1;s:4:"type";s:6:"String";s:7:"summary";s:38:"override locale used to find the names";}}s:6:"source";s:507:"	var label;
	var lookup = dojo.date.locale._getGregorianBundle(locale);
	var props = [item, context, type];
	if(context == 'standAlone'){
		var key = props.join('-');
		label = lookup[key];
		// Fall back to 'format' flavor of name
		if(label[0] == 1){ label = undefined; } // kludge, in the absense of real aliasing support in dojo.cldr
	}
	props[1] = 'format';


	// return by copy so changes won't be made accidentally to the in-memory model
	return (label || lookup[props.join('-')]).concat(); /*Array*/";s:7:"summary";s:68:"Used to get localized strings from dojo.cldr for day or month names.";s:7:"returns";s:5:"Array";}s:26:"dojo.date.locale.isWeekend";a:5:{s:4:"type";s:8:"Function";s:10:"parameters";a:2:{s:10:"dateObject";a:2:{s:8:"optional";b:1;s:4:"type";s:4:"Date";}s:6:"locale";a:2:{s:8:"optional";b:1;s:4:"type";s:6:"String";}}s:6:"source";s:264:"	var weekend = dojo.cldr.supplemental.getWeekend(locale);
	var day = (dateObject || new Date()).getDay();
	if(weekend.end < weekend.start){
		weekend.end += 7;
		if(day < weekend.start){ day += 7; }
	}
	return day >= weekend.start && day <= weekend.end; // Boolean";s:7:"summary";s:69:"Determines if the date falls on a weekend, according to local custom.";s:7:"returns";s:7:"Boolean";}s:30:"dojo.date.locale._getDayOfYear";a:6:{s:4:"type";s:8:"Function";s:10:"parameters";a:1:{s:10:"dateObject";a:1:{s:4:"type";s:4:"Date";}}s:6:"source";s:120:"	return dojo.date.difference(new Date(dateObject.getFullYear(), 0, 1, dateObject.getHours()), dateObject) + 1; // Number";s:7:"summary";s:53:"gets the day of the year as represented by dateObject";s:7:"returns";s:6:"Number";s:7:"private";b:1;}s:31:"dojo.date.locale._getWeekOfYear";a:6:{s:4:"type";s:8:"Function";s:10:"parameters";a:2:{s:10:"dateObject";a:1:{s:4:"type";s:4:"Date";}s:14:"firstDayOfWeek";a:1:{s:4:"type";s:6:"Number";}}s:6:"source";s:416:"	if(arguments.length == 1){ firstDayOfWeek = 0; } // Sunday


	var firstDayOfYear = new Date(dateObject.getFullYear(), 0, 1).getDay();
	var adj = (firstDayOfYear - firstDayOfWeek + 7) % 7;
	var week = Math.floor((dojo.date.locale._getDayOfYear(dateObject) + adj - 1) / 7);


	// if year starts on the specified day, start counting weeks at 1
	if(firstDayOfYear == firstDayOfWeek){ week++; }


	return week; // Number";s:7:"returns";s:6:"Number";s:7:"private";b:1;s:7:"summary";s:0:"";}s:12:"applyPattern";a:1:{s:7:"summary";s:0:"";}s:12:"applyLiteral";a:1:{s:7:"summary";s:0:"";}s:8:"applyAll";a:1:{s:7:"summary";s:0:"";}s:32:"dojo.date.locale.__FormatOptions";a:5:{s:4:"type";s:8:"Function";s:6:"source";s:4891:"dojo.provide("dojo.date.locale");


// Localization methods for Date.   Honor local customs using locale-dependent dojo.cldr data.


dojo.require("dojo.date");
dojo.require("dojo.cldr.supplemental");
dojo.require("dojo.regexp");
dojo.require("dojo.string");
dojo.require("dojo.i18n");


// Load the bundles containing localization information for
// names and formats
dojo.requireLocalization("dojo.cldr", "gregorian");


//NOTE: Everything in this module assumes Gregorian calendars.
// Other calendars will be implemented in separate modules.


(function(){
	// Format a pattern without literals
	function formatPattern(dateObject, bundle, fullYear, pattern){
		return pattern.replace(/([a-z])\1*/ig, function(match){
			var s, pad;
			var c = match.charAt(0);
			var l = match.length;
			var widthList = ["abbr", "wide", "narrow"];
			switch(c){
				case 'G':
					s = bundle[(l < 4) ? "eraAbbr" : "eraNames"][dateObject.getFullYear() < 0 ? 0 : 1];
					break;
				case 'y':
					s = dateObject.getFullYear();
					switch(l){
						case 1:
							break;
						case 2:
							if(!fullYear){
								s = String(s); s = s.substr(s.length - 2);
								break;
							}
							// fallthrough
						default:
							pad = true;
					}
					break;
				case 'Q':
				case 'q':
					s = Math.ceil((dateObject.getMonth()+1)/3);
//					switch(l){
//						case 1: case 2:
							pad = true;
//							break;
//						case 3: case 4: // unimplemented
//					}
					break;
				case 'M':
					var m = dateObject.getMonth();
					if(l<3){
						s = m+1; pad = true;
					}else{
						var propM = ["months", "format", widthList[l-3]].join("-");
						s = bundle[propM][m];
					}
					break;
				case 'w':
					var firstDay = 0;
					s = dojo.date.locale._getWeekOfYear(dateObject, firstDay); pad = true;
					break;
				case 'd':
					s = dateObject.getDate(); pad = true;
					break;
				case 'D':
					s = dojo.date.locale._getDayOfYear(dateObject); pad = true;
					break;
				case 'E':
					var d = dateObject.getDay();
					if(l<3){
						s = d+1; pad = true;
					}else{
						var propD = ["days", "format", widthList[l-3]].join("-");
						s = bundle[propD][d];
					}
					break;
				case 'a':
					var timePeriod = (dateObject.getHours() < 12) ? 'am' : 'pm';
					s = bundle[timePeriod];
					break;
				case 'h':
				case 'H':
				case 'K':
				case 'k':
					var h = dateObject.getHours();
					// strange choices in the date format make it impossible to write this succinctly
					switch (c){
						case 'h': // 1-12
							s = (h % 12) || 12;
							break;
						case 'H': // 0-23
							s = h;
							break;
						case 'K': // 0-11
							s = (h % 12);
							break;
						case 'k': // 1-24
							s = h || 24;
							break;
					}
					pad = true;
					break;
				case 'm':
					s = dateObject.getMinutes(); pad = true;
					break;
				case 's':
					s = dateObject.getSeconds(); pad = true;
					break;
				case 'S':
					s = Math.round(dateObject.getMilliseconds() * Math.pow(10, l-3)); pad = true;
					break;
				case 'v': // FIXME: don't know what this is. seems to be same as z?
				case 'z':
					// We only have one timezone to offer; the one from the browser
					s = dojo.date.getTimezoneName(dateObject);
					if(s){break;}
					l=4;
					// fallthrough... use GMT if tz not available
				case 'Z':
					var offset = dateObject.getTimezoneOffset();
					var tz = [
						(offset<=0 ? "+" : "-"),
						dojo.string.pad(Math.floor(Math.abs(offset)/60), 2),
						dojo.string.pad(Math.abs(offset)% 60, 2)
					];
					if(l==4){
						tz.splice(0, 0, "GMT");
						tz.splice(3, 0, ":");
					}
					s = tz.join("");
					break;
//				case 'Y': case 'u': case 'W': case 'F': case 'g': case 'A': case 'e':
//					console.log(match+" modifier unimplemented");
				default:
					throw new Error("dojo.date.locale.format: invalid pattern char: "+pattern);
			}
			if(pad){ s = dojo.string.pad(s, l); }
			return s;
		});
	}



       
	dojo.date.locale.__FormatOptions = function(){
	//	selector: String
	//		choice of 'time','date' (default: date and time)
	//	formatLength: String
	//		choice of long, short, medium or full (plus any custom additions).  Defaults to 'short'
	//	datePattern:String
	//		override pattern with this string
	//	timePattern:String
	//		override pattern with this string
	//	am: String
	//		override strings for am in times
	//	pm: String
	//		override strings for pm in times
	//	locale: String
	//		override the locale used to determine formatting rules
	//	fullYear: Boolean
	//		(format only) use 4 digit years whenever 2 digit years are called for
	//	strict: Boolean
	//		(parse only) strict parsing, off by default
		this.selector = selector;
		this.formatLength = formatLength;
		this.datePattern = datePattern;
		this.timePattern = timePattern;
		this.am = am;
		this.pm = pm;
		this.locale = locale;
		this.fullYear = fullYear;
		this.strict = strict;";s:7:"private";b:1;s:9:"classlike";b:1;s:7:"summary";s:0:"";}s:41:"dojo.date.locale.__FormatOptions.selector";a:4:{s:8:"instance";s:32:"dojo.date.locale.__FormatOptions";s:4:"type";s:6:"String";s:7:"summary";s:48:"choice of 'time','date' (default: date and time)";s:14:"private_parent";b:1;}s:45:"dojo.date.locale.__FormatOptions.formatLength";a:4:{s:8:"instance";s:32:"dojo.date.locale.__FormatOptions";s:4:"type";s:6:"String";s:7:"summary";s:87:"choice of long, short, medium or full (plus any custom additions).  Defaults to 'short'";s:14:"private_parent";b:1;}s:44:"dojo.date.locale.__FormatOptions.datePattern";a:4:{s:8:"instance";s:32:"dojo.date.locale.__FormatOptions";s:4:"type";s:6:"String";s:7:"summary";s:33:"override pattern with this string";s:14:"private_parent";b:1;}s:44:"dojo.date.locale.__FormatOptions.timePattern";a:4:{s:8:"instance";s:32:"dojo.date.locale.__FormatOptions";s:4:"type";s:6:"String";s:7:"summary";s:33:"override pattern with this string";s:14:"private_parent";b:1;}s:35:"dojo.date.locale.__FormatOptions.am";a:4:{s:8:"instance";s:32:"dojo.date.locale.__FormatOptions";s:4:"type";s:6:"String";s:7:"summary";s:32:"override strings for am in times";s:14:"private_parent";b:1;}s:35:"dojo.date.locale.__FormatOptions.pm";a:4:{s:8:"instance";s:32:"dojo.date.locale.__FormatOptions";s:4:"type";s:6:"String";s:7:"summary";s:32:"override strings for pm in times";s:14:"private_parent";b:1;}s:39:"dojo.date.locale.__FormatOptions.locale";a:4:{s:8:"instance";s:32:"dojo.date.locale.__FormatOptions";s:4:"type";s:6:"String";s:7:"summary";s:54:"override the locale used to determine formatting rules";s:14:"private_parent";b:1;}s:41:"dojo.date.locale.__FormatOptions.fullYear";a:4:{s:8:"instance";s:32:"dojo.date.locale.__FormatOptions";s:4:"type";s:7:"Boolean";s:7:"summary";s:69:"(format only) use 4 digit years whenever 2 digit years are called for";s:14:"private_parent";b:1;}s:39:"dojo.date.locale.__FormatOptions.strict";a:4:{s:8:"instance";s:32:"dojo.date.locale.__FormatOptions";s:4:"type";s:7:"Boolean";s:7:"summary";s:43:"(parse only) strict parsing, off by default";s:14:"private_parent";b:1;}s:23:"dojo.date.locale.format";a:6:{s:4:"type";s:8:"Function";s:10:"parameters";a:2:{s:10:"dateObject";a:2:{s:4:"type";s:4:"Date";s:7:"summary";s:179:"the date and/or time to be formatted.  If a time only is formatted,
the values in the year, month, and day fields are irrelevant.  The
opposite is true when formatting only dates.";}s:7:"options";a:2:{s:8:"optional";b:1;s:4:"type";s:32:"dojo.date.locale.__FormatOptions";}}s:6:"source";s:976:"	options = options || {};


	var locale = dojo.i18n.normalizeLocale(options.locale);
	var formatLength = options.formatLength || 'short';
	var bundle = dojo.date.locale._getGregorianBundle(locale);
	var str = [];
	var sauce = dojo.hitch(this, formatPattern, dateObject, bundle, options.fullYear);
	if(options.selector == "year"){
		// Special case as this is not yet driven by CLDR data
		var year = dateObject.getFullYear();
		if(locale.match(/^zh|^ja/)){
			year += "\u5E74";
		}
		return year;
	}
	if(options.selector != "time"){
		var datePattern = options.datePattern || bundle["dateFormat-"+formatLength];
		if(datePattern){str.push(_processPattern(datePattern, sauce));}
	}
	if(options.selector != "date"){
		var timePattern = options.timePattern || bundle["timeFormat-"+formatLength];
		if(timePattern){str.push(_processPattern(timePattern, sauce));}
	}
	var result = str.join(" "); //TODO: use locale-specific pattern to assemble date + time
	return result; // String";s:7:"summary";s:65:"Format a Date object as a String, using locale-specific settings.";s:11:"description";s:529:"Create a string from a Date object using a known localized pattern.
By default, this method formats both date and time from dateObject.
Formatting patterns are chosen appropriate to the locale.  Different
formatting lengths may be chosen, with "full" used by default.
Custom patterns may be used or registered with translations using
the dojo.date.locale.addCustomFormats method.
Formatting patterns are implemented using [the syntax described at
unicode.org](http://www.unicode.org/reports/tr35/tr35-4.html#Date_Format_Patterns)";s:7:"returns";s:6:"String";}s:23:"dojo.date.locale.regexp";a:5:{s:4:"type";s:8:"Function";s:10:"parameters";a:1:{s:7:"options";a:2:{s:8:"optional";b:1;s:4:"type";s:32:"dojo.date.locale.__FormatOptions";}}s:6:"source";s:62:"	return dojo.date.locale._parseInfo(options).regexp; // String";s:7:"summary";s:51:"Builds the regular needed to parse a localized date";s:7:"returns";s:6:"String";}s:27:"dojo.date.locale._parseInfo";a:5:{s:4:"type";s:8:"Function";s:10:"parameters";a:1:{s:7:"options";a:2:{s:8:"optional";b:1;s:4:"type";s:32:"dojo.date.locale.__FormatOptions";}}s:6:"source";s:778:"	options = options || {};
	var locale = dojo.i18n.normalizeLocale(options.locale);
	var bundle = dojo.date.locale._getGregorianBundle(locale);
	var formatLength = options.formatLength || 'short';
	var datePattern = options.datePattern || bundle["dateFormat-" + formatLength];
	var timePattern = options.timePattern || bundle["timeFormat-" + formatLength];
	var pattern;
	if(options.selector == 'date'){
		pattern = datePattern;
	}else if(options.selector == 'time'){
		pattern = timePattern;
	}else{
		pattern = datePattern + ' ' + timePattern; //TODO: use locale-specific pattern to assemble date + time
	}


	var tokens = [];
	var re = _processPattern(pattern, dojo.hitch(this, _buildDateTimeRE, tokens, bundle, options));
	return {regexp: re, tokens: tokens, bundle: bundle};";s:7:"private";b:1;s:7:"summary";s:0:"";}s:22:"dojo.date.locale.parse";a:6:{s:4:"type";s:8:"Function";s:10:"parameters";a:2:{s:5:"value";a:2:{s:4:"type";s:6:"String";s:7:"summary";s:33:"A string representation of a date";}s:7:"options";a:2:{s:8:"optional";b:1;s:4:"type";s:32:"dojo.date.locale.__FormatOptions";}}s:6:"source";s:5342:"	var info = dojo.date.locale._parseInfo(options);
	var tokens = info.tokens, bundle = info.bundle;
	var re = new RegExp("^" + info.regexp + "$", info.strict ? "" : "i");
	var match = re.exec(value);
	if(!match){ return null; } // null


	var widthList = ['abbr', 'wide', 'narrow'];
	var result = [1970,0,1,0,0,0,0]; // will get converted to a Date at the end
	var amPm = "";
	var valid = dojo.every(match, function(v, i){
		if(!i){return true;}
		var token=tokens[i-1];
		var l=token.length;
		switch(token.charAt(0)){
			case 'y':
				if(l != 2 && options.strict){
					//interpret year literally, so '5' would be 5 A.D.
					result[0] = v;
				}else{
					if(v<100){
						v = Number(v);
						//choose century to apply, according to a sliding window
						//of 80 years before and 20 years after present year
						var year = '' + new Date().getFullYear();
						var century = year.substring(0, 2) * 100;
						var cutoff = Math.min(Number(year.substring(2, 4)) + 20, 99);
						var num = (v < cutoff) ? century + v : century - 100 + v;
						result[0] = num;
					}else{
						//we expected 2 digits and got more...
						if(options.strict){
							return false;
						}
						//interpret literally, so '150' would be 150 A.D.
						//also tolerate '1950', if 'yyyy' input passed to 'yy' format
						result[0] = v;
					}
				}
				break;
			case 'M':
				if(l>2){
					var months = bundle['months-format-' + widthList[l-3]].concat();
					if(!options.strict){
						//Tolerate abbreviating period in month part
						//Case-insensitive comparison
						v = v.replace(".","").toLowerCase();
						months = dojo.map(months, function(s){ return s.replace(".","").toLowerCase(); } );
					}
					v = dojo.indexOf(months, v);
					if(v == -1){
//						console.log("dojo.date.locale.parse: Could not parse month name: '" + v + "'.");
						return false;
					}
				}else{
					v--;
				}
				result[1] = v;
				break;
			case 'E':
			case 'e':
				var days = bundle['days-format-' + widthList[l-3]].concat();
				if(!options.strict){
					//Case-insensitive comparison
					v = v.toLowerCase();
					days = dojo.map(days, function(d){return d.toLowerCase();});
				}
				v = dojo.indexOf(days, v);
				if(v == -1){
//					console.log("dojo.date.locale.parse: Could not parse weekday name: '" + v + "'.");
					return false;
				}


				//TODO: not sure what to actually do with this input,
				//in terms of setting something on the Date obj...?
				//without more context, can't affect the actual date
				//TODO: just validate?
				break;
			case 'D':
				result[1] = 0;
				// fallthrough...
			case 'd':
				result[2] = v;
				break;
			case 'a': //am/pm
				var am = options.am || bundle.am;
				var pm = options.pm || bundle.pm;
				if(!options.strict){
					var period = /\./g;
					v = v.replace(period,'').toLowerCase();
					am = am.replace(period,'').toLowerCase();
					pm = pm.replace(period,'').toLowerCase();
				}
				if(options.strict && v != am && v != pm){
//					console.log("dojo.date.locale.parse: Could not parse am/pm part.");
					return false;
				}


				// we might not have seen the hours field yet, so store the state and apply hour change later
				amPm = (v == pm) ? 'p' : (v == am) ? 'a' : '';
				break;
			case 'K': //hour (1-24)
				if(v == 24){ v = 0; }
				// fallthrough...
			case 'h': //hour (1-12)
			case 'H': //hour (0-23)
			case 'k': //hour (0-11)
				//TODO: strict bounds checking, padding
				if(v > 23){
//					console.log("dojo.date.locale.parse: Illegal hours value");
					return false;
				}


				//in the 12-hour case, adjusting for am/pm requires the 'a' part
				//which could come before or after the hour, so we will adjust later
				result[3] = v;
				break;
			case 'm': //minutes
				result[4] = v;
				break;
			case 's': //seconds
				result[5] = v;
				break;
			case 'S': //milliseconds
				result[6] = v;
//				break;
//			case 'w':
//TODO				var firstDay = 0;
//			default:
//TODO: throw?
//				console.log("dojo.date.locale.parse: unsupported pattern char=" + token.charAt(0));
		}
		return true;
	});


	var hours = +result[3];
	if(amPm === 'p' && hours < 12){
		result[3] = hours + 12; //e.g., 3pm -> 15
	}else if(amPm === 'a' && hours == 12){
		result[3] = 0; //12am -> 0
	}


	//TODO: implement a getWeekday() method in order to test 
	//validity of input strings containing 'EEE' or 'EEEE'...


	var dateObject = new Date(result[0], result[1], result[2], result[3], result[4], result[5], result[6]); // Date
	if(options.strict){
		dateObject.setFullYear(result[0]);
	}


	// Check for overflow.  The Date() constructor normalizes things like April 32nd...
	//TODO: why isn't this done for times as well?
	var allTokens = tokens.join(""),
		dateToken = allTokens.indexOf('d') != -1,
		monthToken = allTokens.indexOf('M') != -1;


	if(!valid ||
		(monthToken && dateObject.getMonth() > result[1]) ||
		(dateToken && dateObject.getDate() > result[2])){
		return null;
	}


	// Check for underflow, due to DST shifts.  See #9366
	// This assumes a 1 hour dst shift correction at midnight
	// We could compare the timezone offset after the shift and add the difference instead.
	if((monthToken && dateObject.getMonth() < result[1]) ||
		(dateToken && dateObject.getDate() < result[2])){
		dateObject = dojo.date.add(dateObject, "hour", 1);
	}


	return dateObject; // Date";s:7:"summary";s:95:"Convert a properly formatted string to a primitive Date object,
using locale-specific settings.";s:11:"description";s:742:"Create a Date object from a string using a known localized pattern.
By default, this method parses looking for both date and time in the string.
Formatting patterns are chosen appropriate to the locale.  Different
formatting lengths may be chosen, with "full" used by default.
Custom patterns may be used or registered with translations using
the dojo.date.locale.addCustomFormats method.

Formatting patterns are implemented using [the syntax described at
unicode.org](http://www.unicode.org/reports/tr35/tr35-4.html#Date_Format_Patterns)
When two digit years are used, a century is chosen according to a sliding
window of 80 years before and 20 years after present year, for both `yy` and `yyyy` patterns.
year < 100CE requires strict mode.";s:7:"returns";s:9:"null|Date";}s:33:"dojo.date.locale.addCustomFormats";a:5:{s:4:"type";s:8:"Function";s:10:"parameters";a:2:{s:11:"packageName";a:1:{s:4:"type";s:6:"String";}s:10:"bundleName";a:1:{s:4:"type";s:6:"String";}}s:6:"source";s:56:"	_customFormats.push({pkg:packageName,name:bundleName});";s:7:"summary";s:120:"Add a reference to a bundle containing localized custom formats to be
used by date/time formatting and parsing routines.";s:11:"description";s:343:"The user may add custom localized formats where the bundle has properties following the
same naming convention used by dojo.cldr: `dateFormat-xxxx` / `timeFormat-xxxx`
The pattern string should match the format used by the CLDR.
See dojo.date.locale.format() for details.
The resources must be loaded by dojo.requireLocalization() prior to use";}s:36:"dojo.date.locale._getGregorianBundle";a:6:{s:4:"type";s:8:"Function";s:10:"parameters";a:1:{s:6:"locale";a:1:{s:4:"type";s:6:"String";}}s:6:"source";s:223:"	var gregorian = {};
	dojo.forEach(_customFormats, function(desc){
		var bundle = dojo.i18n.getLocalization(desc.pkg, desc.name, locale);
		gregorian = dojo.mixin(gregorian, bundle);
	}, this);
	return gregorian; /*Object*/";s:7:"returns";s:6:"Object";s:7:"private";b:1;s:7:"summary";s:0:"";}s:16:"dojo.date.locale";a:2:{s:4:"type";s:6:"Object";s:7:"summary";s:0:"";}s:9:"dojo.date";a:2:{s:4:"type";s:6:"Object";s:7:"summary";s:0:"";}s:4:"dojo";a:2:{s:4:"type";s:6:"Object";s:7:"summary";s:0:"";}}