locutus 2.0.31 → 2.0.34

package/php/datetime/strtotime.js

@@ -1,69 +1,67 @@
-'use strict';
-
-var reSpace = '[ \\t]+';
-var reSpaceOpt = '[ \\t]*';
-var reMeridian = '(?:([ap])\\.?m\\.?([\\t ]|$))';
-var reHour24 = '(2[0-4]|[01]?[0-9])';
-var reHour24lz = '([01][0-9]|2[0-4])';
-var reHour12 = '(0?[1-9]|1[0-2])';
-var reMinute = '([0-5]?[0-9])';
-var reMinutelz = '([0-5][0-9])';
-var reSecond = '(60|[0-5]?[0-9])';
-var reSecondlz = '(60|[0-5][0-9])';
-var reFrac = '(?:\\.([0-9]+))';
-
-var reDayfull = 'sunday|monday|tuesday|wednesday|thursday|friday|saturday';
-var reDayabbr = 'sun|mon|tue|wed|thu|fri|sat';
-var reDaytext = reDayfull + '|' + reDayabbr + '|weekdays?';
-
-var reReltextnumber = 'first|second|third|fourth|fifth|sixth|seventh|eighth?|ninth|tenth|eleventh|twelfth';
-var reReltexttext = 'next|last|previous|this';
-var reReltextunit = '(?:second|sec|minute|min|hour|day|fortnight|forthnight|month|year)s?|weeks|' + reDaytext;
-
-var reYear = '([0-9]{1,4})';
-var reYear2 = '([0-9]{2})';
-var reYear4 = '([0-9]{4})';
-var reYear4withSign = '([+-]?[0-9]{4})';
-var reMonth = '(1[0-2]|0?[0-9])';
-var reMonthlz = '(0[0-9]|1[0-2])';
-var reDay = '(?:(3[01]|[0-2]?[0-9])(?:st|nd|rd|th)?)';
-var reDaylz = '(0[0-9]|[1-2][0-9]|3[01])';
-
-var reMonthFull = 'january|february|march|april|may|june|july|august|september|october|november|december';
-var reMonthAbbr = 'jan|feb|mar|apr|may|jun|jul|aug|sept?|oct|nov|dec';
-var reMonthroman = 'i[vx]|vi{0,3}|xi{0,2}|i{1,3}';
-var reMonthText = '(' + reMonthFull + '|' + reMonthAbbr + '|' + reMonthroman + ')';
-
-var reTzCorrection = '((?:GMT)?([+-])' + reHour24 + ':?' + reMinute + '?)';
-var reTzAbbr = '\\(?([a-zA-Z]{1,6})\\)?';
-var reDayOfYear = '(00[1-9]|0[1-9][0-9]|[12][0-9][0-9]|3[0-5][0-9]|36[0-6])';
-var reWeekOfYear = '(0[1-9]|[1-4][0-9]|5[0-3])';
-
-var reDateNoYear = reMonthText + '[ .\\t-]*' + reDay + '[,.stndrh\\t ]*';
+const reSpace = '[ \\t]+'
+const reSpaceOpt = '[ \\t]*'
+const reMeridian = '(?:([ap])\\.?m\\.?([\\t ]|$))'
+const reHour24 = '(2[0-4]|[01]?[0-9])'
+const reHour24lz = '([01][0-9]|2[0-4])'
+const reHour12 = '(0?[1-9]|1[0-2])'
+const reMinute = '([0-5]?[0-9])'
+const reMinutelz = '([0-5][0-9])'
+const reSecond = '(60|[0-5]?[0-9])'
+const reSecondlz = '(60|[0-5][0-9])'
+const reFrac = '(?:\\.([0-9]+))'
+
+const reDayfull = 'sunday|monday|tuesday|wednesday|thursday|friday|saturday'
+const reDayabbr = 'sun|mon|tue|wed|thu|fri|sat'
+const reDaytext = reDayfull + '|' + reDayabbr + '|weekdays?'
+
+const reReltextnumber = 'first|second|third|fourth|fifth|sixth|seventh|eighth?|ninth|tenth|eleventh|twelfth'
+const reReltexttext = 'next|last|previous|this'
+const reReltextunit = '(?:second|sec|minute|min|hour|day|fortnight|forthnight|month|year)s?|weeks|' + reDaytext
+
+const reYear = '([0-9]{1,4})'
+const reYear2 = '([0-9]{2})'
+const reYear4 = '([0-9]{4})'
+const reYear4withSign = '([+-]?[0-9]{4})'
+const reMonth = '(1[0-2]|0?[0-9])'
+const reMonthlz = '(0[0-9]|1[0-2])'
+const reDay = '(?:(3[01]|[0-2]?[0-9])(?:st|nd|rd|th)?)'
+const reDaylz = '(0[0-9]|[1-2][0-9]|3[01])'
+
+const reMonthFull = 'january|february|march|april|may|june|july|august|september|october|november|december'
+const reMonthAbbr = 'jan|feb|mar|apr|may|jun|jul|aug|sept?|oct|nov|dec'
+const reMonthroman = 'i[vx]|vi{0,3}|xi{0,2}|i{1,3}'
+const reMonthText = '(' + reMonthFull + '|' + reMonthAbbr + '|' + reMonthroman + ')'
+
+const reTzCorrection = '((?:GMT)?([+-])' + reHour24 + ':?' + reMinute + '?)'
+const reTzAbbr = '\\(?([a-zA-Z]{1,6})\\)?'
+const reDayOfYear = '(00[1-9]|0[1-9][0-9]|[12][0-9][0-9]|3[0-5][0-9]|36[0-6])'
+const reWeekOfYear = '(0[1-9]|[1-4][0-9]|5[0-3])'
+
+const reDateNoYear = reMonthText + '[ .\\t-]*' + reDay + '[,.stndrh\\t ]*'
 
 function processMeridian(hour, meridian) {
-  meridian = meridian && meridian.toLowerCase();
+  meridian = meridian && meridian.toLowerCase()
 
   switch (meridian) {
     case 'a':
-      hour += hour === 12 ? -12 : 0;
-      break;
+      hour += hour === 12 ? -12 : 0
+      break
     case 'p':
-      hour += hour !== 12 ? 12 : 0;
-      break;
+      hour += hour !== 12 ? 12 : 0
+      break
   }
 
-  return hour;
+  return hour
 }
 
 function processYear(yearStr) {
-  var year = +yearStr;
+  let year = +yearStr
 
   if (yearStr.length < 4 && year < 100) {
-    year += year < 70 ? 2000 : 1900;
+    year += year < 70 ? 2000 : 1900
   }
 
-  return year;
+  return year
 }
 
 function lookupMonth(monthStr) {
@@ -103,14 +101,12 @@ function lookupMonth(monthStr) {
     xi: 10,
     dec: 11,
     december: 11,
-    xii: 11
-  }[monthStr.toLowerCase()];
+    xii: 11,
+  }[monthStr.toLowerCase()]
 }
 
