quasar 2.18.6 → 2.19.0

package/src/utils/date/date.js

@@ -1,30 +1,27 @@
-/* eslint no-fallthrough: 0 */
-
 import { isDate } from '../is/is.js'
 import { pad, capitalize } from '../format/format.js'
 import { jalaaliMonthLength } from './private.persian.js'
 import Lang, { defaultLang } from '../../plugins/lang/Lang.js'
 
-const
-  MILLISECONDS_IN_DAY = 86400000,
+const MILLISECONDS_IN_DAY = 86400000,
   MILLISECONDS_IN_HOUR = 3600000,
   MILLISECONDS_IN_MINUTE = 60000,
   defaultMask = 'YYYY-MM-DDTHH:mm:ss.SSSZ',
-  token = /\[((?:[^\]\\]|\\]|\\)*)\]|do|d{1,4}|Mo|M{1,4}|m{1,2}|wo|w{1,2}|Qo|Do|DDDo|D{1,4}|YY(?:YY)?|H{1,2}|h{1,2}|s{1,2}|S{1,3}|Z{1,2}|a{1,2}|[AQExX]/g,
-  reverseToken = /(\[[^\]]*\])|do|d{1,4}|Mo|M{1,4}|m{1,2}|wo|w{1,2}|Qo|Do|DDDo|D{1,4}|YY(?:YY)?|H{1,2}|h{1,2}|s{1,2}|S{1,3}|Z{1,2}|a{1,2}|[AQExX]|([.*+:?^,\s${}()|\\]+)/g,
+  token =
+    /\[((?:[^\]\\]|\\]|\\)*)\]|do|d{1,4}|Mo|M{1,4}|m{1,2}|wo|w{1,2}|Qo|Do|DDDo|D{1,4}|YY(?:YY)?|H{1,2}|h{1,2}|s{1,2}|S{1,3}|Z{1,2}|a{1,2}|[AQExX]/g,
+  reverseToken =
+    /(\[[^\]]*\])|do|d{1,4}|Mo|M{1,4}|m{1,2}|wo|w{1,2}|Qo|Do|DDDo|D{1,4}|YY(?:YY)?|H{1,2}|h{1,2}|s{1,2}|S{1,3}|Z{1,2}|a{1,2}|[AQExX]|([.*+:?^,\s${}()|\\]+)/g,
   regexStore = {}
 
