Init

node_modules/cron-parser/test/31_of_month.js

@@ -0,0 +1,17 @@
+var util = require('util');
+var test = require('tap').test;
+var expression = require('../lib/expression');
+
+test('expression 31 of month', function(t) {
+  try {
+    var interval = expression.parse('0 0 31 * *');
+    var i;
+    var d;
+    for (i = 0; i < 20; ++i) {
+      d = interval.next();
+    }
+    t.end();
+  } catch (err) {
+    t.error(err, 'Interval parse error');
+  }
+});

node_modules/cron-parser/test/bug.js

@@ -0,0 +1,29 @@
+var util = require('util');
+var test = require('tap').test;
+var CronExpression = require('../lib/expression');
+var CronDate = require('../lib/date');
+
+
+test('parse expression as UTC', function(t) {
+  try {
+    var options = {
+      utc: true
+    };
+
+    var interval = CronExpression.parse('0 0 10 * * *', options);
+
+    var date = interval.next();
+    t.equal(date.getUTCHours(), 10, 'Correct UTC hour value');
+
+    interval = CronExpression.parse('0 */5 * * * *', options);
+
+    var date = interval.next(), now = new Date();
+    now.setMinutes(now.getMinutes() + 5 - (now.getMinutes() % 5));
+    t.equal(date.getHours(), now.getUTCHours(), 'Correct local time for 5 minute interval');
+
+  } catch (err) {
+    t.error(err, 'UTC parse error');
+  }
+
+  t.end();
+});

node_modules/cron-parser/test/crondate.js

@@ -0,0 +1,16 @@
+// empty around comma
+
+var test = require('tap').test;
+var CronDate = require('../lib/date');
+
+test('is the last weekday of the month', function (t) {
+  // Last monday of septhember
+  var date = new CronDate(new Date(2021, 8, 27));
+  t.equal(date.isLastWeekdayOfMonth(), true);
+
+  // Second-to-last monday of septhember
+  var date = new CronDate(new Date(2021, 8, 20));
+  t.equal(date.isLastWeekdayOfMonth(), false);
+
+  t.end();
+});

node_modules/cron-parser/test/crontab.example

@@ -0,0 +1,7 @@
+# Comment line (ignore)
+ENV1="test1"
+ENV2="test2"
+
+*/10 * * * * /path/to/exe
+*/10 * * * * /path/to/exe
+0 09-18 * * 1-5 /path/to/exe

node_modules/cron-parser/test/empty_around_comma.js

@@ -0,0 +1,22 @@
+// empty around comma
+
+var test = require('tap').test;
+var CronExpression = require('../lib/expression');
+
+const options = {
+  utc: true
+};
+
+test('both empty around comma', function (t) {
+  t.throws(function () {
+    CronExpression.parse('*/10 * * * * ,', options);
+  }, new Error('Invalid list value format'));
+  t.end();
+});
+
+test('one side empty around comma', function (t) {
+  t.throws(function () {
+    CronExpression.parse('*/10 * * * * ,2', options);
+  }, new Error('Invalid list value format'));
+  t.end();
+});

node_modules/cron-parser/test/field_compactor.js

@@ -0,0 +1,250 @@
+'use strict';
+
+var test = require('tap').test;
+var compactField = require('../lib/field_compactor');
+
+test('compact field - empty array', function(t) {
+  try {
+    var result = compactField([]);
+    t.same(result, []);
+  } catch (err) {
+    t.error(err, 'compact field error');
+  }
+  t.end();
+});
+
+test('compact field - single element array', function(t) {
+  try {
+    var result = compactField([1]);
+    t.same(result, [{
+      start: 1,
+      count: 1
+    }]);
+  } catch (err) {
+    t.error(err, 'compact field error');
+  }
+  t.end();
+});
+
+test('compact field - 2 elements array', function(t) {
+  try {
+    var result = compactField([1, 2]);
+    t.same(result, [
+      {
+        start: 1,
+        count: 1
+      },
+      {
+        start: 2,
+        count: 1
+      }
+    ]);
+  } catch (err) {
+    t.error(err, 'compact field error');
+  }
+  t.end();
+});
+
+test('compact field - 2 elements array big step', function(t) {
+  try {
+    var result = compactField([1, 5]);
+    t.same(result, [
+      {
+        start: 1,
+        count: 1
+      },
+      {
+        start: 5,
+        count: 1
+      }
+    ]);
+  } catch (err) {
+    t.error(err, 'compact field error');
+  }
+  t.end();
+});
+
+test('compact field - 3 elements array 1 step', function(t) {
+  try {
+    var result = compactField([1, 2, 3]);
+    t.same(result, [
+      {
+        start: 1,
+        end: 3,
+        count: 3,
+        step: 1
+      }
+    ]);
+  } catch (err) {
+    t.error(err, 'compact field error');
+  }
+  t.end();
+});
+
+test('compact field - 3 elements array 1 step, dangling extra at end', function(t) {
+  try {
+    var result = compactField([1, 2, 3, 5]);
+    t.same(result, [
+      {
+        start: 1,
+        end: 3,
+        count: 3,
+        step: 1
+      },
+      {
+        start: 5,
+        count: 1
+      }
+    ]);
+  } catch (err) {
+    t.error(err, 'compact field error');
+  }
+  t.end();
+});
+
+test('compact field - 3 elements array 1 step, dangling extra at end and beginning', function(t) {
+  try {
+    var result = compactField([1, 4, 5, 6, 9]);
+    t.same(result, [
+      {
+        start: 1,
+        count: 1
+      },
+      {
+        start: 4,
+        end: 6,
+        count: 3,
+        step: 1
+      },
+      {
+        start: 9,
+        count: 1
+      }
+    ]);
+  } catch (err) {
+    t.error(err, 'compact field error');
+  }
+  t.end();
+});
+
+test('compact field - 2 ranges with dangling in the middle', function(t) {
+  try {
+    var result = compactField([1, 2, 3, 6, 9, 11, 13]);
+    t.same(result, [
+      {
+        start: 1,
+        end: 3,
+        count: 3,
+        step: 1
+      },
+      {
+        start: 6,
+        count: 1
+      },
+      {
+        start: 9,
+        end: 13,
+        count: 3,
+        step: 2
+      }
+    ]);
+  } catch (err) {
+    t.error(err, 'compact field error');
+  }
+  t.end();
+});
+
+test('compact field - with chars', function(t) {
+  try {
+    var result = compactField(['L', 'W']);
+    t.same(result, [
+      {
+        start: 'L',
+        count: 1
+      },
+      {
+        start: 'W',
+        count: 1
+      }
+    ]);
+  } catch (err) {
+    t.error(err, 'compact field error');
+  }
+  t.end();
+});
+
+test('compact field - with chars and range', function(t) {
+  try {
+    var result = compactField([1, 'L', 'W']);
+    t.same(result, [
+      {
+        start: 1,
+        count: 1,
+      },
+      {
+        start: 'L',
+        count: 1
+      },
+      {
+        start: 'W',
+        count: 1
+      }
+    ]);
+  } catch (err) {
+    t.error(err, 'compact field error');
+  }
+  t.end();
+});
+
+test('compact field - with chars and range (v2)', function(t) {
+  try {
+    var result = compactField([1, 2, 'L', 'W']);
+    t.same(result, [
+      {
+        start: 1,
+        count: 1,
+      },
+      {
+        start: 2,
+        count: 1,
+      },
+      {
+        start: 'L',
+        count: 1
+      },
+      {
+        start: 'W',
+        count: 1
+      }
+    ]);
+  } catch (err) {
+    t.error(err, 'compact field error');
+  }
+  t.end();
+});
+
+
+test('compact field - with chars and range (v3)', function(t) {
+  try {
+    var result = compactField([1, 2, 3, 'L', 'W']);
+    t.same(result, [
+      {
+        start: 1,
+        end: 3,
+        count: 3,
+        step: 1
+      },
+      {
+        start: 'L',
+        count: 1
+      },
+      {
+        start: 'W',
+        count: 1
+      }
+    ]);
+  } catch (err) {
+    t.error(err, 'compact field error');
+  }
+  t.end();
+});

node_modules/cron-parser/test/field_stringify.js

