globalize-rpk 1.7.1 → 1.7.2

package/dist/globalize-runtime/date.js

@@ -0,0 +1,1657 @@
+/**
+ * Globalize Runtime v1.7.0
+ *
+ * https://github.com/globalizejs/globalize
+ *
+ * Copyright OpenJS Foundation and other contributors
+ * Released under the MIT license
+ * https://jquery.org/license
+ *
+ * Date: 2021-08-02T11:53Z
+ */
+/*!
+ * Globalize Runtime v1.7.0 2021-08-02T11:53Z Released under the MIT license
+ * http://git.io/TrdQbw
+ */
+(function( root, factory ) {
+
+	"use strict";
+
+	// UMD returnExports
+	if ( typeof define === "function" && define.amd ) {
+
+		// AMD
+		define([
+			"../globalize-runtime",
+			"./number"
+		], factory );
+	} else if ( typeof exports === "object" ) {
+
+		// Node, CommonJS
+		module.exports = factory(
+			require( "../globalize-runtime" ),
+			require( "./number" )
+		);
+	} else {
+
+		// Extend global
+		factory( root.Globalize );
+	}
+}(this, function( Globalize ) {
+
+
+
+var createErrorUnsupportedFeature = Globalize._createErrorUnsupportedFeature,
+	looseMatching = Globalize._looseMatching,
+	partsJoin = Globalize._partsJoin,
+	partsPush = Globalize._partsPush,
+	regexpEscape = Globalize._regexpEscape,
+	removeLiteralQuotes = Globalize._removeLiteralQuotes,
+	runtimeKey = Globalize._runtimeKey,
+	stringPad = Globalize._stringPad,
+	validateParameterPresence = Globalize._validateParameterPresence,
+	validateParameterType = Globalize._validateParameterType,
+	validateParameterTypeString = Globalize._validateParameterTypeString;
+
+
+var validateParameterTypeDate = function( value, name ) {
+	validateParameterType( value, name, value === undefined || value instanceof Date, "Date" );
+};
+
+
+var ZonedDateTime = (function() {
+function definePrivateProperty(object, property, value) {
+  Object.defineProperty(object, property, {
+    value: value
+  });
+}
+
+function getUntilsIndex(original, untils) {
+  var index = 0;
+  var originalTime = original.getTime();
+
+  // TODO Should we do binary search for improved performance?
+  while (index < untils.length - 1 && originalTime >= untils[index]) {
+    index++;
+  }
+  return index;
+}
+
+function setWrap(fn) {
+  var offset1 = this.getTimezoneOffset();
+  var ret = fn();
+  this.original.setTime(new Date(this.getTime()));
+  var offset2 = this.getTimezoneOffset();
+  if (offset2 - offset1) {
+    this.original.setMinutes(this.original.getMinutes() + offset2 - offset1);
+  }
+  return ret;
+}
+
+var ZonedDateTime = function(date, timeZoneData) {
+  definePrivateProperty(this, "original", new Date(date.getTime()));
+  definePrivateProperty(this, "local", new Date(date.getTime()));
+  definePrivateProperty(this, "timeZoneData", timeZoneData);
+  definePrivateProperty(this, "setWrap", setWrap);
+  if (!(timeZoneData.untils && timeZoneData.offsets && timeZoneData.isdsts)) {
+    throw new Error("Invalid IANA data");
+  }
+  this.setTime(this.local.getTime() - this.getTimezoneOffset() * 60 * 1000);
+};
+
+ZonedDateTime.prototype.clone = function() {
+  return new ZonedDateTime(this.original, this.timeZoneData);
+};
+
+// Date field getters.
+["getFullYear", "getMonth", "getDate", "getDay", "getHours", "getMinutes",
+"getSeconds", "getMilliseconds"].forEach(function(method) {
+  // Corresponding UTC method, e.g., "getUTCFullYear" if method === "getFullYear".
+  var utcMethod = "getUTC" + method.substr(3);
+  ZonedDateTime.prototype[method] = function() {
+    return this.local[utcMethod]();
+  };
+});
+
+// Note: Define .valueOf = .getTime for arithmetic operations like date1 - date2.
+ZonedDateTime.prototype.valueOf =
+ZonedDateTime.prototype.getTime = function() {
+  return this.local.getTime() + this.getTimezoneOffset() * 60 * 1000;
+};
+
+ZonedDateTime.prototype.getTimezoneOffset = function() {
+  var index = getUntilsIndex(this.original, this.timeZoneData.untils);
+  return this.timeZoneData.offsets[index];
+};
+
+// Date field setters.
+["setFullYear", "setMonth", "setDate", "setHours", "setMinutes", "setSeconds", "setMilliseconds"].forEach(function(method) {
+  // Corresponding UTC method, e.g., "setUTCFullYear" if method === "setFullYear".
+  var utcMethod = "setUTC" + method.substr(3);
+  ZonedDateTime.prototype[method] = function(value) {
+    var local = this.local;
+    // Note setWrap is needed for seconds and milliseconds just because
+    // abs(value) could be >= a minute.
+    return this.setWrap(function() {
+      return local[utcMethod](value);
+    });
+  };
+});
+
+ZonedDateTime.prototype.setTime = function(time) {
+  return this.local.setTime(time);
+};
+
+ZonedDateTime.prototype.isDST = function() {
+  var index = getUntilsIndex(this.original, this.timeZoneData.untils);
+  return Boolean(this.timeZoneData.isdsts[index]);
+};
+
+ZonedDateTime.prototype.inspect = function() {
+  var index = getUntilsIndex(this.original, this.timeZoneData.untils);
+  var abbrs = this.timeZoneData.abbrs;
+  return this.local.toISOString().replace(/Z$/, "") + " " +
+    (abbrs && abbrs[index] + " " || (this.getTimezoneOffset() * -1) + " ") +
+    (this.isDST() ? "(daylight savings)" : "");
+};
+
+ZonedDateTime.prototype.toDate = function() {
+  return new Date(this.getTime());
+};
+
+// Type cast getters.
+["toISOString", "toJSON", "toUTCString"].forEach(function(method) {
+  ZonedDateTime.prototype[method] = function() {
+    return this.toDate()[method]();
+  };
+});
+
+return ZonedDateTime;
+}());
+
+
+/**
+ * dayOfWeek( date, firstDay )
+ *
+ * @date
+ *
+ * @firstDay the result of `dateFirstDayOfWeek( cldr )`
+ *
+ * Return the day of the week normalized by the territory's firstDay [0-6].
+ * Eg for "mon":
+ * - return 0 if territory is GB, or BR, or DE, or FR (week starts on "mon");
+ * - return 1 if territory is US (week starts on "sun");
+ * - return 2 if territory is EG (week starts on "sat");
+ */
+var dateDayOfWeek = function( date, firstDay ) {
+	return ( date.getDay() - firstDay + 7 ) % 7;
+};
+
+
+
+
+/**
+ * distanceInDays( from, to )
+ *
+ * Return the distance in days between from and to Dates.
+ */
+var dateDistanceInDays = function( from, to ) {
+	var inDays = 864e5;
+	return ( to.getTime() - from.getTime() ) / inDays;
+};
+
+
+
+
+/**
+ * startOf changes the input to the beginning of the given unit.
+ *
+ * For example, starting at the start of a day, resets hours, minutes
+ * seconds and milliseconds to 0. Starting at the month does the same, but
+ * also sets the date to 1.
+ *
+ * Returns the modified date
+ */
+var dateStartOf = function( date, unit ) {
+	date = date instanceof ZonedDateTime ? date.clone() : new Date( date.getTime() );
+	switch ( unit ) {
+		case "year":
+			date.setMonth( 0 );
+		/* falls through */
+		case "month":
+			date.setDate( 1 );
+		/* falls through */
+		case "day":
+			date.setHours( 0 );
+		/* falls through */
+		case "hour":
+			date.setMinutes( 0 );
+		/* falls through */
+		case "minute":
+			date.setSeconds( 0 );
+		/* falls through */
+		case "second":
+			date.setMilliseconds( 0 );
+	}
+	return date;
+};
+
+
+
+
+/**
+ * dayOfYear
+ *
+ * Return the distance in days of the date to the begin of the year [0-d].
+ */
+var dateDayOfYear = function( date ) {
+	return Math.floor( dateDistanceInDays( dateStartOf( date, "year" ), date ) );
+};
+
+
+
+
+/**
+ * Returns a new object created by using `object`'s values as keys, and the keys as values.
+ */
+var objectInvert = function( object, fn ) {
+	fn = fn || function( object, key, value ) {
+		object[ value ] = key;
+		return object;
+	};
+	return Object.keys( object ).reduce(function( newObject, key ) {
+		return fn( newObject, key, object[ key ] );
+	}, {});
+};
+
+
+
+
+// Invert key and values, e.g., {"year": "yY"} ==> {"y": "year", "Y": "year"}
+var dateFieldsMap = objectInvert({
+	"era": "G",
+	"year": "yY",
+	"quarter": "qQ",
+	"month": "ML",
+	"week": "wW",
+	"day": "dDF",
+	"weekday": "ecE",
+	"dayperiod": "a",
+	"hour": "hHkK",
+	"minute": "m",
+	"second": "sSA",
+	"zone": "zvVOxX"
+}, function( object, key, value ) {
+	value.split( "" ).forEach(function( symbol ) {
+		object[ symbol ] = key;
+	});
+	return object;
+});
+
+
+
+
+/**
+ * millisecondsInDay
+ */
+var dateMillisecondsInDay = function( date ) {
+
+	// TODO Handle daylight savings discontinuities
+	return date - dateStartOf( date, "day" );
+};
+
+
+
+
+var datePatternRe = ( /([a-z])\1*|'([^']|'')+'|''|./ig );
+
+
+
+
+/**
+ * hourFormat( date, format, timeSeparator, formatNumber )
+ *
+ * Return date's timezone offset according to the format passed.
+ * Eg for format when timezone offset is 180:
+ * - "+H;-H": -3
+ * - "+HHmm;-HHmm": -0300
+ * - "+HH:mm;-HH:mm": -03:00
+ * - "+HH:mm:ss;-HH:mm:ss": -03:00:00
+ */
+var dateTimezoneHourFormat = function( date, format, timeSeparator, formatNumber ) {
+	var absOffset,
+		offset = date.getTimezoneOffset();
+
+	absOffset = Math.abs( offset );
+	formatNumber = formatNumber || {
+		1: function( value ) {
+			return stringPad( value, 1 );
+		},
+		2: function( value ) {
+			return stringPad( value, 2 );
+		}
+	};
+
+	return format
+
+		// Pick the correct sign side (+ or -).
+		.split( ";" )[ offset > 0 ? 1 : 0 ]
+
+		// Localize time separator
+		.replace( ":", timeSeparator )
+
+		// Update hours offset.
+		.replace( /HH?/, function( match ) {
+			return formatNumber[ match.length ]( Math.floor( absOffset / 60 ) );
+		})
+
+		// Update minutes offset and return.
+		.replace( /mm/, function() {
+			return formatNumber[ 2 ]( Math.floor( absOffset % 60 ) );
+		})
+
+		// Update minutes offset and return.
+		.replace( /ss/, function() {
+			return formatNumber[ 2 ]( Math.floor( absOffset % 1 * 60 ) );
+		});
+};
+
+
+
+
+var dateWeekDays = [ "sun", "mon", "tue", "wed", "thu", "fri", "sat" ];
+
+
+
+
+/**
+ * format( date, properties )
+ *
+ * @date [Date instance].
+ *
+ * @properties
+ *
+ * TODO Support other calendar types.
+ *
+ * Disclosure: this function borrows excerpts of dojo/date/locale.
+ */
+var dateFormat = function( date, numberFormatters, properties ) {
+	var parts = [];
+
+	var timeSeparator = properties.timeSeparator;
+
+	// create globalize date with given timezone data
+	if ( properties.timeZoneData ) {
+		date = new ZonedDateTime( date, properties.timeZoneData() );
+	}
+
+	properties.pattern.replace( datePatternRe, function( current ) {
+		var aux, dateField, type, value,
+			chr = current.charAt( 0 ),
+			length = current.length;
+
+		if ( chr === "j" ) {
+
+			// Locale preferred hHKk.
+			// http://www.unicode.org/reports/tr35/tr35-dates.html#Time_Data
+			chr = properties.preferredTime;
+		}
+
+		if ( chr === "Z" ) {
+
+			// Z..ZZZ: same as "xxxx".
+			if ( length < 4 ) {
+				chr = "x";
+				length = 4;
+
+			// ZZZZ: same as "OOOO".
+			} else if ( length < 5 ) {
+				chr = "O";
+				length = 4;
+
+			// ZZZZZ: same as "XXXXX"
+			} else {
+				chr = "X";
+				length = 5;
+			}
+		}
+
+		// z...zzz: "{shortRegion}", e.g., "PST" or "PDT".
+		// zzzz: "{regionName} {Standard Time}" or "{regionName} {Daylight Time}",
+		//       e.g., "Pacific Standard Time" or "Pacific Daylight Time".
+		if ( chr === "z" ) {
+			if ( date.isDST ) {
+				value = date.isDST() ? properties.daylightTzName : properties.standardTzName;
+			}
+
+			// Fall back to "O" format.
+			if ( !value ) {
+				chr = "O";
+				if ( length < 4 ) {
+					length = 1;
+				}
+			}
+		}
+
+		switch ( chr ) {
+
+			// Era
+			case "G":
+				value = properties.eras[ date.getFullYear() < 0 ? 0 : 1 ];
+				break;
+
+			// Year
+			case "y":
+
+				// Plain year.
+				// The length specifies the padding, but for two letters it also specifies the
+				// maximum length.
+				value = date.getFullYear();
+				if ( length === 2 ) {
+					value = String( value );
+					value = +value.substr( value.length - 2 );
+				}
+				break;
+
+			case "Y":
+
+				// Year in "Week of Year"
+				// The length specifies the padding, but for two letters it also specifies the
+				// maximum length.
+				// yearInWeekofYear = date + DaysInAWeek - (dayOfWeek - firstDay) - minDays
+				value = new Date( date.getTime() );
+				value.setDate(
+					value.getDate() + 7 -
+					dateDayOfWeek( date, properties.firstDay ) -
+					properties.firstDay -
+					properties.minDays
+				);
+				value = value.getFullYear();
+				if ( length === 2 ) {
+					value = String( value );
+					value = +value.substr( value.length - 2 );
+				}
+				break;
+
+			// Quarter
+			case "Q":
+			case "q":
+				value = Math.ceil( ( date.getMonth() + 1 ) / 3 );
+				if ( length > 2 ) {
+					value = properties.quarters[ chr ][ length ][ value ];
+				}
+				break;
+
+			// Month
+			case "M":
+			case "L":
+				value = date.getMonth() + 1;
+				if ( length > 2 ) {
+					value = properties.months[ chr ][ length ][ value ];
+				}
+				break;
+
+			// Week
+			case "w":
+
+				// Week of Year.
+				// woy = ceil( ( doy + dow of 1/1 ) / 7 ) - minDaysStuff ? 1 : 0.
+				// TODO should pad on ww? Not documented, but I guess so.
+				value = dateDayOfWeek( dateStartOf( date, "year" ), properties.firstDay );
+				value = Math.ceil( ( dateDayOfYear( date ) + value ) / 7 ) -
+					( 7 - value >= properties.minDays ? 0 : 1 );
+				break;
+
+			case "W":
+
+				// Week of Month.
+				// wom = ceil( ( dom + dow of `1/month` ) / 7 ) - minDaysStuff ? 1 : 0.
+				value = dateDayOfWeek( dateStartOf( date, "month" ), properties.firstDay );
+				value = Math.ceil( ( date.getDate() + value ) / 7 ) -
+					( 7 - value >= properties.minDays ? 0 : 1 );
+				break;
+
+			// Day
+			case "d":
+				value = date.getDate();
+				break;
+
+			case "D":
+				value = dateDayOfYear( date ) + 1;
+				break;
+
+			case "F":
+
+				// Day of Week in month. eg. 2nd Wed in July.
+				value = Math.floor( date.getDate() / 7 ) + 1;
+				break;
+
+			// Week day
+			case "e":
+			case "c":
+				if ( length <= 2 ) {
+
+					// Range is [1-7] (deduced by example provided on documentation)
+					// TODO Should pad with zeros (not specified in the docs)?
+					value = dateDayOfWeek( date, properties.firstDay ) + 1;
+					break;
+				}
+
+			/* falls through */
+			case "E":
+				value = dateWeekDays[ date.getDay() ];
+				value = properties.days[ chr ][ length ][ value ];
+				break;
+
+			// Period (AM or PM)
+			case "a":
+				value = properties.dayPeriods[ date.getHours() < 12 ? "am" : "pm" ];
+				break;
+
+			// Hour
+			case "h": // 1-12
+				value = ( date.getHours() % 12 ) || 12;
+				break;
+
+			case "H": // 0-23
+				value = date.getHours();
+				break;
+
+			case "K": // 0-11
+				value = date.getHours() % 12;
+				break;
+
+			case "k": // 1-24
+				value = date.getHours() || 24;
+				break;
+
+			// Minute
+			case "m":
+				value = date.getMinutes();
+				break;
+
+			// Second
+			case "s":
+				value = date.getSeconds();
+				break;
+
+			case "S":
+				value = Math.round( date.getMilliseconds() * Math.pow( 10, length - 3 ) );
+				break;
+
+			case "A":
+				value = Math.round( dateMillisecondsInDay( date ) * Math.pow( 10, length - 3 ) );
+				break;
+
+			// Zone
+			case "z":
+				break;
+
+			case "v":
+
+				// v...vvv: "{shortRegion}", eg. "PT".
+				// vvvv: "{regionName} {Time}",
+				//       e.g., "Pacific Time".
+				if ( properties.genericTzName ) {
+					value = properties.genericTzName;
+					break;
+				}
+
+			/* falls through */
+			case "V":
+
+				//VVVV: "{explarCity} {Time}", e.g., "Los Angeles Time"
+				if ( properties.timeZoneName ) {
+					value = properties.timeZoneName;
+					break;
+				}
+
+				if ( current === "v" ) {
+					length = 1;
+				}
+
+			/* falls through */
+			case "O":
+
+				// O: "{gmtFormat}+H;{gmtFormat}-H" or "{gmtZeroFormat}", eg. "GMT-8" or "GMT".
+				// OOOO: "{gmtFormat}{hourFormat}" or "{gmtZeroFormat}", eg. "GMT-08:00" or "GMT".
+				if ( date.getTimezoneOffset() === 0 ) {
+					value = properties.gmtZeroFormat;
+				} else {
+
+					// If O..OOO and timezone offset has non-zero minutes, show minutes.
+					if ( length < 4 ) {
+						aux = date.getTimezoneOffset();
+						aux = properties.hourFormat[ aux % 60 - aux % 1 === 0 ? 0 : 1 ];
+					} else {
+						aux = properties.hourFormat;
+					}
+
+					value = dateTimezoneHourFormat(
+						date,
+						aux,
+						timeSeparator,
+						numberFormatters
+					);
+					value = properties.gmtFormat.replace( /\{0\}/, value );
+				}
+				break;
+
+			case "X":
+
+				// Same as x*, except it uses "Z" for zero offset.
+				if ( date.getTimezoneOffset() === 0 ) {
+					value = "Z";
+					break;
+				}
+
+			/* falls through */
+			case "x":
+
+				// x: hourFormat("+HH[mm];-HH[mm]")
+				// xx: hourFormat("+HHmm;-HHmm")
+				// xxx: hourFormat("+HH:mm;-HH:mm")
+				// xxxx: hourFormat("+HHmm[ss];-HHmm[ss]")
+				// xxxxx: hourFormat("+HH:mm[:ss];-HH:mm[:ss]")
+				aux = date.getTimezoneOffset();
+
+				// If x and timezone offset has non-zero minutes, use xx (i.e., show minutes).
+				if ( length === 1 && aux % 60 - aux % 1 !== 0 ) {
+					length += 1;
+				}
+
+				// If (xxxx or xxxxx) and timezone offset has zero seconds, use xx or xxx
+				// respectively (i.e., don't show optional seconds).
+				if ( ( length === 4 || length === 5 ) && aux % 1 === 0 ) {
+					length -= 2;
+				}
+
+				value = [
+					"+HH;-HH",
+					"+HHmm;-HHmm",
+					"+HH:mm;-HH:mm",
+					"+HHmmss;-HHmmss",
+					"+HH:mm:ss;-HH:mm:ss"
+				][ length - 1 ];
+
+				value = dateTimezoneHourFormat( date, value, ":" );
+				break;
+
+			// timeSeparator
+			case ":":
+				value = timeSeparator;
+				break;
+
+			// ' literals.
+			case "'":
+				value = removeLiteralQuotes( current );
+				break;
+
+			// Anything else is considered a literal, including [ ,:/.@#], chinese, japonese, and
+			// arabic characters.
+			default:
+				value = current;
+
+		}
+		if ( typeof value === "number" ) {
+			value = numberFormatters[ length ]( value );
+		}
+
+		dateField = dateFieldsMap[ chr ];
+		type = dateField ? dateField : "literal";
+
+		partsPush( parts, type, value );
+	});
+
+	return parts;
+
+};
+
+
+
+
+var dateFormatterFn = function( dateToPartsFormatter ) {
+	return function dateFormatter( value ) {
+		return partsJoin( dateToPartsFormatter( value ));
+	};
+};
+
+
+
+
+/**
+ * isLeapYear( year )
+ *
+ * @year [Number]
+ *
+ * Returns an indication whether the specified year is a leap year.
+ */
+var dateIsLeapYear = function( year ) {
+	return new Date( year, 1, 29 ).getMonth() === 1;
+};
+
+
+
+
+/**
+ * lastDayOfMonth( date )
+ *
+ * @date [Date]
+ *
+ * Return the last day of the given date's month
+ */
+var dateLastDayOfMonth = function( date ) {
+	return new Date( date.getFullYear(), date.getMonth() + 1, 0 ).getDate();
+};
+
+
+
+
+/**
+ * Differently from native date.setDate(), this function returns a date whose
+ * day remains inside the month boundaries. For example:
+ *
+ * setDate( FebDate, 31 ): a "Feb 28" date.
+ * setDate( SepDate, 31 ): a "Sep 30" date.
+ */
+var dateSetDate = function( date, day ) {
+	var lastDay = new Date( date.getFullYear(), date.getMonth() + 1, 0 ).getDate();
+
+	date.setDate( day < 1 ? 1 : day < lastDay ? day : lastDay );
+};
+
+
+
+
+/**
+ * Differently from native date.setMonth(), this function adjusts date if
+ * needed, so final month is always the one set.
+ *
+ * setMonth( Jan31Date, 1 ): a "Feb 28" date.
+ * setDate( Jan31Date, 8 ): a "Sep 30" date.
+ */
+var dateSetMonth = function( date, month ) {
+	var originalDate = date.getDate();
+
+	date.setDate( 1 );
+	date.setMonth( month );
+	dateSetDate( date, originalDate );
+};
+
+
+
+
+var outOfRange = function( value, low, high ) {
+	return value < low || value > high;
+};
+
+
+
+
+/**
+ * parse( value, tokens, properties )
+ *
+ * @value [String] string date.
+ *
+ * @tokens [Object] tokens returned by date/tokenizer.
+ *
+ * @properties [Object] output returned by date/tokenizer-properties.
+ *
+ * ref: http://www.unicode.org/reports/tr35/tr35-dates.html#Date_Format_Patterns
+ */
+var dateParse = function( _value, tokens, properties ) {
+	var amPm, day, daysOfYear, month, era, hour, hour12, timezoneOffset, valid,
+		YEAR = 0,
+		MONTH = 1,
+		DAY = 2,
+		HOUR = 3,
+		MINUTE = 4,
+		SECOND = 5,
+		MILLISECONDS = 6,
+		date = new Date(),
+		truncateAt = [],
+		units = [ "year", "month", "day", "hour", "minute", "second", "milliseconds" ];
+
+	// Create globalize date with given timezone data.
+	if ( properties.timeZoneData ) {
+		date = new ZonedDateTime( date, properties.timeZoneData() );
+	}
+
+	if ( !tokens.length ) {
+		return null;
+	}
+
+	valid = tokens.every(function( token ) {
+		var century, chr, value, length;
+
+		if ( token.type === "literal" ) {
+
+			// continue
+			return true;
+		}
+
+		chr = token.type.charAt( 0 );
+		length = token.type.length;
+
+		if ( chr === "j" ) {
+
+			// Locale preferred hHKk.
+			// http://www.unicode.org/reports/tr35/tr35-dates.html#Time_Data
+			chr = properties.preferredTimeData;
+		}
+
+		switch ( chr ) {
+
+			// Era
+			case "G":
+				truncateAt.push( YEAR );
+				era = +token.value;
+				break;
+
+			// Year
+			case "y":
+				value = token.value;
+				if ( length === 2 ) {
+					if ( outOfRange( value, 0, 99 ) ) {
+						return false;
+					}
+
+					// mimic dojo/date/locale: choose century to apply, according to a sliding
+					// window of 80 years before and 20 years after present year.
+					century = Math.floor( date.getFullYear() / 100 ) * 100;
+					value += century;
+					if ( value > date.getFullYear() + 20 ) {
+						value -= 100;
+					}
+				}
+				date.setFullYear( value );
+				truncateAt.push( YEAR );
+				break;
+
+			case "Y": // Year in "Week of Year"
+				throw createErrorUnsupportedFeature({
+					feature: "year pattern `" + chr + "`"
+				});
+
+			// Quarter (skip)
+			case "Q":
+			case "q":
+				break;
+
+			// Month
+			case "M":
+			case "L":
+				if ( length <= 2 ) {
+					value = token.value;
+				} else {
+					value = +token.value;
+				}
+				if ( outOfRange( value, 1, 12 ) ) {
+					return false;
+				}
+
+				// Setting the month later so that we have the correct year and can determine
+				// the correct last day of February in case of leap year.
+				month = value;
+				truncateAt.push( MONTH );
+				break;
+
+			// Week (skip)
+			case "w": // Week of Year.
+			case "W": // Week of Month.
+				break;
+
+			// Day
+			case "d":
+				day = token.value;
+				truncateAt.push( DAY );
+				break;
+
+			case "D":
+				daysOfYear = token.value;
+				truncateAt.push( DAY );
+				break;
+
+			case "F":
+
+				// Day of Week in month. eg. 2nd Wed in July.
+				// Skip
+				break;
+
+			// Week day
+			case "e":
+			case "c":
+			case "E":
+
+				// Skip.
+				// value = arrayIndexOf( dateWeekDays, token.value );
+				break;
+
+			// Period (AM or PM)
+			case "a":
+				amPm = token.value;
+				break;
+
+			// Hour
+			case "h": // 1-12
+				value = token.value;
+				if ( outOfRange( value, 1, 12 ) ) {
+					return false;
+				}
+				hour = hour12 = true;
+				date.setHours( value === 12 ? 0 : value );
+				truncateAt.push( HOUR );
+				break;
+
+			case "K": // 0-11
+				value = token.value;
+				if ( outOfRange( value, 0, 11 ) ) {
+					return false;
+				}
+				hour = hour12 = true;
+				date.setHours( value );
+				truncateAt.push( HOUR );
+				break;
+
+			case "k": // 1-24
+				value = token.value;
+				if ( outOfRange( value, 1, 24 ) ) {
+					return false;
+				}
+				hour = true;
+				date.setHours( value === 24 ? 0 : value );
+				truncateAt.push( HOUR );
+				break;
+
+			case "H": // 0-23
+				value = token.value;
+				if ( outOfRange( value, 0, 23 ) ) {
+					return false;
+				}
+				hour = true;
+				date.setHours( value );
+				truncateAt.push( HOUR );
+				break;
+
+			// Minute
+			case "m":
+				value = token.value;
+				if ( outOfRange( value, 0, 59 ) ) {
+					return false;
+				}
+				date.setMinutes( value );
+				truncateAt.push( MINUTE );
+				break;
+
+			// Second
+			case "s":
+				value = token.value;
+				if ( outOfRange( value, 0, 59 ) ) {
+					return false;
+				}
+				date.setSeconds( value );
+				truncateAt.push( SECOND );
+				break;
+
+			case "A":
+				date.setHours( 0 );
+				date.setMinutes( 0 );
+				date.setSeconds( 0 );
+
+			/* falls through */
+			case "S":
+				value = Math.round( token.value * Math.pow( 10, 3 - length ) );
+				date.setMilliseconds( value );
+				truncateAt.push( MILLISECONDS );
+				break;
+
+			// Zone
+			case "z":
+			case "Z":
+			case "O":
+			case "v":
+			case "V":
+			case "X":
+			case "x":
+				if ( typeof token.value === "number" ) {
+					timezoneOffset = token.value;
+				}
+				break;
+		}
+
+		return true;
+	});
+
+	if ( !valid ) {
+		return null;
+	}
+
+	// 12-hour format needs AM or PM, 24-hour format doesn't, ie. return null
+	// if amPm && !hour12 || !amPm && hour12.
+	if ( hour && !( !amPm ^ hour12 ) ) {
+		return null;
+	}
+
+	if ( era === 0 ) {
+
+		// 1 BC = year 0
+		date.setFullYear( date.getFullYear() * -1 + 1 );
+	}
+
+	if ( month !== undefined ) {
+		dateSetMonth( date, month - 1 );
+	}
+
+	if ( day !== undefined ) {
+		if ( outOfRange( day, 1, dateLastDayOfMonth( date ) ) ) {
+			return null;
+		}
+		date.setDate( day );
+	} else if ( daysOfYear !== undefined ) {
+		if ( outOfRange( daysOfYear, 1, dateIsLeapYear( date.getFullYear() ) ? 366 : 365 ) ) {
+			return null;
+		}
+		date.setMonth( 0 );
+		date.setDate( daysOfYear );
+	}
+
+	if ( hour12 && amPm === "pm" ) {
+		date.setHours( date.getHours() + 12 );
+	}
+
+	if ( timezoneOffset !== undefined ) {
+		date.setMinutes( date.getMinutes() + timezoneOffset - date.getTimezoneOffset() );
+	}
+
+	// Truncate date at the most precise unit defined. Eg.
+	// If value is "12/31", and pattern is "MM/dd":
+	// => new Date( <current Year>, 12, 31, 0, 0, 0, 0 );
+	truncateAt = Math.max.apply( null, truncateAt );
+	date = dateStartOf( date, units[ truncateAt ] );
+
+	// Get date back from globalize date.
+	if ( date instanceof ZonedDateTime ) {
+		date = date.toDate();
+	}
+
+	return date;
+};
+
+
+/* eslint-disable no-unused-expressions */
+
+
+
+/**
+ * tokenizer( value, numberParser, properties )
+ *
+ * @value [String] string date.
+ *
+ * @numberParser [Function]
+ *
+ * @properties [Object] output returned by date/tokenizer-properties.
+ *
+ * Returns an Array of tokens, eg. value "5 o'clock PM", pattern "h 'o''clock' a":
+ * [{
+ *   type: "h",
+ *   lexeme: "5"
+ * }, {
+ *   type: "literal",
+ *   lexeme: " "
+ * }, {
+ *   type: "literal",
+ *   lexeme: "o'clock"
+ * }, {
+ *   type: "literal",
+ *   lexeme: " "
+ * }, {
+ *   type: "a",
+ *   lexeme: "PM",
+ *   value: "pm"
+ * }]
+ *
+ * OBS: lexeme's are always String and may return invalid ranges depending of the token type.
+ * Eg. "99" for month number.
+ *
+ * Return an empty Array when not successfully parsed.
+ */
+var dateTokenizer = function( value, numberParser, properties ) {
+	var digitsRe, valid,
+		tokens = [],
+		widths = [ "abbreviated", "wide", "narrow" ];
+
+	digitsRe = properties.digitsRe;
+	value = looseMatching( value );
+
+	valid = properties.pattern.match( datePatternRe ).every(function( current ) {
+		var aux, chr, length, numeric, tokenRe,
+			token = {};
+
+		function hourFormatParse( tokenRe, numberParser ) {
+			var aux, isPositive,
+				match = value.match( tokenRe );
+			numberParser = numberParser || function( value ) {
+				return +value;
+			};
+
+			if ( !match ) {
+				return false;
+			}
+
+			isPositive = match[ 1 ];
+
+			// hourFormat containing H only, e.g., `+H;-H`
+			if ( match.length < 6 ) {
+				aux = isPositive ? 1 : 3;
+				token.value = numberParser( match[ aux ] ) * 60;
+
+			// hourFormat containing H and m, e.g., `+HHmm;-HHmm`
+			} else if ( match.length < 10 ) {
+				aux = isPositive ? [ 1, 3 ] : [ 5, 7 ];
+				token.value = numberParser( match[ aux[ 0 ] ] ) * 60 +
+					numberParser( match[ aux[ 1 ] ] );
+
+			// hourFormat containing H, m, and s e.g., `+HHmmss;-HHmmss`
+			} else {
+				aux = isPositive ? [ 1, 3, 5 ] : [ 7, 9, 11 ];
+				token.value = numberParser( match[ aux[ 0 ] ] ) * 60 +
+					numberParser( match[ aux[ 1 ] ] ) +
+					numberParser( match[ aux[ 2 ] ] ) / 60;
+			}
+
+			if ( isPositive ) {
+				token.value *= -1;
+			}
+
+			return true;
+		}
+
+		function oneDigitIfLengthOne() {
+			if ( length === 1 ) {
+
+				// Unicode equivalent to /\d/
+				numeric = true;
+				return tokenRe = digitsRe;
+			}
+		}
+
+		function oneOrTwoDigitsIfLengthOne() {
+			if ( length === 1 ) {
+
+				// Unicode equivalent to /\d\d?/
+				numeric = true;
+				return tokenRe = new RegExp( "^(" + digitsRe.source + "){1,2}" );
+			}
+		}
+
+		function oneOrTwoDigitsIfLengthOneOrTwo() {
+			if ( length === 1 || length === 2 ) {
+
+				// Unicode equivalent to /\d\d?/
+				numeric = true;
+				return tokenRe = new RegExp( "^(" + digitsRe.source + "){1,2}" );
+			}
+		}
+
+		function twoDigitsIfLengthTwo() {
+			if ( length === 2 ) {
+
+				// Unicode equivalent to /\d\d/
+				numeric = true;
+				return tokenRe = new RegExp( "^(" + digitsRe.source + "){2}" );
+			}
+		}
+
+		// Brute-force test every locale entry in an attempt to match the given value.
+		// Return the first found one (and set token accordingly), or null.
+		function lookup( path ) {
+			var array = properties[ path.join( "/" ) ];
+
+			if ( !array ) {
+				return null;
+			}
+
+			// array of pairs [key, value] sorted by desc value length.
+			array.some(function( item ) {
+				var valueRe = item[ 1 ];
+				if ( valueRe.test( value ) ) {
+					token.value = item[ 0 ];
+					tokenRe = item[ 1 ];
+					return true;
+				}
+			});
+			return null;
+		}
+
+		token.type = current;
+		chr = current.charAt( 0 );
+		length = current.length;
+
+		if ( chr === "Z" ) {
+
+			// Z..ZZZ: same as "xxxx".
+			if ( length < 4 ) {
+				chr = "x";
+				length = 4;
+
+			// ZZZZ: same as "OOOO".
+			} else if ( length < 5 ) {
+				chr = "O";
+				length = 4;
+
+			// ZZZZZ: same as "XXXXX"
+			} else {
+				chr = "X";
+				length = 5;
+			}
+		}
+
+		if ( chr === "z" ) {
+			if ( properties.standardOrDaylightTzName ) {
+				token.value = null;
+				tokenRe = properties.standardOrDaylightTzName;
+			}
+		}
+
+		// v...vvv: "{shortRegion}", eg. "PT".
+		// vvvv: "{regionName} {Time}" or "{regionName} {Time}",
+		// e.g., "Pacific Time"
+		// http://unicode.org/reports/tr35/tr35-dates.html#Date_Format_Patterns
+		if ( chr === "v" ) {
+			if ( properties.genericTzName ) {
+				token.value = null;
+				tokenRe = properties.genericTzName;
+
+			// Fall back to "V" format.
+			} else {
+				chr = "V";
+				length = 4;
+			}
+		}
+
+		if ( chr === "V" && properties.timeZoneName ) {
+			token.value = length === 2 ? properties.timeZoneName : null;
+			tokenRe = properties.timeZoneNameRe;
+		}
+
+		switch ( chr ) {
+
+			// Era
+			case "G":
+				lookup([
+					"gregorian/eras",
+					length <= 3 ? "eraAbbr" : ( length === 4 ? "eraNames" : "eraNarrow" )
+				]);
+				break;
+
+			// Year
+			case "y":
+			case "Y":
+				numeric = true;
+
+				// number l=1:+, l=2:{2}, l=3:{3,}, l=4:{4,}, ...
+				if ( length === 1 ) {
+
+					// Unicode equivalent to /\d+/.
+					tokenRe = new RegExp( "^(" + digitsRe.source + ")+" );
+				} else if ( length === 2 ) {
+
+					// Lenient parsing: there's no year pattern to indicate non-zero-padded 2-digits
+					// year, so parser accepts both zero-padded and non-zero-padded for `yy`.
+					//
+					// Unicode equivalent to /\d\d?/
+					tokenRe = new RegExp( "^(" + digitsRe.source + "){1,2}" );
+				} else {
+
+					// Unicode equivalent to /\d{length,}/
+					tokenRe = new RegExp( "^(" + digitsRe.source + "){" + length + ",}" );
+				}
+				break;
+
+			// Quarter
+			case "Q":
+			case "q":
+
+				// number l=1:{1}, l=2:{2}.
+				// lookup l=3...
+				oneDigitIfLengthOne() || twoDigitsIfLengthTwo() ||
+					lookup([
+						"gregorian/quarters",
+						chr === "Q" ? "format" : "stand-alone",
+						widths[ length - 3 ]
+					]);
+				break;
+
+			// Month
+			case "M":
+			case "L":
+
+				// number l=1:{1,2}, l=2:{2}.
+				// lookup l=3...
+				//
+				// Lenient parsing: skeleton "yMd" (i.e., one M) may include MM for the pattern,
+				// therefore parser accepts both zero-padded and non-zero-padded for M and MM.
+				// Similar for L.
+				oneOrTwoDigitsIfLengthOneOrTwo() || lookup([
+					"gregorian/months",
+					chr === "M" ? "format" : "stand-alone",
+					widths[ length - 3 ]
+				]);
+				break;
+
+			// Day
+			case "D":
+
+				// number {l,3}.
+				if ( length <= 3 ) {
+
+					// Equivalent to /\d{length,3}/
+					numeric = true;
+					tokenRe = new RegExp( "^(" + digitsRe.source + "){" + length + ",3}" );
+				}
+				break;
+
+			case "W":
+			case "F":
+
+				// number l=1:{1}.
+				oneDigitIfLengthOne();
+				break;
+
+			// Week day
+			case "e":
+			case "c":
+
+				// number l=1:{1}, l=2:{2}.
+				// lookup for length >=3.
+				if ( length <= 2 ) {
+					oneDigitIfLengthOne() || twoDigitsIfLengthTwo();
+					break;
+				}
+
+			/* falls through */
+			case "E":
+				if ( length === 6 ) {
+
+					// Note: if short day names are not explicitly specified, abbreviated day
+					// names are used instead http://www.unicode.org/reports/tr35/tr35-dates.html#months_days_quarters_eras
+					lookup([
+						"gregorian/days",
+						[ chr === "c" ? "stand-alone" : "format" ],
+						"short"
+					]) || lookup([
+						"gregorian/days",
+						[ chr === "c" ? "stand-alone" : "format" ],
+						"abbreviated"
+					]);
+				} else {
+					lookup([
+						"gregorian/days",
+						[ chr === "c" ? "stand-alone" : "format" ],
+						widths[ length < 3 ? 0 : length - 3 ]
+					]);
+				}
+				break;
+
+			// Period (AM or PM)
+			case "a":
+				lookup([
+					"gregorian/dayPeriods/format/wide"
+				]);
+				break;
+
+			// Week
+			case "w":
+
+				// number l1:{1,2}, l2:{2}.
+				oneOrTwoDigitsIfLengthOne() || twoDigitsIfLengthTwo();
+				break;
+
+			// Day, Hour, Minute, or Second
+			case "d":
+			case "h":
+			case "H":
+			case "K":
+			case "k":
+			case "j":
+			case "m":
+			case "s":
+
+				// number l1:{1,2}, l2:{2}.
+				//
+				// Lenient parsing:
+				// - skeleton "hms" (i.e., one m) always includes mm for the pattern, i.e., it's
+				//   impossible to use a different skeleton to parse non-zero-padded minutes,
+				//   therefore parser accepts both zero-padded and non-zero-padded for m. Similar
+				//   for seconds s.
+				// - skeleton "hms" (i.e., one h) may include h or hh for the pattern, i.e., it's
+				//   impossible to use a different skeleton to parser non-zero-padded hours for some
+				//   locales, therefore parser accepts both zero-padded and non-zero-padded for h.
+				//   Similar for d (in skeleton yMd).
+				oneOrTwoDigitsIfLengthOneOrTwo();
+				break;
+
+			case "S":
+
+				// number {l}.
+
+				// Unicode equivalent to /\d{length}/
+				numeric = true;
+				tokenRe = new RegExp( "^(" + digitsRe.source + "){" + length + "}" );
+				break;
+
+			case "A":
+
+				// number {l+5}.
+
+				// Unicode equivalent to /\d{length+5}/
+				numeric = true;
+				tokenRe = new RegExp( "^(" + digitsRe.source + "){" + ( length + 5 ) + "}" );
+				break;
+
+			// Zone
+			case "v":
+			case "V":
+			case "z":
+				if ( tokenRe && tokenRe.test( value ) ) {
+					break;
+				}
+				if ( chr === "V" && length === 2 ) {
+					break;
+				}
+
+			/* falls through */
+			case "O":
+
+				// O: "{gmtFormat}+H;{gmtFormat}-H" or "{gmtZeroFormat}", eg. "GMT-8" or "GMT".
+				// OOOO: "{gmtFormat}{hourFormat}" or "{gmtZeroFormat}", eg. "GMT-08:00" or "GMT".
+				if ( value === properties[ "timeZoneNames/gmtZeroFormat" ] ) {
+					token.value = 0;
+					tokenRe = properties[ "timeZoneNames/gmtZeroFormatRe" ];
+				} else {
+					aux = properties[ "timeZoneNames/hourFormat" ].some(function( hourFormatRe ) {
+						if ( hourFormatParse( hourFormatRe, numberParser ) ) {
+							tokenRe = hourFormatRe;
+							return true;
+						}
+					});
+					if ( !aux ) {
+						return null;
+					}
+				}
+				break;
+
+			case "X":
+
+				// Same as x*, except it uses "Z" for zero offset.
+				if ( value === "Z" ) {
+					token.value = 0;
+					tokenRe = /^Z/;
+					break;
+				}
+
+			/* falls through */
+			case "x":
+
+				// x: hourFormat("+HH[mm];-HH[mm]")
+				// xx: hourFormat("+HHmm;-HHmm")
+				// xxx: hourFormat("+HH:mm;-HH:mm")
+				// xxxx: hourFormat("+HHmm[ss];-HHmm[ss]")
+				// xxxxx: hourFormat("+HH:mm[:ss];-HH:mm[:ss]")
+				aux = properties.x.some(function( hourFormatRe ) {
+					if ( hourFormatParse( hourFormatRe ) ) {
+						tokenRe = hourFormatRe;
+						return true;
+					}
+				});
+				if ( !aux ) {
+					return null;
+				}
+				break;
+
+			case "'":
+				token.type = "literal";
+				tokenRe = new RegExp( "^" + regexpEscape( removeLiteralQuotes( current ) ) );
+				break;
+
+			default:
+				token.type = "literal";
+				tokenRe = new RegExp( "^" + regexpEscape( current ) );
+		}
+
+		if ( !tokenRe ) {
+			return false;
+		}
+
+		// Get lexeme and consume it.
+		value = value.replace( tokenRe, function( lexeme ) {
+			token.lexeme = lexeme;
+			if ( numeric ) {
+				token.value = numberParser( lexeme );
+			}
+			return "";
+		});
+
+		if ( !token.lexeme ) {
+			return false;
+		}
+
+		if ( numeric && isNaN( token.value ) ) {
+			return false;
+		}
+
+		tokens.push( token );
+		return true;
+	});
+
+	if ( value !== "" ) {
+		valid = false;
+	}
+
+	return valid ? tokens : [];
+};
+
+
+
+
+var dateParserFn = function( numberParser, parseProperties, tokenizerProperties ) {
+	return function dateParser( value ) {
+		var tokens;
+
+		validateParameterPresence( value, "value" );
+		validateParameterTypeString( value, "value" );
+
+		tokens = dateTokenizer( value, numberParser, tokenizerProperties );
+		return dateParse( value, tokens, parseProperties ) || null;
+	};
+};
+
+
+
+
+var dateToPartsFormatterFn = function( numberFormatters, properties ) {
+	return function dateToPartsFormatter( value ) {
+		validateParameterPresence( value, "value" );
+		validateParameterTypeDate( value, "value" );
+
+		return dateFormat( value, numberFormatters, properties );
+	};
+
+};
+
+
+
+
+Globalize._dateFormat = dateFormat;
+Globalize._dateFormatterFn = dateFormatterFn;
+Globalize._dateParser = dateParse;
+Globalize._dateParserFn = dateParserFn;
+Globalize._dateTokenizer = dateTokenizer;
+Globalize._dateToPartsFormatterFn = dateToPartsFormatterFn;
+Globalize._validateParameterTypeDate = validateParameterTypeDate;
+
+function optionsHasStyle( options ) {
+	return options.skeleton !== undefined ||
+		options.date !== undefined ||
+		options.time !== undefined ||
+		options.datetime !== undefined ||
+		options.raw !== undefined;
+}
+
+Globalize.dateFormatter =
+Globalize.prototype.dateFormatter = function( options ) {
+	options = options || {};
+	if ( !optionsHasStyle( options ) ) {
+		options.skeleton = "yMd";
+	}
+	return Globalize[ runtimeKey( "dateFormatter", this._locale, [ options ] ) ];
+};
+
+Globalize.dateToPartsFormatter =
+Globalize.prototype.dateToPartsFormatter = function( options ) {
+	options = options || {};
+	if ( !optionsHasStyle( options ) ) {
+		options.skeleton = "yMd";
+	}
+	return Globalize[ runtimeKey( "dateToPartsFormatter", this._locale, [ options ] ) ];
+};
+
+Globalize.dateParser =
+Globalize.prototype.dateParser = function( options ) {
+	options = options || {};
+	if ( !optionsHasStyle( options ) ) {
+		options.skeleton = "yMd";
+	}
+	return Globalize[ runtimeKey( "dateParser", this._locale, [ options ] ) ];
+};
+
+Globalize.formatDate =
+Globalize.prototype.formatDate = function( value, options ) {
+	validateParameterPresence( value, "value" );
+	validateParameterTypeDate( value, "value" );
+
+	return this.dateFormatter( options )( value );
+};
+
+Globalize.formatDateToParts =
+Globalize.prototype.formatDateToParts = function( value, options ) {
+	validateParameterPresence( value, "value" );
+	validateParameterTypeDate( value, "value" );
+
+	return this.dateToPartsFormatter( options )( value );
+};
+
+Globalize.parseDate =
+Globalize.prototype.parseDate = function( value, options ) {
+	validateParameterPresence( value, "value" );
+	validateParameterTypeString( value, "value" );
+
+	return this.dateParser( options )( value );
+};
+
+return Globalize;
+
+
+
+
+}));