1 this["wp"] = this["wp"] || {}; this["wp"]["date"] =

     2 /******/ (function(modules) { // webpackBootstrap

     3 /******/ 	// The module cache

     4 /******/ 	var installedModules = {};

     5 /******/

     6 /******/ 	// The require function

     7 /******/ 	function __webpack_require__(moduleId) {

     8 /******/

     9 /******/ 		// Check if module is in cache

    10 /******/ 		if(installedModules[moduleId]) {

    11 /******/ 			return installedModules[moduleId].exports;

    12 /******/ 		}

    13 /******/ 		// Create a new module (and put it into the cache)

    14 /******/ 		var module = installedModules[moduleId] = {

    15 /******/ 			i: moduleId,

    16 /******/ 			l: false,

    17 /******/ 			exports: {}

    18 /******/ 		};

    19 /******/

    20 /******/ 		// Execute the module function

    21 /******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);

    22 /******/

    23 /******/ 		// Flag the module as loaded

    24 /******/ 		module.l = true;

    25 /******/

    26 /******/ 		// Return the exports of the module

    27 /******/ 		return module.exports;

    28 /******/ 	}

    29 /******/

    30 /******/

    31 /******/ 	// expose the modules object (__webpack_modules__)

    32 /******/ 	__webpack_require__.m = modules;

    33 /******/

    34 /******/ 	// expose the module cache

    35 /******/ 	__webpack_require__.c = installedModules;

    36 /******/

    37 /******/ 	// define getter function for harmony exports

    38 /******/ 	__webpack_require__.d = function(exports, name, getter) {

    39 /******/ 		if(!__webpack_require__.o(exports, name)) {

    40 /******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });

    41 /******/ 		}

    42 /******/ 	};

    43 /******/

    44 /******/ 	// define __esModule on exports

    45 /******/ 	__webpack_require__.r = function(exports) {

    46 /******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {

    47 /******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });

    48 /******/ 		}

    49 /******/ 		Object.defineProperty(exports, '__esModule', { value: true });

    50 /******/ 	};

    51 /******/

    52 /******/ 	// create a fake namespace object

    53 /******/ 	// mode & 1: value is a module id, require it

    54 /******/ 	// mode & 2: merge all properties of value into the ns

    55 /******/ 	// mode & 4: return value when already ns object

    56 /******/ 	// mode & 8|1: behave like require

    57 /******/ 	__webpack_require__.t = function(value, mode) {

    58 /******/ 		if(mode & 1) value = __webpack_require__(value);

    59 /******/ 		if(mode & 8) return value;

    60 /******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;

    61 /******/ 		var ns = Object.create(null);

    62 /******/ 		__webpack_require__.r(ns);

    63 /******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });

    64 /******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));

    65 /******/ 		return ns;

    66 /******/ 	};

    67 /******/

    68 /******/ 	// getDefaultExport function for compatibility with non-harmony modules

    69 /******/ 	__webpack_require__.n = function(module) {

    70 /******/ 		var getter = module && module.__esModule ?

    71 /******/ 			function getDefault() { return module['default']; } :

    72 /******/ 			function getModuleExports() { return module; };

    73 /******/ 		__webpack_require__.d(getter, 'a', getter);

    74 /******/ 		return getter;

    75 /******/ 	};

    76 /******/

    77 /******/ 	// Object.prototype.hasOwnProperty.call

    78 /******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };

    79 /******/

    80 /******/ 	// __webpack_public_path__

    81 /******/ 	__webpack_require__.p = "";

    82 /******/

    83 /******/

    84 /******/ 	// Load entry module and return exports

    85 /******/ 	return __webpack_require__(__webpack_require__.s = 335);

    86 /******/ })

    87 /************************************************************************/

    88 /******/ ({

    89 

    90 /***/ 198:

    91 /***/ (function(module, exports, __webpack_require__) {

    92 

    93 var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;//! moment-timezone.js

    94 //! version : 0.5.23

    95 //! Copyright (c) JS Foundation and other contributors

    96 //! license : MIT

    97 //! github.com/moment/moment-timezone

    98 

    99 (function (root, factory) {

   100 	"use strict";

   101 

   102 	/*global define*/

   103 	if ( true && module.exports) {

   104 		module.exports = factory(__webpack_require__(29)); // Node

   105 	} else if (true) {

   106 		!(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(29)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory),

   107 				__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?

   108 				(__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__),

   109 				__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));                 // AMD

   110 	} else {}

   111 }(this, function (moment) {

   112 	"use strict";

   113 

   114 	// Do not load moment-timezone a second time.

   115 	// if (moment.tz !== undefined) {

   116 	// 	logError('Moment Timezone ' + moment.tz.version + ' was already loaded ' + (moment.tz.dataVersion ? 'with data from ' : 'without any data') + moment.tz.dataVersion);

   117 	// 	return moment;

   118 	// }

   119 

   120 	var VERSION = "0.5.23",

   121 		zones = {},

   122 		links = {},

   123 		names = {},

   124 		guesses = {},

   125 		cachedGuess;

   126 

   127 	if (!moment || typeof moment.version !== 'string') {

   128 		logError('Moment Timezone requires Moment.js. See https://momentjs.com/timezone/docs/#/use-it/browser/');

   129 	}

   130 

   131 	var momentVersion = moment.version.split('.'),

   132 		major = +momentVersion[0],

   133 		minor = +momentVersion[1];

   134 

   135 	// Moment.js version check

   136 	if (major < 2 || (major === 2 && minor < 6)) {

   137 		logError('Moment Timezone requires Moment.js >= 2.6.0. You are using Moment.js ' + moment.version + '. See momentjs.com');

   138 	}

   139 

   140 	/************************************

   141 		Unpacking

   142 	************************************/

   143 

   144 	function charCodeToInt(charCode) {

   145 		if (charCode > 96) {

   146 			return charCode - 87;

   147 		} else if (charCode > 64) {

   148 			return charCode - 29;

   149 		}

   150 		return charCode - 48;

   151 	}

   152 

   153 	function unpackBase60(string) {

   154 		var i = 0,

   155 			parts = string.split('.'),

   156 			whole = parts[0],

   157 			fractional = parts[1] || '',

   158 			multiplier = 1,

   159 			num,

   160 			out = 0,

   161 			sign = 1;

   162 

   163 		// handle negative numbers

   164 		if (string.charCodeAt(0) === 45) {

   165 			i = 1;

   166 			sign = -1;

   167 		}

   168 

   169 		// handle digits before the decimal

   170 		for (i; i < whole.length; i++) {

   171 			num = charCodeToInt(whole.charCodeAt(i));

   172 			out = 60 * out + num;

   173 		}

   174 

   175 		// handle digits after the decimal

   176 		for (i = 0; i < fractional.length; i++) {

   177 			multiplier = multiplier / 60;

   178 			num = charCodeToInt(fractional.charCodeAt(i));

   179 			out += num * multiplier;

   180 		}

   181 

   182 		return out * sign;

   183 	}

   184 

   185 	function arrayToInt (array) {

   186 		for (var i = 0; i < array.length; i++) {

   187 			array[i] = unpackBase60(array[i]);

   188 		}

   189 	}

   190 

   191 	function intToUntil (array, length) {

   192 		for (var i = 0; i < length; i++) {

   193 			array[i] = Math.round((array[i - 1] || 0) + (array[i] * 60000)); // minutes to milliseconds

   194 		}

   195 

   196 		array[length - 1] = Infinity;

   197 	}

   198 

   199 	function mapIndices (source, indices) {

   200 		var out = [], i;

   201 

   202 		for (i = 0; i < indices.length; i++) {

   203 			out[i] = source[indices[i]];

   204 		}

   205 

   206 		return out;

   207 	}

   208 

   209 	function unpack (string) {

   210 		var data = string.split('|'),

   211 			offsets = data[2].split(' '),

   212 			indices = data[3].split(''),

   213 			untils  = data[4].split(' ');

   214 

   215 		arrayToInt(offsets);

   216 		arrayToInt(indices);

   217 		arrayToInt(untils);

   218 

   219 		intToUntil(untils, indices.length);

   220 

   221 		return {

   222 			name       : data[0],

   223 			abbrs      : mapIndices(data[1].split(' '), indices),

   224 			offsets    : mapIndices(offsets, indices),

   225 			untils     : untils,

   226 			population : data[5] | 0

   227 		};

   228 	}

   229 

   230 	/************************************

   231 		Zone object

   232 	************************************/

   233 

   234 	function Zone (packedString) {

   235 		if (packedString) {

   236 			this._set(unpack(packedString));

   237 		}

   238 	}

   239 

   240 	Zone.prototype = {

   241 		_set : function (unpacked) {

   242 			this.name       = unpacked.name;

   243 			this.abbrs      = unpacked.abbrs;

   244 			this.untils     = unpacked.untils;

   245 			this.offsets    = unpacked.offsets;

   246 			this.population = unpacked.population;

   247 		},

   248 

   249 		_index : function (timestamp) {

   250 			var target = +timestamp,

   251 				untils = this.untils,

   252 				i;

   253 

   254 			for (i = 0; i < untils.length; i++) {

   255 				if (target < untils[i]) {

   256 					return i;

   257 				}

   258 			}

   259 		},

   260 

   261 		parse : function (timestamp) {

   262 			var target  = +timestamp,

   263 				offsets = this.offsets,

   264 				untils  = this.untils,

   265 				max     = untils.length - 1,

   266 				offset, offsetNext, offsetPrev, i;

   267 

   268 			for (i = 0; i < max; i++) {

   269 				offset     = offsets[i];

   270 				offsetNext = offsets[i + 1];

   271 				offsetPrev = offsets[i ? i - 1 : i];

   272 

   273 				if (offset < offsetNext && tz.moveAmbiguousForward) {

   274 					offset = offsetNext;

   275 				} else if (offset > offsetPrev && tz.moveInvalidForward) {

   276 					offset = offsetPrev;

   277 				}

   278 

   279 				if (target < untils[i] - (offset * 60000)) {

   280 					return offsets[i];

   281 				}

   282 			}

   283 

   284 			return offsets[max];

   285 		},

   286 

   287 		abbr : function (mom) {

   288 			return this.abbrs[this._index(mom)];

   289 		},

   290 

   291 		offset : function (mom) {

   292 			logError("zone.offset has been deprecated in favor of zone.utcOffset");

   293 			return this.offsets[this._index(mom)];

   294 		},

   295 

   296 		utcOffset : function (mom) {

   297 			return this.offsets[this._index(mom)];

   298 		}

   299 	};

   300 

   301 	/************************************

   302 		Current Timezone

   303 	************************************/

   304 

   305 	function OffsetAt(at) {

   306 		var timeString = at.toTimeString();

   307 		var abbr = timeString.match(/\([a-z ]+\)/i);

   308 		if (abbr && abbr[0]) {

   309 			// 17:56:31 GMT-0600 (CST)

   310 			// 17:56:31 GMT-0600 (Central Standard Time)

   311 			abbr = abbr[0].match(/[A-Z]/g);

   312 			abbr = abbr ? abbr.join('') : undefined;

   313 		} else {

   314 			// 17:56:31 CST

   315 			// 17:56:31 GMT+0800 (台北標準時間)

   316 			abbr = timeString.match(/[A-Z]{3,5}/g);

   317 			abbr = abbr ? abbr[0] : undefined;

   318 		}

   319 

   320 		if (abbr === 'GMT') {

   321 			abbr = undefined;

   322 		}

   323 

   324 		this.at = +at;

   325 		this.abbr = abbr;

   326 		this.offset = at.getTimezoneOffset();

   327 	}

   328 

   329 	function ZoneScore(zone) {

   330 		this.zone = zone;

   331 		this.offsetScore = 0;

   332 		this.abbrScore = 0;

   333 	}

   334 

   335 	ZoneScore.prototype.scoreOffsetAt = function (offsetAt) {

   336 		this.offsetScore += Math.abs(this.zone.utcOffset(offsetAt.at) - offsetAt.offset);

   337 		if (this.zone.abbr(offsetAt.at).replace(/[^A-Z]/g, '') !== offsetAt.abbr) {

   338 			this.abbrScore++;

   339 		}

   340 	};

   341 

   342 	function findChange(low, high) {

   343 		var mid, diff;

   344 

   345 		while ((diff = ((high.at - low.at) / 12e4 | 0) * 6e4)) {

   346 			mid = new OffsetAt(new Date(low.at + diff));

   347 			if (mid.offset === low.offset) {

   348 				low = mid;

   349 			} else {

   350 				high = mid;

   351 			}

   352 		}

   353 

   354 		return low;

   355 	}

   356 

   357 	function userOffsets() {

   358 		var startYear = new Date().getFullYear() - 2,

   359 			last = new OffsetAt(new Date(startYear, 0, 1)),

   360 			offsets = [last],

   361 			change, next, i;

   362 

   363 		for (i = 1; i < 48; i++) {

   364 			next = new OffsetAt(new Date(startYear, i, 1));

   365 			if (next.offset !== last.offset) {

   366 				change = findChange(last, next);

   367 				offsets.push(change);

   368 				offsets.push(new OffsetAt(new Date(change.at + 6e4)));

   369 			}

   370 			last = next;

   371 		}

   372 

   373 		for (i = 0; i < 4; i++) {

   374 			offsets.push(new OffsetAt(new Date(startYear + i, 0, 1)));

   375 			offsets.push(new OffsetAt(new Date(startYear + i, 6, 1)));

   376 		}

   377 

   378 		return offsets;

   379 	}

   380 

   381 	function sortZoneScores (a, b) {

   382 		if (a.offsetScore !== b.offsetScore) {

   383 			return a.offsetScore - b.offsetScore;

   384 		}

   385 		if (a.abbrScore !== b.abbrScore) {

   386 			return a.abbrScore - b.abbrScore;

   387 		}

   388 		return b.zone.population - a.zone.population;

   389 	}

   390 

   391 	function addToGuesses (name, offsets) {

   392 		var i, offset;

   393 		arrayToInt(offsets);

   394 		for (i = 0; i < offsets.length; i++) {

   395 			offset = offsets[i];

   396 			guesses[offset] = guesses[offset] || {};

   397 			guesses[offset][name] = true;

   398 		}

   399 	}

   400 

   401 	function guessesForUserOffsets (offsets) {

   402 		var offsetsLength = offsets.length,

   403 			filteredGuesses = {},

   404 			out = [],

   405 			i, j, guessesOffset;

   406 

   407 		for (i = 0; i < offsetsLength; i++) {

   408 			guessesOffset = guesses[offsets[i].offset] || {};

   409 			for (j in guessesOffset) {

   410 				if (guessesOffset.hasOwnProperty(j)) {

   411 					filteredGuesses[j] = true;

   412 				}

   413 			}

   414 		}

   415 

   416 		for (i in filteredGuesses) {

   417 			if (filteredGuesses.hasOwnProperty(i)) {

   418 				out.push(names[i]);

   419 			}

   420 		}

   421 

   422 		return out;

   423 	}

   424 

   425 	function rebuildGuess () {

   426 

   427 		// use Intl API when available and returning valid time zone

   428 		try {

   429 			var intlName = Intl.DateTimeFormat().resolvedOptions().timeZone;

   430 			if (intlName && intlName.length > 3) {

   431 				var name = names[normalizeName(intlName)];

   432 				if (name) {

   433 					return name;

   434 				}

   435 				logError("Moment Timezone found " + intlName + " from the Intl api, but did not have that data loaded.");

   436 			}

   437 		} catch (e) {

   438 			// Intl unavailable, fall back to manual guessing.

   439 		}

   440 

   441 		var offsets = userOffsets(),

   442 			offsetsLength = offsets.length,

   443 			guesses = guessesForUserOffsets(offsets),

   444 			zoneScores = [],

   445 			zoneScore, i, j;

   446 

   447 		for (i = 0; i < guesses.length; i++) {

   448 			zoneScore = new ZoneScore(getZone(guesses[i]), offsetsLength);

   449 			for (j = 0; j < offsetsLength; j++) {

   450 				zoneScore.scoreOffsetAt(offsets[j]);

   451 			}

   452 			zoneScores.push(zoneScore);

   453 		}

   454 

   455 		zoneScores.sort(sortZoneScores);

   456 

   457 		return zoneScores.length > 0 ? zoneScores[0].zone.name : undefined;

   458 	}

   459 

   460 	function guess (ignoreCache) {

   461 		if (!cachedGuess || ignoreCache) {

   462 			cachedGuess = rebuildGuess();

   463 		}

   464 		return cachedGuess;

   465 	}

   466 

   467 	/************************************

   468 		Global Methods

   469 	************************************/

   470 

   471 	function normalizeName (name) {

   472 		return (name || '').toLowerCase().replace(/\//g, '_');

   473 	}

   474 

   475 	function addZone (packed) {

   476 		var i, name, split, normalized;

   477 

   478 		if (typeof packed === "string") {

   479 			packed = [packed];

   480 		}

   481 

   482 		for (i = 0; i < packed.length; i++) {

   483 			split = packed[i].split('|');

   484 			name = split[0];

   485 			normalized = normalizeName(name);

   486 			zones[normalized] = packed[i];

   487 			names[normalized] = name;

   488 			addToGuesses(normalized, split[2].split(' '));

   489 		}

   490 	}

   491 

   492 	function getZone (name, caller) {

   493 		

   494 		name = normalizeName(name);

   495 

   496 		var zone = zones[name];

   497 		var link;

   498 

   499 		if (zone instanceof Zone) {

   500 			return zone;

   501 		}

   502 

   503 		if (typeof zone === 'string') {

   504 			zone = new Zone(zone);

   505 			zones[name] = zone;

   506 			return zone;

   507 		}

   508 

   509 		// Pass getZone to prevent recursion more than 1 level deep

   510 		if (links[name] && caller !== getZone && (link = getZone(links[name], getZone))) {

   511 			zone = zones[name] = new Zone();

   512 			zone._set(link);

   513 			zone.name = names[name];

   514 			return zone;

   515 		}

   516 

   517 		return null;

   518 	}

   519 

   520 	function getNames () {

   521 		var i, out = [];

   522 

   523 		for (i in names) {

   524 			if (names.hasOwnProperty(i) && (zones[i] || zones[links[i]]) && names[i]) {

   525 				out.push(names[i]);

   526 			}

   527 		}

   528 

   529 		return out.sort();

   530 	}

   531 

   532 	function addLink (aliases) {

   533 		var i, alias, normal0, normal1;

   534 

   535 		if (typeof aliases === "string") {

   536 			aliases = [aliases];

   537 		}

   538 

   539 		for (i = 0; i < aliases.length; i++) {

   540 			alias = aliases[i].split('|');

   541 

   542 			normal0 = normalizeName(alias[0]);

   543 			normal1 = normalizeName(alias[1]);

   544 

   545 			links[normal0] = normal1;

   546 			names[normal0] = alias[0];

   547 

   548 			links[normal1] = normal0;

   549 			names[normal1] = alias[1];

   550 		}

   551 	}

   552 

   553 	function loadData (data) {

   554 		addZone(data.zones);

   555 		addLink(data.links);

   556 		tz.dataVersion = data.version;

   557 	}

   558 

   559 	function zoneExists (name) {

   560 		if (!zoneExists.didShowError) {

   561 			zoneExists.didShowError = true;

   562 				logError("moment.tz.zoneExists('" + name + "') has been deprecated in favor of !moment.tz.zone('" + name + "')");

   563 		}

   564 		return !!getZone(name);

   565 	}

   566 

   567 	function needsOffset (m) {

   568 		var isUnixTimestamp = (m._f === 'X' || m._f === 'x');

   569 		return !!(m._a && (m._tzm === undefined) && !isUnixTimestamp);

   570 	}

   571 

   572 	function logError (message) {

   573 		if (typeof console !== 'undefined' && typeof console.error === 'function') {

   574 			console.error(message);

   575 		}

   576 	}

   577 

   578 	/************************************

   579 		moment.tz namespace

   580 	************************************/

   581 

   582 	function tz (input) {

   583 		var args = Array.prototype.slice.call(arguments, 0, -1),

   584 			name = arguments[arguments.length - 1],

   585 			zone = getZone(name),

   586 			out  = moment.utc.apply(null, args);

   587 

   588 		if (zone && !moment.isMoment(input) && needsOffset(out)) {

   589 			out.add(zone.parse(out), 'minutes');

   590 		}

   591 

   592 		out.tz(name);

   593 

   594 		return out;

   595 	}

   596 

   597 	tz.version      = VERSION;

   598 	tz.dataVersion  = '';

   599 	tz._zones       = zones;

   600 	tz._links       = links;

   601 	tz._names       = names;

   602 	tz.add          = addZone;

   603 	tz.link         = addLink;

   604 	tz.load         = loadData;

   605 	tz.zone         = getZone;

   606 	tz.zoneExists   = zoneExists; // deprecated in 0.1.0

   607 	tz.guess        = guess;

   608 	tz.names        = getNames;

   609 	tz.Zone         = Zone;

   610 	tz.unpack       = unpack;

   611 	tz.unpackBase60 = unpackBase60;

   612 	tz.needsOffset  = needsOffset;

   613 	tz.moveInvalidForward   = true;

   614 	tz.moveAmbiguousForward = false;

   615 

   616 	/************************************

   617 		Interface with Moment.js

   618 	************************************/

   619 

   620 	var fn = moment.fn;

   621 

   622 	moment.tz = tz;

   623 

   624 	moment.defaultZone = null;

   625 

   626 	moment.updateOffset = function (mom, keepTime) {

   627 		var zone = moment.defaultZone,

   628 			offset;

   629 

   630 		if (mom._z === undefined) {

   631 			if (zone && needsOffset(mom) && !mom._isUTC) {

   632 				mom._d = moment.utc(mom._a)._d;

   633 				mom.utc().add(zone.parse(mom), 'minutes');

   634 			}

   635 			mom._z = zone;

   636 		}

   637 		if (mom._z) {

   638 			offset = mom._z.utcOffset(mom);

   639 			if (Math.abs(offset) < 16) {

   640 				offset = offset / 60;

   641 			}

   642 			if (mom.utcOffset !== undefined) {

   643 				mom.utcOffset(-offset, keepTime);

   644 			} else {

   645 				mom.zone(offset, keepTime);

   646 			}

   647 		}

   648 	};

   649 

   650 	fn.tz = function (name, keepTime) {

   651 		if (name) {

   652 			if (typeof name !== 'string') {

   653 				throw new Error('Time zone name must be a string, got ' + name + ' [' + typeof name + ']');

   654 			}

   655 			this._z = getZone(name);

   656 			if (this._z) {

   657 				moment.updateOffset(this, keepTime);

   658 			} else {

   659 				logError("Moment Timezone has no data for " + name + ". See http://momentjs.com/timezone/docs/#/data-loading/.");

   660 			}

   661 			return this;

   662 		}

   663 		if (this._z) { return this._z.name; }

   664 	};

   665 

   666 	function abbrWrap (old) {

   667 		return function () {

   668 			if (this._z) { return this._z.abbr(this); }

   669 			return old.call(this);

   670 		};

   671 	}

   672 

   673 	function resetZoneWrap (old) {

   674 		return function () {

   675 			this._z = null;

   676 			return old.apply(this, arguments);

   677 		};

   678 	}

   679 

   680 	fn.zoneName = abbrWrap(fn.zoneName);

   681 	fn.zoneAbbr = abbrWrap(fn.zoneAbbr);

   682 	fn.utc      = resetZoneWrap(fn.utc);

   683 

   684 	moment.tz.setDefault = function(name) {

   685 		if (major < 2 || (major === 2 && minor < 9)) {

   686 			logError('Moment Timezone setDefault() requires Moment.js >= 2.9.0. You are using Moment.js ' + moment.version + '.');

   687 		}

   688 		moment.defaultZone = name ? getZone(name) : null;

   689 		return moment;

   690 	};

   691 

   692 	// Cloning a moment should include the _z property.

   693 	var momentProperties = moment.momentProperties;

   694 	if (Object.prototype.toString.call(momentProperties) === '[object Array]') {

   695 		// moment 2.8.1+

   696 		momentProperties.push('_z');

   697 		momentProperties.push('_a');

   698 	} else if (momentProperties) {

   699 		// moment 2.7.0

   700 		momentProperties._z = null;

   701 	}

   702 

   703 	// INJECT DATA

   704 

   705 	return moment;

   706 }));

   707 

   708 

   709 /***/ }),

   710 

   711 /***/ 29:

   712 /***/ (function(module, exports) {

   713 

   714 (function() { module.exports = this["moment"]; }());

   715 

   716 /***/ }),

   717 

   718 /***/ 335:

   719 /***/ (function(module, __webpack_exports__, __webpack_require__) {

   720 

   721 "use strict";

   722 __webpack_require__.r(__webpack_exports__);

   723 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "setSettings", function() { return setSettings; });

   724 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__experimentalGetSettings", function() { return __experimentalGetSettings; });

   725 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "format", function() { return format; });

   726 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "date", function() { return date; });

   727 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "gmdate", function() { return gmdate; });

   728 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "dateI18n", function() { return dateI18n; });

   729 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "isInTheFuture", function() { return isInTheFuture; });

   730 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "getDate", function() { return getDate; });

   731 /* harmony import */ var moment__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(29);

   732 /* harmony import */ var moment__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(moment__WEBPACK_IMPORTED_MODULE_0__);

   733 /* harmony import */ var moment_timezone_moment_timezone__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(198);

   734 /* harmony import */ var moment_timezone_moment_timezone__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(moment_timezone_moment_timezone__WEBPACK_IMPORTED_MODULE_1__);

   735 /* harmony import */ var moment_timezone_moment_timezone_utils__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(336);

   736 /* harmony import */ var moment_timezone_moment_timezone_utils__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(moment_timezone_moment_timezone_utils__WEBPACK_IMPORTED_MODULE_2__);

   737 /**

   738  * External dependencies

   739  */

   740 

   741 

   742 

   743 var WP_ZONE = 'WP'; // Changes made here will likely need to be made in `lib/client-assets.php` as

   744 // well because it uses the `setSettings()` function to change these settings.

   745 

   746 var settings = {

   747   l10n: {

   748     locale: 'en_US',

   749     months: ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'],

   750     monthsShort: ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'],

   751     weekdays: ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'],

   752     weekdaysShort: ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'],

   753     meridiem: {

   754       am: 'am',

   755       pm: 'pm',

   756       AM: 'AM',

   757       PM: 'PM'

   758     },

   759     relative: {

   760       future: ' % s from now',

   761       past: '% s ago'

   762     }

   763   },

   764   formats: {

   765     time: 'g: i a',

   766     date: 'F j, Y',

   767     datetime: 'F j, Y g: i a',

   768     datetimeAbbreviated: 'M j, Y g: i a'

   769   },

   770   timezone: {

   771     offset: '0',

   772     string: ''

   773   }

   774 };

   775 /**

   776  * Adds a locale to moment, using the format supplied by `wp_localize_script()`.

   777  *

   778  * @param {Object} dateSettings Settings, including locale data.

   779  */

   780 

   781 function setSettings(dateSettings) {

   782   settings = dateSettings; // Backup and restore current locale.

   783 

   784   var currentLocale = moment__WEBPACK_IMPORTED_MODULE_0___default.a.locale();

   785   moment__WEBPACK_IMPORTED_MODULE_0___default.a.updateLocale(dateSettings.l10n.locale, {

   786     // Inherit anything missing from the default locale.

   787     parentLocale: currentLocale,

   788     months: dateSettings.l10n.months,

   789     monthsShort: dateSettings.l10n.monthsShort,

   790     weekdays: dateSettings.l10n.weekdays,

   791     weekdaysShort: dateSettings.l10n.weekdaysShort,

   792     meridiem: function meridiem(hour, minute, isLowercase) {

   793       if (hour < 12) {

   794         return isLowercase ? dateSettings.l10n.meridiem.am : dateSettings.l10n.meridiem.AM;

   795       }

   796 

   797       return isLowercase ? dateSettings.l10n.meridiem.pm : dateSettings.l10n.meridiem.PM;

   798     },

   799     longDateFormat: {

   800       LT: dateSettings.formats.time,

   801       LTS: null,

   802       L: null,

   803       LL: dateSettings.formats.date,

   804       LLL: dateSettings.formats.datetime,

   805       LLLL: null

   806     },

   807     // From human_time_diff?

   808     // Set to `(number, withoutSuffix, key, isFuture) => {}` instead.

   809     relativeTime: {

   810       future: dateSettings.l10n.relative.future,

   811       past: dateSettings.l10n.relative.past,

   812       s: 'seconds',

   813       m: 'a minute',

   814       mm: '%d minutes',

   815       h: 'an hour',

   816       hh: '%d hours',

   817       d: 'a day',

   818       dd: '%d days',

   819       M: 'a month',

   820       MM: '%d months',

   821       y: 'a year',

   822       yy: '%d years'

   823     }

   824   });

   825   moment__WEBPACK_IMPORTED_MODULE_0___default.a.locale(currentLocale);

   826   setupWPTimezone();

   827 }

   828 /**

   829  * Returns the currently defined date settings.

   830  *

   831  * @return {Object} Settings, including locale data.

   832  */

   833 

   834 function __experimentalGetSettings() {

   835   return settings;

   836 }

   837 

   838 function setupWPTimezone() {

   839   // Create WP timezone based off dateSettings.

   840   moment__WEBPACK_IMPORTED_MODULE_0___default.a.tz.add(moment__WEBPACK_IMPORTED_MODULE_0___default.a.tz.pack({

   841     name: WP_ZONE,

   842     abbrs: [WP_ZONE],

   843     untils: [null],

   844     offsets: [-settings.timezone.offset * 60 || 0]

   845   }));

   846 } // Date constants.

   847 

   848 /**

   849  * Number of seconds in one minute.

   850  *

   851  * @type {Number}

   852  */

   853 

   854 

   855 var MINUTE_IN_SECONDS = 60;

   856 /**

   857  * Number of minutes in one hour.

   858  *

   859  * @type {Number}

   860  */

   861 

   862 var HOUR_IN_MINUTES = 60;

   863 /**

   864  * Number of seconds in one hour.

   865  *

   866  * @type {Number}

   867  */

   868 

   869 var HOUR_IN_SECONDS = 60 * MINUTE_IN_SECONDS;

   870 /**

   871  * Map of PHP formats to Moment.js formats.

   872  *

   873  * These are used internally by {@link wp.date.format}, and are either

   874  * a string representing the corresponding Moment.js format code, or a

   875  * function which returns the formatted string.

   876  *

   877  * This should only be used through {@link wp.date.format}, not

   878  * directly.

   879  *

   880  * @type {Object}

   881  */

   882 

   883 var formatMap = {

   884   // Day

   885   d: 'DD',

   886   D: 'ddd',

   887   j: 'D',

   888   l: 'dddd',

   889   N: 'E',

   890 

   891   /**

   892    * Gets the ordinal suffix.

   893    *

   894    * @param {moment} momentDate Moment instance.

   895    *

   896    * @return {string} Formatted date.

   897    */

   898   S: function S(momentDate) {

   899     // Do - D

   900     var num = momentDate.format('D');

   901     var withOrdinal = momentDate.format('Do');

   902     return withOrdinal.replace(num, '');

   903   },

   904   w: 'd',

   905 

   906   /**

   907    * Gets the day of the year (zero-indexed).

   908    *

   909    * @param {moment} momentDate Moment instance.

   910    *

   911    * @return {string} Formatted date.

   912    */

   913   z: function z(momentDate) {

   914     // DDD - 1

   915     return '' + parseInt(momentDate.format('DDD'), 10) - 1;

   916   },

   917   // Week

   918   W: 'W',

   919   // Month

   920   F: 'MMMM',

   921   m: 'MM',

   922   M: 'MMM',

   923   n: 'M',

   924 

   925   /**

   926    * Gets the days in the month.

   927    *

   928    * @param {moment} momentDate Moment instance.

   929    *

   930    * @return {string} Formatted date.

   931    */

   932   t: function t(momentDate) {

   933     return momentDate.daysInMonth();

   934   },

   935   // Year

   936 

   937   /**

   938    * Gets whether the current year is a leap year.

   939    *

   940    * @param {moment} momentDate Moment instance.

   941    *

   942    * @return {string} Formatted date.

   943    */

   944   L: function L(momentDate) {

   945     return momentDate.isLeapYear() ? '1' : '0';

   946   },

   947   o: 'GGGG',

   948   Y: 'YYYY',

   949   y: 'YY',

   950   // Time

   951   a: 'a',

   952   A: 'A',

   953 

   954   /**

   955    * Gets the current time in Swatch Internet Time (.beats).

   956    *

   957    * @param {moment} momentDate Moment instance.

   958    *

   959    * @return {string} Formatted date.

   960    */

   961   B: function B(momentDate) {

   962     var timezoned = moment__WEBPACK_IMPORTED_MODULE_0___default()(momentDate).utcOffset(60);

   963     var seconds = parseInt(timezoned.format('s'), 10),

   964         minutes = parseInt(timezoned.format('m'), 10),

   965         hours = parseInt(timezoned.format('H'), 10);

   966     return parseInt((seconds + minutes * MINUTE_IN_SECONDS + hours * HOUR_IN_SECONDS) / 86.4, 10);

   967   },

   968   g: 'h',

   969   G: 'H',

   970   h: 'hh',

   971   H: 'HH',

   972   i: 'mm',

   973   s: 'ss',

   974   u: 'SSSSSS',

   975   v: 'SSS',

   976   // Timezone

   977   e: 'zz',

   978 

   979   /**

   980    * Gets whether the timezone is in DST currently.

   981    *

   982    * @param {moment} momentDate Moment instance.

   983    *

   984    * @return {string} Formatted date.

   985    */

   986   I: function I(momentDate) {

   987     return momentDate.isDST() ? '1' : '0';

   988   },

   989   O: 'ZZ',

   990   P: 'Z',

   991   T: 'z',

   992 

   993   /**

   994    * Gets the timezone offset in seconds.

   995    *

   996    * @param {moment} momentDate Moment instance.

   997    *

   998    * @return {string} Formatted date.

   999    */

  1000   Z: function Z(momentDate) {

  1001     // Timezone offset in seconds.

  1002     var offset = momentDate.format('Z');

  1003     var sign = offset[0] === '-' ? -1 : 1;

  1004     var parts = offset.substring(1).split(':');

  1005     return sign * (parts[0] * HOUR_IN_MINUTES + parts[1]) * MINUTE_IN_SECONDS;

  1006   },

  1007   // Full date/time

  1008   c: 'YYYY-MM-DDTHH:mm:ssZ',

  1009   // .toISOString

  1010   r: 'ddd, D MMM YYYY HH:mm:ss ZZ',

  1011   U: 'X'

  1012 };

  1013 /**

  1014  * Formats a date. Does not alter the date's timezone.

  1015  *

  1016  * @param {string}                    dateFormat PHP-style formatting string.

  1017  *                                               See php.net/date.

  1018  * @param {(Date|string|moment|null)} dateValue  Date object or string,

  1019  *                                               parsable by moment.js.

  1020  *

  1021  * @return {string} Formatted date.

  1022  */

  1023 

  1024 function format(dateFormat) {

  1025   var dateValue = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Date();

  1026   var i, char;

  1027   var newFormat = [];

  1028   var momentDate = moment__WEBPACK_IMPORTED_MODULE_0___default()(dateValue);

  1029 

  1030   for (i = 0; i < dateFormat.length; i++) {

  1031     char = dateFormat[i]; // Is this an escape?

  1032 

  1033     if ('\\' === char) {

  1034       // Add next character, then move on.

  1035       i++;

  1036       newFormat.push('[' + dateFormat[i] + ']');

  1037       continue;

  1038     }

  1039 

  1040     if (char in formatMap) {

  1041       if (typeof formatMap[char] !== 'string') {

  1042         // If the format is a function, call it.

  1043         newFormat.push('[' + formatMap[char](momentDate) + ']');

  1044       } else {

  1045         // Otherwise, add as a formatting string.

  1046         newFormat.push(formatMap[char]);

  1047       }

  1048     } else {

  1049       newFormat.push('[' + char + ']');

  1050     }

  1051   } // Join with [] between to separate characters, and replace

  1052   // unneeded separators with static text.

  1053 

  1054 

  1055   newFormat = newFormat.join('[]');

  1056   return momentDate.format(newFormat);

  1057 }

  1058 /**

  1059  * Formats a date (like `date()` in PHP), in the site's timezone.

  1060  *

  1061  * @param {string}                    dateFormat PHP-style formatting string.

  1062  *                                               See php.net/date.

  1063  * @param {(Date|string|moment|null)} dateValue  Date object or string,

  1064  *                                               parsable by moment.js.

  1065  *

  1066  * @return {string} Formatted date.

  1067  */

  1068 

  1069 function date(dateFormat) {

  1070   var dateValue = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Date();

  1071   var offset = settings.timezone.offset * HOUR_IN_MINUTES;

  1072   var dateMoment = moment__WEBPACK_IMPORTED_MODULE_0___default()(dateValue).utcOffset(offset, true);

  1073   return format(dateFormat, dateMoment);

  1074 }

  1075 /**

  1076  * Formats a date (like `date()` in PHP), in the UTC timezone.

  1077  *

  1078  * @param {string}                    dateFormat PHP-style formatting string.

  1079  *                                               See php.net/date.

  1080  * @param {(Date|string|moment|null)} dateValue  Date object or string,

  1081  *                                               parsable by moment.js.

  1082  *

  1083  * @return {string} Formatted date.

  1084  */

  1085 

  1086 function gmdate(dateFormat) {

  1087   var dateValue = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Date();

  1088   var dateMoment = moment__WEBPACK_IMPORTED_MODULE_0___default()(dateValue).utc();

  1089   return format(dateFormat, dateMoment);

  1090 }

  1091 /**

  1092  * Formats a date (like `dateI18n()` in PHP).

  1093  *

  1094  * @param {string}                    dateFormat PHP-style formatting string.

  1095  *                                               See php.net/date.

  1096  * @param {(Date|string|moment|null)} dateValue  Date object or string,

  1097  *                                               parsable by moment.js.

  1098  * @param {boolean}                   gmt        True for GMT/UTC, false for

  1099  *                                               site's timezone.

  1100  *

  1101  * @return {string} Formatted date.

  1102  */

  1103 

  1104 function dateI18n(dateFormat) {

  1105   var dateValue = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Date();

  1106   var gmt = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;

  1107   // Defaults.

  1108   var offset = gmt ? 0 : settings.timezone.offset * HOUR_IN_MINUTES; // Convert to moment object.

  1109 

  1110   var dateMoment = moment__WEBPACK_IMPORTED_MODULE_0___default()(dateValue).utcOffset(offset, true); // Set the locale.

  1111 

  1112   dateMoment.locale(settings.l10n.locale); // Format and return.

  1113 

  1114   return format(dateFormat, dateMoment);

  1115 }

  1116 /**

  1117  * Check whether a date is considered in the future according to the WordPress settings.

  1118  *

  1119  * @param {string} dateValue Date String or Date object in the Defined WP Timezone.

  1120  *

  1121  * @return {boolean} Is in the future.

  1122  */

  1123 

  1124 function isInTheFuture(dateValue) {

  1125   var now = moment__WEBPACK_IMPORTED_MODULE_0___default.a.tz(WP_ZONE);

  1126   var momentObject = moment__WEBPACK_IMPORTED_MODULE_0___default.a.tz(dateValue, WP_ZONE);

  1127   return momentObject.isAfter(now);

  1128 }

  1129 /**

  1130  * Create and return a JavaScript Date Object from a date string in the WP timezone.

  1131  *

  1132  * @param {string?} dateString Date formatted in the WP timezone.

  1133  *

  1134  * @return {Date} Date

  1135  */