@@ -0,0 +1,84 @@
+'use strict';
+
+var test = require('tap').test;
+var stringifyField = require('../lib/field_stringify');
+
+test('stringify astrix', function (t) {
+  try {
+    var str = stringifyField([1, 2, 3, 4], 1, 4);
+    t.equal(str, '*');
+  } catch (err) {
+    t.error(err, 'stringify field error');
+  }
+  t.end();
+});
+
+test('stringify astrix step', function (t) {
+  try {
+    var str = stringifyField([0, 2, 4, 6], 0, 7);
+    t.equal(str, '*/2');
+  } catch (err) {
+    t.error(err, 'stringify field error');
+  }
+  t.end();
+});
+
+test('stringify single value', function (t) {
+  try {
+    var str = stringifyField([2], 0, 7);
+    t.equal(str, '2');
+  } catch (err) {
+    t.error(err, 'stringify field error');
+  }
+  t.end();
+});
+
+test('stringify multiple single values', function (t) {
+  try {
+    var str = stringifyField([2, 5, 9], 0, 7);
+    t.equal(str, '2,5,9');
+  } catch (err) {
+    t.error(err, 'stringify field error');
+  }
+  t.end();
+});
+
+test('stringify range', function (t) {
+  try {
+    var str = stringifyField([2, 3, 4], 0, 7);
+    t.equal(str, '2-4');
+  } catch (err) {
+    t.error(err, 'stringify field error');
+  }
+  t.end();
+});
+
+test('stringify range step', function (t) {
+  try {
+    var str = stringifyField([2, 4, 6], 0, 8);
+    t.equal(str, '2-6/2');
+  } catch (err) {
+    t.error(err, 'stringify field error');
+  }
+  t.end();
+});
+
+test('stringify semi range step', function (t) {
+  try {
+    var str = stringifyField([4, 6, 8], 0, 9);
+    t.equal(str, '4/2');
+  } catch (err) {
+    t.error(err, 'stringify field error');
+  }
+  t.end();
+});
+
+test('stringify multi types', function (t) {
+  try {
+    var str = stringifyField([1, 2, 4, 5, 6, 7, 8, 9, 10, 20, 25, 30, 35, 57], 0, 59);
+    t.equal(str, '1,2,4-10,20-35/5,57');
+  } catch (err) {
+    t.error(err, 'stringify field error');
+  }
+  t.end();
+});

node_modules/cron-parser/test/fields.js

@@ -0,0 +1,32 @@
+var test = require('tap').test;
+var CronExpression = require('../lib/expression');
+
+test('Fields are exposed', function(t){
+  try {
+    var interval = CronExpression.parse('0 1 2 3 * 1-3,5');
+    t.ok(interval, 'Interval parsed');
+
+    CronExpression.map.forEach(function(field) {
+      interval.fields[field] = [];
+      t.throws(function() {
+        interval.fields[field].push(-1);
+      }, /Cannot add property .*?, object is not extensible/, field + ' is frozen');
+      delete interval.fields[field];
+    });
+    interval.fields.dummy = [];
+    t.same(interval.fields.dummy, undefined, 'Fields is frozen');
+
+    t.same(interval.fields.second, [0], 'Second matches');
+    t.same(interval.fields.minute, [1], 'Minute matches');
+    t.same(interval.fields.hour, [2], 'Hour matches');
+    t.same(interval.fields.dayOfMonth, [3], 'Day of month matches');
+    t.same(interval.fields.month, [1,2,3,4,5,6,7,8,9,10,11,12], 'Month matches');
+    t.same(interval.fields.dayOfWeek, [1,2,3,5], 'Day of week matches');
+
+  } catch (err) {
+    t.error(err, 'Interval parse error');
+  }
+
+  t.end();
+});
+

node_modules/cron-parser/test/increment_on_first_iteration.js

@@ -0,0 +1,22 @@
+var util = require('util');
+var sinon = require('sinon');
+var test = require('tap').test;
+var CronExpression = require('../lib/expression');
+
+test('increment_on_first_itereation', function(t) {
+  try {
+    var clock = sinon.useFakeTimers();
+    var fake_now = new Date('Tue Feb 21 2017 16:45:00');
+    clock.tick(fake_now.getTime());
+    var interval = CronExpression.parse('* * * * *');
+    t.ok(interval, 'Interval parsed');
+    var next = interval.next();
+    t.ok(next, 'Found next scheduled interval');
+    // Make sure next has incremented in 1 minute
+    t.equal(fake_now.getTime() + 60000, next.getTime());
+    clock.restore();
+    t.end();
+  } catch (err) {
+    t.error(err, 'Interval parse error');
+  }
+});

node_modules/cron-parser/test/index-ts3.test-d.ts

@@ -0,0 +1,133 @@
+import {expectAssignable, expectError, expectNotAssignable, expectType} from 'tsd';
+import {
+    CronDate,
+    CronExpression,
+    CronFields, DateType,
+    parseExpression,
+    parseFile, ParserOptions,
+    parseString,
+    fieldsToExpression,
+    StringResult
+} from '../types/ts3';
+
+const interval = parseExpression('0 1 2 3 * 1-3,5');
+const intervalIterator = parseExpression('0 1 2 3 * 1-3,5', {iterator: true});
+
+expectType<readonly number[]>(interval.fields.second);
+expectType<readonly number[]>(interval.fields.minute);
+expectType<readonly number[]>(interval.fields.hour);
+expectType<readonly (number | 'L')[]>(interval.fields.dayOfMonth);
+expectType<readonly number[]>(interval.fields.month);
+expectType<readonly number[]>(interval.fields.dayOfWeek);
+
+expectError(interval.fields = interval.fields);
+
+expectError(interval.fields.second = []);
+expectError(interval.fields.second.push(1));
+
+expectError(interval.fields.minute = []);
+expectError(interval.fields.minute.push(1));
+
+expectError(interval.fields.hour = []);
+expectError(interval.fields.hour.push(1));
+
+expectError(interval.fields.dayOfMonth = []);
+expectError(interval.fields.dayOfMonth.push(1));
+
+expectError(interval.fields.month = []);
+expectError(interval.fields.month.push(1));
+
+expectError(interval.fields.dayOfWeek = []);
+expectError(interval.fields.dayOfWeek.push(1));
+
+expectAssignable<typeof interval.fields.second[0]>(0);
+expectAssignable<typeof interval.fields.second[0]>(59);
+
+expectAssignable<typeof interval.fields.minute[0]>(0);
+expectAssignable<typeof interval.fields.minute[0]>(59);
+
+expectAssignable<typeof interval.fields.hour[0]>(0);
+expectAssignable<typeof interval.fields.hour[0]>(23);
+
+expectAssignable<typeof interval.fields.dayOfMonth[0]>(1);
+expectAssignable<typeof interval.fields.dayOfMonth[0]>(31);
+expectAssignable<typeof interval.fields.dayOfMonth[0]>('L');
+
+expectAssignable<typeof interval.fields.month[0]>(1);
+expectAssignable<typeof interval.fields.month[0]>(12);
+
+expectAssignable<typeof interval.fields.dayOfWeek[0]>(0);
+expectAssignable<typeof interval.fields.dayOfWeek[0]>(7);
+
+const parseOptions: ParserOptions<true> = {
+    currentDate: 'f',
+    startDate: 4,
+    endDate: new Date(),
+    iterator: true,
+    utc: true,
+    tz: 'f',
+    nthDayOfWeek: 5,
+}
+expectAssignable<{
+    currentDate?: string | number | Date
+    startDate?: string | number | Date
+    endDate?: string | number | Date
+    iterator?: boolean
+    utc?: boolean
+    tz?: string
+    nthDayOfWeek?: number
+}>(parseOptions)
+
+expectType<CronExpression>(parseExpression('0 1 2 3 * 1-3,5'))
+expectType<CronExpression<true>>(parseExpression('0 1 2 3 * 1-3,5', parseOptions))
+
+const fields: CronFields = {
+    second: [1, 1],
+    minute: [1],
+    hour: [1],
+    dayOfMonth: [1],
+    month: [1],
+    dayOfWeek: [1],
+}
+
+expectType<CronExpression>(fieldsToExpression(fields))
+expectType<CronExpression<true>>(fieldsToExpression(fields, parseOptions))
+
+expectType<string>(fieldsToExpression(fields).stringify())
+expectType<string>(fieldsToExpression(fields, parseOptions).stringify())
+expectType<string>(fieldsToExpression(fields, parseOptions).stringify(true))
+
+expectType<void>(parseFile('path', (err: any, data: StringResult) => console.log(data)))
+
+expectType<StringResult>(parseString('path'))
+
+const stringResult = parseString('path');
+expectType<{
+    variables: Record<string, string>,
+    expressions: CronExpression[],
+    errors: Record<string, any>,
+}>(stringResult)
+
+expectType<CronFields>(interval.fields)
+expectType<CronDate>(interval.next())
+expectType<CronDate>(interval.prev())
+expectType<boolean>(interval.hasNext())
+expectType<boolean>(interval.hasPrev())
+expectType<string>(interval.stringify())
+expectType<string>(interval.stringify(true))
+expectType<void>(interval.reset())
+expectType<void>(interval.reset("Sdf"))
+expectType<void>(interval.reset(5))
+expectType<void>(interval.reset(new Date()))
+expectType<CronDate[]>(interval.iterate(5))
+expectType<CronDate[]>(interval.iterate(5, (item: CronDate, i: number) => {}))
+
+expectAssignable<DateType>(new Date())
+expectAssignable<DateType>(5)
+expectAssignable<DateType>("SDf")
+
+
+expectType<IteratorResult<CronDate, CronDate>>(intervalIterator.next())
+expectType<IteratorResult<CronDate, CronDate>>(intervalIterator.prev())
+expectType<IteratorResult<CronDate, CronDate>[]>(intervalIterator.iterate(5))
+expectType<IteratorResult<CronDate, CronDate>[]>(intervalIterator.iterate(5, (item: IteratorResult<CronDate, CronDate>, i: number) => {}))

