diff options
Diffstat (limited to 'srcs/wordpress/wp-includes/js/dist/date.js')
| -rw-r--r-- | srcs/wordpress/wp-includes/js/dist/date.js | 1503 |
1 files changed, 1503 insertions, 0 deletions
diff --git a/srcs/wordpress/wp-includes/js/dist/date.js b/srcs/wordpress/wp-includes/js/dist/date.js new file mode 100644 index 0000000..69082dd --- /dev/null +++ b/srcs/wordpress/wp-includes/js/dist/date.js @@ -0,0 +1,1503 @@ +this["wp"] = this["wp"] || {}; this["wp"]["date"] = +/******/ (function(modules) { // webpackBootstrap +/******/ // The module cache +/******/ var installedModules = {}; +/******/ +/******/ // The require function +/******/ function __webpack_require__(moduleId) { +/******/ +/******/ // Check if module is in cache +/******/ if(installedModules[moduleId]) { +/******/ return installedModules[moduleId].exports; +/******/ } +/******/ // Create a new module (and put it into the cache) +/******/ var module = installedModules[moduleId] = { +/******/ i: moduleId, +/******/ l: false, +/******/ exports: {} +/******/ }; +/******/ +/******/ // Execute the module function +/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); +/******/ +/******/ // Flag the module as loaded +/******/ module.l = true; +/******/ +/******/ // Return the exports of the module +/******/ return module.exports; +/******/ } +/******/ +/******/ +/******/ // expose the modules object (__webpack_modules__) +/******/ __webpack_require__.m = modules; +/******/ +/******/ // expose the module cache +/******/ __webpack_require__.c = installedModules; +/******/ +/******/ // define getter function for harmony exports +/******/ __webpack_require__.d = function(exports, name, getter) { +/******/ if(!__webpack_require__.o(exports, name)) { +/******/ Object.defineProperty(exports, name, { enumerable: true, get: getter }); +/******/ } +/******/ }; +/******/ +/******/ // define __esModule on exports +/******/ __webpack_require__.r = function(exports) { +/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) { +/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); +/******/ } +/******/ Object.defineProperty(exports, '__esModule', { value: true }); +/******/ }; +/******/ +/******/ // create a fake namespace object +/******/ // mode & 1: value is a module id, require it +/******/ // mode & 2: merge all properties of value into the ns +/******/ // mode & 4: return value when already ns object +/******/ // mode & 8|1: behave like require +/******/ __webpack_require__.t = function(value, mode) { +/******/ if(mode & 1) value = __webpack_require__(value); +/******/ if(mode & 8) return value; +/******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value; +/******/ var ns = Object.create(null); +/******/ __webpack_require__.r(ns); +/******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value }); +/******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key)); +/******/ return ns; +/******/ }; +/******/ +/******/ // getDefaultExport function for compatibility with non-harmony modules +/******/ __webpack_require__.n = function(module) { +/******/ var getter = module && module.__esModule ? +/******/ function getDefault() { return module['default']; } : +/******/ function getModuleExports() { return module; }; +/******/ __webpack_require__.d(getter, 'a', getter); +/******/ return getter; +/******/ }; +/******/ +/******/ // Object.prototype.hasOwnProperty.call +/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); }; +/******/ +/******/ // __webpack_public_path__ +/******/ __webpack_require__.p = ""; +/******/ +/******/ +/******/ // Load entry module and return exports +/******/ return __webpack_require__(__webpack_require__.s = 319); +/******/ }) +/************************************************************************/ +/******/ ({ + +/***/ 211: +/***/ (function(module, exports, __webpack_require__) { + +var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;//! moment-timezone.js +//! version : 0.5.26 +//! Copyright (c) JS Foundation and other contributors +//! license : MIT +//! github.com/moment/moment-timezone + +(function (root, factory) { + "use strict"; + + /*global define*/ + if ( true && module.exports) { + module.exports = factory(__webpack_require__(29)); // Node + } else if (true) { + !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(29)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), + __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? + (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), + __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD + } else {} +}(this, function (moment) { + "use strict"; + + // Do not load moment-timezone a second time. + // if (moment.tz !== undefined) { + // logError('Moment Timezone ' + moment.tz.version + ' was already loaded ' + (moment.tz.dataVersion ? 'with data from ' : 'without any data') + moment.tz.dataVersion); + // return moment; + // } + + var VERSION = "0.5.26", + zones = {}, + links = {}, + names = {}, + guesses = {}, + cachedGuess; + + if (!moment || typeof moment.version !== 'string') { + logError('Moment Timezone requires Moment.js. See https://momentjs.com/timezone/docs/#/use-it/browser/'); + } + + var momentVersion = moment.version.split('.'), + major = +momentVersion[0], + minor = +momentVersion[1]; + + // Moment.js version check + if (major < 2 || (major === 2 && minor < 6)) { + logError('Moment Timezone requires Moment.js >= 2.6.0. You are using Moment.js ' + moment.version + '. See momentjs.com'); + } + + /************************************ + Unpacking + ************************************/ + + function charCodeToInt(charCode) { + if (charCode > 96) { + return charCode - 87; + } else if (charCode > 64) { + return charCode - 29; + } + return charCode - 48; + } + + function unpackBase60(string) { + var i = 0, + parts = string.split('.'), + whole = parts[0], + fractional = parts[1] || '', + multiplier = 1, + num, + out = 0, + sign = 1; + + // handle negative numbers + if (string.charCodeAt(0) === 45) { + i = 1; + sign = -1; + } + + // handle digits before the decimal + for (i; i < whole.length; i++) { + num = charCodeToInt(whole.charCodeAt(i)); + out = 60 * out + num; + } + + // handle digits after the decimal + for (i = 0; i < fractional.length; i++) { + multiplier = multiplier / 60; + num = charCodeToInt(fractional.charCodeAt(i)); + out += num * multiplier; + } + + return out * sign; + } + + function arrayToInt (array) { + for (var i = 0; i < array.length; i++) { + array[i] = unpackBase60(array[i]); + } + } + + function intToUntil (array, length) { + for (var i = 0; i < length; i++) { + array[i] = Math.round((array[i - 1] || 0) + (array[i] * 60000)); // minutes to milliseconds + } + + array[length - 1] = Infinity; + } + + function mapIndices (source, indices) { + var out = [], i; + + for (i = 0; i < indices.length; i++) { + out[i] = source[indices[i]]; + } + + return out; + } + + function unpack (string) { + var data = string.split('|'), + offsets = data[2].split(' '), + indices = data[3].split(''), + untils = data[4].split(' '); + + arrayToInt(offsets); + arrayToInt(indices); + arrayToInt(untils); + + intToUntil(untils, indices.length); + + return { + name : data[0], + abbrs : mapIndices(data[1].split(' '), indices), + offsets : mapIndices(offsets, indices), + untils : untils, + population : data[5] | 0 + }; + } + + /************************************ + Zone object + ************************************/ + + function Zone (packedString) { + if (packedString) { + this._set(unpack(packedString)); + } + } + + Zone.prototype = { + _set : function (unpacked) { + this.name = unpacked.name; + this.abbrs = unpacked.abbrs; + this.untils = unpacked.untils; + this.offsets = unpacked.offsets; + this.population = unpacked.population; + }, + + _index : function (timestamp) { + var target = +timestamp, + untils = this.untils, + i; + + for (i = 0; i < untils.length; i++) { + if (target < untils[i]) { + return i; + } + } + }, + + parse : function (timestamp) { + var target = +timestamp, + offsets = this.offsets, + untils = this.untils, + max = untils.length - 1, + offset, offsetNext, offsetPrev, i; + + for (i = 0; i < max; i++) { + offset = offsets[i]; + offsetNext = offsets[i + 1]; + offsetPrev = offsets[i ? i - 1 : i]; + + if (offset < offsetNext && tz.moveAmbiguousForward) { + offset = offsetNext; + } else if (offset > offsetPrev && tz.moveInvalidForward) { + offset = offsetPrev; + } + + if (target < untils[i] - (offset * 60000)) { + return offsets[i]; + } + } + + return offsets[max]; + }, + + abbr : function (mom) { + return this.abbrs[this._index(mom)]; + }, + + offset : function (mom) { + logError("zone.offset has been deprecated in favor of zone.utcOffset"); + return this.offsets[this._index(mom)]; + }, + + utcOffset : function (mom) { + return this.offsets[this._index(mom)]; + } + }; + + /************************************ + Current Timezone + ************************************/ + + function OffsetAt(at) { + var timeString = at.toTimeString(); + var abbr = timeString.match(/\([a-z ]+\)/i); + if (abbr && abbr[0]) { + // 17:56:31 GMT-0600 (CST) + // 17:56:31 GMT-0600 (Central Standard Time) + abbr = abbr[0].match(/[A-Z]/g); + abbr = abbr ? abbr.join('') : undefined; + } else { + // 17:56:31 CST + // 17:56:31 GMT+0800 (台北標準時間) + abbr = timeString.match(/[A-Z]{3,5}/g); + abbr = abbr ? abbr[0] : undefined; + } + + if (abbr === 'GMT') { + abbr = undefined; + } + + this.at = +at; + this.abbr = abbr; + this.offset = at.getTimezoneOffset(); + } + + function ZoneScore(zone) { + this.zone = zone; + this.offsetScore = 0; + this.abbrScore = 0; + } + + ZoneScore.prototype.scoreOffsetAt = function (offsetAt) { + this.offsetScore += Math.abs(this.zone.utcOffset(offsetAt.at) - offsetAt.offset); + if (this.zone.abbr(offsetAt.at).replace(/[^A-Z]/g, '') !== offsetAt.abbr) { + this.abbrScore++; + } + }; + + function findChange(low, high) { + var mid, diff; + + while ((diff = ((high.at - low.at) / 12e4 | 0) * 6e4)) { + mid = new OffsetAt(new Date(low.at + diff)); + if (mid.offset === low.offset) { + low = mid; + } else { + high = mid; + } + } + + return low; + } + + function userOffsets() { + var startYear = new Date().getFullYear() - 2, + last = new OffsetAt(new Date(startYear, 0, 1)), + offsets = [last], + change, next, i; + + for (i = 1; i < 48; i++) { + next = new OffsetAt(new Date(startYear, i, 1)); + if (next.offset !== last.offset) { + change = findChange(last, next); + offsets.push(change); + offsets.push(new OffsetAt(new Date(change.at + 6e4))); + } + last = next; + } + + for (i = 0; i < 4; i++) { + offsets.push(new OffsetAt(new Date(startYear + i, 0, 1))); + offsets.push(new OffsetAt(new Date(startYear + i, 6, 1))); + } + + return offsets; + } + + function sortZoneScores (a, b) { + if (a.offsetScore !== b.offsetScore) { + return a.offsetScore - b.offsetScore; + } + if (a.abbrScore !== b.abbrScore) { + return a.abbrScore - b.abbrScore; + } + if (a.zone.population !== b.zone.population) { + return b.zone.population - a.zone.population; + } + return b.zone.name.localeCompare(a.zone.name); + } + + function addToGuesses (name, offsets) { + var i, offset; + arrayToInt(offsets); + for (i = 0; i < offsets.length; i++) { + offset = offsets[i]; + guesses[offset] = guesses[offset] || {}; + guesses[offset][name] = true; + } + } + + function guessesForUserOffsets (offsets) { + var offsetsLength = offsets.length, + filteredGuesses = {}, + out = [], + i, j, guessesOffset; + + for (i = 0; i < offsetsLength; i++) { + guessesOffset = guesses[offsets[i].offset] || {}; + for (j in guessesOffset) { + if (guessesOffset.hasOwnProperty(j)) { + filteredGuesses[j] = true; + } + } + } + + for (i in filteredGuesses) { + if (filteredGuesses.hasOwnProperty(i)) { + out.push(names[i]); + } + } + + return out; + } + + function rebuildGuess () { + + // use Intl API when available and returning valid time zone + try { + var intlName = Intl.DateTimeFormat().resolvedOptions().timeZone; + if (intlName && intlName.length > 3) { + var name = names[normalizeName(intlName)]; + if (name) { + return name; + } + logError("Moment Timezone found " + intlName + " from the Intl api, but did not have that data loaded."); + } + } catch (e) { + // Intl unavailable, fall back to manual guessing. + } + + var offsets = userOffsets(), + offsetsLength = offsets.length, + guesses = guessesForUserOffsets(offsets), + zoneScores = [], + zoneScore, i, j; + + for (i = 0; i < guesses.length; i++) { + zoneScore = new ZoneScore(getZone(guesses[i]), offsetsLength); + for (j = 0; j < offsetsLength; j++) { + zoneScore.scoreOffsetAt(offsets[j]); + } + zoneScores.push(zoneScore); + } + + zoneScores.sort(sortZoneScores); + + return zoneScores.length > 0 ? zoneScores[0].zone.name : undefined; + } + + function guess (ignoreCache) { + if (!cachedGuess || ignoreCache) { + cachedGuess = rebuildGuess(); + } + return cachedGuess; + } + + /************************************ + Global Methods + ************************************/ + + function normalizeName (name) { + return (name || '').toLowerCase().replace(/\//g, '_'); + } + + function addZone (packed) { + var i, name, split, normalized; + + if (typeof packed === "string") { + packed = [packed]; + } + + for (i = 0; i < packed.length; i++) { + split = packed[i].split('|'); + name = split[0]; + normalized = normalizeName(name); + zones[normalized] = packed[i]; + names[normalized] = name; + addToGuesses(normalized, split[2].split(' ')); + } + } + + function getZone (name, caller) { + + name = normalizeName(name); + + var zone = zones[name]; + var link; + + if (zone instanceof Zone) { + return zone; + } + + if (typeof zone === 'string') { + zone = new Zone(zone); + zones[name] = zone; + return zone; + } + + // Pass getZone to prevent recursion more than 1 level deep + if (links[name] && caller !== getZone && (link = getZone(links[name], getZone))) { + zone = zones[name] = new Zone(); + zone._set(link); + zone.name = names[name]; + return zone; + } + + return null; + } + + function getNames () { + var i, out = []; + + for (i in names) { + if (names.hasOwnProperty(i) && (zones[i] || zones[links[i]]) && names[i]) { + out.push(names[i]); + } + } + + return out.sort(); + } + + function addLink (aliases) { + var i, alias, normal0, normal1; + + if (typeof aliases === "string") { + aliases = [aliases]; + } + + for (i = 0; i < aliases.length; i++) { + alias = aliases[i].split('|'); + + normal0 = normalizeName(alias[0]); + normal1 = normalizeName(alias[1]); + + links[normal0] = normal1; + names[normal0] = alias[0]; + + links[normal1] = normal0; + names[normal1] = alias[1]; + } + } + + function loadData (data) { + addZone(data.zones); + addLink(data.links); + tz.dataVersion = data.version; + } + + function zoneExists (name) { + if (!zoneExists.didShowError) { + zoneExists.didShowError = true; + logError("moment.tz.zoneExists('" + name + "') has been deprecated in favor of !moment.tz.zone('" + name + "')"); + } + return !!getZone(name); + } + + function needsOffset (m) { + var isUnixTimestamp = (m._f === 'X' || m._f === 'x'); + return !!(m._a && (m._tzm === undefined) && !isUnixTimestamp); + } + + function logError (message) { + if (typeof console !== 'undefined' && typeof console.error === 'function') { + console.error(message); + } + } + + /************************************ + moment.tz namespace + ************************************/ + + function tz (input) { + var args = Array.prototype.slice.call(arguments, 0, -1), + name = arguments[arguments.length - 1], + zone = getZone(name), + out = moment.utc.apply(null, args); + + if (zone && !moment.isMoment(input) && needsOffset(out)) { + out.add(zone.parse(out), 'minutes'); + } + + out.tz(name); + + return out; + } + + tz.version = VERSION; + tz.dataVersion = ''; + tz._zones = zones; + tz._links = links; + tz._names = names; + tz.add = addZone; + tz.link = addLink; + tz.load = loadData; + tz.zone = getZone; + tz.zoneExists = zoneExists; // deprecated in 0.1.0 + tz.guess = guess; + tz.names = getNames; + tz.Zone = Zone; + tz.unpack = unpack; + tz.unpackBase60 = unpackBase60; + tz.needsOffset = needsOffset; + tz.moveInvalidForward = true; + tz.moveAmbiguousForward = false; + + /************************************ + Interface with Moment.js + ************************************/ + + var fn = moment.fn; + + moment.tz = tz; + + moment.defaultZone = null; + + moment.updateOffset = function (mom, keepTime) { + var zone = moment.defaultZone, + offset; + + if (mom._z === undefined) { + if (zone && needsOffset(mom) && !mom._isUTC) { + mom._d = moment.utc(mom._a)._d; + mom.utc().add(zone.parse(mom), 'minutes'); + } + mom._z = zone; + } + if (mom._z) { + offset = mom._z.utcOffset(mom); + if (Math.abs(offset) < 16) { + offset = offset / 60; + } + if (mom.utcOffset !== undefined) { + var z = mom._z; + mom.utcOffset(-offset, keepTime); + mom._z = z; + } else { + mom.zone(offset, keepTime); + } + } + }; + + fn.tz = function (name, keepTime) { + if (name) { + if (typeof name !== 'string') { + throw new Error('Time zone name must be a string, got ' + name + ' [' + typeof name + ']'); + } + this._z = getZone(name); + if (this._z) { + moment.updateOffset(this, keepTime); + } else { + logError("Moment Timezone has no data for " + name + ". See http://momentjs.com/timezone/docs/#/data-loading/."); + } + return this; + } + if (this._z) { return this._z.name; } + }; + + function abbrWrap (old) { + return function () { + if (this._z) { return this._z.abbr(this); } + return old.call(this); + }; + } + + function resetZoneWrap (old) { + return function () { + this._z = null; + return old.apply(this, arguments); + }; + } + + function resetZoneWrap2 (old) { + return function () { + if (arguments.length > 0) this._z = null; + return old.apply(this, arguments); + }; + } + + fn.zoneName = abbrWrap(fn.zoneName); + fn.zoneAbbr = abbrWrap(fn.zoneAbbr); + fn.utc = resetZoneWrap(fn.utc); + fn.local = resetZoneWrap(fn.local); + fn.utcOffset = resetZoneWrap2(fn.utcOffset); + + moment.tz.setDefault = function(name) { + if (major < 2 || (major === 2 && minor < 9)) { + logError('Moment Timezone setDefault() requires Moment.js >= 2.9.0. You are using Moment.js ' + moment.version + '.'); + } + moment.defaultZone = name ? getZone(name) : null; + return moment; + }; + + // Cloning a moment should include the _z property. + var momentProperties = moment.momentProperties; + if (Object.prototype.toString.call(momentProperties) === '[object Array]') { + // moment 2.8.1+ + momentProperties.push('_z'); + momentProperties.push('_a'); + } else if (momentProperties) { + // moment 2.7.0 + momentProperties._z = null; + } + + // INJECT DATA + + return moment; +})); + + +/***/ }), + +/***/ 29: +/***/ (function(module, exports) { + +(function() { module.exports = this["moment"]; }()); + +/***/ }), + +/***/ 319: +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "setSettings", function() { return setSettings; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__experimentalGetSettings", function() { return __experimentalGetSettings; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "format", function() { return format; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "date", function() { return date; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "gmdate", function() { return gmdate; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "dateI18n", function() { return dateI18n; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "isInTheFuture", function() { return isInTheFuture; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "getDate", function() { return getDate; }); +/* harmony import */ var moment__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(29); +/* harmony import */ var moment__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(moment__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var moment_timezone_moment_timezone__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(211); +/* harmony import */ var moment_timezone_moment_timezone__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(moment_timezone_moment_timezone__WEBPACK_IMPORTED_MODULE_1__); +/* harmony import */ var moment_timezone_moment_timezone_utils__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(320); +/* 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__); +/** + * External dependencies + */ + + + +var WP_ZONE = 'WP'; // Changes made here will likely need to be made in `lib/client-assets.php` as +// well because it uses the `setSettings()` function to change these settings. + +var settings = { + l10n: { + locale: 'en', + months: ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'], + monthsShort: ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'], + weekdays: ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'], + weekdaysShort: ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'], + meridiem: { + am: 'am', + pm: 'pm', + AM: 'AM', + PM: 'PM' + }, + relative: { + future: '%s from now', + past: '%s ago', + s: 'a few seconds', + ss: '%d seconds', + m: 'a minute', + mm: '%d minutes', + h: 'an hour', + hh: '%d hours', + d: 'a day', + dd: '%d days', + M: 'a month', + MM: '%d months', + y: 'a year', + yy: '%d years' + } + }, + formats: { + time: 'g: i a', + date: 'F j, Y', + datetime: 'F j, Y g: i a', + datetimeAbbreviated: 'M j, Y g: i a' + }, + timezone: { + offset: '0', + string: '' + } +}; +/** + * Adds a locale to moment, using the format supplied by `wp_localize_script()`. + * + * @param {Object} dateSettings Settings, including locale data. + */ + +function setSettings(dateSettings) { + settings = dateSettings; // Backup and restore current locale. + + var currentLocale = moment__WEBPACK_IMPORTED_MODULE_0___default.a.locale(); + moment__WEBPACK_IMPORTED_MODULE_0___default.a.updateLocale(dateSettings.l10n.locale, { + // Inherit anything missing from the default locale. + parentLocale: currentLocale, + months: dateSettings.l10n.months, + monthsShort: dateSettings.l10n.monthsShort, + weekdays: dateSettings.l10n.weekdays, + weekdaysShort: dateSettings.l10n.weekdaysShort, + meridiem: function meridiem(hour, minute, isLowercase) { + if (hour < 12) { + return isLowercase ? dateSettings.l10n.meridiem.am : dateSettings.l10n.meridiem.AM; + } + + return isLowercase ? dateSettings.l10n.meridiem.pm : dateSettings.l10n.meridiem.PM; + }, + longDateFormat: { + LT: dateSettings.formats.time, + LTS: null, + L: null, + LL: dateSettings.formats.date, + LLL: dateSettings.formats.datetime, + LLLL: null + }, + // From human_time_diff? + // Set to `(number, withoutSuffix, key, isFuture) => {}` instead. + relativeTime: dateSettings.l10n.relative + }); + moment__WEBPACK_IMPORTED_MODULE_0___default.a.locale(currentLocale); + setupWPTimezone(); +} +/** + * Returns the currently defined date settings. + * + * @return {Object} Settings, including locale data. + */ + +function __experimentalGetSettings() { + return settings; +} + +function setupWPTimezone() { + // Create WP timezone based off dateSettings. + moment__WEBPACK_IMPORTED_MODULE_0___default.a.tz.add(moment__WEBPACK_IMPORTED_MODULE_0___default.a.tz.pack({ + name: WP_ZONE, + abbrs: [WP_ZONE], + untils: [null], + offsets: [-settings.timezone.offset * 60 || 0] + })); +} // Date constants. + +/** + * Number of seconds in one minute. + * + * @type {number} + */ + + +var MINUTE_IN_SECONDS = 60; +/** + * Number of minutes in one hour. + * + * @type {number} + */ + +var HOUR_IN_MINUTES = 60; +/** + * Number of seconds in one hour. + * + * @type {number} + */ + +var HOUR_IN_SECONDS = 60 * MINUTE_IN_SECONDS; +/** + * Map of PHP formats to Moment.js formats. + * + * These are used internally by {@link wp.date.format}, and are either + * a string representing the corresponding Moment.js format code, or a + * function which returns the formatted string. + * + * This should only be used through {@link wp.date.format}, not + * directly. + * + * @type {Object} + */ + +var formatMap = { + // Day + d: 'DD', + D: 'ddd', + j: 'D', + l: 'dddd', + N: 'E', + + /** + * Gets the ordinal suffix. + * + * @param {moment} momentDate Moment instance. + * + * @return {string} Formatted date. + */ + S: function S(momentDate) { + // Do - D + var num = momentDate.format('D'); + var withOrdinal = momentDate.format('Do'); + return withOrdinal.replace(num, ''); + }, + w: 'd', + + /** + * Gets the day of the year (zero-indexed). + * + * @param {moment} momentDate Moment instance. + * + * @return {string} Formatted date. + */ + z: function z(momentDate) { + // DDD - 1 + return '' + parseInt(momentDate.format('DDD'), 10) - 1; + }, + // Week + W: 'W', + // Month + F: 'MMMM', + m: 'MM', + M: 'MMM', + n: 'M', + + /** + * Gets the days in the month. + * + * @param {moment} momentDate Moment instance. + * + * @return {string} Formatted date. + */ + t: function t(momentDate) { + return momentDate.daysInMonth(); + }, + // Year + + /** + * Gets whether the current year is a leap year. + * + * @param {moment} momentDate Moment instance. + * + * @return {string} Formatted date. + */ + L: function L(momentDate) { + return momentDate.isLeapYear() ? '1' : '0'; + }, + o: 'GGGG', + Y: 'YYYY', + y: 'YY', + // Time + a: 'a', + A: 'A', + + /** + * Gets the current time in Swatch Internet Time (.beats). + * + * @param {moment} momentDate Moment instance. + * + * @return {string} Formatted date. + */ + B: function B(momentDate) { + var timezoned = moment__WEBPACK_IMPORTED_MODULE_0___default()(momentDate).utcOffset(60); + var seconds = parseInt(timezoned.format('s'), 10), + minutes = parseInt(timezoned.format('m'), 10), + hours = parseInt(timezoned.format('H'), 10); + return parseInt((seconds + minutes * MINUTE_IN_SECONDS + hours * HOUR_IN_SECONDS) / 86.4, 10); + }, + g: 'h', + G: 'H', + h: 'hh', + H: 'HH', + i: 'mm', + s: 'ss', + u: 'SSSSSS', + v: 'SSS', + // Timezone + e: 'zz', + + /** + * Gets whether the timezone is in DST currently. + * + * @param {moment} momentDate Moment instance. + * + * @return {string} Formatted date. + */ + I: function I(momentDate) { + return momentDate.isDST() ? '1' : '0'; + }, + O: 'ZZ', + P: 'Z', + T: 'z', + + /** + * Gets the timezone offset in seconds. + * + * @param {moment} momentDate Moment instance. + * + * @return {string} Formatted date. + */ + Z: function Z(momentDate) { + // Timezone offset in seconds. + var offset = momentDate.format('Z'); + var sign = offset[0] === '-' ? -1 : 1; + var parts = offset.substring(1).split(':'); + return sign * (parts[0] * HOUR_IN_MINUTES + parts[1]) * MINUTE_IN_SECONDS; + }, + // Full date/time + c: 'YYYY-MM-DDTHH:mm:ssZ', + // .toISOString + r: 'ddd, D MMM YYYY HH:mm:ss ZZ', + U: 'X' +}; +/** + * Formats a date. Does not alter the date's timezone. + * + * @param {string} dateFormat PHP-style formatting string. + * See php.net/date. + * @param {(Date|string|moment|null)} dateValue Date object or string, + * parsable by moment.js. + * + * @return {string} Formatted date. + */ + +function format(dateFormat) { + var dateValue = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Date(); + var i, char; + var newFormat = []; + var momentDate = moment__WEBPACK_IMPORTED_MODULE_0___default()(dateValue); + + for (i = 0; i < dateFormat.length; i++) { + char = dateFormat[i]; // Is this an escape? + + if ('\\' === char) { + // Add next character, then move on. + i++; + newFormat.push('[' + dateFormat[i] + ']'); + continue; + } + + if (char in formatMap) { + if (typeof formatMap[char] !== 'string') { + // If the format is a function, call it. + newFormat.push('[' + formatMap[char](momentDate) + ']'); + } else { + // Otherwise, add as a formatting string. + newFormat.push(formatMap[char]); + } + } else { + newFormat.push('[' + char + ']'); + } + } // Join with [] between to separate characters, and replace + // unneeded separators with static text. + + + newFormat = newFormat.join('[]'); + return momentDate.format(newFormat); +} +/** + * Formats a date (like `date()` in PHP), in the site's timezone. + * + * @param {string} dateFormat PHP-style formatting string. + * See php.net/date. + * @param {(Date|string|moment|null)} dateValue Date object or string, + * parsable by moment.js. + * + * @return {string} Formatted date. + */ + +function date(dateFormat) { + var dateValue = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Date(); + var offset = settings.timezone.offset * HOUR_IN_MINUTES; + var dateMoment = moment__WEBPACK_IMPORTED_MODULE_0___default()(dateValue).utcOffset(offset, true); + return format(dateFormat, dateMoment); +} +/** + * Formats a date (like `date()` in PHP), in the UTC timezone. + * + * @param {string} dateFormat PHP-style formatting string. + * See php.net/date. + * @param {(Date|string|moment|null)} dateValue Date object or string, + * parsable by moment.js. + * + * @return {string} Formatted date. + */ + +function gmdate(dateFormat) { + var dateValue = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Date(); + var dateMoment = moment__WEBPACK_IMPORTED_MODULE_0___default()(dateValue).utc(); + return format(dateFormat, dateMoment); +} +/** + * Formats a date (like `date_i18n()` in PHP). + * + * @param {string} dateFormat PHP-style formatting string. + * See php.net/date. + * @param {(Date|string|moment|null)} dateValue Date object or string, + * parsable by moment.js. + * @param {boolean} gmt True for GMT/UTC, false for + * site's timezone. + * + * @return {string} Formatted date. + */ + +function dateI18n(dateFormat) { + var dateValue = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Date(); + var gmt = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; + // Defaults. + var offset = gmt ? 0 : settings.timezone.offset * HOUR_IN_MINUTES; // Convert to moment object. + + var dateMoment = moment__WEBPACK_IMPORTED_MODULE_0___default()(dateValue).utcOffset(offset, true); // Set the locale. + + dateMoment.locale(settings.l10n.locale); // Format and return. + + return format(dateFormat, dateMoment); +} +/** + * Check whether a date is considered in the future according to the WordPress settings. + * + * @param {string} dateValue Date String or Date object in the Defined WP Timezone. + * + * @return {boolean} Is in the future. + */ + +function isInTheFuture(dateValue) { + var now = moment__WEBPACK_IMPORTED_MODULE_0___default.a.tz(WP_ZONE); + var momentObject = moment__WEBPACK_IMPORTED_MODULE_0___default.a.tz(dateValue, WP_ZONE); + return momentObject.isAfter(now); +} +/** + * Create and return a JavaScript Date Object from a date string in the WP timezone. + * |