-function lookupWeekday(dayStr) {
-  var desiredSundayNumber = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-
-  var dayNumbers = {
+function lookupWeekday(dayStr, desiredSundayNumber = 0) {
+  const dayNumbers = {
     mon: 1,
     monday: 1,
     tue: 2,
@@ -124,14 +120,14 @@ function lookupWeekday(dayStr) {
     sat: 6,
     saturday: 6,
     sun: 0,
-    sunday: 0
-  };
+    sunday: 0,
+  }
 
-  return dayNumbers[dayStr.toLowerCase()] || desiredSundayNumber;
+  return dayNumbers[dayStr.toLowerCase()] || desiredSundayNumber
 }
 
 function lookupRelative(relText) {
-  var relativeNumbers = {
+  const relativeNumbers = {
     last: -1,
     previous: -1,
     this: 0,
@@ -148,44 +144,44 @@ function lookupRelative(relText) {
     ninth: 9,
     tenth: 10,
     eleventh: 11,
-    twelfth: 12
-  };
+    twelfth: 12,
+  }
 
-  var relativeBehavior = {
-    this: 1
-  };
+  const relativeBehavior = {
+    this: 1,
+  }
 
-  var relTextLower = relText.toLowerCase();
+  const relTextLower = relText.toLowerCase()
 
   return {
     amount: relativeNumbers[relTextLower],
-    behavior: relativeBehavior[relTextLower] || 0
-  };
+    behavior: relativeBehavior[relTextLower] || 0,
+  }
 }
 
 function processTzCorrection(tzOffset, oldValue) {
-  var reTzCorrectionLoose = /(?:GMT)?([+-])(\d+)(:?)(\d{0,2})/i;
-  tzOffset = tzOffset && tzOffset.match(reTzCorrectionLoose);
+  const reTzCorrectionLoose = /(?:GMT)?([+-])(\d+)(:?)(\d{0,2})/i
+  tzOffset = tzOffset && tzOffset.match(reTzCorrectionLoose)
 
   if (!tzOffset) {
-    return oldValue;
+    return oldValue
   }
 
-  var sign = tzOffset[1] === '-' ? -1 : 1;
-  var hours = +tzOffset[2];
-  var minutes = +tzOffset[4];
+  const sign = tzOffset[1] === '-' ? -1 : 1
+  let hours = +tzOffset[2]
+  let minutes = +tzOffset[4]
 
   if (!tzOffset[4] && !tzOffset[3]) {
-    minutes = Math.floor(hours % 100);
-    hours = Math.floor(hours / 100);
+    minutes = Math.floor(hours % 100)
+    hours = Math.floor(hours / 100)
   }
 
   // timezone offset in seconds
-  return sign * (hours * 60 + minutes) * 60;
+  return sign * (hours * 60 + minutes) * 60
 }
 
 // tz abbrevation : tz offset in seconds
-var tzAbbrOffsets = {
+const tzAbbrOffsets = {
   acdt: 37800,
   acst: 34200,
   addt: -7200,
@@ -329,114 +325,129 @@ var tzAbbrOffsets = {
   w: -36000,
   x: -39600,
   y: -43200,
-  z: 0
-};
+  z: 0,
+}
 
-var formats = {
+const formats = {
   yesterday: {
     regex: /^yesterday/i,
     name: 'yesterday',
-    callback: function callback() {
-      this.rd -= 1;
-      return this.resetTime();
-    }
+    callback() {
+      this.rd -= 1
+      return this.resetTime()
+    },
   },
 
   now: {
     regex: /^now/i,
-    name: 'now'
+    name: 'now',
     // do nothing
   },
 
   noon: {
     regex: /^noon/i,
     name: 'noon',
-    callback: function callback() {
-      return this.resetTime() && this.time(12, 0, 0, 0);
-    }
+    callback() {
+      return this.resetTime() && this.time(12, 0, 0, 0)
+    },
   },
 
   midnightOrToday: {
     regex: /^(midnight|today)/i,
     name: 'midnight | today',
-    callback: function callback() {
-      return this.resetTime();
-    }
+    callback() {
+      return this.resetTime()
+    },
   },
 
   tomorrow: {
     regex: /^tomorrow/i,
     name: 'tomorrow',
-    callback: function callback() {
-      this.rd += 1;
-      return this.resetTime();
-    }
+    callback() {
+      this.rd += 1
+      return this.resetTime()
+    },
   },
 
   timestamp: {
     regex: /^@(-?\d+)/i,
     name: 'timestamp',
-    callback: function callback(match, timestamp) {
-      this.rs += +timestamp;
-      this.y = 1970;
-      this.m = 0;
-      this.d = 1;
-      this.dates = 0;
-
-      return this.resetTime() && this.zone(0);
-    }
+    callback(match, timestamp) {
+      this.rs += +timestamp
+      this.y = 1970
+      this.m = 0
+      this.d = 1
+      this.dates = 0
+
+      return this.resetTime() && this.zone(0)
+    },
   },
 
   firstOrLastDay: {
     regex: /^(first|last) day of/i,
     name: 'firstdayof | lastdayof',
-    callback: function callback(match, day) {
+    callback(match, day) {
       if (day.toLowerCase() === 'first') {
-        this.firstOrLastDayOfMonth = 1;
+        this.firstOrLastDayOfMonth = 1
       } else {
-        this.firstOrLastDayOfMonth = -1;
+        this.firstOrLastDayOfMonth = -1
       }
-    }
+    },
   },
 
   backOrFrontOf: {
-    regex: RegExp('^(back|front) of ' + reHour24 + reSpaceOpt + reMeridian + '?', 'i'),
+    regex: new RegExp('^(back|front) of ' + reHour24 + reSpaceOpt + reMeridian + '?', 'i'),
     name: 'backof | frontof',
-    callback: function callback(match, side, hours, meridian) {
-      var back = side.toLowerCase() === 'back';
-      var hour = +hours;
-      var minute = 15;
+    callback(match, side, hours, meridian) {
+      const back = side.toLowerCase() === 'back'
+      let hour = +hours
+      let minute = 15
 
       if (!back) {
-        hour -= 1;
-        minute = 45;
+        hour -= 1
+        minute = 45
       }
 
-      hour = processMeridian(hour, meridian);
+      hour = processMeridian(hour, meridian)
 
-      return this.resetTime() && this.time(hour, minute, 0, 0);
-    }
+      return this.resetTime() && this.time(hour, minute, 0, 0)
+    },
   },
 
   weekdayOf: {
-    regex: RegExp('^(' + reReltextnumber + '|' + reReltexttext + ')' + reSpace + '(' + reDayfull + '|' + reDayabbr + ')' + reSpace + 'of', 'i'),
-    name: 'weekdayof'
+    regex: new RegExp(
+      '^(' +
+        reReltextnumber +
+        '|' +
+        reReltexttext +
+        ')' +
+        reSpace +
+        '(' +
+        reDayfull +
+        '|' +
+        reDayabbr +
+        ')' +
+        reSpace +
+        'of',
+      'i',
+    ),
+    name: 'weekdayof',
     // todo
   },
 
   mssqltime: {
-    regex: RegExp('^' + reHour12 + ':' + reMinutelz + ':' + reSecondlz + '[:.]([0-9]+)' + reMeridian, 'i'),
+    regex: new RegExp('^' + reHour12 + ':' + reMinutelz + ':' + reSecondlz + '[:.]([0-9]+)' + reMeridian, 'i'),
     name: 'mssqltime',
-    callback: function callback(match, hour, minute, second, frac, meridian) {
-      return this.time(processMeridian(+hour, meridian), +minute, +second, +frac.substr(0, 3));
-    }
+    callback(match, hour, minute, second, frac, meridian) {
+      return this.time(processMeridian(+hour, meridian), +minute, +second, +frac.substr(0, 3))
+    },
   },
 
   oracledate: {
     regex: /^(\d{2})-([A-Z]{3})-(\d{2})$/i,
     name: 'd-M-y',
-    callback: function callback(match, day, monthText, year) {
-      var month = {
+    callback(match, day, monthText, year) {
+      const month = {
         JAN: 0,
         FEB: 1,
         MAR: 2,
@@ -448,363 +459,405 @@ var formats = {
         SEP: 8,
         OCT: 9,
         NOV: 10,
-        DEC: 11
-      }[monthText.toUpperCase()];
-      return this.ymd(2000 + parseInt(year, 10), month, parseInt(day, 10));
-    }
+        DEC: 11,
+      }[monthText.toUpperCase()]
+      return this.ymd(2000 + parseInt(year, 10), month, parseInt(day, 10))
+    },
   },
 
   timeLong12: {
-    regex: RegExp('^' + reHour12 + '[:.]' + reMinute + '[:.]' + reSecondlz + reSpaceOpt + reMeridian, 'i'),
+    regex: new RegExp('^' + reHour12 + '[:.]' + reMinute + '[:.]' + reSecondlz + reSpaceOpt + reMeridian, 'i'),
     name: 'timelong12',
-    callback: function callback(match, hour, minute, second, meridian) {
-      return this.time(processMeridian(+hour, meridian), +minute, +second, 0);
-    }
+    callback(match, hour, minute, second, meridian) {
+      return this.time(processMeridian(+hour, meridian), +minute, +second, 0)
+    },
   },
 
   timeShort12: {
-    regex: RegExp('^' + reHour12 + '[:.]' + reMinutelz + reSpaceOpt + reMeridian, 'i'),
+    regex: new RegExp('^' + reHour12 + '[:.]' + reMinutelz + reSpaceOpt + reMeridian, 'i'),
     name: 'timeshort12',
-    callback: function callback(match, hour, minute, meridian) {
-      return this.time(processMeridian(+hour, meridian), +minute, 0, 0);
-    }
+    callback(match, hour, minute, meridian) {
+      return this.time(processMeridian(+hour, meridian), +minute, 0, 0)
+    },
   },
 
   timeTiny12: {
-    regex: RegExp('^' + reHour12 + reSpaceOpt + reMeridian, 'i'),
+    regex: new RegExp('^' + reHour12 + reSpaceOpt + reMeridian, 'i'),
     name: 'timetiny12',
-    callback: function callback(match, hour, meridian) {
-      return this.time(processMeridian(+hour, meridian), 0, 0, 0);
-    }
+    callback(match, hour, meridian) {
+      return this.time(processMeridian(+hour, meridian), 0, 0, 0)
+    },
   },
 
   soap: {
-    regex: RegExp('^' + reYear4 + '-' + reMonthlz + '-' + reDaylz + 'T' + reHour24lz + ':' + reMinutelz + ':' + reSecondlz + reFrac + reTzCorrection + '?', 'i'),
+    regex: new RegExp(
+      '^' +
+        reYear4 +
+        '-' +
+        reMonthlz +
+        '-' +
+        reDaylz +
+        'T' +
+        reHour24lz +
+        ':' +
+        reMinutelz +
+        ':' +
+        reSecondlz +
+        reFrac +
+        reTzCorrection +
+        '?',
+      'i',
+    ),
     name: 'soap',
-    callback: function callback(match, year, month, day, hour, minute, second, frac, tzCorrection) {
-      return this.ymd(+year, month - 1, +day) && this.time(+hour, +minute, +second, +frac.substr(0, 3)) && this.zone(processTzCorrection(tzCorrection));
-    }
+    callback(match, year, month, day, hour, minute, second, frac, tzCorrection) {
+      return (
+        this.ymd(+year, month - 1, +day) &&
+        this.time(+hour, +minute, +second, +frac.substr(0, 3)) &&
+        this.zone(processTzCorrection(tzCorrection))
+      )
+    },
   },
 
   wddx: {
-    regex: RegExp('^' + reYear4 + '-' + reMonth + '-' + reDay + 'T' + reHour24 + ':' + reMinute + ':' + reSecond),
+    regex: new RegExp('^' + reYear4 + '-' + reMonth + '-' + reDay + 'T' + reHour24 + ':' + reMinute + ':' + reSecond),
     name: 'wddx',
-    callback: function callback(match, year, month, day, hour, minute, second) {
-      return this.ymd(+year, month - 1, +day) && this.time(+hour, +minute, +second, 0);
-    }
+    callback(match, year, month, day, hour, minute, second) {
+      return this.ymd(+year, month - 1, +day) && this.time(+hour, +minute, +second, 0)
+    },
   },
 
   exif: {
-    regex: RegExp('^' + reYear4 + ':' + reMonthlz + ':' + reDaylz + ' ' + reHour24lz + ':' + reMinutelz + ':' + reSecondlz, 'i'),
+    regex: new RegExp(
+      '^' + reYear4 + ':' + reMonthlz + ':' + reDaylz + ' ' + reHour24lz + ':' + reMinutelz + ':' + reSecondlz,
+      'i',
+    ),
     name: 'exif',
-    callback: function callback(match, year, month, day, hour, minute, second) {
-      return this.ymd(+year, month - 1, +day) && this.time(+hour, +minute, +second, 0);
-    }
+    callback(match, year, month, day, hour, minute, second) {
+      return this.ymd(+year, month - 1, +day) && this.time(+hour, +minute, +second, 0)
+    },
   },
 
   xmlRpc: {
-    regex: RegExp('^' + reYear4 + reMonthlz + reDaylz + 'T' + reHour24 + ':' + reMinutelz + ':' + reSecondlz),
+    regex: new RegExp('^' + reYear4 + reMonthlz + reDaylz + 'T' + reHour24 + ':' + reMinutelz + ':' + reSecondlz),
     name: 'xmlrpc',
-    callback: function callback(match, year, month, day, hour, minute, second) {
-      return this.ymd(+year, month - 1, +day) && this.time(+hour, +minute, +second, 0);
-    }
+    callback(match, year, month, day, hour, minute, second) {
+      return this.ymd(+year, month - 1, +day) && this.time(+hour, +minute, +second, 0)
+    },
   },
 
   xmlRpcNoColon: {
-    regex: RegExp('^' + reYear4 + reMonthlz + reDaylz + '[Tt]' + reHour24 + reMinutelz + reSecondlz),
+    regex: new RegExp('^' + reYear4 + reMonthlz + reDaylz + '[Tt]' + reHour24 + reMinutelz + reSecondlz),
     name: 'xmlrpcnocolon',
-    callback: function callback(match, year, month, day, hour, minute, second) {
-      return this.ymd(+year, month - 1, +day) && this.time(+hour, +minute, +second, 0);
-    }
+    callback(match, year, month, day, hour, minute, second) {
+      return this.ymd(+year, month - 1, +day) && this.time(+hour, +minute, +second, 0)
+    },
   },
 
   clf: {
-    regex: RegExp('^' + reDay + '/(' + reMonthAbbr + ')/' + reYear4 + ':' + reHour24lz + ':' + reMinutelz + ':' + reSecondlz + reSpace + reTzCorrection, 'i'),
+    regex: new RegExp(
+      '^' +
+        reDay +
+        '/(' +
+        reMonthAbbr +
+        ')/' +
+        reYear4 +
+        ':' +
+        reHour24lz +
+        ':' +
+        reMinutelz +
+        ':' +
+        reSecondlz +
+        reSpace +
+        reTzCorrection,
+      'i',
+    ),
     name: 'clf',
-    callback: function callback(match, day, month, year, hour, minute, second, tzCorrection) {
-      return this.ymd(+year, lookupMonth(month), +day) && this.time(+hour, +minute, +second, 0) && this.zone(processTzCorrection(tzCorrection));
-    }
+    callback(match, day, month, year, hour, minute, second, tzCorrection) {
+      return (
+        this.ymd(+year, lookupMonth(month), +day) &&
+        this.time(+hour, +minute, +second, 0) &&
+        this.zone(processTzCorrection(tzCorrection))
+      )
+    },
   },
 
   iso8601long: {
-    regex: RegExp('^t?' + reHour24 + '[:.]' + reMinute + '[:.]' + reSecond + reFrac, 'i'),
+    regex: new RegExp('^t?' + reHour24 + '[:.]' + reMinute + '[:.]' + reSecond + reFrac, 'i'),
     name: 'iso8601long',
-    callback: function callback(match, hour, minute, second, frac) {
-      return this.time(+hour, +minute, +second, +frac.substr(0, 3));
-    }
+    callback(match, hour, minute, second, frac) {
+      return this.time(+hour, +minute, +second, +frac.substr(0, 3))
+    },
   },
 
   dateTextual: {
-    regex: RegExp('^' + reMonthText + '[ .\\t-]*' + reDay + '[,.stndrh\\t ]+' + reYear, 'i'),
+    regex: new RegExp('^' + reMonthText + '[ .\\t-]*' + reDay + '[,.stndrh\\t ]+' + reYear, 'i'),
     name: 'datetextual',
-    callback: function callback(match, month, day, year) {
-      return this.ymd(processYear(year), lookupMonth(month), +day);
-    }
+    callback(match, month, day, year) {
+      return this.ymd(processYear(year), lookupMonth(month), +day)
+    },
   },
 
   pointedDate4: {
-    regex: RegExp('^' + reDay + '[.\\t-]' + reMonth + '[.-]' + reYear4),
+    regex: new RegExp('^' + reDay + '[.\\t-]' + reMonth + '[.-]' + reYear4),
     name: 'pointeddate4',
-    callback: function callback(match, day, month, year) {
-      return this.ymd(+year, month - 1, +day);
-    }
+    callback(match, day, month, year) {
+      return this.ymd(+year, month - 1, +day)
+    },
   },
 
   pointedDate2: {
-    regex: RegExp('^' + reDay + '[.\\t]' + reMonth + '\\.' + reYear2),
+    regex: new RegExp('^' + reDay + '[.\\t]' + reMonth + '\\.' + reYear2),
     name: 'pointeddate2',
-    callback: function callback(match, day, month, year) {
-      return this.ymd(processYear(year), month - 1, +day);
-    }
+    callback(match, day, month, year) {
+      return this.ymd(processYear(year), month - 1, +day)
+    },
   },
 
   timeLong24: {
-    regex: RegExp('^t?' + reHour24 + '[:.]' + reMinute + '[:.]' + reSecond),
+    regex: new RegExp('^t?' + reHour24 + '[:.]' + reMinute + '[:.]' + reSecond),
     name: 'timelong24',
-    callback: function callback(match, hour, minute, second) {
-      return this.time(+hour, +minute, +second, 0);
-    }
+    callback(match, hour, minute, second) {
+      return this.time(+hour, +minute, +second, 0)
+    },
   },
 
   dateNoColon: {
-    regex: RegExp('^' + reYear4 + reMonthlz + reDaylz),
+    regex: new RegExp('^' + reYear4 + reMonthlz + reDaylz),
     name: 'datenocolon',
-    callback: function callback(match, year, month, day) {
-      return this.ymd(+year, month - 1, +day);
-    }
+    callback(match, year, month, day) {
+      return this.ymd(+year, month - 1, +day)
+    },
   },
 
   pgydotd: {
-    regex: RegExp('^' + reYear4 + '\\.?' + reDayOfYear),
+    regex: new RegExp('^' + reYear4 + '\\.?' + reDayOfYear),
     name: 'pgydotd',
-    callback: function callback(match, year, day) {
-      return this.ymd(+year, 0, +day);
-    }
+    callback(match, year, day) {
+      return this.ymd(+year, 0, +day)
+    },
   },
 
   timeShort24: {
-    regex: RegExp('^t?' + reHour24 + '[:.]' + reMinute, 'i'),
+    regex: new RegExp('^t?' + reHour24 + '[:.]' + reMinute, 'i'),
     name: 'timeshort24',
-    callback: function callback(match, hour, minute) {
-      return this.time(+hour, +minute, 0, 0);
-    }
+    callback(match, hour, minute) {
+      return this.time(+hour, +minute, 0, 0)
+    },
   },
 
   iso8601noColon: {
-    regex: RegExp('^t?' + reHour24lz + reMinutelz + reSecondlz, 'i'),
+    regex: new RegExp('^t?' + reHour24lz + reMinutelz + reSecondlz, 'i'),
     name: 'iso8601nocolon',
-    callback: function callback(match, hour, minute, second) {
-      return this.time(+hour, +minute, +second, 0);
-    }
+    callback(match, hour, minute, second) {
+      return this.time(+hour, +minute, +second, 0)
+    },
   },
 
   iso8601dateSlash: {
     // eventhough the trailing slash is optional in PHP
     // here it's mandatory and inputs without the slash
     // are handled by dateslash
-    regex: RegExp('^' + reYear4 + '/' + reMonthlz + '/' + reDaylz + '/'),
+    regex: new RegExp('^' + reYear4 + '/' + reMonthlz + '/' + reDaylz + '/'),
     name: 'iso8601dateslash',
-    callback: function callback(match, year, month, day) {
-      return this.ymd(+year, month - 1, +day);
-    }
+    callback(match, year, month, day) {
+      return this.ymd(+year, month - 1, +day)
+    },
   },
 
   dateSlash: {
-    regex: RegExp('^' + reYear4 + '/' + reMonth + '/' + reDay),
+    regex: new RegExp('^' + reYear4 + '/' + reMonth + '/' + reDay),
     name: 'dateslash',
-    callback: function callback(match, year, month, day) {
-      return this.ymd(+year, month - 1, +day);
-    }
+    callback(match, year, month, day) {
+      return this.ymd(+year, month - 1, +day)
+    },
   },
 
   american: {
-    regex: RegExp('^' + reMonth + '/' + reDay + '/' + reYear),
+    regex: new RegExp('^' + reMonth + '/' + reDay + '/' + reYear),
     name: 'american',
-    callback: function callback(match, month, day, year) {
-      return this.ymd(processYear(year), month - 1, +day);
-    }
+    callback(match, month, day, year) {
+      return this.ymd(processYear(year), month - 1, +day)
+    },
   },
 
   americanShort: {
-    regex: RegExp('^' + reMonth + '/' + reDay),
+    regex: new RegExp('^' + reMonth + '/' + reDay),
     name: 'americanshort',
-    callback: function callback(match, month, day) {
-      return this.ymd(this.y, month - 1, +day);
-    }
+    callback(match, month, day) {
+      return this.ymd(this.y, month - 1, +day)
+    },
   },
 
   gnuDateShortOrIso8601date2: {
     // iso8601date2 is complete subset of gnudateshort
-    regex: RegExp('^' + reYear + '-' + reMonth + '-' + reDay),
+    regex: new RegExp('^' + reYear + '-' + reMonth + '-' + reDay),
     name: 'gnudateshort | iso8601date2',
-    callback: function callback(match, year, month, day) {
-      return this.ymd(processYear(year), month - 1, +day);
-    }
+    callback(match, year, month, day) {
+      return this.ymd(processYear(year), month - 1, +day)
+    },
   },
 
   iso8601date4: {
-    regex: RegExp('^' + reYear4withSign + '-' + reMonthlz + '-' + reDaylz),
+    regex: new RegExp('^' + reYear4withSign + '-' + reMonthlz + '-' + reDaylz),
     name: 'iso8601date4',
-    callback: function callback(match, year, month, day) {
-      return this.ymd(+year, month - 1, +day);
-    }
+    callback(match, year, month, day) {
+      return this.ymd(+year, month - 1, +day)
+    },
   },
 
   gnuNoColon: {
-    regex: RegExp('^t?' + reHour24lz + reMinutelz, 'i'),
+    regex: new RegExp('^t?' + reHour24lz + reMinutelz, 'i'),
     name: 'gnunocolon',
-    callback: function callback(match, hour, minute) {
+    callback(match, hour, minute) {
       // this rule is a special case
       // if time was already set once by any preceding rule, it sets the captured value as year
       switch (this.times) {
         case 0:
-          return this.time(+hour, +minute, 0, this.f);
+          return this.time(+hour, +minute, 0, this.f)
         case 1:
-          this.y = hour * 100 + +minute;
-          this.times++;
+          this.y = hour * 100 + +minute
+          this.times++
 
-          return true;
+          return true
         default:
-          return false;
+          return false
       }
-    }
+    },
   },
 
   gnuDateShorter: {
-    regex: RegExp('^' + reYear4 + '-' + reMonth),
+    regex: new RegExp('^' + reYear4 + '-' + reMonth),
     name: 'gnudateshorter',
-    callback: function callback(match, year, month) {
-      return this.ymd(+year, month - 1, 1);
-    }
+    callback(match, year, month) {
+      return this.ymd(+year, month - 1, 1)
+    },
   },
 
   pgTextReverse: {
-    // note: allowed years are from 32-9999
+    //             note: allowed years are from 32-9999
     // years below 32 should be treated as days in datefull
-    regex: RegExp('^' + '(\\d{3,4}|[4-9]\\d|3[2-9])-(' + reMonthAbbr + ')-' + reDaylz, 'i'),
+    regex: new RegExp('^' + '(\\d{3,4}|[4-9]\\d|3[2-9])-(' + reMonthAbbr + ')-' + reDaylz, 'i'),
     name: 'pgtextreverse',
-    callback: function callback(match, year, month, day) {
-      return this.ymd(processYear(year), lookupMonth(month), +day);
-    }
+    callback(match, year, month, day) {
+      return this.ymd(processYear(year), lookupMonth(month), +day)
+    },
   },
 
   dateFull: {
-    regex: RegExp('^' + reDay + '[ \\t.-]*' + reMonthText + '[ \\t.-]*' + reYear, 'i'),
+    regex: new RegExp('^' + reDay + '[ \\t.-]*' + reMonthText + '[ \\t.-]*' + reYear, 'i'),
     name: 'datefull',
-    callback: function callback(match, day, month, year) {
-      return this.ymd(processYear(year), lookupMonth(month), +day);
-    }
+    callback(match, day, month, year) {
+      return this.ymd(processYear(year), lookupMonth(month), +day)
+    },
   },
 
   dateNoDay: {
-    regex: RegExp('^' + reMonthText + '[ .\\t-]*' + reYear4, 'i'),
+    regex: new RegExp('^' + reMonthText + '[ .\\t-]*' + reYear4, 'i'),
     name: 'datenoday',
-    callback: function callback(match, month, year) {
-      return this.ymd(+year, lookupMonth(month), 1);
-    }
+    callback(match, month, year) {
+      return this.ymd(+year, lookupMonth(month), 1)
+    },
   },
 
   dateNoDayRev: {
-    regex: RegExp('^' + reYear4 + '[ .\\t-]*' + reMonthText, 'i'),
+    regex: new RegExp('^' + reYear4 + '[ .\\t-]*' + reMonthText, 'i'),
     name: 'datenodayrev',
-    callback: function callback(match, year, month) {
-      return this.ymd(+year, lookupMonth(month), 1);
-    }
+    callback(match, year, month) {
+      return this.ymd(+year, lookupMonth(month), 1)
+    },
   },
 
   pgTextShort: {
-    regex: RegExp('^(' + reMonthAbbr + ')-' + reDaylz + '-' + reYear, 'i'),
+    regex: new RegExp('^(' + reMonthAbbr + ')-' + reDaylz + '-' + reYear, 'i'),
     name: 'pgtextshort',
-    callback: function callback(match, month, day, year) {
-      return this.ymd(processYear(year), lookupMonth(month), +day);
-    }
+    callback(match, month, day, year) {
+      return this.ymd(processYear(year), lookupMonth(month), +day)
+    },
   },
 
   dateNoYear: {
-    regex: RegExp('^' + reDateNoYear, 'i'),
+    regex: new RegExp('^' + reDateNoYear, 'i'),
     name: 'datenoyear',
-    callback: function callback(match, month, day) {
-      return this.ymd(this.y, lookupMonth(month), +day);
-    }
+    callback(match, month, day) {
+      return this.ymd(this.y, lookupMonth(month), +day)
+    },
   },
 
   dateNoYearRev: {
-    regex: RegExp('^' + reDay + '[ .\\t-]*' + reMonthText, 'i'),
+    regex: new RegExp('^' + reDay + '[ .\\t-]*' + reMonthText, 'i'),
     name: 'datenoyearrev',
-    callback: function callback(match, day, month) {
-      return this.ymd(this.y, lookupMonth(month), +day);
-    }
+    callback(match, day, month) {
+      return this.ymd(this.y, lookupMonth(month), +day)
+    },
   },
 
   isoWeekDay: {
-    regex: RegExp('^' + reYear4 + '-?W' + reWeekOfYear + '(?:-?([0-7]))?'),
+    regex: new RegExp('^' + reYear4 + '-?W' + reWeekOfYear + '(?:-?([0-7]))?'),
     name: 'isoweekday | isoweek',
-    callback: function callback(match, year, week, day) {
-      day = day ? +day : 1;
+    callback(match, year, week, day) {
+      day = day ? +day : 1
 
       if (!this.ymd(+year, 0, 1)) {
-        return false;
+        return false
       }
 
       // get day of week for Jan 1st
-      var dayOfWeek = new Date(this.y, this.m, this.d).getDay();
+      let dayOfWeek = new Date(this.y, this.m, this.d).getDay()
 
       // and use the day to figure out the offset for day 1 of week 1
-      dayOfWeek = 0 - (dayOfWeek > 4 ? dayOfWeek - 7 : dayOfWeek);
+      dayOfWeek = 0 - (dayOfWeek > 4 ? dayOfWeek - 7 : dayOfWeek)
 
-      this.rd += dayOfWeek + (week - 1) * 7 + day;
-    }
+      this.rd += dayOfWeek + (week - 1) * 7 + day
+    },
   },
 
   relativeText: {
-    regex: RegExp('^(' + reReltextnumber + '|' + reReltexttext + ')' + reSpace + '(' + reReltextunit + ')', 'i'),
+    regex: new RegExp('^(' + reReltextnumber + '|' + reReltexttext + ')' + reSpace + '(' + reReltextunit + ')', 'i'),
     name: 'relativetext',
-    callback: function callback(match, relValue, relUnit) {
+    callback(match, relValue, relUnit) {
       // todo: implement handling of 'this time-unit'
-      // eslint-disable-next-line no-unused-vars
-      var _lookupRelative = lookupRelative(relValue),
-          amount = _lookupRelative.amount,
-          behavior = _lookupRelative.behavior;
+      // biome-ignore lint/correctness/noUnusedVariables: behavior reserved for future use
+      const { amount, behavior } = lookupRelative(relValue)
 
       switch (relUnit.toLowerCase()) {
         case 'sec':
         case 'secs':
         case 'second':
         case 'seconds':
-          this.rs += amount;
-          break;
+          this.rs += amount
+          break
         case 'min':
         case 'mins':
         case 'minute':
         case 'minutes':
-          this.ri += amount;
-          break;
+          this.ri += amount
+          break
         case 'hour':
         case 'hours':
-          this.rh += amount;
-          break;
+          this.rh += amount
+          break
         case 'day':
         case 'days':
-          this.rd += amount;
-          break;
+          this.rd += amount
+          break
         case 'fortnight':
         case 'fortnights':
         case 'forthnight':
         case 'forthnights':
-          this.rd += amount * 14;
-          break;
+          this.rd += amount * 14
+          break
         case 'week':
         case 'weeks':
-          this.rd += amount * 7;
-          break;
+          this.rd += amount * 7
+          break
         case 'month':
         case 'months':
-          this.rm += amount;
-          break;
+          this.rm += amount
+          break
         case 'year':
         case 'years':
-          this.ry += amount;
-          break;
+          this.ry += amount
+          break
         case 'mon':
         case 'monday':
         case 'tue':
@@ -819,66 +872,66 @@ var formats = {
         case 'saturday':
         case 'sun':
         case 'sunday':
-          this.resetTime();
-          this.weekday = lookupWeekday(relUnit, 7);
-          this.weekdayBehavior = 1;
-          this.rd += (amount > 0 ? amount - 1 : amount) * 7;
-          break;
+          this.resetTime()
+          this.weekday = lookupWeekday(relUnit, 7)
+          this.weekdayBehavior = 1
+          this.rd += (amount > 0 ? amount - 1 : amount) * 7
+          break
         case 'weekday':
         case 'weekdays':
           // todo
-          break;
+          break
       }
-    }
+    },
   },
 
   relative: {
-    regex: RegExp('^([+-]*)[ \\t]*(\\d+)' + reSpaceOpt + '(' + reReltextunit + '|week)', 'i'),
+    regex: new RegExp('^([+-]*)[ \\t]*(\\d+)' + reSpaceOpt + '(' + reReltextunit + '|week)', 'i'),
     name: 'relative',
-    callback: function callback(match, signs, relValue, relUnit) {
-      var minuses = signs.replace(/[^-]/g, '').length;
+    callback(match, signs, relValue, relUnit) {
+      const minuses = signs.replace(/[^-]/g, '').length
 
-      var amount = +relValue * Math.pow(-1, minuses);
+      const amount = +relValue * Math.pow(-1, minuses)
 
       switch (relUnit.toLowerCase()) {
         case 'sec':
         case 'secs':
         case 'second':
         case 'seconds':
-          this.rs += amount;
-          break;
+          this.rs += amount
+          break
         case 'min':
         case 'mins':
         case 'minute':
         case 'minutes':
-          this.ri += amount;
-          break;
+          this.ri += amount
+          break
         case 'hour':
         case 'hours':
-          this.rh += amount;
-          break;
+          this.rh += amount
+          break
         case 'day':
         case 'days':
-          this.rd += amount;
-          break;
+          this.rd += amount
+          break
         case 'fortnight':
         case 'fortnights':
         case 'forthnight':
         case 'forthnights':
-          this.rd += amount * 14;
-          break;
+          this.rd += amount * 14
+          break
         case 'week':
         case 'weeks':
-          this.rd += amount * 7;
-          break;
+          this.rd += amount * 7
+          break
         case 'month':
         case 'months':
-          this.rm += amount;
-          break;
+          this.rm += amount
+          break
         case 'year':
         case 'years':
-          this.ry += amount;
-          break;
+          this.ry += amount
+          break
         case 'mon':
         case 'monday':
         case 'tue':
@@ -893,150 +946,155 @@ var formats = {
         case 'saturday':
         case 'sun':
         case 'sunday':
-          this.resetTime();
-          this.weekday = lookupWeekday(relUnit, 7);
-          this.weekdayBehavior = 1;
-          this.rd += (amount > 0 ? amount - 1 : amount) * 7;
-          break;
+          this.resetTime()
+          this.weekday = lookupWeekday(relUnit, 7)
+          this.weekdayBehavior = 1
+          this.rd += (amount > 0 ? amount - 1 : amount) * 7
+          break
         case 'weekday':
         case 'weekdays':
           // todo
-          break;
+          break
       }
-    }
+    },
   },
 
   dayText: {
-    regex: RegExp('^(' + reDaytext + ')', 'i'),
+    regex: new RegExp('^(' + reDaytext + ')', 'i'),
     name: 'daytext',
-    callback: function callback(match, dayText) {
-      this.resetTime();
-      this.weekday = lookupWeekday(dayText, 0);
+    callback(match, dayText) {
+      this.resetTime()
+      this.weekday = lookupWeekday(dayText, 0)
 
       if (this.weekdayBehavior !== 2) {
-        this.weekdayBehavior = 1;
+        this.weekdayBehavior = 1
       }
-    }
+    },
   },
 
   relativeTextWeek: {
-    regex: RegExp('^(' + reReltexttext + ')' + reSpace + 'week', 'i'),
+    regex: new RegExp('^(' + reReltexttext + ')' + reSpace + 'week', 'i'),
     name: 'relativetextweek',
-    callback: function callback(match, relText) {
-      this.weekdayBehavior = 2;
+    callback(match, relText) {
+      this.weekdayBehavior = 2
 
       switch (relText.toLowerCase()) {
         case 'this':
-          this.rd += 0;
-          break;
+          this.rd += 0
+          break
         case 'next':
-          this.rd += 7;
-          break;
+          this.rd += 7
+          break
         case 'last':
         case 'previous':
-          this.rd -= 7;
-          break;
+          this.rd -= 7
+          break
       }
 
       if (isNaN(this.weekday)) {
-        this.weekday = 1;
+        this.weekday = 1
       }
-    }
+    },
   },
 
   monthFullOrMonthAbbr: {
-    regex: RegExp('^(' + reMonthFull + '|' + reMonthAbbr + ')', 'i'),
+    regex: new RegExp('^(' + reMonthFull + '|' + reMonthAbbr + ')', 'i'),
     name: 'monthfull | monthabbr',
-    callback: function callback(match, month) {
-      return this.ymd(this.y, lookupMonth(month), this.d);
-    }
+    callback(match, month) {
+      return this.ymd(this.y, lookupMonth(month), this.d)
+    },
   },
 
   tzCorrection: {
-    regex: RegExp('^' + reTzCorrection, 'i'),
+    regex: new RegExp('^' + reTzCorrection, 'i'),
     name: 'tzcorrection',
-    callback: function callback(tzCorrection) {
-      return this.zone(processTzCorrection(tzCorrection));
-    }
+    callback(tzCorrection) {
+      return this.zone(processTzCorrection(tzCorrection))
+    },
   },
 
   tzAbbr: {
-    regex: RegExp('^' + reTzAbbr),
+    regex: new RegExp('^' + reTzAbbr),
     name: 'tzabbr',
-    callback: function callback(match, abbr) {
-      var offset = tzAbbrOffsets[abbr.toLowerCase()];
+    callback(match, abbr) {
+      const offset = tzAbbrOffsets[abbr.toLowerCase()]
 
       if (isNaN(offset)) {
-        return false;
+        return false
       }
 
-      return this.zone(offset);
-    }
+      return this.zone(offset)
+    },
   },
 
   ago: {
     regex: /^ago/i,
     name: 'ago',
-    callback: function callback() {
-      this.ry = -this.ry;
-      this.rm = -this.rm;
-      this.rd = -this.rd;
-      this.rh = -this.rh;
-      this.ri = -this.ri;
-      this.rs = -this.rs;
-      this.rf = -this.rf;
-    }
+    callback() {
+      this.ry = -this.ry
+      this.rm = -this.rm
+      this.rd = -this.rd
+      this.rh = -this.rh
+      this.ri = -this.ri
+      this.rs = -this.rs
+      this.rf = -this.rf
+    },
   },
 
   year4: {
-    regex: RegExp('^' + reYear4),
+    regex: new RegExp('^' + reYear4),
     name: 'year4',
-    callback: function callback(match, year) {
-      this.y = +year;
-      return true;
-    }
+    callback(match, year) {
+      this.y = +year
+      return true
+    },
   },
 
   whitespace: {
     regex: /^[ .,\t]+/,
-    name: 'whitespace'
+    name: 'whitespace',
     // do nothing
   },
 
   dateShortWithTimeLong: {
-    regex: RegExp('^' + reDateNoYear + 't?' + reHour24 + '[:.]' + reMinute + '[:.]' + reSecond, 'i'),
+    regex: new RegExp('^' + reDateNoYear + 't?' + reHour24 + '[:.]' + reMinute + '[:.]' + reSecond, 'i'),
     name: 'dateshortwithtimelong',
-    callback: function callback(match, month, day, hour, minute, second) {
-      return this.ymd(this.y, lookupMonth(month), +day) && this.time(+hour, +minute, +second, 0);
-    }
+    callback(match, month, day, hour, minute, second) {
+      return this.ymd(this.y, lookupMonth(month), +day) && this.time(+hour, +minute, +second, 0)
+    },
   },
 
   dateShortWithTimeLong12: {
-    regex: RegExp('^' + reDateNoYear + reHour12 + '[:.]' + reMinute + '[:.]' + reSecondlz + reSpaceOpt + reMeridian, 'i'),
+    regex: new RegExp(
+      '^' + reDateNoYear + reHour12 + '[:.]' + reMinute + '[:.]' + reSecondlz + reSpaceOpt + reMeridian,
+      'i',
+    ),
     name: 'dateshortwithtimelong12',
-    callback: function callback(match, month, day, hour, minute, second, meridian) {
-      return this.ymd(this.y, lookupMonth(month), +day) && this.time(processMeridian(+hour, meridian), +minute, +second, 0);
-    }
+    callback(match, month, day, hour, minute, second, meridian) {
+      return (
+        this.ymd(this.y, lookupMonth(month), +day) && this.time(processMeridian(+hour, meridian), +minute, +second, 0)
+      )
+    },
   },
 
   dateShortWithTimeShort: {
-    regex: RegExp('^' + reDateNoYear + 't?' + reHour24 + '[:.]' + reMinute, 'i'),
+    regex: new RegExp('^' + reDateNoYear + 't?' + reHour24 + '[:.]' + reMinute, 'i'),
     name: 'dateshortwithtimeshort',
-    callback: function callback(match, month, day, hour, minute) {
-      return this.ymd(this.y, lookupMonth(month), +day) && this.time(+hour, +minute, 0, 0);
-    }
+    callback(match, month, day, hour, minute) {
+      return this.ymd(this.y, lookupMonth(month), +day) && this.time(+hour, +minute, 0, 0)
+    },
   },
 
   dateShortWithTimeShort12: {
-    regex: RegExp('^' + reDateNoYear + reHour12 + '[:.]' + reMinutelz + reSpaceOpt + reMeridian, 'i'),
+    regex: new RegExp('^' + reDateNoYear + reHour12 + '[:.]' + reMinutelz + reSpaceOpt + reMeridian, 'i'),
     name: 'dateshortwithtimeshort12',
-    callback: function callback(match, month, day, hour, minute, meridian) {
-      return this.ymd(this.y, lookupMonth(month), +day) && this.time(processMeridian(+hour, meridian), +minute, 0, 0);
-    }
-  }
-};
+    callback(match, month, day, hour, minute, meridian) {
+      return this.ymd(this.y, lookupMonth(month), +day) && this.time(processMeridian(+hour, meridian), +minute, 0, 0)
+    },
+  },
+}
 
-var resultProto = {
+const resultProto = {
   // date
   y: NaN,
   m: NaN,
@@ -1073,174 +1131,178 @@ var resultProto = {
   zones: 0,
 
   // helper functions
-  ymd: function ymd(y, m, d) {
+  ymd(y, m, d) {
     if (this.dates > 0) {
-      return false;
+      return false
     }
 
-    this.dates++;
-    this.y = y;
-    this.m = m;
-    this.d = d;
-    return true;
+    this.dates++
+    this.y = y
+    this.m = m
+    this.d = d
+    return true
   },
-  time: function time(h, i, s, f) {
+
+  time(h, i, s, f) {
     if (this.times > 0) {
-      return false;
+      return false
     }
 
-    this.times++;
-    this.h = h;
-    this.i = i;
-    this.s = s;
-    this.f = f;
+    this.times++
+    this.h = h
+    this.i = i
+    this.s = s
+    this.f = f
 
-    return true;
+    return true
   },
-  resetTime: function resetTime() {
-    this.h = 0;
-    this.i = 0;
-    this.s = 0;
-    this.f = 0;
-    this.times = 0;
 
-    return true;
+  resetTime() {
+    this.h = 0
+    this.i = 0
+    this.s = 0
+    this.f = 0
+    this.times = 0
+
+    return true
   },
-  zone: function zone(minutes) {
+
+  zone(minutes) {
     if (this.zones <= 1) {
-      this.zones++;
-      this.z = minutes;
-      return true;
+      this.zones++
+      this.z = minutes
+      return true
     }
 
-    return false;
+    return false
   },
-  toDate: function toDate(relativeTo) {
+
+  toDate(relativeTo) {
     if (this.dates && !this.times) {
-      this.h = this.i = this.s = this.f = 0;
+      this.h = this.i = this.s = this.f = 0
     }
 
     // fill holes
     if (isNaN(this.y)) {
-      this.y = relativeTo.getFullYear();
+      this.y = relativeTo.getFullYear()
     }
 
     if (isNaN(this.m)) {
-      this.m = relativeTo.getMonth();
+      this.m = relativeTo.getMonth()
     }
 
     if (isNaN(this.d)) {
-      this.d = relativeTo.getDate();
+      this.d = relativeTo.getDate()
     }
 
     if (isNaN(this.h)) {
-      this.h = relativeTo.getHours();
+      this.h = relativeTo.getHours()
     }
 
     if (isNaN(this.i)) {
-      this.i = relativeTo.getMinutes();
+      this.i = relativeTo.getMinutes()
     }
 
     if (isNaN(this.s)) {
-      this.s = relativeTo.getSeconds();
+      this.s = relativeTo.getSeconds()
     }
 
     if (isNaN(this.f)) {
-      this.f = relativeTo.getMilliseconds();
+      this.f = relativeTo.getMilliseconds()
     }
 
     // adjust special early
     switch (this.firstOrLastDayOfMonth) {
       case 1:
-        this.d = 1;
-        break;
+        this.d = 1
+        break
       case -1:
-        this.d = 0;
-        this.m += 1;
-        break;
+        this.d = 0
+        this.m += 1
+        break
     }
 
     if (!isNaN(this.weekday)) {
-      var date = new Date(relativeTo.getTime());
-      date.setFullYear(this.y, this.m, this.d);
-      date.setHours(this.h, this.i, this.s, this.f);
+      const date = new Date(relativeTo.getTime())
+      date.setFullYear(this.y, this.m, this.d)
+      date.setHours(this.h, this.i, this.s, this.f)
 
-      var dow = date.getDay();
+      const dow = date.getDay()
 
       if (this.weekdayBehavior === 2) {
         // To make "this week" work, where the current day of week is a "sunday"
         if (dow === 0 && this.weekday !== 0) {
-          this.weekday = -6;
+          this.weekday = -6
         }
 
         // To make "sunday this week" work, where the current day of week is not a "sunday"
         if (this.weekday === 0 && dow !== 0) {
-          this.weekday = 7;
+          this.weekday = 7
         }
 
-        this.d -= dow;
-        this.d += this.weekday;
+        this.d -= dow
+        this.d += this.weekday
       } else {
-        var diff = this.weekday - dow;
+        let diff = this.weekday - dow
 
         // some PHP magic
-        if (this.rd < 0 && diff < 0 || this.rd >= 0 && diff <= -this.weekdayBehavior) {
-          diff += 7;
+        if ((this.rd < 0 && diff < 0) || (this.rd >= 0 && diff <= -this.weekdayBehavior)) {
+          diff += 7
         }
 
         if (this.weekday >= 0) {
-          this.d += diff;
+          this.d += diff
         } else {
-          this.d -= 7 - (Math.abs(this.weekday) - dow);
+          this.d -= 7 - (Math.abs(this.weekday) - dow)
         }
 
-        this.weekday = NaN;
+        this.weekday = NaN
       }
     }
 
     // adjust relative
-    this.y += this.ry;
-    this.m += this.rm;
-    this.d += this.rd;
+    this.y += this.ry
+    this.m += this.rm
+    this.d += this.rd
 
-    this.h += this.rh;
-    this.i += this.ri;
-    this.s += this.rs;
-    this.f += this.rf;
+    this.h += this.rh
+    this.i += this.ri
+    this.s += this.rs
+    this.f += this.rf
 
-    this.ry = this.rm = this.rd = 0;
-    this.rh = this.ri = this.rs = this.rf = 0;
+    this.ry = this.rm = this.rd = 0
+    this.rh = this.ri = this.rs = this.rf = 0
 
-    var result = new Date(relativeTo.getTime());
+    const result = new Date(relativeTo.getTime())
     // since Date constructor treats years <= 99 as 1900+
     // it can't be used, thus this weird way
-    result.setFullYear(this.y, this.m, this.d);
-    result.setHours(this.h, this.i, this.s, this.f);
+    result.setFullYear(this.y, this.m, this.d)
+    result.setHours(this.h, this.i, this.s, this.f)
 
-    // note: this is done twice in PHP
+    //             note: this is done twice in PHP
     // early when processing special relatives
     // and late
     // todo: check if the logic can be reduced
     // to just one time action
     switch (this.firstOrLastDayOfMonth) {
       case 1:
-        result.setDate(1);
-        break;
+        result.setDate(1)
+        break
       case -1:
-        result.setMonth(result.getMonth() + 1, 0);
-        break;
+        result.setMonth(result.getMonth() + 1, 0)
+        break
     }
 
     // adjust timezone
     if (!isNaN(this.z) && result.getTimezoneOffset() !== this.z) {
-      result.setUTCFullYear(result.getFullYear(), result.getMonth(), result.getDate());
+      result.setUTCFullYear(result.getFullYear(), result.getMonth(), result.getDate())
 
-      result.setUTCHours(result.getHours(), result.getMinutes(), result.getSeconds() - this.z, result.getMilliseconds());
+      result.setUTCHours(result.getHours(), result.getMinutes(), result.getSeconds() - this.z, result.getMilliseconds())
     }
 
-    return result;
-  }
-};
+    return result
+  },
+}
 
 module.exports = function strtotime(str, now) {
   //       discuss at: https://locutus.io/php/strtotime/
@@ -1274,44 +1336,101 @@ module.exports = function strtotime(str, now) {
   //        returns 7: 1499644800
 
   if (now == null) {
-    now = Math.floor(Date.now() / 1000);
+    now = Math.floor(Date.now() / 1000)
   }
 
   // the rule order is important
   // if multiple rules match, the longest match wins
   // if multiple rules match the same string, the first match wins
-  var rules = [formats.yesterday, formats.now, formats.noon, formats.midnightOrToday, formats.tomorrow, formats.timestamp, formats.firstOrLastDay, formats.backOrFrontOf,
-  // formats.weekdayOf, // not yet implemented
-  formats.timeTiny12, formats.timeShort12, formats.timeLong12, formats.mssqltime, formats.oracledate, formats.timeShort24, formats.timeLong24, formats.iso8601long, formats.gnuNoColon, formats.iso8601noColon, formats.americanShort, formats.american, formats.iso8601date4, formats.iso8601dateSlash, formats.dateSlash, formats.gnuDateShortOrIso8601date2, formats.gnuDateShorter, formats.dateFull, formats.pointedDate4, formats.pointedDate2, formats.dateNoDay, formats.dateNoDayRev, formats.dateTextual, formats.dateNoYear, formats.dateNoYearRev, formats.dateNoColon, formats.xmlRpc, formats.xmlRpcNoColon, formats.soap, formats.wddx, formats.exif, formats.pgydotd, formats.isoWeekDay, formats.pgTextShort, formats.pgTextReverse, formats.clf, formats.year4, formats.ago, formats.dayText, formats.relativeTextWeek, formats.relativeText, formats.monthFullOrMonthAbbr, formats.tzCorrection, formats.tzAbbr, formats.dateShortWithTimeShort12, formats.dateShortWithTimeLong12, formats.dateShortWithTimeShort, formats.dateShortWithTimeLong, formats.relative, formats.whitespace];
-
-  var result = Object.create(resultProto);
+  const rules = [
+    formats.yesterday,
+    formats.now,
+    formats.noon,
+    formats.midnightOrToday,
+    formats.tomorrow,
+    formats.timestamp,
+    formats.firstOrLastDay,
+    formats.backOrFrontOf,
+    // formats.weekdayOf, // not yet implemented
+    formats.timeTiny12,
+    formats.timeShort12,
+    formats.timeLong12,
+    formats.mssqltime,
+    formats.oracledate,
+    formats.timeShort24,
+    formats.timeLong24,
+    formats.iso8601long,
+    formats.gnuNoColon,
+    formats.iso8601noColon,
+    formats.americanShort,
+    formats.american,
+    formats.iso8601date4,
+    formats.iso8601dateSlash,
+    formats.dateSlash,
+    formats.gnuDateShortOrIso8601date2,
+    formats.gnuDateShorter,
+    formats.dateFull,
+    formats.pointedDate4,
+    formats.pointedDate2,
+    formats.dateNoDay,
+    formats.dateNoDayRev,
+    formats.dateTextual,
+    formats.dateNoYear,
+    formats.dateNoYearRev,
+    formats.dateNoColon,
+    formats.xmlRpc,
+    formats.xmlRpcNoColon,
+    formats.soap,
+    formats.wddx,
+    formats.exif,
+    formats.pgydotd,
+    formats.isoWeekDay,
+    formats.pgTextShort,
+    formats.pgTextReverse,
+    formats.clf,
+    formats.year4,
+    formats.ago,
+    formats.dayText,
+    formats.relativeTextWeek,
+    formats.relativeText,
+    formats.monthFullOrMonthAbbr,
+    formats.tzCorrection,
+    formats.tzAbbr,
+    formats.dateShortWithTimeShort12,
+    formats.dateShortWithTimeLong12,
+    formats.dateShortWithTimeShort,
+    formats.dateShortWithTimeLong,
+    formats.relative,
+    formats.whitespace,
+  ]
+
+  const result = Object.create(resultProto)
 
   while (str.length) {
-    var longestMatch = null;
-    var finalRule = null;
+    let longestMatch = null
+    let finalRule = null
 
-    for (var i = 0, l = rules.length; i < l; i++) {
-      var format = rules[i];
+    for (let i = 0, l = rules.length; i < l; i++) {
+      const format = rules[i]
 
-      var match = str.match(format.regex);
+      const match = str.match(format.regex)
 
       if (match) {
         if (!longestMatch || match[0].length > longestMatch[0].length) {
-          longestMatch = match;
-          finalRule = format;
+          longestMatch = match
+          finalRule = format
         }
       }
     }
 
-    if (!finalRule || finalRule.callback && finalRule.callback.apply(result, longestMatch) === false) {
-      return false;
+    if (!finalRule || (finalRule.callback && finalRule.callback.apply(result, longestMatch) === false)) {
+      return false
     }
 
-    str = str.substr(longestMatch[0].length);
-    finalRule = null;
-    longestMatch = null;
+    str = str.substr(longestMatch[0].length)
+    finalRule = null
+    longestMatch = null
   }
 
-  return Math.floor(result.toDate(new Date(now * 1000)) / 1000);
-};
-//# sourceMappingURL=strtotime.js.map
+  return Math.floor(result.toDate(new Date(now * 1000)) / 1000)
+}