node_modules/cron-parser/test/index.test-d.ts

@@ -0,0 +1,138 @@
+import {expectAssignable, expectError, expectNotAssignable, expectType} from 'tsd';
+import {
+    CronDate,
+    CronExpression,
+    CronFields, DateType,
+    parseExpression,
+    parseFile, ParserOptions,
+    parseString,
+    fieldsToExpression,
+    StringResult
+} from '../index';
+
+const interval = parseExpression('0 1 2 3 * 1-3,5');
+const intervalIterator = parseExpression('0 1 2 3 * 1-3,5', {iterator: true});
+
+expectError(interval.fields = interval.fields);
+
+expectError(interval.fields.second = []);
+expectError(interval.fields.second.push(1));
+
+expectError(interval.fields.minute = []);
+expectError(interval.fields.minute.push(1));
+
+expectError(interval.fields.hour = []);
+expectError(interval.fields.hour.push(1));
+
+expectError(interval.fields.dayOfMonth = []);
+expectError(interval.fields.dayOfMonth.push(1));
+
+expectError(interval.fields.month = []);
+expectError(interval.fields.month.push(1));
+
+expectError(interval.fields.dayOfWeek = []);
+expectError(interval.fields.dayOfWeek.push(1));
+
+expectAssignable<typeof interval.fields.second[0]>(0);
+expectAssignable<typeof interval.fields.second[0]>(59);
+expectNotAssignable<typeof interval.fields.second[0]>(-1);
+expectNotAssignable<typeof interval.fields.second[0]>(60);
+
+expectAssignable<typeof interval.fields.minute[0]>(0);
+expectAssignable<typeof interval.fields.minute[0]>(59);
+expectNotAssignable<typeof interval.fields.minute[0]>(-1);
+expectNotAssignable<typeof interval.fields.minute[0]>(60);
+
+expectAssignable<typeof interval.fields.hour[0]>(0);
+expectAssignable<typeof interval.fields.hour[0]>(23);
+expectNotAssignable<typeof interval.fields.hour[0]>(-1);
+expectNotAssignable<typeof interval.fields.hour[0]>(24);
+
+expectAssignable<typeof interval.fields.dayOfMonth[0]>(1);
+expectAssignable<typeof interval.fields.dayOfMonth[0]>(31);
+expectAssignable<typeof interval.fields.dayOfMonth[0]>('L');
+expectNotAssignable<typeof interval.fields.dayOfMonth[0]>(0);
+expectNotAssignable<typeof interval.fields.dayOfMonth[0]>(32);
+
+expectAssignable<typeof interval.fields.month[0]>(1);
+expectAssignable<typeof interval.fields.month[0]>(12);
+expectNotAssignable<typeof interval.fields.month[0]>(0);
+expectNotAssignable<typeof interval.fields.month[0]>(13);
+
+expectAssignable<typeof interval.fields.dayOfWeek[0]>(0);
+expectAssignable<typeof interval.fields.dayOfWeek[0]>(7);
+expectNotAssignable<typeof interval.fields.dayOfWeek[0]>(-1);
+expectNotAssignable<typeof interval.fields.dayOfWeek[0]>(8);
+
+const parseOptions: ParserOptions<true> = {
+    currentDate: 'f',
+    startDate: 4,
+    endDate: new Date(),
+    iterator: true,
+    utc: true,
+    tz: 'f',
+    nthDayOfWeek: 5,
+}
+expectAssignable<{
+    currentDate?: string | number | Date
+    startDate?: string | number | Date
+    endDate?: string | number | Date
+    iterator?: boolean
+    utc?: boolean
+    tz?: string
+    nthDayOfWeek?: number
+}>(parseOptions)
+
+expectType<CronExpression>(parseExpression('0 1 2 3 * 1-3,5'))
+expectType<CronExpression<true>>(parseExpression('0 1 2 3 * 1-3,5', parseOptions))
+
+const fields: CronFields = {
+    second: [1, 1],
+    minute: [1],
+    hour: [1],
+    dayOfMonth: [1],
+    month: [1],
+    dayOfWeek: [1],
+}
+
+expectType<CronExpression>(fieldsToExpression(fields))
+expectType<CronExpression<true>>(fieldsToExpression(fields, parseOptions))
+
+expectType<string>(fieldsToExpression(fields).stringify())
+expectType<string>(fieldsToExpression(fields, parseOptions).stringify())
+expectType<string>(fieldsToExpression(fields, parseOptions).stringify(true))
+
+expectType<void>(parseFile('path', (err: any, data: StringResult) => console.log(data)))
+
+expectType<StringResult>(parseString('path'))
+
+const stringResult = parseString('path');
+expectType<{
+    variables: Record<string, string>,
+    expressions: CronExpression[],
+    errors: Record<string, any>,
+}>(stringResult)
+
+expectType<CronFields>(interval.fields)
+expectType<CronDate>(interval.next())
+expectType<CronDate>(interval.prev())
+expectType<boolean>(interval.hasNext())
+expectType<boolean>(interval.hasPrev())
+expectType<string>(interval.stringify())
+expectType<string>(interval.stringify(true))
+expectType<void>(interval.reset())
+expectType<void>(interval.reset("Sdf"))
+expectType<void>(interval.reset(5))
+expectType<void>(interval.reset(new Date()))
+expectType<CronDate[]>(interval.iterate(5))
+expectType<CronDate[]>(interval.iterate(5, (item: CronDate, i: number) => {}))
+
+expectAssignable<DateType>(new Date())
+expectAssignable<DateType>(5)
+expectAssignable<DateType>("SDf")
+
+
+expectType<IteratorResult<CronDate, CronDate>>(intervalIterator.next())
+expectType<IteratorResult<CronDate, CronDate>>(intervalIterator.prev())
+expectType<IteratorResult<CronDate, CronDate>[]>(intervalIterator.iterate(5))
+expectType<IteratorResult<CronDate, CronDate>[]>(intervalIterator.iterate(5, (item: IteratorResult<CronDate, CronDate>, i: number) => {}))

node_modules/cron-parser/test/leap_year.js

@@ -0,0 +1,17 @@
+var util = require('util');
+var test = require('tap').test;
+var expression = require('../lib/expression');
+
+test('leap year', function(t) {
+  try {
+    var interval = expression.parse('0 0 29 2 *');
+    var i;
+    var d;
+    for (i = 0; i < 20; ++i) {
+      d = interval.next();
+    }
+    t.end();
+  } catch (err) {
+    t.error(err, 'Interval parse error');
+  }
+});

node_modules/cron-parser/test/parser.js