-function getRegexData (mask, dateLocale) {
-  const
-    days = '(' + dateLocale.days.join('|') + ')',
+function getRegexData(mask, dateLocale) {
+  const days = '(' + dateLocale.days.join('|') + ')',
     key = mask + days
 
-  if (regexStore[ key ] !== void 0) {
-    return regexStore[ key ]
+  if (regexStore[key] !== void 0) {
+    return regexStore[key]
   }
 
-  const
-    daysShort = '(' + dateLocale.daysShort.join('|') + ')',
+  const daysShort = '(' + dateLocale.daysShort.join('|') + ')',
     months = '(' + dateLocale.months.join('|') + ')',
     monthsShort = '(' + dateLocale.monthsShort.join('|') + ')'
 
@@ -150,7 +147,7 @@ function getRegexData (mask, dateLocale) {
 
       default:
         index--
-        if (match[ 0 ] === '[') {
+        if (match[0] === '[') {
           match = match.substring(1, match.length - 1)
         }
         return match.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
@@ -158,24 +155,21 @@ function getRegexData (mask, dateLocale) {
   })
 
   const res = { map, regex: new RegExp('^' + regexText) }
-  regexStore[ key ] = res
+  regexStore[key] = res
 
   return res
 }
 
-function getDateLocale (paramDateLocale, langProps) {
+function getDateLocale(paramDateLocale, langProps) {
   return paramDateLocale !== void 0
     ? paramDateLocale
-    : (
-        langProps !== void 0
-          ? langProps.date
-          : defaultLang.date
-      )
+    : langProps !== void 0
+      ? langProps.date
+      : defaultLang.date
 }
 
-function formatTimezone (offset, delimeter = '') {
-  const
-    sign = offset > 0 ? '-' : '+',
+function formatTimezone(offset, delimeter = '') {
+  const sign = offset > 0 ? '-' : '+',
     absOffset = Math.abs(offset),
     hours = Math.floor(absOffset / 60),
     minutes = absOffset % 60
@@ -183,9 +177,8 @@ function formatTimezone (offset, delimeter = '') {
   return sign + pad(hours) + delimeter + pad(minutes)
 }
 
-function applyYearMonthDayChange (date, mod, sign) {
-  let
-    year = date.getFullYear(),
+function applyYearMonthDayChange(date, mod, sign) {
+  let year = date.getFullYear(),
     month = date.getMonth()
 
   const day = date.getDate()
@@ -215,19 +208,21 @@ function applyYearMonthDayChange (date, mod, sign) {
   return date
 }
 
-function applyYearMonthDay (date, mod, middle) {
-  const
-    year = mod.year !== void 0 ? mod.year : date[ `get${ middle }FullYear` ](),
-    month = mod.month !== void 0 ? mod.month - 1 : date[ `get${ middle }Month` ](),
-    maxDay = (new Date(year, month + 1, 0)).getDate(),
-    day = Math.min(maxDay, mod.date !== void 0 ? mod.date : date[ `get${ middle }Date` ]())
+function applyYearMonthDay(date, mod, middle) {
+  const year = mod.year !== void 0 ? mod.year : date[`get${middle}FullYear`](),
+    month = mod.month !== void 0 ? mod.month - 1 : date[`get${middle}Month`](),
+    maxDay = new Date(year, month + 1, 0).getDate(),
+    day = Math.min(
+      maxDay,
+      mod.date !== void 0 ? mod.date : date[`get${middle}Date`]()
+    )
 
-  date[ `set${ middle }Date` ](1)
-  date[ `set${ middle }Month` ](2)
+  date[`set${middle}Date`](1)
+  date[`set${middle}Month`](2)
 
-  date[ `set${ middle }FullYear` ](year)
-  date[ `set${ middle }Month` ](month)
-  date[ `set${ middle }Date` ](day)
+  date[`set${middle}FullYear`](year)
+  date[`set${middle}Month`](month)
+  date[`set${middle}Date`](day)
 
   delete mod.year
   delete mod.month
@@ -236,23 +231,23 @@ function applyYearMonthDay (date, mod, middle) {
   return date
 }
 
-function getChange (date, rawMod, sign) {
-  const
-    mod = normalizeMod(rawMod),
+function getChange(date, rawMod, sign) {
+  const mod = normalizeMod(rawMod),
     d = new Date(date),
-    t = mod.year !== void 0 || mod.month !== void 0 || mod.date !== void 0
-      ? applyYearMonthDayChange(d, mod, sign) // removes year/month/day
-      : d
+    t =
+      mod.year !== void 0 || mod.month !== void 0 || mod.date !== void 0
+        ? applyYearMonthDayChange(d, mod, sign) // removes year/month/day
+        : d
 
   for (const key in mod) {
     const op = capitalize(key)
-    t[ `set${ op }` ](t[ `get${ op }` ]() + sign * mod[ key ])
+    t[`set${op}`](t[`get${op}`]() + sign * mod[key])
   }
 
   return t
 }
 
-function normalizeMod (mod) {
+function normalizeMod(mod) {
   const acc = { ...mod }
 
   if (mod.years !== void 0) {
@@ -297,24 +292,24 @@ function normalizeMod (mod) {
   return acc
 }
 
-export function adjustDate (date, rawMod, utc) {
-  const
-    mod = normalizeMod(rawMod),
+export function adjustDate(date, rawMod, utc) {
+  const mod = normalizeMod(rawMod),
     middle = utc === true ? 'UTC' : '',
     d = new Date(date),
-    t = mod.year !== void 0 || mod.month !== void 0 || mod.date !== void 0
-      ? applyYearMonthDay(d, mod, middle) // removes year/month/day
-      : d
+    t =
+      mod.year !== void 0 || mod.month !== void 0 || mod.date !== void 0
+        ? applyYearMonthDay(d, mod, middle) // removes year/month/day
+        : d
 
   for (const key in mod) {
     const op = key.charAt(0).toUpperCase() + key.slice(1)
-    t[ `set${ middle }${ op }` ](mod[ key ])
+    t[`set${middle}${op}`](mod[key])
   }
 
   return t
 }
 
-export function extractDate (str, mask, dateLocale) {
+export function extractDate(str, mask, dateLocale) {
   const d = __splitDate(str, mask, dateLocale)
 
   const date = new Date(
@@ -334,7 +329,7 @@ export function extractDate (str, mask, dateLocale) {
     : getChange(date, { minutes: d.timezoneOffset - tzOffset }, 1)
 }
 
-export function __splitDate (str, mask, dateLocale, calendar, defaultModel) {
+export function __splitDate(str, mask, dateLocale, calendar, defaultModel) {
   const date = {
     year: null,
     month: null,
@@ -348,14 +343,9 @@ export function __splitDate (str, mask, dateLocale, calendar, defaultModel) {
     timeHash: null
   }
 
-  defaultModel !== void 0 && Object.assign(date, defaultModel)
+  if (defaultModel !== void 0) Object.assign(date, defaultModel)
 
-  if (
-    str === void 0
-    || str === null
-    || str === ''
-    || typeof str !== 'string'
-  ) {
+  if (str === void 0 || str === null || str === '' || typeof str !== 'string') {
     return date
   }
 
@@ -363,8 +353,7 @@ export function __splitDate (str, mask, dateLocale, calendar, defaultModel) {
     mask = defaultMask
   }
 
-  const
-    langOpts = getDateLocale(dateLocale, Lang.props),
+  const langOpts = getDateLocale(dateLocale, Lang.props),
     months = langOpts.months,
     monthsShort = langOpts.monthsShort
 
@@ -379,7 +368,7 @@ export function __splitDate (str, mask, dateLocale, calendar, defaultModel) {
   let tzString = ''
 
   if (map.X !== void 0 || map.x !== void 0) {
-    const stamp = parseInt(match[ map.X !== void 0 ? map.X : map.x ], 10)
+    const stamp = parseInt(match[map.X !== void 0 ? map.X : map.x], 10)
 
     if (isNaN(stamp) === true || stamp < 0) {
       return date
@@ -394,39 +383,36 @@ export function __splitDate (str, mask, dateLocale, calendar, defaultModel) {
     date.minute = d.getMinutes()
     date.second = d.getSeconds()
     date.millisecond = d.getMilliseconds()
-  }
-  else {
+  } else {
     if (map.YYYY !== void 0) {
-      date.year = parseInt(match[ map.YYYY ], 10)
-    }
-    else if (map.YY !== void 0) {
-      const y = parseInt(match[ map.YY ], 10)
+      date.year = parseInt(match[map.YYYY], 10)
+    } else if (map.YY !== void 0) {
+      const y = parseInt(match[map.YY], 10)
       date.year = y < 0 ? y : 2000 + y
     }
 
     if (map.M !== void 0) {
-      date.month = parseInt(match[ map.M ], 10)
+      date.month = parseInt(match[map.M], 10)
       if (date.month < 1 || date.month > 12) {
         return date
       }
-    }
-    else if (map.MMM !== void 0) {
-      date.month = monthsShort.indexOf(match[ map.MMM ]) + 1
-    }
-    else if (map.MMMM !== void 0) {
-      date.month = months.indexOf(match[ map.MMMM ]) + 1
+    } else if (map.MMM !== void 0) {
+      date.month = monthsShort.indexOf(match[map.MMM]) + 1
+    } else if (map.MMMM !== void 0) {
+      date.month = months.indexOf(match[map.MMMM]) + 1
     }
 
     if (map.D !== void 0) {
-      date.day = parseInt(match[ map.D ], 10)
+      date.day = parseInt(match[map.D], 10)
 
       if (date.year === null || date.month === null || date.day < 1) {
         return date
       }
 
-      const maxDay = calendar !== 'persian'
-        ? (new Date(date.year, date.month, 0)).getDate()
-        : jalaaliMonthLength(date.year, date.month)
+      const maxDay =
+        calendar !== 'persian'
+          ? new Date(date.year, date.month, 0).getDate()
+          : jalaaliMonthLength(date.year, date.month)
 
       if (date.day > maxDay) {
         return date
@@ -434,14 +420,13 @@ export function __splitDate (str, mask, dateLocale, calendar, defaultModel) {
     }
 
     if (map.H !== void 0) {
-      date.hour = parseInt(match[ map.H ], 10) % 24
-    }
-    else if (map.h !== void 0) {
-      date.hour = parseInt(match[ map.h ], 10) % 12
+      date.hour = parseInt(match[map.H], 10) % 24
+    } else if (map.h !== void 0) {
+      date.hour = parseInt(match[map.h], 10) % 12
       if (
-        (map.A && match[ map.A ] === 'PM')
-        || (map.a && match[ map.a ] === 'pm')
-        || (map.aa && match[ map.aa ] === 'p.m.')
+        (map.A && match[map.A] === 'PM') ||
+        (map.a && match[map.a] === 'pm') ||
+        (map.aa && match[map.aa] === 'p.m.')
       ) {
         date.hour += 12
       }
@@ -449,45 +434,49 @@ export function __splitDate (str, mask, dateLocale, calendar, defaultModel) {
     }
 
     if (map.m !== void 0) {
-      date.minute = parseInt(match[ map.m ], 10) % 60
+      date.minute = parseInt(match[map.m], 10) % 60
     }
 
     if (map.s !== void 0) {
-      date.second = parseInt(match[ map.s ], 10) % 60
+      date.second = parseInt(match[map.s], 10) % 60
     }
 
     if (map.S !== void 0) {
-      date.millisecond = parseInt(match[ map.S ], 10) * 10 ** (3 - match[ map.S ].length)
+      date.millisecond =
+        parseInt(match[map.S], 10) * 10 ** (3 - match[map.S].length)
     }
 
     if (map.Z !== void 0 || map.ZZ !== void 0) {
-      tzString = (map.Z !== void 0 ? match[ map.Z ].replace(':', '') : match[ map.ZZ ])
-      date.timezoneOffset = (tzString[ 0 ] === '+' ? -1 : 1) * (60 * tzString.slice(1, 3) + 1 * tzString.slice(3, 5))
+      tzString =
+        map.Z !== void 0 ? match[map.Z].replace(':', '') : match[map.ZZ]
+      date.timezoneOffset =
+        (tzString[0] === '+' ? -1 : 1) *
+        (60 * tzString.slice(1, 3) + Number(tzString.slice(3, 5)))
     }
   }
 
-  date.dateHash = pad(date.year, 4) + '/' + pad(date.month) + '/' + pad(date.day)
-  date.timeHash = pad(date.hour) + ':' + pad(date.minute) + ':' + pad(date.second) + tzString
+  date.dateHash =
+    pad(date.year, 4) + '/' + pad(date.month) + '/' + pad(date.day)
+  date.timeHash =
+    pad(date.hour) + ':' + pad(date.minute) + ':' + pad(date.second) + tzString
 
   return date
 }
 
-export function isValid (date) {
-  return typeof date === 'number'
-    ? true
-    : isNaN(Date.parse(date)) === false
+export function isValid(date) {
+  return typeof date === 'number' ? true : isNaN(Date.parse(date)) === false
 }
 
-export function buildDate (mod, utc) {
+export function buildDate(mod, utc) {
   return adjustDate(new Date(), mod, utc)
 }
 
-export function getDayOfWeek (date) {
+export function getDayOfWeek(date) {
   const dow = new Date(date).getDay()
   return dow === 0 ? 7 : dow
 }
 
-export function getWeekOfYear (date) {
+export function getWeekOfYear(date) {
   // Remove time components of date
   const thursday = new Date(date.getFullYear(), date.getMonth(), date.getDate())
 
@@ -498,7 +487,9 @@ export function getWeekOfYear (date) {
   const firstThursday = new Date(thursday.getFullYear(), 0, 4)
 
   // Change date to Thursday same week
-  firstThursday.setDate(firstThursday.getDate() - ((firstThursday.getDay() + 6) % 7) + 3)
+  firstThursday.setDate(
+    firstThursday.getDate() - ((firstThursday.getDay() + 6) % 7) + 3
+  )
 
   // Check if daylight-saving-time-switch occurred and correct for it
   const ds = thursday.getTimezoneOffset() - firstThursday.getTimezoneOffset()
@@ -509,139 +500,155 @@ export function getWeekOfYear (date) {
   return 1 + Math.floor(weekDiff)
 }
 
-function getDayIdentifier (date) {
+function getDayIdentifier(date) {
   return date.getFullYear() * 10000 + date.getMonth() * 100 + date.getDate()
 }
 
-function getDateIdentifier (date, onlyDate /* = false */) {
+function getDateIdentifier(date, onlyDate /* = false */) {
   const d = new Date(date)
   return onlyDate === true ? getDayIdentifier(d) : d.getTime()
 }
 
-export function isBetweenDates (date, from, to, opts = {}) {
-  const
-    d1 = getDateIdentifier(from, opts.onlyDate),
+export function isBetweenDates(date, from, to, opts = {}) {
+  const d1 = getDateIdentifier(from, opts.onlyDate),
     d2 = getDateIdentifier(to, opts.onlyDate),
     cur = getDateIdentifier(date, opts.onlyDate)
 
-  return (cur > d1 || (opts.inclusiveFrom === true && cur === d1))
-    && (cur < d2 || (opts.inclusiveTo === true && cur === d2))
+  return (
+    (cur > d1 || (opts.inclusiveFrom === true && cur === d1)) &&
+    (cur < d2 || (opts.inclusiveTo === true && cur === d2))
+  )
 }
 
-export function addToDate (date, mod) {
+export function addToDate(date, mod) {
   return getChange(date, mod, 1)
 }
-export function subtractFromDate (date, mod) {
+export function subtractFromDate(date, mod) {
   return getChange(date, mod, -1)
 }
 
-export function startOfDate (date, unit, utc) {
-  const
-    t = new Date(date),
-    prefix = `set${ utc === true ? 'UTC' : '' }`
+export function startOfDate(date, unit, utc) {
+  const t = new Date(date),
+    prefix = `set${utc === true ? 'UTC' : ''}`
 
   switch (unit) {
     case 'year':
     case 'years':
-      t[ `${ prefix }Month` ](0)
+      t[`${prefix}Month`](0)
     case 'month':
     case 'months':
-      t[ `${ prefix }Date` ](1)
+      t[`${prefix}Date`](1)
     case 'day':
     case 'days':
     case 'date':
-      t[ `${ prefix }Hours` ](0)
+      t[`${prefix}Hours`](0)
     case 'hour':
     case 'hours':
-      t[ `${ prefix }Minutes` ](0)
+      t[`${prefix}Minutes`](0)
     case 'minute':
     case 'minutes':
-      t[ `${ prefix }Seconds` ](0)
+      t[`${prefix}Seconds`](0)
     case 'second':
     case 'seconds':
-      t[ `${ prefix }Milliseconds` ](0)
+      t[`${prefix}Milliseconds`](0)
   }
   return t
 }
 
-export function endOfDate (date, unit, utc) {
-  const
-    t = new Date(date),
-    prefix = `set${ utc === true ? 'UTC' : '' }`
+export function endOfDate(date, unit, utc) {
+  const t = new Date(date),
+    prefix = `set${utc === true ? 'UTC' : ''}`
 
   switch (unit) {
     case 'year':
     case 'years':
-      t[ `${ prefix }Month` ](11)
+      t[`${prefix}Month`](11)
     case 'month':
     case 'months':
-      t[ `${ prefix }Date` ](daysInMonth(t))
+      t[`${prefix}Date`](daysInMonth(t))
     case 'day':
     case 'days':
     case 'date':
-      t[ `${ prefix }Hours` ](23)
+      t[`${prefix}Hours`](23)
     case 'hour':
     case 'hours':
-      t[ `${ prefix }Minutes` ](59)
+      t[`${prefix}Minutes`](59)
     case 'minute':
     case 'minutes':
-      t[ `${ prefix }Seconds` ](59)
+      t[`${prefix}Seconds`](59)
     case 'second':
     case 'seconds':
-      t[ `${ prefix }Milliseconds` ](999)
+      t[`${prefix}Milliseconds`](999)
   }
   return t
 }
 
-export function getMaxDate (date /* , ...args */) {
+export function getMaxDate(date /* , ...args */) {
   let t = new Date(date)
   Array.prototype.slice.call(arguments, 1).forEach(d => {
     t = Math.max(t, new Date(d))
   })
-  return t
+  return new Date(t)
 }
 
-export function getMinDate (date /*, ...args */) {
+export function getMinDate(date /*, ...args */) {
   let t = new Date(date)
   Array.prototype.slice.call(arguments, 1).forEach(d => {
     t = Math.min(t, new Date(d))
   })
-  return t
+  return new Date(t)
 }
 
-function getDiff (t, sub, interval) {
+function getDiff(t, sub, interval) {
   return (
-    (t.getTime() - t.getTimezoneOffset() * MILLISECONDS_IN_MINUTE)
-    - (sub.getTime() - sub.getTimezoneOffset() * MILLISECONDS_IN_MINUTE)
-  ) / interval
+    (t.getTime() -
+      t.getTimezoneOffset() * MILLISECONDS_IN_MINUTE -
+      (sub.getTime() - sub.getTimezoneOffset() * MILLISECONDS_IN_MINUTE)) /
+    interval
+  )
 }
 
-export function getDateDiff (date, subtract, unit = 'days') {
-  const
-    t = new Date(date),
+export function getDateDiff(date, subtract, unit = 'days') {
+  const t = new Date(date),
     sub = new Date(subtract)
 
   switch (unit) {
     case 'years':
     case 'year':
-      return (t.getFullYear() - sub.getFullYear())
+      return t.getFullYear() - sub.getFullYear()
 
     case 'months':
     case 'month':
-      return (t.getFullYear() - sub.getFullYear()) * 12 + t.getMonth() - sub.getMonth()
+      return (
+        (t.getFullYear() - sub.getFullYear()) * 12 +
+        t.getMonth() -
+        sub.getMonth()
+      )
 
     case 'days':
     case 'day':
     case 'date':
-      return getDiff(startOfDate(t, 'day'), startOfDate(sub, 'day'), MILLISECONDS_IN_DAY)
+      return getDiff(
+        startOfDate(t, 'day'),
+        startOfDate(sub, 'day'),
+        MILLISECONDS_IN_DAY
+      )
 
     case 'hours':
     case 'hour':
-      return getDiff(startOfDate(t, 'hour'), startOfDate(sub, 'hour'), MILLISECONDS_IN_HOUR)
+      return getDiff(
+        startOfDate(t, 'hour'),
+        startOfDate(sub, 'hour'),
+        MILLISECONDS_IN_HOUR
+      )
 
     case 'minutes':
     case 'minute':
-      return getDiff(startOfDate(t, 'minute'), startOfDate(sub, 'minute'), MILLISECONDS_IN_MINUTE)
+      return getDiff(
+        startOfDate(t, 'minute'),
+        startOfDate(sub, 'minute'),
+        MILLISECONDS_IN_MINUTE
+      )
 
     case 'seconds':
     case 'second':
@@ -649,17 +656,19 @@ export function getDateDiff (date, subtract, unit = 'days') {
   }
 }
 
-export function getDayOfYear (date) {
+export function getDayOfYear(date) {
   return getDateDiff(date, startOfDate(date, 'year'), 'days') + 1
 }
 
-export function inferDateFormat (date) {
+export function inferDateFormat(date) {
   return isDate(date) === true
     ? 'date'
-    : (typeof date === 'number' ? 'number' : 'string')
+    : typeof date === 'number'
+      ? 'number'
+      : 'string'
 }
 
-export function getDateBetween (date, min, max) {
+export function getDateBetween(date, min, max) {
   const t = new Date(date)
 
   if (min) {
@@ -679,9 +688,8 @@ export function getDateBetween (date, min, max) {
   return t
 }
 
-export function isSameDate (date, date2, unit) {
-  const
-    t = new Date(date),
+export function isSameDate(date, date2, unit) {
+  const t = new Date(date),
     d = new Date(date2)
 
   if (unit === void 0) {
@@ -722,40 +730,41 @@ export function isSameDate (date, date2, unit) {
       }
       break
     default:
-      throw new Error(`date isSameDate unknown unit ${ unit }`)
+      throw new Error(`date isSameDate unknown unit ${unit}`)
   }
 
   return true
 }
 
-export function daysInMonth (date) {
-  return (new Date(date.getFullYear(), date.getMonth() + 1, 0)).getDate()
+export function daysInMonth(date) {
+  return new Date(date.getFullYear(), date.getMonth() + 1, 0).getDate()
 }
 
-function getOrdinal (n) {
+function getOrdinal(n) {
   if (n >= 11 && n <= 13) {
-    return `${ n }th`
+    return `${n}th`
   }
   switch (n % 10) {
-    case 1: return `${ n }st`
-    case 2: return `${ n }nd`
-    case 3: return `${ n }rd`
+    case 1:
+      return `${n}st`
+    case 2:
+      return `${n}nd`
+    case 3:
+      return `${n}rd`
   }
-  return `${ n }th`
+  return `${n}th`
 }
 
 const formatter = {
   // Year: 00, 01, ..., 99
-  YY (date, dateLocale, forcedYear) {
+  YY(date, dateLocale, forcedYear) {
     // workaround for < 1900 with new Date()
-    const y = this.YYYY(date, dateLocale, forcedYear) % 100
-    return y >= 0
-      ? pad(y)
-      : '-' + pad(Math.abs(y))
+    const y = this.YYYY(date, dateLocale, forcedYear) % 100 // oxlint-disable-line new-cap
+    return y >= 0 ? pad(y) : '-' + pad(Math.abs(y))
   },
 
   // Year: 1900, 1901, ..., 2099
-  YYYY (date, _dateLocale, forcedYear) {
+  YYYY(date, _dateLocale, forcedYear) {
     // workaround for < 1900 with new Date()
     return forcedYear !== void 0 && forcedYear !== null
       ? forcedYear
@@ -763,223 +772,225 @@ const formatter = {
   },
 
   // Month: 1, 2, ..., 12
-  M (date) {
+  M(date) {
     return date.getMonth() + 1
   },
 
   // Month: 1st, 2nd, ..., 12th
-  Mo (date) {
+  Mo(date) {
     return getOrdinal(date.getMonth() + 1)
   },
 
   // Month: 01, 02, ..., 12
-  MM (date) {
+  MM(date) {
     return pad(date.getMonth() + 1)
   },
 
   // Month Short Name: Jan, Feb, ...
-  MMM (date, dateLocale) {
-    return dateLocale.monthsShort[ date.getMonth() ]
+  MMM(date, dateLocale) {
+    return dateLocale.monthsShort[date.getMonth()]
   },
 
   // Month Name: January, February, ...
-  MMMM (date, dateLocale) {
-    return dateLocale.months[ date.getMonth() ]
+  MMMM(date, dateLocale) {
+    return dateLocale.months[date.getMonth()]
   },
 
   // Quarter: 1, 2, 3, 4
-  Q (date) {
+  Q(date) {
     return Math.ceil((date.getMonth() + 1) / 3)
   },
 
   // Quarter: 1st, 2nd, 3rd, 4th
-  Qo (date) {
-    return getOrdinal(this.Q(date))
+  Qo(date) {
+    return getOrdinal(this.Q(date)) // oxlint-disable-line new-cap
   },
 
   // Day of month: 1, 2, ..., 31
-  D (date) {
+  D(date) {
     return date.getDate()
   },
 
   // Day of month: 1st, 2nd, ..., 31st
-  Do (date) {
+  Do(date) {
     return getOrdinal(date.getDate())
   },
 
   // Day of month: 01, 02, ..., 31
-  DD (date) {
+  DD(date) {
     return pad(date.getDate())
   },
 
   // Day of year: 1, 2, ..., 366
-  DDD (date) {
+  DDD(date) {
     return getDayOfYear(date)
   },
 
   // Day of year: 1st, 2nd, ..., 366th
-  DDDo (date) {
+  DDDo(date) {
     return getOrdinal(getDayOfYear(date))
   },
 
   // Day of year: 001, 002, ..., 366
-  DDDD (date) {
+  DDDD(date) {
     return pad(getDayOfYear(date), 3)
   },
 
   // Day of week: 0, 1, ..., 6
-  d (date) {
+  d(date) {
     return date.getDay()
   },
 
   // Day of week: 0th, 1st, ..., 6th
-  do (date) {
+  do(date) {
     return getOrdinal(date.getDay())
   },
 
   // Day of week: Su, Mo, ...
-  dd (date, dateLocale) {
-    return (dateLocale.days[ date.getDay() ]).slice(0, 2)
+  dd(date, dateLocale) {
+    return dateLocale.days[date.getDay()].slice(0, 2)
   },
 
   // Day of week: Sun, Mon, ...
-  ddd (date, dateLocale) {
-    return dateLocale.daysShort[ date.getDay() ]
+  ddd(date, dateLocale) {
+    return dateLocale.daysShort[date.getDay()]
   },
 
   // Day of week: Sunday, Monday, ...
-  dddd (date, dateLocale) {
-    return dateLocale.days[ date.getDay() ]
+  dddd(date, dateLocale) {
+    return dateLocale.days[date.getDay()]
   },
 
   // Day of ISO week: 1, 2, ..., 7
-  E (date) {
+  E(date) {
     return date.getDay() || 7
   },
 
   // Week of Year: 1 2 ... 52 53
-  w (date) {
+  w(date) {
     return getWeekOfYear(date)
   },
 
   // Week of Year: 1st 2nd ... 52nd 53rd
-  wo (date) {
+  wo(date) {
     return getOrdinal(getWeekOfYear(date))
   },
 
   // Week of Year: 01 02 ... 52 53
-  ww (date) {
+  ww(date) {
     return pad(getWeekOfYear(date))
   },
 
   // Hour: 0, 1, ... 23
-  H (date) {
+  H(date) {
     return date.getHours()
   },
 
   // Hour: 00, 01, ..., 23
-  HH (date) {
+  HH(date) {
     return pad(date.getHours())
   },
 
   // Hour: 1, 2, ..., 12
-  h (date) {
+  h(date) {
     const hours = date.getHours()
-    return hours === 0
-      ? 12
-      : (hours > 12 ? hours % 12 : hours)
+    return hours === 0 ? 12 : hours > 12 ? hours % 12 : hours
   },
 
   // Hour: 01, 02, ..., 12
-  hh (date) {
+  hh(date) {
     return pad(this.h(date))
   },
 
   // Minute: 0, 1, ..., 59
-  m (date) {
+  m(date) {
     return date.getMinutes()
   },
 
   // Minute: 00, 01, ..., 59
-  mm (date) {
+  mm(date) {
     return pad(date.getMinutes())
   },
 
   // Second: 0, 1, ..., 59
-  s (date) {
+  s(date) {
     return date.getSeconds()
   },
 
   // Second: 00, 01, ..., 59
-  ss (date) {
+  ss(date) {
     return pad(date.getSeconds())
   },
 
   // 1/10 of second: 0, 1, ..., 9
-  S (date) {
+  S(date) {
     return Math.floor(date.getMilliseconds() / 100)
   },
 
   // 1/100 of second: 00, 01, ..., 99
-  SS (date) {
+  SS(date) {
     return pad(Math.floor(date.getMilliseconds() / 10))
   },
 
   // Millisecond: 000, 001, ..., 999
-  SSS (date) {
+  SSS(date) {
     return pad(date.getMilliseconds(), 3)
   },
 
   // Meridiem: AM, PM
-  A (date) {
+  A(date) {
     return date.getHours() < 12 ? 'AM' : 'PM'
   },
 
   // Meridiem: am, pm
-  a (date) {
+  a(date) {
     return date.getHours() < 12 ? 'am' : 'pm'
   },
 
   // Meridiem: a.m., p.m.
-  aa (date) {
+  aa(date) {
     return date.getHours() < 12 ? 'a.m.' : 'p.m.'
   },
 
   // Timezone: -01:00, +00:00, ... +12:00
-  Z (date, _dateLocale, _forcedYear, forcedTimezoneOffset) {
-    const tzOffset = forcedTimezoneOffset === void 0 || forcedTimezoneOffset === null
-      ? date.getTimezoneOffset()
-      : forcedTimezoneOffset
+  Z(date, _dateLocale, _forcedYear, forcedTimezoneOffset) {
+    const tzOffset =
+      forcedTimezoneOffset === void 0 || forcedTimezoneOffset === null
+        ? date.getTimezoneOffset()
+        : forcedTimezoneOffset
 
     return formatTimezone(tzOffset, ':')
   },
 
   // Timezone: -0100, +0000, ... +1200
-  ZZ (date, _dateLocale, _forcedYear, forcedTimezoneOffset) {
-    const tzOffset = forcedTimezoneOffset === void 0 || forcedTimezoneOffset === null
-      ? date.getTimezoneOffset()
-      : forcedTimezoneOffset
+  ZZ(date, _dateLocale, _forcedYear, forcedTimezoneOffset) {
+    const tzOffset =
+      forcedTimezoneOffset === void 0 || forcedTimezoneOffset === null
+        ? date.getTimezoneOffset()
+        : forcedTimezoneOffset
 
     return formatTimezone(tzOffset)
   },
 
   // Seconds timestamp: 512969520
-  X (date) {
+  X(date) {
     return Math.floor(date.getTime() / 1000)
   },
 
   // Milliseconds timestamp: 512969520900
-  x (date) {
+  x(date) {
     return date.getTime()
   }
 }
 
-export function formatDate (val, mask, dateLocale, __forcedYear, __forcedTimezoneOffset) {
-  if (
-    (val !== 0 && !val)
-    || val === Infinity
-    || val === -Infinity
-  ) return
+export function formatDate(
+  val,
+  mask,
+  dateLocale,
+  __forcedYear,
+  __forcedTimezoneOffset
+) {
+  if ((val !== 0 && !val) || val === Infinity || val === -Infinity) return
 
   const date = new Date(val)
 
@@ -991,20 +1002,17 @@ export function formatDate (val, mask, dateLocale, __forcedYear, __forcedTimezon
 
   const locale = getDateLocale(dateLocale, Lang.props)
 
-  return mask.replace(
-    token,
-    (match, text) => (
-      match in formatter
-        ? formatter[ match ](date, locale, __forcedYear, __forcedTimezoneOffset)
-        : (text === void 0 ? match : text.split('\\]').join(']'))
-    )
+  return mask.replace(token, (match, text) =>
+    match in formatter
+      ? formatter[match](date, locale, __forcedYear, __forcedTimezoneOffset)
+      : text === void 0
+        ? match
+        : text.split('\\]').join(']')
   )
 }
 
-export function clone (date) {
-  return isDate(date) === true
-    ? new Date(date.getTime())
-    : date
+export function clone(date) {
+  return isDate(date) === true ? new Date(date.getTime()) : date
 }
 
 export default {