@livetiles/reach-components-react 0.4.0-preview.218 → 0.4.0-preview.219

package/index.umd.js

@@ -1214,16 +1214,16 @@
 	var process$7 = global$r.process;
 	var versions$5 = process$7 && process$7.versions;
 	var v8$4 = versions$5 && versions$5.v8;
-	var match$5, version$a;
+	var match$7, version$a;
 
 	if (v8$4) {
-	  match$5 = v8$4.split('.');
-	  version$a = match$5[0] + match$5[1];
+	  match$7 = v8$4.split('.');
+	  version$a = match$7[0] + match$7[1];
 	} else if (userAgent$5) {
-	  match$5 = userAgent$5.match(/Edge\/(\d+)/);
-	  if (!match$5 || match$5[1] >= 74) {
-	    match$5 = userAgent$5.match(/Chrome\/(\d+)/);
-	    if (match$5) version$a = match$5[1];
+	  match$7 = userAgent$5.match(/Edge\/(\d+)/);
+	  if (!match$7 || match$7[1] >= 74) {
+	    match$7 = userAgent$5.match(/Chrome\/(\d+)/);
+	    if (match$7) version$a = match$7[1];
 	  }
 	}
 
@@ -41518,17 +41518,17 @@
 	var process$1$3 = global$2$3.process;
 	var versions$3 = process$1$3 && process$1$3.versions;
 	var v8$3 = versions$3 && versions$3.v8;
-	var match$4, version$7;
+	var match$6, version$7;
 
 	if (v8$3) {
-	  match$4 = v8$3.split('.');
-	  version$7 = match$4[0] + match$4[1];
+	  match$6 = v8$3.split('.');
+	  version$7 = match$6[0] + match$6[1];
 	} else if (userAgent$4) {
-	  match$4 = userAgent$4.match(/Edge\/(\d+)/);
+	  match$6 = userAgent$4.match(/Edge\/(\d+)/);
 
-	  if (!match$4 || match$4[1] >= 74) {
-	    match$4 = userAgent$4.match(/Chrome\/(\d+)/);
-	    if (match$4) version$7 = match$4[1];
+	  if (!match$6 || match$6[1] >= 74) {
+	    match$6 = userAgent$4.match(/Chrome\/(\d+)/);
+	    if (match$6) version$7 = match$6[1];
 	  }
 	}
 
@@ -49753,17 +49753,17 @@
 	var process$2$2 = global$4$2.process;
 	var versions$2 = process$2$2 && process$2$2.versions;
 	var v8$2 = versions$2 && versions$2.v8;
-	var match$3, version$6;
+	var match$5, version$6;
 
 	if (v8$2) {
-	  match$3 = v8$2.split('.');
-	  version$6 = match$3[0] + match$3[1];
+	  match$5 = v8$2.split('.');
+	  version$6 = match$5[0] + match$5[1];
 	} else if (userAgent$3) {
-	  match$3 = userAgent$3.match(/Edge\/(\d+)/);
+	  match$5 = userAgent$3.match(/Edge\/(\d+)/);
 
-	  if (!match$3 || match$3[1] >= 74) {
-	    match$3 = userAgent$3.match(/Chrome\/(\d+)/);
-	    if (match$3) version$6 = match$3[1];
+	  if (!match$5 || match$5[1] >= 74) {
+	    match$5 = userAgent$3.match(/Chrome\/(\d+)/);
+	    if (match$5) version$6 = match$5[1];
 	  }
 	}
 
@@ -66092,7 +66092,7 @@
 	var booleanValueOf = Boolean.prototype.valueOf;
 	var objectToString = Object.prototype.toString;
 	var functionToString$2 = Function.prototype.toString;
-	var match$2 = String.prototype.match;
+	var match$4 = String.prototype.match;
 	var bigIntValueOf = typeof BigInt === 'function' ? BigInt.prototype.valueOf : null;
 	var gOPS = Object.getOwnPropertySymbols;
 	var symToString = typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol' ? Symbol.prototype.toString : null;
@@ -66268,7 +66268,7 @@
 	    if (isString$1(obj)) {
 	        return markBoxed(inspect(String(obj)));
 	    }
-	    if (!isDate(obj) && !isRegExp$8(obj)) {
+	    if (!isDate$1(obj) && !isRegExp$8(obj)) {
 	        var ys = arrObjKeys(obj, inspect);
 	        var isPlainObject = gPO ? gPO(obj) === Object.prototype : obj instanceof Object || obj.constructor === Object;
 	        var protoTag = obj instanceof Object ? '' : 'null prototype';
@@ -66294,7 +66294,7 @@
 	}
 
 	function isArray$8(obj) { return toStr(obj) === '[object Array]' && (!toStringTag || !(typeof obj === 'object' && toStringTag in obj)); }
-	function isDate(obj) { return toStr(obj) === '[object Date]' && (!toStringTag || !(typeof obj === 'object' && toStringTag in obj)); }
+	function isDate$1(obj) { return toStr(obj) === '[object Date]' && (!toStringTag || !(typeof obj === 'object' && toStringTag in obj)); }
 	function isRegExp$8(obj) { return toStr(obj) === '[object RegExp]' && (!toStringTag || !(typeof obj === 'object' && toStringTag in obj)); }
 	function isError(obj) { return toStr(obj) === '[object Error]' && (!toStringTag || !(typeof obj === 'object' && toStringTag in obj)); }
 	function isString$1(obj) { return toStr(obj) === '[object String]' && (!toStringTag || !(typeof obj === 'object' && toStringTag in obj)); }
@@ -66341,7 +66341,7 @@
 
 	function nameOf(f) {
 	    if (f.name) { return f.name; }
-	    var m = match$2.call(functionToString$2.call(f), /^function\s*([\w$]+)/);
+	    var m = match$4.call(functionToString$2.call(f), /^function\s*([\w$]+)/);
 	    if (m) { return m[1]; }
 	    return null;
 	}
@@ -70876,7 +70876,7 @@
 
 	var defaultMessage = "Copy to clipboard: #{key}, Enter";
 
-	function format(message) {
+	function format$1(message) {
 	  var copyKey = (/mac os x/i.test(navigator.userAgent) ? "⌘" : "Ctrl") + "+C";
 	  return message.replace(/#{\s*key\s*}/g, copyKey);
 	}
@@ -70955,7 +70955,7 @@
 	    } catch (err) {
 	      debug && console.error("unable to copy using clipboardData: ", err);
 	      debug && console.error("falling back to prompt");
-	      message = format("message" in options ? options.message : defaultMessage);
+	      message = format$1("message" in options ? options.message : defaultMessage);
 	      window.prompt(message, text);
 	    }
 	  } finally {
@@ -80172,17 +80172,17 @@
 	var process$2$1 = global$2$1.process;
 	var versions$1 = process$2$1 && process$2$1.versions;
 	var v8$1 = versions$1 && versions$1.v8;
-	var match$1, version$2;
+	var match$3, version$2;
 
 	if (v8$1) {
-	  match$1 = v8$1.split('.');
-	  version$2 = match$1[0] + match$1[1];
+	  match$3 = v8$1.split('.');
+	  version$2 = match$3[0] + match$3[1];
 	} else if (userAgent$2) {
-	  match$1 = userAgent$2.match(/Edge\/(\d+)/);
+	  match$3 = userAgent$2.match(/Edge\/(\d+)/);
 
-	  if (!match$1 || match$1[1] >= 74) {
-	    match$1 = userAgent$2.match(/Chrome\/(\d+)/);
-	    if (match$1) version$2 = match$1[1];
+	  if (!match$3 || match$3[1] >= 74) {
+	    match$3 = userAgent$2.match(/Chrome\/(\d+)/);
+	    if (match$3) version$2 = match$3[1];
 	  }
 	}
 
@@ -87330,9 +87330,9 @@
 	  }), void 0);
 	};
 
-	var version$1 = "0.4.0-preview.218";
-	var buildId = "98536";
-	var commitId = "53d1e2e7ca6cdb579383c5337dad032ea701dfec";
+	var version$1 = "0.4.0-preview.219";
+	var buildId = "98555";
+	var commitId = "7017e140d89782fc7985a4be2c49f4898fab5489";
 	var isCustomerBuild = false;
 	var buildInfo = {
 		version: version$1,
@@ -131493,7 +131493,7 @@
 	// - setTimeout
 	}else {notify$1=function(){// strange IE + webpack dev server bug - use .call(global)
 	macrotask.call(global$6,flush);};}}var microtask$1=queueMicrotask||function(fn){var task={fn:fn,next:undefined};if(last)last.next=task;if(!head){head=task;notify$1();}last=task;};var newPromiseCapability$2={};var aFunction$4=aFunction$7;var PromiseCapability=function(C){var resolve,reject;this.promise=new C(function($$resolve,$$reject){if(resolve!==undefined||reject!==undefined)throw TypeError('Bad Promise constructor');resolve=$$resolve;reject=$$reject;});this.resolve=aFunction$4(resolve);this.reject=aFunction$4(reject);};// 25.4.1.5 NewPromiseCapability(C)
-	newPromiseCapability$2.f=function(C){return new PromiseCapability(C);};var anObject$2$1=anObject$h;var isObject$3=isObject$c;var newPromiseCapability$1=newPromiseCapability$2;var promiseResolve$1=function(C,x){anObject$2$1(C);if(isObject$3(x)&&x.constructor===C)return x;var promiseCapability=newPromiseCapability$1.f(C);var resolve=promiseCapability.resolve;resolve(x);return promiseCapability.promise;};var global$5=global$m;var hostReportErrors$1=function(a,b){var console=global$5.console;if(console&&console.error){arguments.length===1?console.error(a):console.error(a,b);}};var perform$1=function(exec){try{return {error:false,value:exec()};}catch(error){return {error:true,value:error};}};var global$4=global$m;var userAgent=engineUserAgent;var process$1=global$4.process;var versions=process$1&&process$1.versions;var v8=versions&&versions.v8;var match,version;if(v8){match=v8.split('.');version=match[0]+match[1];}else if(userAgent){match=userAgent.match(/Edge\/(\d+)/);if(!match||match[1]>=74){match=userAgent.match(/Chrome\/(\d+)/);if(match)version=match[1];}}var engineV8Version=version&&+version;var $$9=_export;var global$3=global$m;var getBuiltIn=getBuiltIn$6;var NativePromise=nativePromiseConstructor;var redefine$a=redefine$9.exports;var redefineAll=redefineAll$2;var setToStringTag=setToStringTag$5;var setSpecies=setSpecies$2;var isObject$2=isObject$c;var aFunction$3=aFunction$7;var anInstance=anInstance$3;var classof$1=classofRaw$1;var inspectSource=inspectSource$3;var iterate=iterate$2.exports;var checkCorrectnessOfIteration=checkCorrectnessOfIteration$1;var speciesConstructor=speciesConstructor$2;var task=task$1.set;var microtask=microtask$1;var promiseResolve=promiseResolve$1;var hostReportErrors=hostReportErrors$1;var newPromiseCapabilityModule=newPromiseCapability$2;var perform=perform$1;var InternalStateModule=internalState;var isForced=isForced_1;var wellKnownSymbol$2=wellKnownSymbol$l;var V8_VERSION=engineV8Version;var SPECIES$1=wellKnownSymbol$2('species');var PROMISE='Promise';var getInternalState=InternalStateModule.get;var setInternalState=InternalStateModule.set;var getInternalPromiseState=InternalStateModule.getterFor(PROMISE);var PromiseConstructor=NativePromise;var TypeError$1=global$3.TypeError;var document$1=global$3.document;var process$4=global$3.process;var $fetch=getBuiltIn('fetch');var newPromiseCapability=newPromiseCapabilityModule.f;var newGenericPromiseCapability=newPromiseCapability;var IS_NODE=classof$1(process$4)=='process';var DISPATCH_EVENT=!!(document$1&&document$1.createEvent&&global$3.dispatchEvent);var UNHANDLED_REJECTION='unhandledrejection';var REJECTION_HANDLED='rejectionhandled';var PENDING=0;var FULFILLED=1;var REJECTED=2;var HANDLED=1;var UNHANDLED=2;var Internal,OwnPromiseCapability,PromiseWrapper,nativeThen;var FORCED$2=isForced(PROMISE,function(){var GLOBAL_CORE_JS_PROMISE=inspectSource(PromiseConstructor)!==String(PromiseConstructor);if(!GLOBAL_CORE_JS_PROMISE){// V8 6.6 (Node 10 and Chrome 66) have a bug with resolving custom thenables
+	newPromiseCapability$2.f=function(C){return new PromiseCapability(C);};var anObject$2$1=anObject$h;var isObject$3=isObject$c;var newPromiseCapability$1=newPromiseCapability$2;var promiseResolve$1=function(C,x){anObject$2$1(C);if(isObject$3(x)&&x.constructor===C)return x;var promiseCapability=newPromiseCapability$1.f(C);var resolve=promiseCapability.resolve;resolve(x);return promiseCapability.promise;};var global$5=global$m;var hostReportErrors$1=function(a,b){var console=global$5.console;if(console&&console.error){arguments.length===1?console.error(a):console.error(a,b);}};var perform$1=function(exec){try{return {error:false,value:exec()};}catch(error){return {error:true,value:error};}};var global$4=global$m;var userAgent=engineUserAgent;var process$1=global$4.process;var versions=process$1&&process$1.versions;var v8=versions&&versions.v8;var match$2,version;if(v8){match$2=v8.split('.');version=match$2[0]+match$2[1];}else if(userAgent){match$2=userAgent.match(/Edge\/(\d+)/);if(!match$2||match$2[1]>=74){match$2=userAgent.match(/Chrome\/(\d+)/);if(match$2)version=match$2[1];}}var engineV8Version=version&&+version;var $$9=_export;var global$3=global$m;var getBuiltIn=getBuiltIn$6;var NativePromise=nativePromiseConstructor;var redefine$a=redefine$9.exports;var redefineAll=redefineAll$2;var setToStringTag=setToStringTag$5;var setSpecies=setSpecies$2;var isObject$2=isObject$c;var aFunction$3=aFunction$7;var anInstance=anInstance$3;var classof$1=classofRaw$1;var inspectSource=inspectSource$3;var iterate=iterate$2.exports;var checkCorrectnessOfIteration=checkCorrectnessOfIteration$1;var speciesConstructor=speciesConstructor$2;var task=task$1.set;var microtask=microtask$1;var promiseResolve=promiseResolve$1;var hostReportErrors=hostReportErrors$1;var newPromiseCapabilityModule=newPromiseCapability$2;var perform=perform$1;var InternalStateModule=internalState;var isForced=isForced_1;var wellKnownSymbol$2=wellKnownSymbol$l;var V8_VERSION=engineV8Version;var SPECIES$1=wellKnownSymbol$2('species');var PROMISE='Promise';var getInternalState=InternalStateModule.get;var setInternalState=InternalStateModule.set;var getInternalPromiseState=InternalStateModule.getterFor(PROMISE);var PromiseConstructor=NativePromise;var TypeError$1=global$3.TypeError;var document$1=global$3.document;var process$4=global$3.process;var $fetch=getBuiltIn('fetch');var newPromiseCapability=newPromiseCapabilityModule.f;var newGenericPromiseCapability=newPromiseCapability;var IS_NODE=classof$1(process$4)=='process';var DISPATCH_EVENT=!!(document$1&&document$1.createEvent&&global$3.dispatchEvent);var UNHANDLED_REJECTION='unhandledrejection';var REJECTION_HANDLED='rejectionhandled';var PENDING=0;var FULFILLED=1;var REJECTED=2;var HANDLED=1;var UNHANDLED=2;var Internal,OwnPromiseCapability,PromiseWrapper,nativeThen;var FORCED$2=isForced(PROMISE,function(){var GLOBAL_CORE_JS_PROMISE=inspectSource(PromiseConstructor)!==String(PromiseConstructor);if(!GLOBAL_CORE_JS_PROMISE){// V8 6.6 (Node 10 and Chrome 66) have a bug with resolving custom thenables
 	// https://bugs.chromium.org/p/chromium/issues/detail?id=830565
 	// We can't detect it synchronously, so just check versions
 	if(V8_VERSION===66)return true;// Unhandled rejections tracking support, NodeJS Promise without it fails @@species test
@@ -135245,6 +135245,36 @@
 	  }
 	}
 
+	/**
+	 * @name addMilliseconds
+	 * @category Millisecond Helpers
+	 * @summary Add the specified number of milliseconds to the given date.
+	 *
+	 * @description
+	 * Add the specified number of milliseconds to the given date.
+	 *
+	 * ### v2.0.0 breaking changes:
+	 *
+	 * - [Changes that are common for the whole library](https://github.com/date-fns/date-fns/blob/master/docs/upgradeGuide.md#Common-Changes).
+	 *
+	 * @param {Date|Number} date - the date to be changed
+	 * @param {Number} amount - the amount of milliseconds to be added. Positive decimals will be rounded using `Math.floor`, decimals less than zero will be rounded using `Math.ceil`.
+	 * @returns {Date} the new date with the milliseconds added
+	 * @throws {TypeError} 2 arguments required
+	 *
+	 * @example
+	 * // Add 750 milliseconds to 10 July 2014 12:45:30.000:
+	 * const result = addMilliseconds(new Date(2014, 6, 10, 12, 45, 30, 0), 750)
+	 * //=> Thu Jul 10 2014 12:45:30.750
+	 */
+
+	function addMilliseconds(dirtyDate, dirtyAmount) {
+	  requiredArgs(2, arguments);
+	  var timestamp = toDate(dirtyDate).getTime();
+	  var amount = toInteger(dirtyAmount);
+	  return new Date(timestamp + amount);
+	}
+
 	/**
 	 * @name startOfWeek
 	 * @category Week Helpers
@@ -135297,6 +135327,23 @@
 	  return date;
 	}
 
+	/**
+	 * Google Chrome as of 67.0.3396.87 introduced timezones with offset that includes seconds.
+	 * They usually appear for dates that denote time before the timezones were introduced
+	 * (e.g. for 'Europe/Prague' timezone the offset is GMT+00:57:44 before 1 October 1891
+	 * and GMT+01:00:00 after that date)
+	 *
+	 * Date#getTimezoneOffset returns the offset in minutes and would return 57 for the example above,
+	 * which would lead to incorrect calculations.
+	 *
+	 * This function returns the timezone offset in milliseconds that takes seconds in account.
+	 */
+	function getTimezoneOffsetInMilliseconds(date) {
+	  var utcDate = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate(), date.getHours(), date.getMinutes(), date.getSeconds(), date.getMilliseconds()));
+	  utcDate.setUTCFullYear(date.getFullYear());
+	  return date.getTime() - utcDate.getTime();
+	}
+
 	/**
 	 * @name startOfDay
 	 * @category Day Helpers
@@ -135327,6 +135374,117 @@
 	  return date;
 	}
 
+	/**
+	 * @name isDate
+	 * @category Common Helpers
+	 * @summary Is the given value a date?
+	 *
+	 * @description
+	 * Returns true if the given value is an instance of Date. The function works for dates transferred across iframes.
+	 *
+	 * ### v2.0.0 breaking changes:
+	 *
+	 * - [Changes that are common for the whole library](https://github.com/date-fns/date-fns/blob/master/docs/upgradeGuide.md#Common-Changes).
+	 *
+	 * @param {*} value - the value to check
+	 * @returns {boolean} true if the given value is a date
+	 * @throws {TypeError} 1 arguments required
+	 *
+	 * @example
+	 * // For a valid date:
+	 * const result = isDate(new Date())
+	 * //=> true
+	 *
+	 * @example
+	 * // For an invalid date:
+	 * const result = isDate(new Date(NaN))
+	 * //=> true
+	 *
+	 * @example
+	 * // For some value:
+	 * const result = isDate('2014-02-31')
+	 * //=> false
+	 *
+	 * @example
+	 * // For an object:
+	 * const result = isDate({})
+	 * //=> false
+	 */
+
+	function isDate(value) {
+	  requiredArgs(1, arguments);
+	  return value instanceof Date || typeof value === 'object' && Object.prototype.toString.call(value) === '[object Date]';
+	}
+
+	/**
+	 * @name isValid
+	 * @category Common Helpers
+	 * @summary Is the given date valid?
+	 *
+	 * @description
+	 * Returns false if argument is Invalid Date and true otherwise.
+	 * Argument is converted to Date using `toDate`. See [toDate]{@link https://date-fns.org/docs/toDate}
+	 * Invalid Date is a Date, whose time value is NaN.
+	 *
+	 * Time value of Date: http://es5.github.io/#x15.9.1.1
+	 *
+	 * ### v2.0.0 breaking changes:
+	 *
+	 * - [Changes that are common for the whole library](https://github.com/date-fns/date-fns/blob/master/docs/upgradeGuide.md#Common-Changes).
+	 *
+	 * - Now `isValid` doesn't throw an exception
+	 *   if the first argument is not an instance of Date.
+	 *   Instead, argument is converted beforehand using `toDate`.
+	 *
+	 *   Examples:
+	 *
+	 *   | `isValid` argument        | Before v2.0.0 | v2.0.0 onward |
+	 *   |---------------------------|---------------|---------------|
+	 *   | `new Date()`              | `true`        | `true`        |
+	 *   | `new Date('2016-01-01')`  | `true`        | `true`        |
+	 *   | `new Date('')`            | `false`       | `false`       |
+	 *   | `new Date(1488370835081)` | `true`        | `true`        |
+	 *   | `new Date(NaN)`           | `false`       | `false`       |
+	 *   | `'2016-01-01'`            | `TypeError`   | `false`       |
+	 *   | `''`                      | `TypeError`   | `false`       |
+	 *   | `1488370835081`           | `TypeError`   | `true`        |
+	 *   | `NaN`                     | `TypeError`   | `false`       |
+	 *
+	 *   We introduce this change to make *date-fns* consistent with ECMAScript behavior
+	 *   that try to coerce arguments to the expected type
+	 *   (which is also the case with other *date-fns* functions).
+	 *
+	 * @param {*} date - the date to check
+	 * @returns {Boolean} the date is valid
+	 * @throws {TypeError} 1 argument required
+	 *
+	 * @example
+	 * // For the valid date:
+	 * const result = isValid(new Date(2014, 1, 31))
+	 * //=> true
+	 *
+	 * @example
+	 * // For the value, convertable into a date:
+	 * const result = isValid(1393804800000)
+	 * //=> true
+	 *
+	 * @example
+	 * // For the invalid date:
+	 * const result = isValid(new Date(''))
+	 * //=> false
+	 */
+
+	function isValid(dirtyDate) {
+	  requiredArgs(1, arguments);
+
+	  if (!isDate(dirtyDate) && typeof dirtyDate !== 'number') {
+	    return false;
+	  }
+
+	  var date = toDate(dirtyDate);
+	  return !isNaN(Number(date));
+	}
+
 	/**
 	 * @name endOfDay
 	 * @category Day Helpers
@@ -135471,6 +135629,2200 @@
 	  return date;
 	}
 
+	var formatDistanceLocale = {
+	  lessThanXSeconds: {
+	    one: 'less than a second',
+	    other: 'less than {{count}} seconds'
+	  },
+	  xSeconds: {
+	    one: '1 second',
+	    other: '{{count}} seconds'
+	  },
+	  halfAMinute: 'half a minute',
+	  lessThanXMinutes: {
+	    one: 'less than a minute',
+	    other: 'less than {{count}} minutes'
+	  },
+	  xMinutes: {
+	    one: '1 minute',
+	    other: '{{count}} minutes'
+	  },
+	  aboutXHours: {
+	    one: 'about 1 hour',
+	    other: 'about {{count}} hours'
+	  },
+	  xHours: {
+	    one: '1 hour',
+	    other: '{{count}} hours'
+	  },
+	  xDays: {
+	    one: '1 day',
+	    other: '{{count}} days'
+	  },
+	  aboutXWeeks: {
+	    one: 'about 1 week',
+	    other: 'about {{count}} weeks'
+	  },
+	  xWeeks: {
+	    one: '1 week',
+	    other: '{{count}} weeks'
+	  },
+	  aboutXMonths: {
+	    one: 'about 1 month',
+	    other: 'about {{count}} months'
+	  },
+	  xMonths: {
+	    one: '1 month',
+	    other: '{{count}} months'
+	  },
+	  aboutXYears: {
+	    one: 'about 1 year',
+	    other: 'about {{count}} years'
+	  },
+	  xYears: {
+	    one: '1 year',
+	    other: '{{count}} years'
+	  },
+	  overXYears: {
+	    one: 'over 1 year',
+	    other: 'over {{count}} years'
+	  },
+	  almostXYears: {
+	    one: 'almost 1 year',
+	    other: 'almost {{count}} years'
+	  }
+	};
+
+	var formatDistance = function (token, count, options) {
+	  var result;
+	  var tokenValue = formatDistanceLocale[token];
+
+	  if (typeof tokenValue === 'string') {
+	    result = tokenValue;
+	  } else if (count === 1) {
+	    result = tokenValue.one;
+	  } else {
+	    result = tokenValue.other.replace('{{count}}', count.toString());
+	  }
+
+	  if (options !== null && options !== void 0 && options.addSuffix) {
+	    if (options.comparison && options.comparison > 0) {
+	      return 'in ' + result;
+	    } else {
+	      return result + ' ago';
+	    }
+	  }
+
+	  return result;
+	};
+
+	var formatDistance$1 = formatDistance;
+
+	function buildFormatLongFn(args) {
+	  return function () {
+	    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+	    // TODO: Remove String()
+	    var width = options.width ? String(options.width) : args.defaultWidth;
+	    var format = args.formats[width] || args.formats[args.defaultWidth];
+	    return format;
+	  };
+	}
+
+	var dateFormats = {
+	  full: 'EEEE, MMMM do, y',
+	  long: 'MMMM do, y',
+	  medium: 'MMM d, y',
+	  short: 'MM/dd/yyyy'
+	};
+	var timeFormats = {
+	  full: 'h:mm:ss a zzzz',
+	  long: 'h:mm:ss a z',
+	  medium: 'h:mm:ss a',
+	  short: 'h:mm a'
+	};
+	var dateTimeFormats = {
+	  full: "{{date}} 'at' {{time}}",
+	  long: "{{date}} 'at' {{time}}",
+	  medium: '{{date}}, {{time}}',
+	  short: '{{date}}, {{time}}'
+	};
+	var formatLong = {
+	  date: buildFormatLongFn({
+	    formats: dateFormats,
+	    defaultWidth: 'full'
+	  }),
+	  time: buildFormatLongFn({
+	    formats: timeFormats,
+	    defaultWidth: 'full'
+	  }),
+	  dateTime: buildFormatLongFn({
+	    formats: dateTimeFormats,
+	    defaultWidth: 'full'
+	  })
+	};
+	var formatLong$1 = formatLong;
+
+	var formatRelativeLocale = {
+	  lastWeek: "'last' eeee 'at' p",
+	  yesterday: "'yesterday at' p",
+	  today: "'today at' p",
+	  tomorrow: "'tomorrow at' p",
+	  nextWeek: "eeee 'at' p",
+	  other: 'P'
+	};
+
+	var formatRelative = function (token, _date, _baseDate, _options) {
+	  return formatRelativeLocale[token];
+	};
+
+	var formatRelative$1 = formatRelative;
+
+	function buildLocalizeFn(args) {
+	  return function (dirtyIndex, dirtyOptions) {
+	    var options = dirtyOptions || {};
+	    var context = options.context ? String(options.context) : 'standalone';
+	    var valuesArray;
+
+	    if (context === 'formatting' && args.formattingValues) {
+	      var defaultWidth = args.defaultFormattingWidth || args.defaultWidth;
+	      var width = options.width ? String(options.width) : defaultWidth;
+	      valuesArray = args.formattingValues[width] || args.formattingValues[defaultWidth];
+	    } else {
+	      var _defaultWidth = args.defaultWidth;
+
+	      var _width = options.width ? String(options.width) : args.defaultWidth;
+
+	      valuesArray = args.values[_width] || args.values[_defaultWidth];
+	    }
+
+	    var index = args.argumentCallback ? args.argumentCallback(dirtyIndex) : dirtyIndex; // @ts-ignore: For some reason TypeScript just don't want to match it, no matter how hard we try. I challange you to try to remove it!
+
+	    return valuesArray[index];
+	  };
+	}
+
+	var eraValues = {
+	  narrow: ['B', 'A'],
+	  abbreviated: ['BC', 'AD'],
+	  wide: ['Before Christ', 'Anno Domini']
+	};
+	var quarterValues = {
+	  narrow: ['1', '2', '3', '4'],
+	  abbreviated: ['Q1', 'Q2', 'Q3', 'Q4'],
+	  wide: ['1st quarter', '2nd quarter', '3rd quarter', '4th quarter']
+	}; // Note: in English, the names of days of the week and months are capitalized.
+	// If you are making a new locale based on this one, check if the same is true for the language you're working on.
+	// Generally, formatted dates should look like they are in the middle of a sentence,
+	// e.g. in Spanish language the weekdays and months should be in the lowercase.
+
+	var monthValues = {
+	  narrow: ['J', 'F', 'M', 'A', 'M', 'J', 'J', 'A', 'S', 'O', 'N', 'D'],
+	  abbreviated: ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'],
+	  wide: ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December']
+	};
+	var dayValues = {
+	  narrow: ['S', 'M', 'T', 'W', 'T', 'F', 'S'],
+	  short: ['Su', 'Mo', 'Tu', 'We', 'Th', 'Fr', 'Sa'],
+	  abbreviated: ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'],
+	  wide: ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']
+	};
+	var dayPeriodValues = {
+	  narrow: {
+	    am: 'a',
+	    pm: 'p',
+	    midnight: 'mi',
+	    noon: 'n',
+	    morning: 'morning',
+	    afternoon: 'afternoon',
+	    evening: 'evening',
+	    night: 'night'
+	  },
+	  abbreviated: {
+	    am: 'AM',
+	    pm: 'PM',
+	    midnight: 'midnight',
+	    noon: 'noon',
+	    morning: 'morning',
+	    afternoon: 'afternoon',
+	    evening: 'evening',
+	    night: 'night'
+	  },
+	  wide: {
+	    am: 'a.m.',
+	    pm: 'p.m.',
+	    midnight: 'midnight',
+	    noon: 'noon',
+	    morning: 'morning',
+	    afternoon: 'afternoon',
+	    evening: 'evening',
+	    night: 'night'
+	  }
+	};
+	var formattingDayPeriodValues = {
+	  narrow: {
+	    am: 'a',
+	    pm: 'p',
+	    midnight: 'mi',
+	    noon: 'n',
+	    morning: 'in the morning',
+	    afternoon: 'in the afternoon',
+	    evening: 'in the evening',
+	    night: 'at night'
+	  },
+	  abbreviated: {
+	    am: 'AM',
+	    pm: 'PM',
+	    midnight: 'midnight',
+	    noon: 'noon',
+	    morning: 'in the morning',
+	    afternoon: 'in the afternoon',
+	    evening: 'in the evening',
+	    night: 'at night'
+	  },
+	  wide: {
+	    am: 'a.m.',
+	    pm: 'p.m.',
+	    midnight: 'midnight',
+	    noon: 'noon',
+	    morning: 'in the morning',
+	    afternoon: 'in the afternoon',
+	    evening: 'in the evening',
+	    night: 'at night'
+	  }
+	};
+
+	var ordinalNumber = function (dirtyNumber, _options) {
+	  var number = Number(dirtyNumber); // If ordinal numbers depend on context, for example,
+	  // if they are different for different grammatical genders,
+	  // use `options.unit`.
+	  //
+	  // `unit` can be 'year', 'quarter', 'month', 'week', 'date', 'dayOfYear',
+	  // 'day', 'hour', 'minute', 'second'.
+
+	  var rem100 = number % 100;
+
+	  if (rem100 > 20 || rem100 < 10) {
+	    switch (rem100 % 10) {
+	      case 1:
+	        return number + 'st';
+
+	      case 2:
+	        return number + 'nd';
+
+	      case 3:
+	        return number + 'rd';
+	    }
+	  }
+
+	  return number + 'th';
+	};
+
+	var localize = {
+	  ordinalNumber: ordinalNumber,
+	  era: buildLocalizeFn({
+	    values: eraValues,
+	    defaultWidth: 'wide'
+	  }),
+	  quarter: buildLocalizeFn({
+	    values: quarterValues,
+	    defaultWidth: 'wide',
+	    argumentCallback: function (quarter) {
+	      return quarter - 1;
+	    }
+	  }),
+	  month: buildLocalizeFn({
+	    values: monthValues,
+	    defaultWidth: 'wide'
+	  }),
+	  day: buildLocalizeFn({
+	    values: dayValues,
+	    defaultWidth: 'wide'
+	  }),
+	  dayPeriod: buildLocalizeFn({
+	    values: dayPeriodValues,
+	    defaultWidth: 'wide',
+	    formattingValues: formattingDayPeriodValues,
+	    defaultFormattingWidth: 'wide'
+	  })
+	};
+	var localize$1 = localize;
+
+	function buildMatchFn(args) {
+	  return function (string) {
+	    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+	    var width = options.width;
+	    var matchPattern = width && args.matchPatterns[width] || args.matchPatterns[args.defaultMatchWidth];
+	    var matchResult = string.match(matchPattern);
+
+	    if (!matchResult) {
+	      return null;
+	    }
+
+	    var matchedString = matchResult[0];
+	    var parsePatterns = width && args.parsePatterns[width] || args.parsePatterns[args.defaultParseWidth];
+	    var key = Array.isArray(parsePatterns) ? findIndex(parsePatterns, function (pattern) {
+	      return pattern.test(matchedString);
+	    }) : findKey(parsePatterns, function (pattern) {
+	      return pattern.test(matchedString);
+	    });
+	    var value;
+	    value = args.valueCallback ? args.valueCallback(key) : key;
+	    value = options.valueCallback ? options.valueCallback(value) : value;
+	    var rest = string.slice(matchedString.length);
+	    return {
+	      value: value,
+	      rest: rest
+	    };
+	  };
+	}
+
+	function findKey(object, predicate) {
+	  for (var key in object) {
+	    if (object.hasOwnProperty(key) && predicate(object[key])) {
+	      return key;
+	    }
+	  }
+
+	  return undefined;
+	}
+
+	function findIndex(array, predicate) {
+	  for (var key = 0; key < array.length; key++) {
+	    if (predicate(array[key])) {
+	      return key;
+	    }
+	  }
+
+	  return undefined;
+	}
+
+	function buildMatchPatternFn(args) {
+	  return function (string) {
+	    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+	    var matchResult = string.match(args.matchPattern);
+	    if (!matchResult) return null;
+	    var matchedString = matchResult[0];
+	    var parseResult = string.match(args.parsePattern);
+	    if (!parseResult) return null;
+	    var value = args.valueCallback ? args.valueCallback(parseResult[0]) : parseResult[0];
+	    value = options.valueCallback ? options.valueCallback(value) : value;
+	    var rest = string.slice(matchedString.length);
+	    return {
+	      value: value,
+	      rest: rest
+	    };
+	  };
+	}
+
+	var matchOrdinalNumberPattern = /^(\d+)(th|st|nd|rd)?/i;
+	var parseOrdinalNumberPattern = /\d+/i;
+	var matchEraPatterns = {
+	  narrow: /^(b|a)/i,
+	  abbreviated: /^(b\.?\s?c\.?|b\.?\s?c\.?\s?e\.?|a\.?\s?d\.?|c\.?\s?e\.?)/i,
+	  wide: /^(before christ|before common era|anno domini|common era)/i
+	};
+	var parseEraPatterns = {
+	  any: [/^b/i, /^(a|c)/i]
+	};
+	var matchQuarterPatterns = {
+	  narrow: /^[1234]/i,
+	  abbreviated: /^q[1234]/i,
+	  wide: /^[1234](th|st|nd|rd)? quarter/i
+	};
+	var parseQuarterPatterns = {
+	  any: [/1/i, /2/i, /3/i, /4/i]
+	};
+	var matchMonthPatterns = {
+	  narrow: /^[jfmasond]/i,
+	  abbreviated: /^(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)/i,
+	  wide: /^(january|february|march|april|may|june|july|august|september|october|november|december)/i
+	};
+	var parseMonthPatterns = {
+	  narrow: [/^j/i, /^f/i, /^m/i, /^a/i, /^m/i, /^j/i, /^j/i, /^a/i, /^s/i, /^o/i, /^n/i, /^d/i],
+	  any: [/^ja/i, /^f/i, /^mar/i, /^ap/i, /^may/i, /^jun/i, /^jul/i, /^au/i, /^s/i, /^o/i, /^n/i, /^d/i]
+	};
+	var matchDayPatterns = {
+	  narrow: /^[smtwf]/i,
+	  short: /^(su|mo|tu|we|th|fr|sa)/i,
+	  abbreviated: /^(sun|mon|tue|wed|thu|fri|sat)/i,
+	  wide: /^(sunday|monday|tuesday|wednesday|thursday|friday|saturday)/i
+	};
+	var parseDayPatterns = {
+	  narrow: [/^s/i, /^m/i, /^t/i, /^w/i, /^t/i, /^f/i, /^s/i],
+	  any: [/^su/i, /^m/i, /^tu/i, /^w/i, /^th/i, /^f/i, /^sa/i]
+	};
+	var matchDayPeriodPatterns = {
+	  narrow: /^(a|p|mi|n|(in the|at) (morning|afternoon|evening|night))/i,
+	  any: /^([ap]\.?\s?m\.?|midnight|noon|(in the|at) (morning|afternoon|evening|night))/i
+	};
+	var parseDayPeriodPatterns = {
+	  any: {
+	    am: /^a/i,
+	    pm: /^p/i,
+	    midnight: /^mi/i,
+	    noon: /^no/i,
+	    morning: /morning/i,
+	    afternoon: /afternoon/i,
+	    evening: /evening/i,
+	    night: /night/i
+	  }
+	};
+	var match = {
+	  ordinalNumber: buildMatchPatternFn({
+	    matchPattern: matchOrdinalNumberPattern,
+	    parsePattern: parseOrdinalNumberPattern,
+	    valueCallback: function (value) {
+	      return parseInt(value, 10);
+	    }
+	  }),
+	  era: buildMatchFn({
+	    matchPatterns: matchEraPatterns,
+	    defaultMatchWidth: 'wide',
+	    parsePatterns: parseEraPatterns,
+	    defaultParseWidth: 'any'
+	  }),
+	  quarter: buildMatchFn({
+	    matchPatterns: matchQuarterPatterns,
+	    defaultMatchWidth: 'wide',
+	    parsePatterns: parseQuarterPatterns,
+	    defaultParseWidth: 'any',
+	    valueCallback: function (index) {
+	      return index + 1;
+	    }
+	  }),
+	  month: buildMatchFn({
+	    matchPatterns: matchMonthPatterns,
+	    defaultMatchWidth: 'wide',
+	    parsePatterns: parseMonthPatterns,
+	    defaultParseWidth: 'any'
+	  }),
+	  day: buildMatchFn({
+	    matchPatterns: matchDayPatterns,
+	    defaultMatchWidth: 'wide',
+	    parsePatterns: parseDayPatterns,
+	    defaultParseWidth: 'any'
+	  }),
+	  dayPeriod: buildMatchFn({
+	    matchPatterns: matchDayPeriodPatterns,
+	    defaultMatchWidth: 'any',
+	    parsePatterns: parseDayPeriodPatterns,
+	    defaultParseWidth: 'any'
+	  })
+	};
+	var match$1 = match;
+
+	/**
+	 * @type {Locale}
+	 * @category Locales
+	 * @summary English locale (United States).
+	 * @language English
+	 * @iso-639-2 eng
+	 * @author Sasha Koss [@kossnocorp]{@link https://github.com/kossnocorp}
+	 * @author Lesha Koss [@leshakoss]{@link https://github.com/leshakoss}
+	 */
+	var locale = {
+	  code: 'en-US',
+	  formatDistance: formatDistance$1,
+	  formatLong: formatLong$1,
+	  formatRelative: formatRelative$1,
+	  localize: localize$1,
+	  match: match$1,
+	  options: {
+	    weekStartsOn: 0
+	    /* Sunday */
+	    ,
+	    firstWeekContainsDate: 1
+	  }
+	};
+	var defaultLocale = locale;
+
+	/**
+	 * @name subMilliseconds
+	 * @category Millisecond Helpers
+	 * @summary Subtract the specified number of milliseconds from the given date.
+	 *
+	 * @description
+	 * Subtract the specified number of milliseconds from the given date.
+	 *
+	 * ### v2.0.0 breaking changes:
+	 *
+	 * - [Changes that are common for the whole library](https://github.com/date-fns/date-fns/blob/master/docs/upgradeGuide.md#Common-Changes).
+	 *
+	 * @param {Date|Number} date - the date to be changed
+	 * @param {Number} amount - the amount of milliseconds to be subtracted. Positive decimals will be rounded using `Math.floor`, decimals less than zero will be rounded using `Math.ceil`.
+	 * @returns {Date} the new date with the milliseconds subtracted
+	 * @throws {TypeError} 2 arguments required
+	 *
+	 * @example
+	 * // Subtract 750 milliseconds from 10 July 2014 12:45:30.000:
+	 * const result = subMilliseconds(new Date(2014, 6, 10, 12, 45, 30, 0), 750)
+	 * //=> Thu Jul 10 2014 12:45:29.250
+	 */
+
+	function subMilliseconds(dirtyDate, dirtyAmount) {
+	  requiredArgs(2, arguments);
+	  var amount = toInteger(dirtyAmount);
+	  return addMilliseconds(dirtyDate, -amount);
+	}
+
+	function addLeadingZeros(number, targetLength) {
+	  var sign = number < 0 ? '-' : '';
+	  var output = Math.abs(number).toString();
+
+	  while (output.length < targetLength) {
+	    output = '0' + output;
+	  }
+
+	  return sign + output;
+	}
+
+	/*
+	 * |     | Unit                           |     | Unit                           |
+	 * |-----|--------------------------------|-----|--------------------------------|
+	 * |  a  | AM, PM                         |  A* |                                |
+	 * |  d  | Day of month                   |  D  |                                |
+	 * |  h  | Hour [1-12]                    |  H  | Hour [0-23]                    |
+	 * |  m  | Minute                         |  M  | Month                          |
+	 * |  s  | Second                         |  S  | Fraction of second             |
+	 * |  y  | Year (abs)                     |  Y  |                                |
+	 *
+	 * Letters marked by * are not implemented but reserved by Unicode standard.
+	 */
+
+	var formatters$2 = {
+	  // Year
+	  y: function (date, token) {
+	    // From http://www.unicode.org/reports/tr35/tr35-31/tr35-dates.html#Date_Format_tokens
+	    // | Year     |     y | yy |   yyy |  yyyy | yyyyy |
+	    // |----------|-------|----|-------|-------|-------|
+	    // | AD 1     |     1 | 01 |   001 |  0001 | 00001 |
+	    // | AD 12    |    12 | 12 |   012 |  0012 | 00012 |
+	    // | AD 123   |   123 | 23 |   123 |  0123 | 00123 |
+	    // | AD 1234  |  1234 | 34 |  1234 |  1234 | 01234 |
+	    // | AD 12345 | 12345 | 45 | 12345 | 12345 | 12345 |
+	    var signedYear = date.getUTCFullYear(); // Returns 1 for 1 BC (which is year 0 in JavaScript)
+
+	    var year = signedYear > 0 ? signedYear : 1 - signedYear;
+	    return addLeadingZeros(token === 'yy' ? year % 100 : year, token.length);
+	  },
+	  // Month
+	  M: function (date, token) {
+	    var month = date.getUTCMonth();
+	    return token === 'M' ? String(month + 1) : addLeadingZeros(month + 1, 2);
+	  },
+	  // Day of the month
+	  d: function (date, token) {
+	    return addLeadingZeros(date.getUTCDate(), token.length);
+	  },
+	  // AM or PM
+	  a: function (date, token) {
+	    var dayPeriodEnumValue = date.getUTCHours() / 12 >= 1 ? 'pm' : 'am';
+
+	    switch (token) {
+	      case 'a':
+	      case 'aa':
+	        return dayPeriodEnumValue.toUpperCase();
+
+	      case 'aaa':
+	        return dayPeriodEnumValue;
+
+	      case 'aaaaa':
+	        return dayPeriodEnumValue[0];
+
+	      case 'aaaa':
+	      default:
+	        return dayPeriodEnumValue === 'am' ? 'a.m.' : 'p.m.';
+	    }
+	  },
+	  // Hour [1-12]
+	  h: function (date, token) {
+	    return addLeadingZeros(date.getUTCHours() % 12 || 12, token.length);
+	  },
+	  // Hour [0-23]
+	  H: function (date, token) {
+	    return addLeadingZeros(date.getUTCHours(), token.length);
+	  },
+	  // Minute
+	  m: function (date, token) {
+	    return addLeadingZeros(date.getUTCMinutes(), token.length);
+	  },
+	  // Second
+	  s: function (date, token) {
+	    return addLeadingZeros(date.getUTCSeconds(), token.length);
+	  },
+	  // Fraction of second
+	  S: function (date, token) {
+	    var numberOfDigits = token.length;
+	    var milliseconds = date.getUTCMilliseconds();
+	    var fractionalSeconds = Math.floor(milliseconds * Math.pow(10, numberOfDigits - 3));
+	    return addLeadingZeros(fractionalSeconds, token.length);
+	  }
+	};
+	var formatters$3 = formatters$2;
+
+	var MILLISECONDS_IN_DAY = 86400000; // This function will be a part of public API when UTC function will be implemented.
+	// See issue: https://github.com/date-fns/date-fns/issues/376
+
+	function getUTCDayOfYear(dirtyDate) {
+	  requiredArgs(1, arguments);
+	  var date = toDate(dirtyDate);
+	  var timestamp = date.getTime();
+	  date.setUTCMonth(0, 1);
+	  date.setUTCHours(0, 0, 0, 0);
+	  var startOfYearTimestamp = date.getTime();
+	  var difference = timestamp - startOfYearTimestamp;
+	  return Math.floor(difference / MILLISECONDS_IN_DAY) + 1;
+	}
+
+	// See issue: https://github.com/date-fns/date-fns/issues/376
+
+	function startOfUTCISOWeek(dirtyDate) {
+	  requiredArgs(1, arguments);
+	  var weekStartsOn = 1;
+	  var date = toDate(dirtyDate);
+	  var day = date.getUTCDay();
+	  var diff = (day < weekStartsOn ? 7 : 0) + day - weekStartsOn;
+	  date.setUTCDate(date.getUTCDate() - diff);
+	  date.setUTCHours(0, 0, 0, 0);
+	  return date;
+	}
+
+	// See issue: https://github.com/date-fns/date-fns/issues/376
+
+	function getUTCISOWeekYear(dirtyDate) {
+	  requiredArgs(1, arguments);
+	  var date = toDate(dirtyDate);
+	  var year = date.getUTCFullYear();
+	  var fourthOfJanuaryOfNextYear = new Date(0);
+	  fourthOfJanuaryOfNextYear.setUTCFullYear(year + 1, 0, 4);
+	  fourthOfJanuaryOfNextYear.setUTCHours(0, 0, 0, 0);
+	  var startOfNextYear = startOfUTCISOWeek(fourthOfJanuaryOfNextYear);
+	  var fourthOfJanuaryOfThisYear = new Date(0);
+	  fourthOfJanuaryOfThisYear.setUTCFullYear(year, 0, 4);
+	  fourthOfJanuaryOfThisYear.setUTCHours(0, 0, 0, 0);
+	  var startOfThisYear = startOfUTCISOWeek(fourthOfJanuaryOfThisYear);
+
+	  if (date.getTime() >= startOfNextYear.getTime()) {
+	    return year + 1;
+	  } else if (date.getTime() >= startOfThisYear.getTime()) {
+	    return year;
+	  } else {
+	    return year - 1;
+	  }
+	}
+
+	// See issue: https://github.com/date-fns/date-fns/issues/376
+
+	function startOfUTCISOWeekYear(dirtyDate) {
+	  requiredArgs(1, arguments);
+	  var year = getUTCISOWeekYear(dirtyDate);
+	  var fourthOfJanuary = new Date(0);
+	  fourthOfJanuary.setUTCFullYear(year, 0, 4);
+	  fourthOfJanuary.setUTCHours(0, 0, 0, 0);
+	  var date = startOfUTCISOWeek(fourthOfJanuary);
+	  return date;
+	}
+
+	var MILLISECONDS_IN_WEEK$1 = 604800000; // This function will be a part of public API when UTC function will be implemented.
+	// See issue: https://github.com/date-fns/date-fns/issues/376
+
+	function getUTCISOWeek(dirtyDate) {
+	  requiredArgs(1, arguments);
+	  var date = toDate(dirtyDate);
+	  var diff = startOfUTCISOWeek(date).getTime() - startOfUTCISOWeekYear(date).getTime(); // Round the number of days to the nearest integer
+	  // because the number of milliseconds in a week is not constant
+	  // (e.g. it's different in the week of the daylight saving time clock shift)
+
+	  return Math.round(diff / MILLISECONDS_IN_WEEK$1) + 1;
+	}
+
+	// See issue: https://github.com/date-fns/date-fns/issues/376
+
+	function startOfUTCWeek(dirtyDate, dirtyOptions) {
+	  requiredArgs(1, arguments);
+	  var options = dirtyOptions || {};
+	  var locale = options.locale;
+	  var localeWeekStartsOn = locale && locale.options && locale.options.weekStartsOn;
+	  var defaultWeekStartsOn = localeWeekStartsOn == null ? 0 : toInteger(localeWeekStartsOn);
+	  var weekStartsOn = options.weekStartsOn == null ? defaultWeekStartsOn : toInteger(options.weekStartsOn); // Test if weekStartsOn is between 0 and 6 _and_ is not NaN
+
+	  if (!(weekStartsOn >= 0 && weekStartsOn <= 6)) {
+	    throw new RangeError('weekStartsOn must be between 0 and 6 inclusively');
+	  }
+
+	  var date = toDate(dirtyDate);
+	  var day = date.getUTCDay();
+	  var diff = (day < weekStartsOn ? 7 : 0) + day - weekStartsOn;
+	  date.setUTCDate(date.getUTCDate() - diff);
+	  date.setUTCHours(0, 0, 0, 0);
+	  return date;
+	}
+
+	// See issue: https://github.com/date-fns/date-fns/issues/376
+
+	function getUTCWeekYear(dirtyDate, dirtyOptions) {
+	  requiredArgs(1, arguments);
+	  var date = toDate(dirtyDate, dirtyOptions);
+	  var year = date.getUTCFullYear();
+	  var options = dirtyOptions || {};
+	  var locale = options.locale;
+	  var localeFirstWeekContainsDate = locale && locale.options && locale.options.firstWeekContainsDate;
+	  var defaultFirstWeekContainsDate = localeFirstWeekContainsDate == null ? 1 : toInteger(localeFirstWeekContainsDate);
+	  var firstWeekContainsDate = options.firstWeekContainsDate == null ? defaultFirstWeekContainsDate : toInteger(options.firstWeekContainsDate); // Test if weekStartsOn is between 1 and 7 _and_ is not NaN
+
+	  if (!(firstWeekContainsDate >= 1 && firstWeekContainsDate <= 7)) {
+	    throw new RangeError('firstWeekContainsDate must be between 1 and 7 inclusively');
+	  }
+
+	  var firstWeekOfNextYear = new Date(0);
+	  firstWeekOfNextYear.setUTCFullYear(year + 1, 0, firstWeekContainsDate);
+	  firstWeekOfNextYear.setUTCHours(0, 0, 0, 0);
+	  var startOfNextYear = startOfUTCWeek(firstWeekOfNextYear, dirtyOptions);
+	  var firstWeekOfThisYear = new Date(0);
+	  firstWeekOfThisYear.setUTCFullYear(year, 0, firstWeekContainsDate);
+	  firstWeekOfThisYear.setUTCHours(0, 0, 0, 0);
+	  var startOfThisYear = startOfUTCWeek(firstWeekOfThisYear, dirtyOptions);
+
+	  if (date.getTime() >= startOfNextYear.getTime()) {
+	    return year + 1;
+	  } else if (date.getTime() >= startOfThisYear.getTime()) {
+	    return year;
+	  } else {
+	    return year - 1;
+	  }
+	}
+
+	// See issue: https://github.com/date-fns/date-fns/issues/376
+
+	function startOfUTCWeekYear(dirtyDate, dirtyOptions) {
+	  requiredArgs(1, arguments);
+	  var options = dirtyOptions || {};
+	  var locale = options.locale;
+	  var localeFirstWeekContainsDate = locale && locale.options && locale.options.firstWeekContainsDate;
+	  var defaultFirstWeekContainsDate = localeFirstWeekContainsDate == null ? 1 : toInteger(localeFirstWeekContainsDate);
+	  var firstWeekContainsDate = options.firstWeekContainsDate == null ? defaultFirstWeekContainsDate : toInteger(options.firstWeekContainsDate);
+	  var year = getUTCWeekYear(dirtyDate, dirtyOptions);
+	  var firstWeek = new Date(0);
+	  firstWeek.setUTCFullYear(year, 0, firstWeekContainsDate);
+	  firstWeek.setUTCHours(0, 0, 0, 0);
+	  var date = startOfUTCWeek(firstWeek, dirtyOptions);
+	  return date;
+	}
+
+	var MILLISECONDS_IN_WEEK = 604800000; // This function will be a part of public API when UTC function will be implemented.
+	// See issue: https://github.com/date-fns/date-fns/issues/376
+
+	function getUTCWeek(dirtyDate, options) {
+	  requiredArgs(1, arguments);
+	  var date = toDate(dirtyDate);
+	  var diff = startOfUTCWeek(date, options).getTime() - startOfUTCWeekYear(date, options).getTime(); // Round the number of days to the nearest integer
+	  // because the number of milliseconds in a week is not constant
+	  // (e.g. it's different in the week of the daylight saving time clock shift)
+
+	  return Math.round(diff / MILLISECONDS_IN_WEEK) + 1;
+	}
+
+	var dayPeriodEnum = {
+	  am: 'am',
+	  pm: 'pm',
+	  midnight: 'midnight',
+	  noon: 'noon',
+	  morning: 'morning',
+	  afternoon: 'afternoon',
+	  evening: 'evening',
+	  night: 'night'
+	};
+	/*
+	 * |     | Unit                           |     | Unit                           |
+	 * |-----|--------------------------------|-----|--------------------------------|
+	 * |  a  | AM, PM                         |  A* | Milliseconds in day            |
+	 * |  b  | AM, PM, noon, midnight         |  B  | Flexible day period            |
+	 * |  c  | Stand-alone local day of week  |  C* | Localized hour w/ day period   |
+	 * |  d  | Day of month                   |  D  | Day of year                    |
+	 * |  e  | Local day of week              |  E  | Day of week                    |
+	 * |  f  |                                |  F* | Day of week in month           |
+	 * |  g* | Modified Julian day            |  G  | Era                            |
+	 * |  h  | Hour [1-12]                    |  H  | Hour [0-23]                    |
+	 * |  i! | ISO day of week                |  I! | ISO week of year               |
+	 * |  j* | Localized hour w/ day period   |  J* | Localized hour w/o day period  |
+	 * |  k  | Hour [1-24]                    |  K  | Hour [0-11]                    |
+	 * |  l* | (deprecated)                   |  L  | Stand-alone month              |
+	 * |  m  | Minute                         |  M  | Month                          |
+	 * |  n  |                                |  N  |                                |
+	 * |  o! | Ordinal number modifier        |  O  | Timezone (GMT)                 |
+	 * |  p! | Long localized time            |  P! | Long localized date            |
+	 * |  q  | Stand-alone quarter            |  Q  | Quarter                        |
+	 * |  r* | Related Gregorian year         |  R! | ISO week-numbering year        |
+	 * |  s  | Second                         |  S  | Fraction of second             |
+	 * |  t! | Seconds timestamp              |  T! | Milliseconds timestamp         |
+	 * |  u  | Extended year                  |  U* | Cyclic year                    |
+	 * |  v* | Timezone (generic non-locat.)  |  V* | Timezone (location)            |
+	 * |  w  | Local week of year             |  W* | Week of month                  |
+	 * |  x  | Timezone (ISO-8601 w/o Z)      |  X  | Timezone (ISO-8601)            |
+	 * |  y  | Year (abs)                     |  Y  | Local week-numbering year      |
+	 * |  z  | Timezone (specific non-locat.) |  Z* | Timezone (aliases)             |
+	 *
+	 * Letters marked by * are not implemented but reserved by Unicode standard.
+	 *
+	 * Letters marked by ! are non-standard, but implemented by date-fns:
+	 * - `o` modifies the previous token to turn it into an ordinal (see `format` docs)
+	 * - `i` is ISO day of week. For `i` and `ii` is returns numeric ISO week days,
+	 *   i.e. 7 for Sunday, 1 for Monday, etc.
+	 * - `I` is ISO week of year, as opposed to `w` which is local week of year.
+	 * - `R` is ISO week-numbering year, as opposed to `Y` which is local week-numbering year.
+	 *   `R` is supposed to be used in conjunction with `I` and `i`
+	 *   for universal ISO week-numbering date, whereas
+	 *   `Y` is supposed to be used in conjunction with `w` and `e`
+	 *   for week-numbering date specific to the locale.
+	 * - `P` is long localized date format
+	 * - `p` is long localized time format
+	 */
+
+	var formatters = {
+	  // Era
+	  G: function (date, token, localize) {
+	    var era = date.getUTCFullYear() > 0 ? 1 : 0;
+
+	    switch (token) {
+	      // AD, BC
+	      case 'G':
+	      case 'GG':
+	      case 'GGG':
+	        return localize.era(era, {
+	          width: 'abbreviated'
+	        });
+	      // A, B
+
+	      case 'GGGGG':
+	        return localize.era(era, {
+	          width: 'narrow'
+	        });
+	      // Anno Domini, Before Christ
+
+	      case 'GGGG':
+	      default:
+	        return localize.era(era, {
+	          width: 'wide'
+	        });
+	    }
+	  },
+	  // Year
+	  y: function (date, token, localize) {
+	    // Ordinal number
+	    if (token === 'yo') {
+	      var signedYear = date.getUTCFullYear(); // Returns 1 for 1 BC (which is year 0 in JavaScript)
+
+	      var year = signedYear > 0 ? signedYear : 1 - signedYear;
+	      return localize.ordinalNumber(year, {
+	        unit: 'year'
+	      });
+	    }
+
+	    return formatters$3.y(date, token);
+	  },
+	  // Local week-numbering year
+	  Y: function (date, token, localize, options) {
+	    var signedWeekYear = getUTCWeekYear(date, options); // Returns 1 for 1 BC (which is year 0 in JavaScript)
+
+	    var weekYear = signedWeekYear > 0 ? signedWeekYear : 1 - signedWeekYear; // Two digit year
+
+	    if (token === 'YY') {
+	      var twoDigitYear = weekYear % 100;
+	      return addLeadingZeros(twoDigitYear, 2);
+	    } // Ordinal number
+
+
+	    if (token === 'Yo') {
+	      return localize.ordinalNumber(weekYear, {
+	        unit: 'year'
+	      });
+	    } // Padding
+
+
+	    return addLeadingZeros(weekYear, token.length);
+	  },
+	  // ISO week-numbering year
+	  R: function (date, token) {
+	    var isoWeekYear = getUTCISOWeekYear(date); // Padding
+
+	    return addLeadingZeros(isoWeekYear, token.length);
+	  },
+	  // Extended year. This is a single number designating the year of this calendar system.
+	  // The main difference between `y` and `u` localizers are B.C. years:
+	  // | Year | `y` | `u` |
+	  // |------|-----|-----|
+	  // | AC 1 |   1 |   1 |
+	  // | BC 1 |   1 |   0 |
+	  // | BC 2 |   2 |  -1 |
+	  // Also `yy` always returns the last two digits of a year,
+	  // while `uu` pads single digit years to 2 characters and returns other years unchanged.
+	  u: function (date, token) {
+	    var year = date.getUTCFullYear();
+	    return addLeadingZeros(year, token.length);
+	  },
+	  // Quarter
+	  Q: function (date, token, localize) {
+	    var quarter = Math.ceil((date.getUTCMonth() + 1) / 3);
+
+	    switch (token) {
+	      // 1, 2, 3, 4
+	      case 'Q':
+	        return String(quarter);
+	      // 01, 02, 03, 04
+
+	      case 'QQ':
+	        return addLeadingZeros(quarter, 2);
+	      // 1st, 2nd, 3rd, 4th
+
+	      case 'Qo':
+	        return localize.ordinalNumber(quarter, {
+	          unit: 'quarter'
+	        });
+	      // Q1, Q2, Q3, Q4
+
+	      case 'QQQ':
+	        return localize.quarter(quarter, {
+	          width: 'abbreviated',
+	          context: 'formatting'
+	        });
+	      // 1, 2, 3, 4 (narrow quarter; could be not numerical)
+
+	      case 'QQQQQ':
+	        return localize.quarter(quarter, {
+	          width: 'narrow',
+	          context: 'formatting'
+	        });
+	      // 1st quarter, 2nd quarter, ...
+
+	      case 'QQQQ':
+	      default:
+	        return localize.quarter(quarter, {
+	          width: 'wide',
+	          context: 'formatting'
+	        });
+	    }
+	  },
+	  // Stand-alone quarter
+	  q: function (date, token, localize) {
+	    var quarter = Math.ceil((date.getUTCMonth() + 1) / 3);
+
+	    switch (token) {
+	      // 1, 2, 3, 4
+	      case 'q':
+	        return String(quarter);
+	      // 01, 02, 03, 04
+
+	      case 'qq':
+	        return addLeadingZeros(quarter, 2);
+	      // 1st, 2nd, 3rd, 4th
+
+	      case 'qo':
+	        return localize.ordinalNumber(quarter, {
+	          unit: 'quarter'
+	        });
+	      // Q1, Q2, Q3, Q4
+
+	      case 'qqq':
+	        return localize.quarter(quarter, {
+	          width: 'abbreviated',
+	          context: 'standalone'
+	        });
+	      // 1, 2, 3, 4 (narrow quarter; could be not numerical)
+
+	      case 'qqqqq':
+	        return localize.quarter(quarter, {
+	          width: 'narrow',
+	          context: 'standalone'
+	        });
+	      // 1st quarter, 2nd quarter, ...
+
+	      case 'qqqq':
+	      default:
+	        return localize.quarter(quarter, {
+	          width: 'wide',
+	          context: 'standalone'
+	        });
+	    }
+	  },
+	  // Month
+	  M: function (date, token, localize) {
+	    var month = date.getUTCMonth();
+
+	    switch (token) {
+	      case 'M':
+	      case 'MM':
+	        return formatters$3.M(date, token);
+	      // 1st, 2nd, ..., 12th
+
+	      case 'Mo':
+	        return localize.ordinalNumber(month + 1, {
+	          unit: 'month'
+	        });
+	      // Jan, Feb, ..., Dec
+
+	      case 'MMM':
+	        return localize.month(month, {
+	          width: 'abbreviated',
+	          context: 'formatting'
+	        });
+	      // J, F, ..., D
+
+	      case 'MMMMM':
+	        return localize.month(month, {
+	          width: 'narrow',
+	          context: 'formatting'
+	        });
+	      // January, February, ..., December
+
+	      case 'MMMM':
+	      default:
+	        return localize.month(month, {
+	          width: 'wide',
+	          context: 'formatting'
+	        });
+	    }
+	  },
+	  // Stand-alone month
+	  L: function (date, token, localize) {
+	    var month = date.getUTCMonth();
+
+	    switch (token) {
+	      // 1, 2, ..., 12
+	      case 'L':
+	        return String(month + 1);
+	      // 01, 02, ..., 12
+
+	      case 'LL':
+	        return addLeadingZeros(month + 1, 2);
+	      // 1st, 2nd, ..., 12th
+
+	      case 'Lo':
+	        return localize.ordinalNumber(month + 1, {
+	          unit: 'month'
+	        });
+	      // Jan, Feb, ..., Dec
+
+	      case 'LLL':
+	        return localize.month(month, {
+	          width: 'abbreviated',
+	          context: 'standalone'
+	        });
+	      // J, F, ..., D
+
+	      case 'LLLLL':
+	        return localize.month(month, {
+	          width: 'narrow',
+	          context: 'standalone'
+	        });
+	      // January, February, ..., December
+
+	      case 'LLLL':
+	      default:
+	        return localize.month(month, {
+	          width: 'wide',
+	          context: 'standalone'
+	        });
+	    }
+	  },
+	  // Local week of year
+	  w: function (date, token, localize, options) {
+	    var week = getUTCWeek(date, options);
+
+	    if (token === 'wo') {
+	      return localize.ordinalNumber(week, {
+	        unit: 'week'
+	      });
+	    }
+
+	    return addLeadingZeros(week, token.length);
+	  },
+	  // ISO week of year
+	  I: function (date, token, localize) {
+	    var isoWeek = getUTCISOWeek(date);
+
+	    if (token === 'Io') {
+	      return localize.ordinalNumber(isoWeek, {
+	        unit: 'week'
+	      });
+	    }
+
+	    return addLeadingZeros(isoWeek, token.length);
+	  },
+	  // Day of the month
+	  d: function (date, token, localize) {
+	    if (token === 'do') {
+	      return localize.ordinalNumber(date.getUTCDate(), {
+	        unit: 'date'
+	      });
+	    }
+
+	    return formatters$3.d(date, token);
+	  },
+	  // Day of year
+	  D: function (date, token, localize) {
+	    var dayOfYear = getUTCDayOfYear(date);
+
+	    if (token === 'Do') {
+	      return localize.ordinalNumber(dayOfYear, {
+	        unit: 'dayOfYear'
+	      });
+	    }
+
+	    return addLeadingZeros(dayOfYear, token.length);
+	  },
+	  // Day of week
+	  E: function (date, token, localize) {
+	    var dayOfWeek = date.getUTCDay();
+
+	    switch (token) {
+	      // Tue
+	      case 'E':
+	      case 'EE':
+	      case 'EEE':
+	        return localize.day(dayOfWeek, {
+	          width: 'abbreviated',
+	          context: 'formatting'
+	        });
+	      // T
+
+	      case 'EEEEE':
+	        return localize.day(dayOfWeek, {
+	          width: 'narrow',
+	          context: 'formatting'
+	        });
+	      // Tu
+
+	      case 'EEEEEE':
+	        return localize.day(dayOfWeek, {
+	          width: 'short',
+	          context: 'formatting'
+	        });
+	      // Tuesday
+
+	      case 'EEEE':
+	      default:
+	        return localize.day(dayOfWeek, {
+	          width: 'wide',
+	          context: 'formatting'
+	        });
+	    }
+	  },
+	  // Local day of week
+	  e: function (date, token, localize, options) {
+	    var dayOfWeek = date.getUTCDay();
+	    var localDayOfWeek = (dayOfWeek - options.weekStartsOn + 8) % 7 || 7;
+
+	    switch (token) {
+	      // Numerical value (Nth day of week with current locale or weekStartsOn)
+	      case 'e':
+	        return String(localDayOfWeek);
+	      // Padded numerical value
+
+	      case 'ee':
+	        return addLeadingZeros(localDayOfWeek, 2);
+	      // 1st, 2nd, ..., 7th
+
+	      case 'eo':
+	        return localize.ordinalNumber(localDayOfWeek, {
+	          unit: 'day'
+	        });
+
+	      case 'eee':
+	        return localize.day(dayOfWeek, {
+	          width: 'abbreviated',
+	          context: 'formatting'
+	        });
+	      // T
+
+	      case 'eeeee':
+	        return localize.day(dayOfWeek, {
+	          width: 'narrow',
+	          context: 'formatting'
+	        });
+	      // Tu
+
+	      case 'eeeeee':
+	        return localize.day(dayOfWeek, {
+	          width: 'short',
+	          context: 'formatting'
+	        });
+	      // Tuesday
+
+	      case 'eeee':
+	      default:
+	        return localize.day(dayOfWeek, {
+	          width: 'wide',
+	          context: 'formatting'
+	        });
+	    }
+	  },
+	  // Stand-alone local day of week
+	  c: function (date, token, localize, options) {
+	    var dayOfWeek = date.getUTCDay();
+	    var localDayOfWeek = (dayOfWeek - options.weekStartsOn + 8) % 7 || 7;
+
+	    switch (token) {
+	      // Numerical value (same as in `e`)
+	      case 'c':
+	        return String(localDayOfWeek);
+	      // Padded numerical value
+
+	      case 'cc':
+	        return addLeadingZeros(localDayOfWeek, token.length);
+	      // 1st, 2nd, ..., 7th
+
+	      case 'co':
+	        return localize.ordinalNumber(localDayOfWeek, {
+	          unit: 'day'
+	        });
+
+	      case 'ccc':
+	        return localize.day(dayOfWeek, {
+	          width: 'abbreviated',
+	          context: 'standalone'
+	        });
+	      // T
+
+	      case 'ccccc':
+	        return localize.day(dayOfWeek, {
+	          width: 'narrow',
+	          context: 'standalone'
+	        });
+	      // Tu
+
+	      case 'cccccc':
+	        return localize.day(dayOfWeek, {
+	          width: 'short',
+	          context: 'standalone'
+	        });
+	      // Tuesday
+
+	      case 'cccc':
+	      default:
+	        return localize.day(dayOfWeek, {
+	          width: 'wide',
+	          context: 'standalone'
+	        });
+	    }
+	  },
+	  // ISO day of week
+	  i: function (date, token, localize) {
+	    var dayOfWeek = date.getUTCDay();
+	    var isoDayOfWeek = dayOfWeek === 0 ? 7 : dayOfWeek;
+
+	    switch (token) {
+	      // 2
+	      case 'i':
+	        return String(isoDayOfWeek);
+	      // 02
+
+	      case 'ii':
+	        return addLeadingZeros(isoDayOfWeek, token.length);
+	      // 2nd
+
+	      case 'io':
+	        return localize.ordinalNumber(isoDayOfWeek, {
+	          unit: 'day'
+	        });
+	      // Tue
+
+	      case 'iii':
+	        return localize.day(dayOfWeek, {
+	          width: 'abbreviated',
+	          context: 'formatting'
+	        });
+	      // T
+
+	      case 'iiiii':
+	        return localize.day(dayOfWeek, {
+	          width: 'narrow',
+	          context: 'formatting'
+	        });
+	      // Tu
+
+	      case 'iiiiii':
+	        return localize.day(dayOfWeek, {
+	          width: 'short',
+	          context: 'formatting'
+	        });
+	      // Tuesday
+
+	      case 'iiii':
+	      default:
+	        return localize.day(dayOfWeek, {
+	          width: 'wide',
+	          context: 'formatting'
+	        });
+	    }
+	  },
+	  // AM or PM
+	  a: function (date, token, localize) {
+	    var hours = date.getUTCHours();
+	    var dayPeriodEnumValue = hours / 12 >= 1 ? 'pm' : 'am';
+
+	    switch (token) {
+	      case 'a':
+	      case 'aa':
+	        return localize.dayPeriod(dayPeriodEnumValue, {
+	          width: 'abbreviated',
+	          context: 'formatting'
+	        });
+
+	      case 'aaa':
+	        return localize.dayPeriod(dayPeriodEnumValue, {
+	          width: 'abbreviated',
+	          context: 'formatting'
+	        }).toLowerCase();
+
+	      case 'aaaaa':
+	        return localize.dayPeriod(dayPeriodEnumValue, {
+	          width: 'narrow',
+	          context: 'formatting'
+	        });
+
+	      case 'aaaa':
+	      default:
+	        return localize.dayPeriod(dayPeriodEnumValue, {
+	          width: 'wide',
+	          context: 'formatting'
+	        });
+	    }
+	  },
+	  // AM, PM, midnight, noon
+	  b: function (date, token, localize) {
+	    var hours = date.getUTCHours();
+	    var dayPeriodEnumValue;
+
+	    if (hours === 12) {
+	      dayPeriodEnumValue = dayPeriodEnum.noon;
+	    } else if (hours === 0) {
+	      dayPeriodEnumValue = dayPeriodEnum.midnight;
+	    } else {
+	      dayPeriodEnumValue = hours / 12 >= 1 ? 'pm' : 'am';
+	    }
+
+	    switch (token) {
+	      case 'b':
+	      case 'bb':
+	        return localize.dayPeriod(dayPeriodEnumValue, {
+	          width: 'abbreviated',
+	          context: 'formatting'
+	        });
+
+	      case 'bbb':
+	        return localize.dayPeriod(dayPeriodEnumValue, {
+	          width: 'abbreviated',
+	          context: 'formatting'
+	        }).toLowerCase();
+
+	      case 'bbbbb':
+	        return localize.dayPeriod(dayPeriodEnumValue, {
+	          width: 'narrow',
+	          context: 'formatting'
+	        });
+
+	      case 'bbbb':
+	      default:
+	        return localize.dayPeriod(dayPeriodEnumValue, {
+	          width: 'wide',
+	          context: 'formatting'
+	        });
+	    }
+	  },
+	  // in the morning, in the afternoon, in the evening, at night
+	  B: function (date, token, localize) {
+	    var hours = date.getUTCHours();
+	    var dayPeriodEnumValue;
+
+	    if (hours >= 17) {
+	      dayPeriodEnumValue = dayPeriodEnum.evening;
+	    } else if (hours >= 12) {
+	      dayPeriodEnumValue = dayPeriodEnum.afternoon;
+	    } else if (hours >= 4) {
+	      dayPeriodEnumValue = dayPeriodEnum.morning;
+	    } else {
+	      dayPeriodEnumValue = dayPeriodEnum.night;
+	    }
+
+	    switch (token) {
+	      case 'B':
+	      case 'BB':
+	      case 'BBB':
+	        return localize.dayPeriod(dayPeriodEnumValue, {
+	          width: 'abbreviated',
+	          context: 'formatting'
+	        });
+
+	      case 'BBBBB':
+	        return localize.dayPeriod(dayPeriodEnumValue, {
+	          width: 'narrow',
+	          context: 'formatting'
+	        });
+
+	      case 'BBBB':
+	      default:
+	        return localize.dayPeriod(dayPeriodEnumValue, {
+	          width: 'wide',
+	          context: 'formatting'
+	        });
+	    }
+	  },
+	  // Hour [1-12]
+	  h: function (date, token, localize) {
+	    if (token === 'ho') {
+	      var hours = date.getUTCHours() % 12;
+	      if (hours === 0) hours = 12;
+	      return localize.ordinalNumber(hours, {
+	        unit: 'hour'
+	      });
+	    }
+
+	    return formatters$3.h(date, token);
+	  },
+	  // Hour [0-23]
+	  H: function (date, token, localize) {
+	    if (token === 'Ho') {
+	      return localize.ordinalNumber(date.getUTCHours(), {
+	        unit: 'hour'
+	      });
+	    }
+
+	    return formatters$3.H(date, token);
+	  },
+	  // Hour [0-11]
+	  K: function (date, token, localize) {
+	    var hours = date.getUTCHours() % 12;
+
+	    if (token === 'Ko') {
+	      return localize.ordinalNumber(hours, {
+	        unit: 'hour'
+	      });
+	    }
+
+	    return addLeadingZeros(hours, token.length);
+	  },
+	  // Hour [1-24]
+	  k: function (date, token, localize) {
+	    var hours = date.getUTCHours();
+	    if (hours === 0) hours = 24;
+
+	    if (token === 'ko') {
+	      return localize.ordinalNumber(hours, {
+	        unit: 'hour'
+	      });
+	    }
+
+	    return addLeadingZeros(hours, token.length);
+	  },
+	  // Minute
+	  m: function (date, token, localize) {
+	    if (token === 'mo') {
+	      return localize.ordinalNumber(date.getUTCMinutes(), {
+	        unit: 'minute'
+	      });
+	    }
+
+	    return formatters$3.m(date, token);
+	  },
+	  // Second
+	  s: function (date, token, localize) {
+	    if (token === 'so') {
+	      return localize.ordinalNumber(date.getUTCSeconds(), {
+	        unit: 'second'
+	      });
+	    }
+
+	    return formatters$3.s(date, token);
+	  },
+	  // Fraction of second
+	  S: function (date, token) {
+	    return formatters$3.S(date, token);
+	  },
+	  // Timezone (ISO-8601. If offset is 0, output is always `'Z'`)
+	  X: function (date, token, _localize, options) {
+	    var originalDate = options._originalDate || date;
+	    var timezoneOffset = originalDate.getTimezoneOffset();
+
+	    if (timezoneOffset === 0) {
+	      return 'Z';
+	    }
+
+	    switch (token) {
+	      // Hours and optional minutes
+	      case 'X':
+	        return formatTimezoneWithOptionalMinutes(timezoneOffset);
+	      // Hours, minutes and optional seconds without `:` delimiter
+	      // Note: neither ISO-8601 nor JavaScript supports seconds in timezone offsets
+	      // so this token always has the same output as `XX`
+
+	      case 'XXXX':
+	      case 'XX':
+	        // Hours and minutes without `:` delimiter
+	        return formatTimezone(timezoneOffset);
+	      // Hours, minutes and optional seconds with `:` delimiter
+	      // Note: neither ISO-8601 nor JavaScript supports seconds in timezone offsets
+	      // so this token always has the same output as `XXX`
+
+	      case 'XXXXX':
+	      case 'XXX': // Hours and minutes with `:` delimiter
+
+	      default:
+	        return formatTimezone(timezoneOffset, ':');
+	    }
+	  },
+	  // Timezone (ISO-8601. If offset is 0, output is `'+00:00'` or equivalent)
+	  x: function (date, token, _localize, options) {
+	    var originalDate = options._originalDate || date;
+	    var timezoneOffset = originalDate.getTimezoneOffset();
+
+	    switch (token) {
+	      // Hours and optional minutes
+	      case 'x':
+	        return formatTimezoneWithOptionalMinutes(timezoneOffset);
+	      // Hours, minutes and optional seconds without `:` delimiter
+	      // Note: neither ISO-8601 nor JavaScript supports seconds in timezone offsets
+	      // so this token always has the same output as `xx`
+
+	      case 'xxxx':
+	      case 'xx':
+	        // Hours and minutes without `:` delimiter
+	        return formatTimezone(timezoneOffset);
+	      // Hours, minutes and optional seconds with `:` delimiter
+	      // Note: neither ISO-8601 nor JavaScript supports seconds in timezone offsets
+	      // so this token always has the same output as `xxx`
+
+	      case 'xxxxx':
+	      case 'xxx': // Hours and minutes with `:` delimiter
+
+	      default:
+	        return formatTimezone(timezoneOffset, ':');
+	    }
+	  },
+	  // Timezone (GMT)
+	  O: function (date, token, _localize, options) {
+	    var originalDate = options._originalDate || date;
+	    var timezoneOffset = originalDate.getTimezoneOffset();
+
+	    switch (token) {
+	      // Short
+	      case 'O':
+	      case 'OO':
+	      case 'OOO':
+	        return 'GMT' + formatTimezoneShort(timezoneOffset, ':');
+	      // Long
+
+	      case 'OOOO':
+	      default:
+	        return 'GMT' + formatTimezone(timezoneOffset, ':');
+	    }
+	  },
+	  // Timezone (specific non-location)
+	  z: function (date, token, _localize, options) {
+	    var originalDate = options._originalDate || date;
+	    var timezoneOffset = originalDate.getTimezoneOffset();
+
+	    switch (token) {
+	      // Short
+	      case 'z':
+	      case 'zz':
+	      case 'zzz':
+	        return 'GMT' + formatTimezoneShort(timezoneOffset, ':');
+	      // Long
+
+	      case 'zzzz':
+	      default:
+	        return 'GMT' + formatTimezone(timezoneOffset, ':');
+	    }
+	  },
+	  // Seconds timestamp
+	  t: function (date, token, _localize, options) {
+	    var originalDate = options._originalDate || date;
+	    var timestamp = Math.floor(originalDate.getTime() / 1000);
+	    return addLeadingZeros(timestamp, token.length);
+	  },
+	  // Milliseconds timestamp
+	  T: function (date, token, _localize, options) {
+	    var originalDate = options._originalDate || date;
+	    var timestamp = originalDate.getTime();
+	    return addLeadingZeros(timestamp, token.length);
+	  }
+	};
+
+	function formatTimezoneShort(offset, dirtyDelimiter) {
+	  var sign = offset > 0 ? '-' : '+';
+	  var absOffset = Math.abs(offset);
+	  var hours = Math.floor(absOffset / 60);
+	  var minutes = absOffset % 60;
+
+	  if (minutes === 0) {
+	    return sign + String(hours);
+	  }
+
+	  var delimiter = dirtyDelimiter || '';
+	  return sign + String(hours) + delimiter + addLeadingZeros(minutes, 2);
+	}
+
+	function formatTimezoneWithOptionalMinutes(offset, dirtyDelimiter) {
+	  if (offset % 60 === 0) {
+	    var sign = offset > 0 ? '-' : '+';
+	    return sign + addLeadingZeros(Math.abs(offset) / 60, 2);
+	  }
+
+	  return formatTimezone(offset, dirtyDelimiter);
+	}
+
+	function formatTimezone(offset, dirtyDelimiter) {
+	  var delimiter = dirtyDelimiter || '';
+	  var sign = offset > 0 ? '-' : '+';
+	  var absOffset = Math.abs(offset);
+	  var hours = addLeadingZeros(Math.floor(absOffset / 60), 2);
+	  var minutes = addLeadingZeros(absOffset % 60, 2);
+	  return sign + hours + delimiter + minutes;
+	}
+
+	var formatters$1 = formatters;
+
+	function dateLongFormatter(pattern, formatLong) {
+	  switch (pattern) {
+	    case 'P':
+	      return formatLong.date({
+	        width: 'short'
+	      });
+
+	    case 'PP':
+	      return formatLong.date({
+	        width: 'medium'
+	      });
+
+	    case 'PPP':
+	      return formatLong.date({
+	        width: 'long'
+	      });
+
+	    case 'PPPP':
+	    default:
+	      return formatLong.date({
+	        width: 'full'
+	      });
+	  }
+	}
+
+	function timeLongFormatter(pattern, formatLong) {
+	  switch (pattern) {
+	    case 'p':
+	      return formatLong.time({
+	        width: 'short'
+	      });
+
+	    case 'pp':
+	      return formatLong.time({
+	        width: 'medium'
+	      });
+
+	    case 'ppp':
+	      return formatLong.time({
+	        width: 'long'
+	      });
+
+	    case 'pppp':
+	    default:
+	      return formatLong.time({
+	        width: 'full'
+	      });
+	  }
+	}
+
+	function dateTimeLongFormatter(pattern, formatLong) {
+	  var matchResult = pattern.match(/(P+)(p+)?/);
+	  var datePattern = matchResult[1];
+	  var timePattern = matchResult[2];
+
+	  if (!timePattern) {
+	    return dateLongFormatter(pattern, formatLong);
+	  }
+
+	  var dateTimeFormat;
+
+	  switch (datePattern) {
+	    case 'P':
+	      dateTimeFormat = formatLong.dateTime({
+	        width: 'short'
+	      });
+	      break;
+
+	    case 'PP':
+	      dateTimeFormat = formatLong.dateTime({
+	        width: 'medium'
+	      });
+	      break;
+
+	    case 'PPP':
+	      dateTimeFormat = formatLong.dateTime({
+	        width: 'long'
+	      });
+	      break;
+
+	    case 'PPPP':
+	    default:
+	      dateTimeFormat = formatLong.dateTime({
+	        width: 'full'
+	      });
+	      break;
+	  }
+
+	  return dateTimeFormat.replace('{{date}}', dateLongFormatter(datePattern, formatLong)).replace('{{time}}', timeLongFormatter(timePattern, formatLong));
+	}
+
+	var longFormatters = {
+	  p: timeLongFormatter,
+	  P: dateTimeLongFormatter
+	};
+	var longFormatters$1 = longFormatters;
+
+	var protectedDayOfYearTokens = ['D', 'DD'];
+	var protectedWeekYearTokens = ['YY', 'YYYY'];
+	function isProtectedDayOfYearToken(token) {
+	  return protectedDayOfYearTokens.indexOf(token) !== -1;
+	}
+	function isProtectedWeekYearToken(token) {
+	  return protectedWeekYearTokens.indexOf(token) !== -1;
+	}
+	function throwProtectedError(token, format, input) {
+	  if (token === 'YYYY') {
+	    throw new RangeError("Use `yyyy` instead of `YYYY` (in `".concat(format, "`) for formatting years to the input `").concat(input, "`; see: https://git.io/fxCyr"));
+	  } else if (token === 'YY') {
+	    throw new RangeError("Use `yy` instead of `YY` (in `".concat(format, "`) for formatting years to the input `").concat(input, "`; see: https://git.io/fxCyr"));
+	  } else if (token === 'D') {
+	    throw new RangeError("Use `d` instead of `D` (in `".concat(format, "`) for formatting days of the month to the input `").concat(input, "`; see: https://git.io/fxCyr"));
+	  } else if (token === 'DD') {
+	    throw new RangeError("Use `dd` instead of `DD` (in `".concat(format, "`) for formatting days of the month to the input `").concat(input, "`; see: https://git.io/fxCyr"));
+	  }
+	}
+
+	// - [yYQqMLwIdDecihHKkms]o matches any available ordinal number token
+	//   (one of the certain letters followed by `o`)
+	// - (\w)\1* matches any sequences of the same letter
+	// - '' matches two quote characters in a row
+	// - '(''|[^'])+('|$) matches anything surrounded by two quote characters ('),
+	//   except a single quote symbol, which ends the sequence.
+	//   Two quote characters do not end the sequence.
+	//   If there is no matching single quote
+	//   then the sequence will continue until the end of the string.
+	// - . matches any single character unmatched by previous parts of the RegExps
+
+	var formattingTokensRegExp = /[yYQqMLwIdDecihHKkms]o|(\w)\1*|''|'(''|[^'])+('|$)|./g; // This RegExp catches symbols escaped by quotes, and also
+	// sequences of symbols P, p, and the combinations like `PPPPPPPppppp`
+
+	var longFormattingTokensRegExp = /P+p+|P+|p+|''|'(''|[^'])+('|$)|./g;
+	var escapedStringRegExp = /^'([^]*?)'?$/;
+	var doubleQuoteRegExp = /''/g;
+	var unescapedLatinCharacterRegExp = /[a-zA-Z]/;
+	/**
+	 * @name format
+	 * @category Common Helpers
+	 * @summary Format the date.
+	 *
+	 * @description
+	 * Return the formatted date string in the given format. The result may vary by locale.
+	 *
+	 * > ⚠️ Please note that the `format` tokens differ from Moment.js and other libraries.
+	 * > See: https://git.io/fxCyr
+	 *
+	 * The characters wrapped between two single quotes characters (') are escaped.
+	 * Two single quotes in a row, whether inside or outside a quoted sequence, represent a 'real' single quote.
+	 * (see the last example)
+	 *
+	 * Format of the string is based on Unicode Technical Standard #35:
+	 * https://www.unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table
+	 * with a few additions (see note 7 below the table).
+	 *
+	 * Accepted patterns:
+	 * | Unit                            | Pattern | Result examples                   | Notes |
+	 * |---------------------------------|---------|-----------------------------------|-------|
+	 * | Era                             | G..GGG  | AD, BC                            |       |
+	 * |                                 | GGGG    | Anno Domini, Before Christ        | 2     |
+	 * |                                 | GGGGG   | A, B                              |       |
+	 * | Calendar year                   | y       | 44, 1, 1900, 2017                 | 5     |
+	 * |                                 | yo      | 44th, 1st, 0th, 17th              | 5,7   |
+	 * |                                 | yy      | 44, 01, 00, 17                    | 5     |
+	 * |                                 | yyy     | 044, 001, 1900, 2017              | 5     |
+	 * |                                 | yyyy    | 0044, 0001, 1900, 2017            | 5     |
+	 * |                                 | yyyyy   | ...                               | 3,5   |
+	 * | Local week-numbering year       | Y       | 44, 1, 1900, 2017                 | 5     |
+	 * |                                 | Yo      | 44th, 1st, 1900th, 2017th         | 5,7   |
+	 * |                                 | YY      | 44, 01, 00, 17                    | 5,8   |
+	 * |                                 | YYY     | 044, 001, 1900, 2017              | 5     |
+	 * |                                 | YYYY    | 0044, 0001, 1900, 2017            | 5,8   |
+	 * |                                 | YYYYY   | ...                               | 3,5   |
+	 * | ISO week-numbering year         | R       | -43, 0, 1, 1900, 2017             | 5,7   |
+	 * |                                 | RR      | -43, 00, 01, 1900, 2017           | 5,7   |
+	 * |                                 | RRR     | -043, 000, 001, 1900, 2017        | 5,7   |
+	 * |                                 | RRRR    | -0043, 0000, 0001, 1900, 2017     | 5,7   |
+	 * |                                 | RRRRR   | ...                               | 3,5,7 |
+	 * | Extended year                   | u       | -43, 0, 1, 1900, 2017             | 5     |
+	 * |                                 | uu      | -43, 01, 1900, 2017               | 5     |
+	 * |                                 | uuu     | -043, 001, 1900, 2017             | 5     |
+	 * |                                 | uuuu    | -0043, 0001, 1900, 2017           | 5     |
+	 * |                                 | uuuuu   | ...                               | 3,5   |
+	 * | Quarter (formatting)            | Q       | 1, 2, 3, 4                        |       |
+	 * |                                 | Qo      | 1st, 2nd, 3rd, 4th                | 7     |
+	 * |                                 | QQ      | 01, 02, 03, 04                    |       |
+	 * |                                 | QQQ     | Q1, Q2, Q3, Q4                    |       |
+	 * |                                 | QQQQ    | 1st quarter, 2nd quarter, ...     | 2     |
+	 * |                                 | QQQQQ   | 1, 2, 3, 4                        | 4     |
+	 * | Quarter (stand-alone)           | q       | 1, 2, 3, 4                        |       |
+	 * |                                 | qo      | 1st, 2nd, 3rd, 4th                | 7     |
+	 * |                                 | qq      | 01, 02, 03, 04                    |       |
+	 * |                                 | qqq     | Q1, Q2, Q3, Q4                    |       |
+	 * |                                 | qqqq    | 1st quarter, 2nd quarter, ...     | 2     |
+	 * |                                 | qqqqq   | 1, 2, 3, 4                        | 4     |
+	 * | Month (formatting)              | M       | 1, 2, ..., 12                     |       |
+	 * |                                 | Mo      | 1st, 2nd, ..., 12th               | 7     |
+	 * |                                 | MM      | 01, 02, ..., 12                   |       |
+	 * |                                 | MMM     | Jan, Feb, ..., Dec                |       |
+	 * |                                 | MMMM    | January, February, ..., December  | 2     |
+	 * |                                 | MMMMM   | J, F, ..., D                      |       |
+	 * | Month (stand-alone)             | L       | 1, 2, ..., 12                     |       |
+	 * |                                 | Lo      | 1st, 2nd, ..., 12th               | 7     |
+	 * |                                 | LL      | 01, 02, ..., 12                   |       |
+	 * |                                 | LLL     | Jan, Feb, ..., Dec                |       |
+	 * |                                 | LLLL    | January, February, ..., December  | 2     |
+	 * |                                 | LLLLL   | J, F, ..., D                      |       |
+	 * | Local week of year              | w       | 1, 2, ..., 53                     |       |
+	 * |                                 | wo      | 1st, 2nd, ..., 53th               | 7     |
+	 * |                                 | ww      | 01, 02, ..., 53                   |       |
+	 * | ISO week of year                | I       | 1, 2, ..., 53                     | 7     |
+	 * |                                 | Io      | 1st, 2nd, ..., 53th               | 7     |
+	 * |                                 | II      | 01, 02, ..., 53                   | 7     |
+	 * | Day of month                    | d       | 1, 2, ..., 31                     |       |
+	 * |                                 | do      | 1st, 2nd, ..., 31st               | 7     |
+	 * |                                 | dd      | 01, 02, ..., 31                   |       |
+	 * | Day of year                     | D       | 1, 2, ..., 365, 366               | 9     |
+	 * |                                 | Do      | 1st, 2nd, ..., 365th, 366th       | 7     |
+	 * |                                 | DD      | 01, 02, ..., 365, 366             | 9     |
+	 * |                                 | DDD     | 001, 002, ..., 365, 366           |       |
+	 * |                                 | DDDD    | ...                               | 3     |
+	 * | Day of week (formatting)        | E..EEE  | Mon, Tue, Wed, ..., Sun           |       |
+	 * |                                 | EEEE    | Monday, Tuesday, ..., Sunday      | 2     |
+	 * |                                 | EEEEE   | M, T, W, T, F, S, S               |       |
+	 * |                                 | EEEEEE  | Mo, Tu, We, Th, Fr, Sa, Su        |       |
+	 * | ISO day of week (formatting)    | i       | 1, 2, 3, ..., 7                   | 7     |
+	 * |                                 | io      | 1st, 2nd, ..., 7th                | 7     |
+	 * |                                 | ii      | 01, 02, ..., 07                   | 7     |
+	 * |                                 | iii     | Mon, Tue, Wed, ..., Sun           | 7     |
+	 * |                                 | iiii    | Monday, Tuesday, ..., Sunday      | 2,7   |
+	 * |                                 | iiiii   | M, T, W, T, F, S, S               | 7     |
+	 * |                                 | iiiiii  | Mo, Tu, We, Th, Fr, Sa, Su        | 7     |
+	 * | Local day of week (formatting)  | e       | 2, 3, 4, ..., 1                   |       |
+	 * |                                 | eo      | 2nd, 3rd, ..., 1st                | 7     |
+	 * |                                 | ee      | 02, 03, ..., 01                   |       |
+	 * |                                 | eee     | Mon, Tue, Wed, ..., Sun           |       |
+	 * |                                 | eeee    | Monday, Tuesday, ..., Sunday      | 2     |
+	 * |                                 | eeeee   | M, T, W, T, F, S, S               |       |
+	 * |                                 | eeeeee  | Mo, Tu, We, Th, Fr, Sa, Su        |       |
+	 * | Local day of week (stand-alone) | c       | 2, 3, 4, ..., 1                   |       |
+	 * |                                 | co      | 2nd, 3rd, ..., 1st                | 7     |
+	 * |                                 | cc      | 02, 03, ..., 01                   |       |
+	 * |                                 | ccc     | Mon, Tue, Wed, ..., Sun           |       |
+	 * |                                 | cccc    | Monday, Tuesday, ..., Sunday      | 2     |
+	 * |                                 | ccccc   | M, T, W, T, F, S, S               |       |
+	 * |                                 | cccccc  | Mo, Tu, We, Th, Fr, Sa, Su        |       |
+	 * | AM, PM                          | a..aa   | AM, PM                            |       |
+	 * |                                 | aaa     | am, pm                            |       |
+	 * |                                 | aaaa    | a.m., p.m.                        | 2     |
+	 * |                                 | aaaaa   | a, p                              |       |
+	 * | AM, PM, noon, midnight          | b..bb   | AM, PM, noon, midnight            |       |
+	 * |                                 | bbb     | am, pm, noon, midnight            |       |
+	 * |                                 | bbbb    | a.m., p.m., noon, midnight        | 2     |
+	 * |                                 | bbbbb   | a, p, n, mi                       |       |
+	 * | Flexible day period             | B..BBB  | at night, in the morning, ...     |       |
+	 * |                                 | BBBB    | at night, in the morning, ...     | 2     |
+	 * |                                 | BBBBB   | at night, in the morning, ...     |       |
+	 * | Hour [1-12]                     | h       | 1, 2, ..., 11, 12                 |       |
+	 * |                                 | ho      | 1st, 2nd, ..., 11th, 12th         | 7     |
+	 * |                                 | hh      | 01, 02, ..., 11, 12               |       |
+	 * | Hour [0-23]                     | H       | 0, 1, 2, ..., 23                  |       |
+	 * |                                 | Ho      | 0th, 1st, 2nd, ..., 23rd          | 7     |
+	 * |                                 | HH      | 00, 01, 02, ..., 23               |       |
+	 * | Hour [0-11]                     | K       | 1, 2, ..., 11, 0                  |       |
+	 * |                                 | Ko      | 1st, 2nd, ..., 11th, 0th          | 7     |
+	 * |                                 | KK      | 01, 02, ..., 11, 00               |       |
+	 * | Hour [1-24]                     | k       | 24, 1, 2, ..., 23                 |       |
+	 * |                                 | ko      | 24th, 1st, 2nd, ..., 23rd         | 7     |
+	 * |                                 | kk      | 24, 01, 02, ..., 23               |       |
+	 * | Minute                          | m       | 0, 1, ..., 59                     |       |
+	 * |                                 | mo      | 0th, 1st, ..., 59th               | 7     |
+	 * |                                 | mm      | 00, 01, ..., 59                   |       |
+	 * | Second                          | s       | 0, 1, ..., 59                     |       |
+	 * |                                 | so      | 0th, 1st, ..., 59th               | 7     |
+	 * |                                 | ss      | 00, 01, ..., 59                   |       |
+	 * | Fraction of second              | S       | 0, 1, ..., 9                      |       |
+	 * |                                 | SS      | 00, 01, ..., 99                   |       |
+	 * |                                 | SSS     | 000, 001, ..., 999                |       |
+	 * |                                 | SSSS    | ...                               | 3     |
+	 * | Timezone (ISO-8601 w/ Z)        | X       | -08, +0530, Z                     |       |
+	 * |                                 | XX      | -0800, +0530, Z                   |       |
+	 * |                                 | XXX     | -08:00, +05:30, Z                 |       |
+	 * |                                 | XXXX    | -0800, +0530, Z, +123456          | 2     |
+	 * |                                 | XXXXX   | -08:00, +05:30, Z, +12:34:56      |       |
+	 * | Timezone (ISO-8601 w/o Z)       | x       | -08, +0530, +00                   |       |
+	 * |                                 | xx      | -0800, +0530, +0000               |       |
+	 * |                                 | xxx     | -08:00, +05:30, +00:00            | 2     |
+	 * |                                 | xxxx    | -0800, +0530, +0000, +123456      |       |
+	 * |                                 | xxxxx   | -08:00, +05:30, +00:00, +12:34:56 |       |
+	 * | Timezone (GMT)                  | O...OOO | GMT-8, GMT+5:30, GMT+0            |       |
+	 * |                                 | OOOO    | GMT-08:00, GMT+05:30, GMT+00:00   | 2     |
+	 * | Timezone (specific non-locat.)  | z...zzz | GMT-8, GMT+5:30, GMT+0            | 6     |
+	 * |                                 | zzzz    | GMT-08:00, GMT+05:30, GMT+00:00   | 2,6   |
+	 * | Seconds timestamp               | t       | 512969520                         | 7     |
+	 * |                                 | tt      | ...                               | 3,7   |
+	 * | Milliseconds timestamp          | T       | 512969520900                      | 7     |
+	 * |                                 | TT      | ...                               | 3,7   |
+	 * | Long localized date             | P       | 04/29/1453                        | 7     |
+	 * |                                 | PP      | Apr 29, 1453                      | 7     |
+	 * |                                 | PPP     | April 29th, 1453                  | 7     |
+	 * |                                 | PPPP    | Friday, April 29th, 1453          | 2,7   |
+	 * | Long localized time             | p       | 12:00 AM                          | 7     |
+	 * |                                 | pp      | 12:00:00 AM                       | 7     |
+	 * |                                 | ppp     | 12:00:00 AM GMT+2                 | 7     |
+	 * |                                 | pppp    | 12:00:00 AM GMT+02:00             | 2,7   |
+	 * | Combination of date and time    | Pp      | 04/29/1453, 12:00 AM              | 7     |
+	 * |                                 | PPpp    | Apr 29, 1453, 12:00:00 AM         | 7     |
+	 * |                                 | PPPppp  | April 29th, 1453 at ...           | 7     |
+	 * |                                 | PPPPpppp| Friday, April 29th, 1453 at ...   | 2,7   |
+	 * Notes:
+	 * 1. "Formatting" units (e.g. formatting quarter) in the default en-US locale
+	 *    are the same as "stand-alone" units, but are different in some languages.
+	 *    "Formatting" units are declined according to the rules of the language
+	 *    in the context of a date. "Stand-alone" units are always nominative singular:
+	 *
+	 *    `format(new Date(2017, 10, 6), 'do LLLL', {locale: cs}) //=> '6. listopad'`
+	 *
+	 *    `format(new Date(2017, 10, 6), 'do MMMM', {locale: cs}) //=> '6. listopadu'`
+	 *
+	 * 2. Any sequence of the identical letters is a pattern, unless it is escaped by
+	 *    the single quote characters (see below).
+	 *    If the sequence is longer than listed in table (e.g. `EEEEEEEEEEE`)
+	 *    the output will be the same as default pattern for this unit, usually
+	 *    the longest one (in case of ISO weekdays, `EEEE`). Default patterns for units
+	 *    are marked with "2" in the last column of the table.
+	 *
+	 *    `format(new Date(2017, 10, 6), 'MMM') //=> 'Nov'`
+	 *
+	 *    `format(new Date(2017, 10, 6), 'MMMM') //=> 'November'`
+	 *
+	 *    `format(new Date(2017, 10, 6), 'MMMMM') //=> 'N'`
+	 *
+	 *    `format(new Date(2017, 10, 6), 'MMMMMM') //=> 'November'`
+	 *
+	 *    `format(new Date(2017, 10, 6), 'MMMMMMM') //=> 'November'`
+	 *
+	 * 3. Some patterns could be unlimited length (such as `yyyyyyyy`).
+	 *    The output will be padded with zeros to match the length of the pattern.
+	 *
+	 *    `format(new Date(2017, 10, 6), 'yyyyyyyy') //=> '00002017'`
+	 *
+	 * 4. `QQQQQ` and `qqqqq` could be not strictly numerical in some locales.
+	 *    These tokens represent the shortest form of the quarter.
+	 *
+	 * 5. The main difference between `y` and `u` patterns are B.C. years:
+	 *
+	 *    | Year | `y` | `u` |
+	 *    |------|-----|-----|
+	 *    | AC 1 |   1 |   1 |
+	 *    | BC 1 |   1 |   0 |
+	 *    | BC 2 |   2 |  -1 |
+	 *
+	 *    Also `yy` always returns the last two digits of a year,
+	 *    while `uu` pads single digit years to 2 characters and returns other years unchanged:
+	 *
+	 *    | Year | `yy` | `uu` |
+	 *    |------|------|------|
+	 *    | 1    |   01 |   01 |
+	 *    | 14   |   14 |   14 |
+	 *    | 376  |   76 |  376 |
+	 *    | 1453 |   53 | 1453 |
+	 *
+	 *    The same difference is true for local and ISO week-numbering years (`Y` and `R`),
+	 *    except local week-numbering years are dependent on `options.weekStartsOn`
+	 *    and `options.firstWeekContainsDate` (compare [getISOWeekYear]{@link https://date-fns.org/docs/getISOWeekYear}
+	 *    and [getWeekYear]{@link https://date-fns.org/docs/getWeekYear}).
+	 *
+	 * 6. Specific non-location timezones are currently unavailable in `date-fns`,
+	 *    so right now these tokens fall back to GMT timezones.
+	 *
+	 * 7. These patterns are not in the Unicode Technical Standard #35:
+	 *    - `i`: ISO day of week
+	 *    - `I`: ISO week of year
+	 *    - `R`: ISO week-numbering year
+	 *    - `t`: seconds timestamp
+	 *    - `T`: milliseconds timestamp
+	 *    - `o`: ordinal number modifier
+	 *    - `P`: long localized date
+	 *    - `p`: long localized time
+	 *
+	 * 8. `YY` and `YYYY` tokens represent week-numbering years but they are often confused with years.
+	 *    You should enable `options.useAdditionalWeekYearTokens` to use them. See: https://git.io/fxCyr
+	 *
+	 * 9. `D` and `DD` tokens represent days of the year but they are ofthen confused with days of the month.
+	 *    You should enable `options.useAdditionalDayOfYearTokens` to use them. See: https://git.io/fxCyr
+	 *
+	 * ### v2.0.0 breaking changes:
+	 *
+	 * - [Changes that are common for the whole library](https://github.com/date-fns/date-fns/blob/master/docs/upgradeGuide.md#Common-Changes).
+	 *
+	 * - The second argument is now required for the sake of explicitness.
+	 *
+	 *   ```javascript
+	 *   // Before v2.0.0
+	 *   format(new Date(2016, 0, 1))
+	 *
+	 *   // v2.0.0 onward
+	 *   format(new Date(2016, 0, 1), "yyyy-MM-dd'T'HH:mm:ss.SSSxxx")
+	 *   ```
+	 *
+	 * - New format string API for `format` function
+	 *   which is based on [Unicode Technical Standard #35](https://www.unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table).
+	 *   See [this post](https://blog.date-fns.org/post/unicode-tokens-in-date-fns-v2-sreatyki91jg) for more details.
+	 *
+	 * - Characters are now escaped using single quote symbols (`'`) instead of square brackets.
+	 *
+	 * @param {Date|Number} date - the original date
+	 * @param {String} format - the string of tokens
+	 * @param {Object} [options] - an object with options.
+	 * @param {Locale} [options.locale=defaultLocale] - the locale object. See [Locale]{@link https://date-fns.org/docs/Locale}
+	 * @param {0|1|2|3|4|5|6} [options.weekStartsOn=0] - the index of the first day of the week (0 - Sunday)
+	 * @param {Number} [options.firstWeekContainsDate=1] - the day of January, which is
+	 * @param {Boolean} [options.useAdditionalWeekYearTokens=false] - if true, allows usage of the week-numbering year tokens `YY` and `YYYY`;
+	 *   see: https://git.io/fxCyr
+	 * @param {Boolean} [options.useAdditionalDayOfYearTokens=false] - if true, allows usage of the day of year tokens `D` and `DD`;
+	 *   see: https://git.io/fxCyr
+	 * @returns {String} the formatted date string
+	 * @throws {TypeError} 2 arguments required
+	 * @throws {RangeError} `date` must not be Invalid Date
+	 * @throws {RangeError} `options.locale` must contain `localize` property
+	 * @throws {RangeError} `options.locale` must contain `formatLong` property
+	 * @throws {RangeError} `options.weekStartsOn` must be between 0 and 6
+	 * @throws {RangeError} `options.firstWeekContainsDate` must be between 1 and 7
+	 * @throws {RangeError} use `yyyy` instead of `YYYY` for formatting years using [format provided] to the input [input provided]; see: https://git.io/fxCyr
+	 * @throws {RangeError} use `yy` instead of `YY` for formatting years using [format provided] to the input [input provided]; see: https://git.io/fxCyr
+	 * @throws {RangeError} use `d` instead of `D` for formatting days of the month using [format provided] to the input [input provided]; see: https://git.io/fxCyr
+	 * @throws {RangeError} use `dd` instead of `DD` for formatting days of the month using [format provided] to the input [input provided]; see: https://git.io/fxCyr
+	 * @throws {RangeError} format string contains an unescaped latin alphabet character
+	 *
+	 * @example
+	 * // Represent 11 February 2014 in middle-endian format:
+	 * var result = format(new Date(2014, 1, 11), 'MM/dd/yyyy')
+	 * //=> '02/11/2014'
+	 *
+	 * @example
+	 * // Represent 2 July 2014 in Esperanto:
+	 * import { eoLocale } from 'date-fns/locale/eo'
+	 * var result = format(new Date(2014, 6, 2), "do 'de' MMMM yyyy", {
+	 *   locale: eoLocale
+	 * })
+	 * //=> '2-a de julio 2014'
+	 *
+	 * @example
+	 * // Escape string by single quote characters:
+	 * var result = format(new Date(2014, 6, 2, 15), "h 'o''clock'")
+	 * //=> "3 o'clock"
+	 */
+
+	function format(dirtyDate, dirtyFormatStr, dirtyOptions) {
+	  requiredArgs(2, arguments);
+	  var formatStr = String(dirtyFormatStr);
+	  var options = dirtyOptions || {};
+	  var locale = options.locale || defaultLocale;
+	  var localeFirstWeekContainsDate = locale.options && locale.options.firstWeekContainsDate;
+	  var defaultFirstWeekContainsDate = localeFirstWeekContainsDate == null ? 1 : toInteger(localeFirstWeekContainsDate);
+	  var firstWeekContainsDate = options.firstWeekContainsDate == null ? defaultFirstWeekContainsDate : toInteger(options.firstWeekContainsDate); // Test if weekStartsOn is between 1 and 7 _and_ is not NaN
+
+	  if (!(firstWeekContainsDate >= 1 && firstWeekContainsDate <= 7)) {
+	    throw new RangeError('firstWeekContainsDate must be between 1 and 7 inclusively');
+	  }
+
+	  var localeWeekStartsOn = locale.options && locale.options.weekStartsOn;
+	  var defaultWeekStartsOn = localeWeekStartsOn == null ? 0 : toInteger(localeWeekStartsOn);
+	  var weekStartsOn = options.weekStartsOn == null ? defaultWeekStartsOn : toInteger(options.weekStartsOn); // Test if weekStartsOn is between 0 and 6 _and_ is not NaN
+
+	  if (!(weekStartsOn >= 0 && weekStartsOn <= 6)) {
+	    throw new RangeError('weekStartsOn must be between 0 and 6 inclusively');
+	  }
+
+	  if (!locale.localize) {
+	    throw new RangeError('locale must contain localize property');
+	  }
+
+	  if (!locale.formatLong) {
+	    throw new RangeError('locale must contain formatLong property');
+	  }
+
+	  var originalDate = toDate(dirtyDate);
+
+	  if (!isValid(originalDate)) {
+	    throw new RangeError('Invalid time value');
+	  } // Convert the date in system timezone to the same date in UTC+00:00 timezone.
+	  // This ensures that when UTC functions will be implemented, locales will be compatible with them.
+	  // See an issue about UTC functions: https://github.com/date-fns/date-fns/issues/376
+
+
+	  var timezoneOffset = getTimezoneOffsetInMilliseconds(originalDate);
+	  var utcDate = subMilliseconds(originalDate, timezoneOffset);
+	  var formatterOptions = {
+	    firstWeekContainsDate: firstWeekContainsDate,
+	    weekStartsOn: weekStartsOn,
+	    locale: locale,
+	    _originalDate: originalDate
+	  };
+	  var result = formatStr.match(longFormattingTokensRegExp).map(function (substring) {
+	    var firstCharacter = substring[0];
+
+	    if (firstCharacter === 'p' || firstCharacter === 'P') {
+	      var longFormatter = longFormatters$1[firstCharacter];
+	      return longFormatter(substring, locale.formatLong, formatterOptions);
+	    }
+
+	    return substring;
+	  }).join('').match(formattingTokensRegExp).map(function (substring) {
+	    // Replace two single quote characters with one single quote character
+	    if (substring === "''") {
+	      return "'";
+	    }
+
+	    var firstCharacter = substring[0];
+
+	    if (firstCharacter === "'") {
+	      return cleanEscapedString(substring);
+	    }
+
+	    var formatter = formatters$1[firstCharacter];
+
+	    if (formatter) {
+	      if (!options.useAdditionalWeekYearTokens && isProtectedWeekYearToken(substring)) {
+	        throwProtectedError(substring, dirtyFormatStr, dirtyDate);
+	      }
+
+	      if (!options.useAdditionalDayOfYearTokens && isProtectedDayOfYearToken(substring)) {
+	        throwProtectedError(substring, dirtyFormatStr, dirtyDate);
+	      }
+
+	      return formatter(utcDate, substring, locale.localize, formatterOptions);
+	    }
+
+	    if (firstCharacter.match(unescapedLatinCharacterRegExp)) {
+	      throw new RangeError('Format string contains an unescaped latin alphabet character `' + firstCharacter + '`');
+	    }
+
+	    return substring;
+	  }).join('');
+	  return result;
+	}
+
+	function cleanEscapedString(input) {
+	  return input.match(escapedStringRegExp)[1].replace(doubleQuoteRegExp, "'");
+	}
+
 	var PublishingDateFilter = function PublishingDateFilter() {
 	  var publishingDateRef = React$d.useRef();
 	  var formatMessage = useIntl().formatMessage;
@@ -135486,6 +137838,7 @@
 	  var today = new Date();
 	  var startOfToday = startOfDay(today);
 	  var endOfToday = endOfDay(today);
+	  var isActive = (filter === null || filter === void 0 ? void 0 : filter.beforeDate) || (filter === null || filter === void 0 ? void 0 : filter.afterDate);
 	  return jsxRuntime.jsxs("div", __assign$g({
 	    ref: publishingDateRef
 	  }, {
@@ -135493,13 +137846,13 @@
 	      iconProps: {
 	        iconName: showDates ? 'ChevronUp' : 'ChevronDown'
 	      },
-	      text: formatMessage({
+	      text: isActive ? getButtonText() : formatMessage({
 	        id: 'FilterPanel.publishingDate'
 	      }),
 	      onClick: function () {
 	        return setShowDates(!showDates);
 	      },
-	      isActive: (filter === null || filter === void 0 ? void 0 : filter.beforeDate) || (filter === null || filter === void 0 ? void 0 : filter.afterDate)
+	      isActive: isActive
 	    }, void 0), showDates && jsxRuntime.jsx(Callout, __assign$g({
 	      target: publishingDateRef.current,
 	      onDismiss: function () {
@@ -135533,8 +137886,7 @@
 	          noDateResourceKey: "MetadataEditor.noDate",
 	          selectDateResourceKey: "FilterPanel.publishingDatePlaceholder",
 	          onChanged: handleEndDateChange,
-	          minDate: filter === null || filter === void 0 ? void 0 : filter.afterDate,
-	          maxDate: today.toString()
+	          minDate: filter === null || filter === void 0 ? void 0 : filter.afterDate
 	        }, void 0), jsxRuntime.jsxs(DateShortcuts, {
 	          children: [jsxRuntime.jsx(FormattedMessage$1, {
 	            id: "FilterPanel.publishingDateShortcuts"
@@ -135608,6 +137960,25 @@
 	      afterDate: null
 	    }));
 	  }
+
+	  function getButtonText() {
+	    var start = format(new Date(filter.afterDate), 'P');
+	    var end = format(new Date(filter.beforeDate), 'P');
+
+	    if (!filter.afterDate) {
+	      return formatMessage({
+	        id: 'FilterPanel.publishingDateBefore'
+	      }) + " " + end;
+	    }
+
+	    if (!filter.beforeDate) {
+	      return formatMessage({
+	        id: 'FilterPanel.publishingDateAfter'
+	      }) + " " + start;
+	    }
+
+	    return start + " - " + end;
+	  }
 	};
 
 	var DateShortcutButton = function DateShortcutButton(_a) {
@@ -152581,6 +154952,8 @@
 	  "FilterPanel.publishingDate": "Publishing date",
 	  "FilterPanel.publishingDateFrom": "From",
 	  "FilterPanel.publishingDateTo": "To",
+	  "FilterPanel.publishingDateBefore": "Before",
+	  "FilterPanel.publishingDateAfter": "After",
 	  "FilterPanel.publishingDatePlaceholder": "Date",
 	  "FilterPanel.publishingDateShortcuts": "Date range shortcuts",
 	  "FilterPanel.publishingDateShortcuts.yesterday": "Yesterday",