@@ -0,0 +1,46 @@
+var test = require('tap').test;
+var CronParser = require('../lib/parser');
+
+// Globals
+
+test('load crontab file', function(t) {
+  CronParser.parseFile(__dirname + '/crontab.example', function(err, result) {
+    t.error(err, 'File read error');
+    t.ok(result, 'Crontab parsed parsed');
+
+    t.equal(Object.keys(result.variables).length, 2, 'variables length matches');
+    t.equal(Object.keys(result.errors).length, 0, 'errors length matches');
+    t.equal(result.expressions.length, 3, 'expressions length matches');
+
+    // Parse expressions
+    var next = null;
+
+    t.equal(result.expressions[0].hasNext(), true);
+    next = result.expressions[0].next();
+    t.ok(next, 'first date');
+
+    next = result.expressions[1].next();
+    t.ok(next, 'second date');
+
+    next = result.expressions[2].next();
+    t.ok(next, 'third date');
+
+    t.end();
+  });
+});
+
+test('no next date', function(t) {
+  var options = {
+    currentDate: new Date(2014, 0, 1),
+    endDate: new Date(2014, 0, 1)
+  };
+
+  try {
+    var interval = CronParser.parseExpression('* * 2 * *', options);
+    t.equal(interval.hasNext(), false);
+  } catch (err) {
+    t.error(err, 'Parse read error');
+  }
+
+  t.end();
+});

node_modules/cron-parser/test/parser_crondate_formats.js

@@ -0,0 +1,145 @@
+var luxon = require('luxon');
+var test = require('tap').test;
+var CronDate = require('../lib/date');
+
+test('parse cron date formats with local timezone', (t) => {
+  // Some tests need the local offset to be compatible without invoking timezone management.
+  // Local offset is dependent on what the system being tested on is
+  var offset = new Date().getTimezoneOffset();
+  var offsetHours = Math.abs(Math.floor(offset/60));
+  var offsetMinutes = offset % 60;
+  var offsetSign = offset < 0 ? '-' : '+';
+
+  var expectedTime = new Date(2021, 0, 4, 10, 0, 0).toString();
+
+  test('undefined date', (t) => {
+    const realDate = new Date();
+    var d = new CronDate();
+
+    t.equal(d.toDate().toString(), realDate.toString());
+
+    t.end();
+  });
+
+  test('JS Date', (t) => {
+    var d = new CronDate(new Date(2021, 0, 4, 10, 0, 0));
+    t.equal(d.toDate().toString(), expectedTime);
+
+    t.end();
+  });
+
+  test('ISO 8601', (t) => {
+    var d = new CronDate('2021-01-04T10:00:00');
+    t.equal(d.toDate().toString(), expectedTime);
+
+    t.end();
+  });
+
+  test('ISO 8601 date', (t) => {
+
+    var d = new CronDate('2021-01-04');
+    var expectedTime = new Date(2021, 0, 4, 0, 0, 0).toString();
+
+    t.equal(d.toDate().toString(), expectedTime);
+
+    t.end();
+  });
+
+  test('RFC2822', (t) => {
+    var offsetString = offsetSign + String(offsetHours).padStart(2, 0) + String(offsetMinutes).padStart(2, 0);
+
+    var d = new CronDate('Mon, 4 Jan 2021 10:00:00 ' + offsetString);
+    t.equal(d.toDate().toString(), expectedTime);
+
+    t.end();
+  });
+
+  test('RFC2822-like without timezone offset', (t) => {
+    var d = new CronDate('Mon, 4 Jan 2021 10:00:00');
+    t.equal(d.toDate().toString(), expectedTime);
+
+    t.end();
+  });
+
+  test('SQL', (t) => {
+    var d = new CronDate('2021-01-04 10:00:00');
+    t.equal(d.toDate().toString(), expectedTime);
+
+    t.end();
+  });
+
+  test('milliseconds', (t) => {
+    var d = new CronDate(new Date('2021-01-04 10:00:00').valueOf());
+    t.equal(d.toDate().toString(), expectedTime);
+
+    t.end();
+  });
+
+  test('CronDate', (t) => {
+    var date = new CronDate('Mon, 4 Jan 2021 10:00:00');
+    var d = new CronDate(date);
+    t.equal(d.toDate().toString(), expectedTime);
+
+    t.end();
+  });
+
+  test('invalid', (t) => {
+    t.throws(() => {
+      var d = new CronDate('2021-01-4 10:00:00');
+    });
+
+    t.end();
+  });
+
+  t.end();
+});
+
+test('parse cron date formats with another timezone', (t) => {
+  test('ISO 8601 without offset', (t) => {
+    // implies format already in timezone
+    var d = new CronDate('2021-01-04T10:00:00', 'Europe/Athens');
+    t.equal(d.toISOString(), '2021-01-04T08:00:00.000Z');
+
+    t.end();
+  });
+
+  test('ISO 8601 with non-local offset', (t) => {
+    var d = new CronDate('2021-01-04T10:00:00+01:00', 'Europe/Athens');
+    t.equal(d.toISOString(), '2021-01-04T09:00:00.000Z');
+
+    t.end();
+  });
+
+  test('RFC2822 with non-local offset', (t) => {
+    var d = new CronDate('Mon, 4 Jan 2021 10:00:00 +0100', 'Europe/Athens');
+    t.equal(d.toISOString(), '2021-01-04T09:00:00.000Z');
+
+    t.end();
+  });
+
+  test('milliseconds', (t) => {
+    var date = luxon.DateTime.fromISO('2021-01-04T11:00:00.000+02:00').valueOf();
+    var d = new CronDate(date, 'Europe/Athens');
+    t.equal(d.toISOString(), '2021-01-04T09:00:00.000Z');
+
+    t.end();
+  });
+
+  test('CronDate with same timezone', (t) => {
+    var date = new CronDate('Mon, 4 Jan 2021 10:00:00', 'Europe/Athens');
+    var d = new CronDate(date);
+    t.equal(d.toISOString(), '2021-01-04T08:00:00.000Z');
+
+    t.end();
+  });
+
+  test('CronDate with different timezone', (t) => {
+    var date = new CronDate('Mon, 4 Jan 2021 10:00:00', 'America/New_York');
+    var d = new CronDate(date, 'Europe/Athens');
+    t.equal(d.toISOString(), '2021-01-04T15:00:00.000Z');
+
+    t.end();
+  });
+
+  t.end('crondate input should');
+});

node_modules/cron-parser/test/parser_day_of_month.js

@@ -0,0 +1,169 @@
+var test = require('tap').test;
+var CronParser = require('../lib/parser');
+
+test('parse cron with last day in a month', function(t) {
+  var options = {
+    currentDate: new Date(2014, 0, 1),
+    endDate: new Date(2014, 10, 1)
+  };
+
+  try {
+    var interval = CronParser.parseExpression('0 0 L * *', options);
+    t.equal(interval.hasNext(), true);
+
+    for (i = 0; i < 10; ++i) {
+      var next = interval.next();
+      t.ok(next, 'has a date');
+    }
+  } catch (err) {
+    t.error(err, 'Parse read error');
+  }
+
+  t.end();
+});
+
+test('parse cron with last day in feb', function(t) {
+  var options = {
+    currentDate: new Date(2016, 0, 1),
+    endDate: new Date(2016, 10, 1)
+  };
+
+  try {
+    var interval = CronParser.parseExpression('0 0 6-20/2,L 2 *', options);
+    t.equal(interval.hasNext(), true);
+    var next = null;
+    var items = 9;
+    var i = 0;
+    while(interval.hasNext()) {
+      next = interval.next();
+      i += 1;
+      t.ok(next, 'has a date');
+    }
+    //leap year
+    t.equal(next.getDate(), 29);
+    t.equal(i, items);
+  } catch (err) {
+    t.error(err, 'Parse read error');
+  }
+
+  t.end();
+});
+
+test('parse cron with last day in feb', function(t) {
+  var options = {
+    currentDate: new Date(2014, 0, 1),
+    endDate: new Date(2014, 10, 1)
+  };
+
+  try {
+    var interval = CronParser.parseExpression('0 0 1,3,6-10,L 2 *', options);
+    t.equal(interval.hasNext(), true);
+    var next = null;
+    while(interval.hasNext()) {
+      next = interval.next();
+      t.ok(next, 'has a date');
+    }
+    //common year
+    t.equal(next.getDate(), 28);
+  } catch (err) {
+    t.error(err, 'Parse read error');
+  }
+
+  t.end();
+});
+
+test('parse cron with last weekday of the month', function(t) {
+  var options = {
+    currentDate: new Date(2021, 8, 1),
+    endDate: new Date(2021, 11, 1)
+  };
+
+  var testCases = [
+    { expression: '0 0 0 * * 1L', expectedDate: 27 },
+    { expression: '0 0 0 * * 2L', expectedDate: 28 },
+    { expression: '0 0 0 * * 3L', expectedDate: 29 },
+    { expression: '0 0 0 * * 4L', expectedDate: 30 },
+    { expression: '0 0 0 * * 5L', expectedDate: 24 },
+    { expression: '0 0 0 * * 6L', expectedDate: 25 },
+    { expression: '0 0 0 * * 0L', expectedDate: 26 },
+    { expression: '0 0 0 * * 7L', expectedDate: 26 }
+  ];
+
+  testCases.forEach(function({ expression, expectedDate }) {
+    t.test(expression, function(t) {
+      try {
+        var interval = CronParser.parseExpression(expression, options);
+
+        t.equal(interval.hasNext(), true);
+
+        var next = interval.next();
+
+        t.equal(next.getDate(), expectedDate);
+      } catch (err) {
+        t.error(err, 'Parse read error');
+      }
+
+      t.end();
+    });
+  });
+
+  t.end();
+});
+
+test('parses expression that runs on both last monday and friday of the month', function(t) {
+  var options = {
+    currentDate: new Date(2021, 8, 1),
+    endDate: new Date(2021, 11, 1)
+  };
+
+  try {
+    var interval = CronParser.parseExpression('0 0 0 * * 1L,5L', options);
+
+    t.equal(interval.next().getDate(), 24);
+    t.equal(interval.next().getDate(), 27);
+  } catch (err) {
+    t.error(err, 'Parse read error');
+  }
+
+  t.end();
+});
+
+test('parses expression that runs on both every monday and last friday of mont', function(t) {
+  var options = {
+    currentDate: new Date(2021, 8, 1),
+    endDate: new Date(2021, 8, 30)
+  };
+
+  try {
+    var interval = CronParser.parseExpression('0 0 0 * * 1,5L', options);
+
+    var dates = [];
+
+    while(true) {
+      try {
+        dates.push(interval.next().getDate());
+      } catch (e) {
+        if (e.message !== 'Out of the timespan range') {
+          throw e;
+        }
+
+        break;
+      }
+    }
+
+    t.same(dates, [6, 13, 20, 24, 27]);
+  } catch (err) {
+    t.error(err, 'Parse read error');
+  }
+
+  t.end();
+});
+
+test('fails to parse for invalid last weekday of month expression', function(t) {
+  t.throws(function() {
+    var interval = CronParser.parseExpression('0 0 0 * * L');
+    interval.next();
+  });
+
+  t.end();
+});

node_modules/cron-parser/test/prev_date.js

@@ -0,0 +1,32 @@
+var test = require('tap').test;
+var CronExpression = require('../lib/expression');
+
+test('prev should match correctly (issue #98) when milliseconds are greater than 0', function(t) {
+  var options = {
+    currentDate: new Date('2017-06-13T18:21:25.002Z')
+  };
+
+  var interval = CronExpression.parse('*/5 * * * * *', options);
+  var prev = interval.prev();
+  t.equal(prev.getSeconds(), 25);
+
+  t.end();
+});
+
+test('prev should match correctly (issue #98) when milliseconds are equal to 0', function(t) {
+  var interval = CronExpression.parse('59 59 23 * * *',{
+    currentDate : new Date('2012-12-26 14:38:53')
+  });
+
+  [25, 24, 23, 22].forEach(function(date) {
+    var prev = interval.prev();
+    t.equal(prev.getFullYear(), 2012);
+    t.equal(prev.getMonth(), 11);
+    t.equal(prev.getDate(), date);
+    t.equal(prev.getHours(), 23);
+    t.equal(prev.getMinutes(), 59);
+    t.equal(prev.getSeconds(), 59);
+  });
+
+  t.end();
+});

node_modules/cron-parser/test/stringify.js

@@ -0,0 +1,457 @@
+'use strict';
+
+var test = require('tap').test;
+var CronParser = require('../lib/parser');
+
+test('stringify cron expression all stars no seconds', function (t) {
+  try {
+    var expected = '0 * * * * *';
+    var interval = CronParser.parseExpression('* * * * *', {});
+    var str = interval.stringify(true);
+    t.equal(str, expected);
+    str = CronParser.fieldsToExpression(interval.fields).stringify(true);
+    t.equal(str, expected);
+
+  } catch (err) {
+    t.error(err, 'Parse read error');
+  }
+
+  t.end();
+});
+
+test('stringify cron expression all stars no seconds (discard seconds)', function (t) {
+  try {
+    var expected = '* * * * *';
+    var interval = CronParser.parseExpression('* * * * *', {});
+    var str = interval.stringify();
+    t.equal(str, expected);
+    str = CronParser.fieldsToExpression(interval.fields).stringify();
+    t.equal(str, expected);
+
+  } catch (err) {
+    t.error(err, 'Parse read error');
+  }
+
+  t.end();
+});
+
+test('stringify cron expression all stars with seconds', function (t) {
+  try {
+    var expected = '* * * * * *';
+    var interval = CronParser.parseExpression('* * * * * *', {});
+    var str = interval.stringify(true);
+    t.equal(str, expected);
+    str = CronParser.fieldsToExpression(interval.fields).stringify(true);
+    t.equal(str, expected);
+
+  } catch (err) {
+    t.error(err, 'Parse read error');
+  }
+
+  t.end();
+});
+
+test('stringify cron expression all stars with seconds (discard seconds)', function (t) {
+  try {
+    var expected = '* * * * *';
+    var interval = CronParser.parseExpression('* * * * * *', {});
+    var str = interval.stringify();
+    t.equal(str, expected);
+    str = CronParser.fieldsToExpression(interval.fields).stringify();
+    t.equal(str, expected);
+
+  } catch (err) {
+    t.error(err, 'Parse read error');
+  }
+
+  t.end();
+});
+
+test('stringify cron expression', function (t) {
+  try {
+    var expected = '0 1,2,4-10,20-35/5,57 * * * *';
+    var interval = CronParser.parseExpression('1,2,4-10,20-35/5,57 * * * *', {});
+    var str = interval.stringify(true);
+    t.equal(str, expected);
+    str = CronParser.fieldsToExpression(interval.fields).stringify(true);
+    t.equal(str, expected);
+
+  } catch (err) {
+    t.error(err, 'Parse read error');
+  }
+
+  t.end();
+});
+
+test('stringify cron expression (discard seconds)', function (t) {
+  try {
+    var expected = '1,2,4-10,20-35/5,57 * * * *';
+    var interval = CronParser.parseExpression('1,2,4-10,20-35/5,57 * * * *', {});
+    var str = interval.stringify();
+    t.equal(str, expected);
+    str = CronParser.fieldsToExpression(interval.fields).stringify();
+    t.equal(str, expected);
+
+  } catch (err) {
+    t.error(err, 'Parse read error');
+  }
+
+  t.end();
+});
+
+test('stringify cron expression with star range step', function (t) {
+  try {
+    var expected = '0 */5 */2 * * *';
+    var interval = CronParser.parseExpression('*/5 */2 */1 * *', {});
+    var str = interval.stringify(true);
+    t.equal(str, expected);
+    str = CronParser.fieldsToExpression(interval.fields).stringify(true);
+    t.equal(str, expected);
+
+  } catch (err) {
+    t.error(err, 'Parse read error');
+  }
+
+  t.end();
+});
+
+test('stringify cron expression with star range step (discard seconds)', function (t) {
+  try {
+    var expected = '*/5 */2 * * *';
+    var interval = CronParser.parseExpression('*/5 */2 */1 * *', {});
+    var str = interval.stringify();
+    t.equal(str, expected);
+    str = CronParser.fieldsToExpression(interval.fields).stringify();
+    t.equal(str, expected);
+
+  } catch (err) {
+    t.error(err, 'Parse read error');
+  }
+
+  t.end();
+});
+
+test('stringify cron expression with semi range step', function (t) {
+
+  try {
+    var expected = '0 5/5 * * * *';
+    var interval = CronParser.parseExpression('5/5 * * * *', {});
+    var str = interval.stringify(true);
+    t.equal(str, expected);
+    str = CronParser.fieldsToExpression(interval.fields).stringify(true);
+    t.equal(str, expected);
+
+  } catch (err) {
+    t.error(err, 'Parse read error');
+  }
+
+  t.end();
+});
+
+test('stringify cron expression with semi range step (discard seconds)', function (t) {
+  try {
+    var expected = '5/5 * * * *';
+    var interval = CronParser.parseExpression('5/5 * * * *', {});
+    var str = interval.stringify();
+    t.equal(str, expected);
+    str = CronParser.fieldsToExpression(interval.fields).stringify();
+    t.equal(str, expected);
+
+  } catch (err) {
+    t.error(err, 'Parse read error');
+  }
+
+  t.end();
+});
+
+test('stringify cron expression with L', function (t) {
+  try {
+    var expected = '0 * * 1,4-10,L * *';
+    var interval = CronParser.parseExpression('* * 1,4-10,L * *', {});
+    var str = interval.stringify(true);
+    t.equal(str, expected);
+    str = CronParser.fieldsToExpression(interval.fields).stringify(true);
+    t.equal(str, expected);
+
+  } catch (err) {
+    t.error(err, 'Parse read error');
+  }
+
+  t.end();
+});
+
+test('stringify cron expression with L (discard seconds)', function (t) {
+  try {
+    var expected = '* * 1,4-10,L * *';
+    var interval = CronParser.parseExpression('* * 1,4-10,L * *', {});
+    var str = interval.stringify();
+    t.equal(str, expected);
+    str = CronParser.fieldsToExpression(interval.fields).stringify();
+    t.equal(str, expected);
+
+  } catch (err) {
+    t.error(err, 'Parse read error');
+  }
+
+  t.end();
+});
+
+test('stringify cron expression with weekday L', function (t) {
+  try {
+    var expected = '0 0 0 * * 1L';
+    var interval = CronParser.parseExpression(expected, {});
+    var str = interval.stringify(true);
+    t.equal(str, expected);
+    str = CronParser.fieldsToExpression(interval.fields).stringify(true);
+    t.equal(str, expected);
+
+  } catch (err) {
+    t.error(err, 'Parse read error');
+  }
+
+  t.end();
+});
+
+test('stringify cron expression with multiple weekday, one of them with an L', function (t) {
+  try {
+    var expected = '0 0 0 * * 4,6L';
+    var interval = CronParser.parseExpression(expected, {});
+    var str = interval.stringify(true);
+    t.equal(str, expected);
+    str = CronParser.fieldsToExpression(interval.fields).stringify(true);
+    t.equal(str, expected);
+
+  } catch (err) {
+    t.error(err, 'Parse read error');
+  }
+
+  t.end();
+});
+
+test('stringify cron expression with multiple weekday, two of them with an L', function (t) {
+  try {
+    var expected = '0 0 0 * * 1L,5L';
+    var interval = CronParser.parseExpression(expected, {});
+    var str = interval.stringify(true);
+    t.equal(str, expected);
+    str = CronParser.fieldsToExpression(interval.fields).stringify(true);
+    t.equal(str, expected);
+
+  } catch (err) {
+    t.error(err, 'Parse read error');
+  }
+
+  t.end();
+});
+
+test('stringify cron expression with wildcard day of month and single month value', function (t) {
+  try {
+    var expected = '* * * 4 *';
+    var interval = CronParser.parseExpression(expected, {});
+    var str = interval.stringify();
+    t.equal(str, expected);
+  } catch (err) {
+    t.error(err, 'Parse read error');
+  }
+
+  t.end();
+});
+
+test('stringify cron expression with wildcard day of month and month rangee', function (t) {
+  try {
+    var expected = '* * * 4-6 *';
+    var interval = CronParser.parseExpression(expected, {});
+    var str = interval.stringify();
+    t.equal(str, expected);
+  } catch (err) {
+    t.error(err, 'Parse read error');
+  }
+
+  t.end();
+});
+
+
+test('stringify cron expression with day of month range and single month value', function (t) {
+  try {
+    var expected = '* * 1-25 4 *';
+    var interval = CronParser.parseExpression(expected, {});
+    var str = interval.stringify();
+    t.equal(str, expected);
+  } catch (err) {
+    t.error(err, 'Parse read error');
+  }
+
+  t.end();
+});
+
+test('stringify from fields out of order', function (t) {
+  try {
+    var expected = '1-5 1 1 1 1 1';
+    var str = CronParser.fieldsToExpression({
+      second: [5,2,1,4,3],
+      minute: [1],
+      hour: [1],
+      month: [1],
+      dayOfMonth: [1],
+      dayOfWeek: [1],
+    }).stringify(true);
+    t.equal(str, expected);
+  } catch (err) {
+    t.error(err, 'Parse read error');
+  }
+
+  t.end();
+});
+
+test('stringify from fields out of order (discard seconds)', function (t) {
+  try {
+    var expected = '1 1 1 1 1';
+    var str = CronParser.fieldsToExpression({
+      second: [5,2,1,4,3],
+      minute: [1],
+      hour: [1],
+      month: [1],
+      dayOfMonth: [1],
+      dayOfWeek: [1],
+    }).stringify();
+    t.equal(str, expected);
+  } catch (err) {
+    t.error(err, 'Parse read error');
+  }
+
+  t.end();
+});
+
+test('stringify cron expression with extended day of week range (0,7)', function (t) {
+  try {
+    var expected = '* * * * *';
+    var interval = CronParser.parseExpression('* * * * *');
+
+    var str = CronParser.fieldsToExpression({
+      second: interval.fields.second,
+      minute: interval.fields.minute,
+      hour: interval.fields.hour,
+      month: interval.fields.month,
+      dayOfMonth: interval.fields.dayOfMonth,
+      dayOfWeek: [0, 1, 2, 3, 4, 5, 6],
+    }).stringify();
+    t.equal(str, expected);
+
+    str = CronParser.fieldsToExpression({
+      second: interval.fields.second,
+      minute: interval.fields.minute,
+      hour: interval.fields.hour,
+      month: interval.fields.month,
+      dayOfMonth: interval.fields.dayOfMonth,
+      dayOfWeek: [0, 1, 2, 3, 4, 5, 6, 7],
+    }).stringify();
+    t.equal(str, expected);
+  } catch (err) {
+    t.error(err, 'Parse read error');
+  }
+
+  t.end();
+});
+
+test('validation error - missing seconds', function (t) {
+  t.throws(function () {
+    CronParser.fieldsToExpression({
+      minute: [1],
+      hour: [1],
+      dayOfMonth: [1],
+      month: [1],
+      dayOfWeek: [1],
+    });
+  }, new Error('Validation error, Field second is missing'));
+
+  t.end();
+});
+
+test('validation error - empty seconds', function (t) {
+  t.throws(function () {
+    CronParser.fieldsToExpression({
+      second: [],
+      minute: [1],
+      hour: [1],
+      dayOfMonth: [1],
+      month: [1],
+      dayOfWeek: [1],
+    });
+  }, new Error('Validation error, Field second contains no values'));
+
+  t.end();
+});
+
+test('validation error - missing values - empty array', function (t) {
+  t.throws(function () {
+    CronParser.fieldsToExpression({
+      second: [1],
+      minute: [],
+      hour: [1],
+      dayOfMonth: [1],
+      month: [1],
+      dayOfWeek: [1],
+    });
+  }, new Error('Validation error, Field minute contains no values'));
+
+  t.end();
+});
+
+test('validation error - missing values', function (t) {
+  t.throws(function () {
+    CronParser.fieldsToExpression({
+      second: [1],
+      hour: [1],
+      dayOfMonth: [1],
+      month: [1],
+      dayOfWeek: [1],
+    });
+  }, new Error('Validation error, Field minute is missing'));
+
+  t.end();
+});
+
+test('validation error - range error', function (t) {
+  t.throws(function () {
+    CronParser.fieldsToExpression({
+      second: [-1, 1, 0],
+      minute: [1],
+      hour: [1],
+      dayOfMonth: [1],
+      month: [1],
+      dayOfWeek: [1],
+    });
+  }, new Error('Constraint error, got value -1 expected range 0-59'));
+
+  t.end();
+});
+
+test('validation error - bad chars error', function (t) {
+  t.throws(function () {
+    CronParser.fieldsToExpression({
+      second: [0, 'R'],
+      minute: [1],
+      hour: [1],
+      dayOfMonth: [1],
+      month: [1],
+      dayOfWeek: [1],
+    });
+  }, new Error('Constraint error, got value R expected range 0-59'));
+
+  t.end();
+});
+
+test('validation error - duplicates', function (t) {
+  t.throws(function () {
+    CronParser.fieldsToExpression({
+      second: [1, 1],
+      minute: [1],
+      hour: [1],
+      dayOfMonth: [1],
+      month: [1],
+      dayOfWeek: [1],
+    });
+  }, new Error('Validation error, Field second contains duplicate values'));
+
+  t.end();
+});

node_modules/cron-parser/test/timezone.js

@@ -0,0 +1,422 @@
+var test = require('tap').test;
+var CronExpression = require('../lib/expression');
+
+test('It works on DST start', function(t) {
+  try {
+    var options = {
+      currentDate: '2016-03-27 02:00:01',
+      tz: 'Europe/Athens'
+    };
+
+    var interval, date;
+
+    interval = CronExpression.parse('0 * * * *', options);
+    t.ok(interval, 'Interval parsed');
+
+    date = interval.next();
+    t.equal(date.getMinutes(), 0, '0 Minutes');
+    t.equal(date.getHours(), 4, 'Due to DST start in Athens, 3 is skipped');
+    t.equal(date.getDate(), 27, 'on the 27th');
+
+    date = interval.next();
+    t.equal(date.getMinutes(), 0, '0 Minutes');
+    t.equal(date.getHours(), 5, '5 AM');
+    t.equal(date.getDate(), 27, 'on the 27th');
+
+    interval = CronExpression.parse('30 2 * * *', options);
+    t.ok(interval, 'Interval parsed');
+
+    date = interval.next();
+    t.equal(date.getMinutes(), 30, '30 Minutes');
+    t.equal(date.getHours(), 2, '2 AM');
+    t.equal(date.getDate(), 27, 'on the 27th');
+
+    date = interval.next();
+    t.equal(date.getMinutes(), 30, '30 Minutes');
+    t.equal(date.getHours(), 2, '2 AM');
+    t.equal(date.getDate(), 28, 'on the 28th');
+
+    interval = CronExpression.parse('0 3 * * *', options);
+    t.ok(interval, 'Interval parsed');
+
+    date = interval.next();
+    t.equal(date.getMinutes(), 0, '0 Minutes');
+    t.equal(date.getHours(), 4, 'Due to DST start in Athens, 3 is skipped');
+    t.equal(date.getDate(), 27, 'on the 27th');
+
+    date = interval.next();
+    t.equal(date.getMinutes(), 0, '0 Minutes');
+    t.equal(date.getHours(), 3, '3 on the 28th');
+    t.equal(date.getDate(), 28, 'on the 28th');
+
+    interval = CronExpression.parse('*/20 3 * * *', options);
+    t.ok(interval, 'Interval parsed');
+
+    date = interval.next();
+    t.equal(date.getMinutes(), 0, '0 Minutes');
+    t.equal(date.getHours(), 4, 'Due to DST start in Athens, 3 is skipped');
+    t.equal(date.getDate(), 27, 'on the 27th');
+
+    date = interval.next();
+    t.equal(date.getMinutes(), 20, '20 Minutes');
+    t.equal(date.getHours(), 4, 'Due to DST start in Athens, 3 is skipped');
+    t.equal(date.getDate(), 27, 'on the 27th');
+
+    date = interval.next();
+    t.equal(date.getMinutes(), 40, '20 Minutes');
+    t.equal(date.getHours(), 4, 'Due to DST start in Athens, 3 is skipped');
+    t.equal(date.getDate(), 27, 'on the 27th');
+
+    date = interval.next();
+    t.equal(date.getMinutes(), 0, '0 Minutes');
+    t.equal(date.getHours(), 3, '3 AM');
+    t.equal(date.getDate(), 28, 'on the 28th');
+
+    options.currentDate = '2016-03-27 00:00:01';
+
+    interval = CronExpression.parse('0 * 27 * *', options);
+    t.ok(interval, 'Interval parsed');
+
+    date = interval.next();
+    t.equal(date.getMinutes(), 0, '0 Minutes');
+    t.equal(date.getHours(), 1, '1 AM');
+    t.equal(date.getDate(), 27, 'on the 27th');
+
+    date = interval.next();
+    t.equal(date.getMinutes(), 0, '0 Minutes');
+    t.equal(date.getHours(), 2, '2 AM');
+    t.equal(date.getDate(), 27, 'on the 27th');
+
+    date = interval.next();
+    t.equal(date.getMinutes(), 0, '0 Minutes');
+    t.equal(date.getHours(), 4, '4 AM');
+    t.equal(date.getDate(), 27, 'on the 27th');
+
+    date = interval.next();
+    t.equal(date.getMinutes(), 0, '0 Minutes');
+    t.equal(date.getHours(), 5, '5 AM');
+    t.equal(date.getDate(), 27, 'on the 27th');
+
+    options.currentDate = '2016-03-27 00:00:01';
+    options.endDate = '2016-03-27 03:00:01';
+
+    interval = CronExpression.parse('0 * * * *', options);
+    t.ok(interval, 'Interval parsed');
+
+    date = interval.next();
+    t.equal(date.getMinutes(), 0, '0 Minutes');
+    t.equal(date.getHours(), 1, '1 AM');
+    t.equal(date.getDate(), 27, 'on the 27th');
+
+    date = interval.next();
+    t.equal(date.getMinutes(), 0, '0 Minutes');
+    t.equal(date.getHours(), 2, '2 AM');
+    t.equal(date.getDate(), 27, 'on the 27th');
+
+    date = interval.next();
+    t.equal(date.getMinutes(), 0, '0 Minutes');
+    t.equal(date.getHours(), 4, '4 AM');
+    t.equal(date.getDate(), 27, 'on the 27th');
+
+    // Out of the timespan range
+    t.throws(function() {
+      date = interval.next();
+    });
+  } catch (err) {
+    t.error(err, 'Interval parse error');
+  }
+
+  t.end();
+});
+
+test('It works on DST end', function(t) {
+  try {
+    var options = {
+      currentDate: '2016-10-30 02:00:01',
+      tz: 'Europe/Athens'
+    };
+
+    var interval, date;
+
+    interval = CronExpression.parse('0 * * * *', options);
+    t.ok(interval, 'Interval parsed');
+
+    date = interval.next();
+    t.equal(date.getHours(), 3, '3 AM');
+    t.equal(date.getDate(), 30, '30th');
+
+    date = interval.next();
+    t.equal(date.getHours(), 3, 'Due to DST end in Athens (4-->3)');
+    t.equal(date.getDate(), 30, '30th');
+
+    date = interval.next();
+    t.equal(date.getHours(), 4, '4 AM');
+    t.equal(date.getDate(), 30, '30th');
+
+    interval = CronExpression.parse('0 3 * * *', options);
+    t.ok(interval, 'Interval parsed');
+
+    date = interval.next();
+    t.equal(date.getHours(), 3, '3 AM');
+    t.equal(date.getDate(), 30, '30th');
+
+    date = interval.next();
+    t.equal(date.getHours(), 3, '3 AM');
+    t.equal(date.getDate(), 31, '31st');
+
+    interval = CronExpression.parse('*/20 3 * * *', options);
+    t.ok(interval, 'Interval parsed');
+
+    date = interval.next();
+    t.equal(date.getMinutes(), 0, '0');
+    t.equal(date.getHours(), 3, '3 AM');
+    t.equal(date.getDate(), 30, '30th');
+
+    date = interval.next();
+    t.equal(date.getMinutes(), 20, '20');
+    t.equal(date.getHours(), 3, '3 AM');
+    t.equal(date.getDate(), 30, '30th');
+
+    date = interval.next();
+    t.equal(date.getMinutes(), 40, '40');
+    t.equal(date.getHours(), 3, '3 AM');
+    t.equal(date.getDate(), 30, '30th');
+
+    date = interval.next();
+    t.equal(date.getMinutes(), 0, '0');
+    t.equal(date.getHours(), 3, '3 AM');
+    t.equal(date.getDate(), 31, '31st');
+
+    options.currentDate = '2016-10-30 00:00:01';
+
+    interval = CronExpression.parse('0 * 30 * *', options);
+    t.ok(interval, 'Interval parsed');
+
+    date = interval.next();
+    t.equal(date.getHours(), 1, '1 AM');
+    t.equal(date.getDate(), 30, '30th');
+
+    date = interval.next();
+    t.equal(date.getHours(), 2, '2 AM');
+    t.equal(date.getDate(), 30, '30th');
+
+    date = interval.next();
+    t.equal(date.getHours(), 3, '3 AM');
+    t.equal(date.getDate(), 30, '30th');
+
+    date = interval.next();
+    t.equal(date.getHours(), 3, '3 AM');
+    t.equal(date.getDate(), 30, '30th');
+
+    date = interval.next();
+    t.equal(date.getHours(), 4, '4 AM');
+    t.equal(date.getDate(), 30, '30th');
+
+    options.currentDate = '2016-10-30 00:00:01';
+    // specify the DST offset via ISO 8601 format, as 3am is repeated
+    options.endDate = '2016-10-30T03:00:01+03';
+
+    interval = CronExpression.parse('0 * * * *', options);
+    t.ok(interval, 'Interval parsed');
+
+    date = interval.next();
+    t.equal(date.getHours(), 1, '1 AM');
+    t.equal(date.getDate(), 30, '30th');
+
+    date = interval.next();
+    t.equal(date.getHours(), 2, '2 AM');
+    t.equal(date.getDate(), 30, '30th');
+
+    date = interval.next();
+    t.equal(date.getHours(), 3, '3 AM');
+    t.equal(date.getDate(), 30, '30th');
+
+    // Out of the timespan range
+    t.throws(function() {
+      date = interval.next();
+    });
+
+    options.endDate = '2016-10-30 04:00:01';
+
+    interval = CronExpression.parse('0 * * * *', options);
+    t.ok(interval, 'Interval parsed');
+
+    date = interval.next();
+    t.equal(date.getHours(), 1, '1 AM');
+    t.equal(date.getDate(), 30, '30th');
+
+    date = interval.next();
+    t.equal(date.getHours(), 2, '2 AM');
+    t.equal(date.getDate(), 30, '30th');
+
+    date = interval.next();
+    t.equal(date.getHours(), 3, '3 AM');
+    t.equal(date.getDate(), 30, '30th');
+
+    date = interval.next();
+    t.equal(date.getHours(), 3, '3 AM');
+    t.equal(date.getDate(), 30, '30th');
+
+    date = interval.next();
+    t.equal(date.getHours(), 4, '4 AM');
+    t.equal(date.getDate(), 30, '30th');
+
+    // Out of the timespan range
+    t.throws(function() {
+      date = interval.next();
+    });
+
+    options = {
+      currentDate : new Date('Sun Oct 29 2016 01:00:00 GMT+0200')
+    };
+
+    interval = CronExpression.parse('0 12 * * *', options);
+    t.ok(interval, 'Interval parsed');
+
+    date = interval.next();
+    t.equal(date.getHours(), 12, '12');
+    t.equal(date.getDate(), 29, '29th');
+    date = interval.next();
+    t.equal(date.getHours(), 12, '12');
+    t.equal(date.getDate(), 30, '30th');
+    date = interval.next();
+    t.equal(date.getHours(), 12, '12');
+    t.equal(date.getDate(), 31, '31st');
+
+    options = {
+      currentDate : new Date('Sun Oct 29 2016 02:59:00 GMT+0200')
+    };
+
+    interval = CronExpression.parse('0 12 * * *', options);
+    t.ok(interval, 'Interval parsed');
+
+    date = interval.next();
+    t.equal(date.getHours(), 12, '12');
+    t.equal(date.getDate(), 29, '29th');
+    date = interval.next();
+    t.equal(date.getHours(), 12, '12');
+    t.equal(date.getDate(), 30, '30th');
+    date = interval.next();
+    t.equal(date.getHours(), 12, '12');
+    t.equal(date.getDate(), 31, '31st');
+
+    options = {
+      currentDate : new Date('Sun Oct 29 2016 02:59:59 GMT+0200')
+    };
+
+    interval = CronExpression.parse('0 12 * * *', options);
+    t.ok(interval, 'Interval parsed');
+
+    date = interval.next();
+    t.equal(date.getHours(), 12, '12');
+    t.equal(date.getDate(), 29, '29th');
+    date = interval.next();
+    t.equal(date.getHours(), 12, '12');
+    t.equal(date.getDate(), 30, '30th');
+    date = interval.next();
+    t.equal(date.getHours(), 12, '12');
+    t.equal(date.getDate(), 31, '31st');
+
+    options = {
+      currentDate : new Date('Sun Oct 30 2016 01:00:00 GMT+0200')
+    };
+
+    interval = CronExpression.parse('0 12 * * *', options);
+    t.ok(interval, 'Interval parsed');
+
+    date = interval.next();
+    t.equal(date.getHours(), 12, '12');
+    t.equal(date.getDate(), 30, '30th');
+    date = interval.next();
+    t.equal(date.getHours(), 12, '12');
+    t.equal(date.getDate(), 31, '31st');
+
+    options = {
+      currentDate : new Date('Sun Oct 30 2016 01:59:00 GMT+0200')
+    };
+
+    interval = CronExpression.parse('0 12 * * *', options);
+    t.ok(interval, 'Interval parsed');
+
+    date = interval.next();
+    t.equal(date.getHours(), 12, '12');
+    t.equal(date.getDate(), 30, '30th');
+    date = interval.next();
+    t.equal(date.getHours(), 12, '12');
+    t.equal(date.getDate(), 31, '31st');
+
+    options = {
+      currentDate : new Date('Sun Oct 30 2016 01:59:59 GMT+0200')
+    };
+
+    interval = CronExpression.parse('0 12 * * *', options);
+    t.ok(interval, 'Interval parsed');
+
+    date = interval.next();
+    t.equal(date.getHours(), 12, '12');
+    t.equal(date.getDate(), 30, '30th');
+    date = interval.next();
+    t.equal(date.getHours(), 12, '12');
+    t.equal(date.getDate(), 31, '31st');
+
+    options = {
+      currentDate : new Date('Sun Oct 30 2016 02:59:00 GMT+0200')
+    };
+
+    interval = CronExpression.parse('0 12 * * *', options);
+    t.ok(interval, 'Interval parsed');
+
+    date = interval.next();
+    t.equal(date.getHours(), 12, '12');
+    t.equal(date.getDate(), 30, '30th');
+    date = interval.next();
+    t.equal(date.getHours(), 12, '12');
+    t.equal(date.getDate(), 31, '31st');
+  } catch (err) {
+    t.error(err, 'Interval parse error');
+  }
+
+  t.end();
+});
+
+test('it will work with #131 issue case', function(t) {
+  var options = {
+    tz: 'America/Sao_Paulo',
+    currentDate : new Date('Sun Oct 30 2018 02:59:00 GMT+0200')
+  };
+
+  var interval = CronExpression.parse('0 9 1 1 *', options);
+  var date = interval.next();
+
+  t.equal(date.getFullYear(), 2019);
+  t.equal(date.getDate(), 1);
+  t.equal(date.getMonth(), 0);
+
+  date = interval.prev();
+  t.equal(date.getFullYear(), 2018);
+  t.equal(date.getDate(), 1);
+  t.equal(date.getMonth(), 0);
+
+  date = interval.prev();
+  t.equal(date.getFullYear(), 2017);
+  t.equal(date.getDate(), 1);
+  t.equal(date.getMonth(), 0);
+
+  t.end();
+});
+
+test('it will work with #137 issue case', function(t) {
+  var options = {
+    tz: 'America/New_York',
+    currentDate : new Date('10/28/2018')
+  };
+
+  var interval = CronExpression.parse('0 12 * * 3', options);
+  var date = interval.next();
+
+  t.equal(date.getFullYear(), 2018);
+  t.equal(date.getDate(), 31);
+  t.equal(date.getMonth(), 9);
+
+  t.end();
+});