@checkdigit/time 3.0.0-PR.17-5aaf → 4.0.0-PR.18-81a3

package/src/date-fns/_lib/format/formatters/index.ts

@@ -1,20 +1,20 @@
-import getDayOfYear from '../../../getDayOfYear/index';
-import getISOWeek from '../../../getISOWeek/index';
-import getISOWeekYear from '../../../getISOWeekYear/index';
-import getWeek from '../../../getWeek/index';
-import getWeekYear from '../../../getWeekYear/index';
+import { getDayOfYear } from '../../../getDayOfYear/index';
+import { getISOWeek } from '../../../getISOWeek/index';
+import { getISOWeekYear } from '../../../getISOWeekYear/index';
+import { getWeek } from '../../../getWeek/index';
+import { getWeekYear } from '../../../getWeekYear/index';
 import type { LocaleDayPeriod, Localize } from '../../../locale/types';
 import type {
   Day,
   Era,
   FirstWeekContainsDateOptions,
-  LocaleOptions,
+  LocalizedOptions,
   Month,
   Quarter,
-  WeekStartOptions,
+  WeekOptions,
 } from '../../../types';
-import addLeadingZeros from '../../addLeadingZeros/index';
-import lightFormatters from '../lightFormatters/index';
+import { addLeadingZeros } from '../../addLeadingZeros/index';
+import { lightFormatters } from '../lightFormatters/index';
 
 const dayPeriodEnum = {
   am: 'am',
@@ -31,9 +31,7 @@ type Formatter = (
   date: Date,
   token: string,
   localize: Localize,
-  options: Required<LocaleOptions & WeekStartOptions & FirstWeekContainsDateOptions> & {
-    _originalDate: Date;
-  },
+  options: Required<LocalizedOptions<'options'> & WeekOptions & FirstWeekContainsDateOptions>,
 ) => string;
 
 /*
@@ -82,7 +80,7 @@ type Formatter = (
  * - `p` is long localized time format
  */
 
-const formatters: { [token: string]: Formatter } = {
+export const formatters: { [token: string]: Formatter } = {
   // Era
   G: function (date, token, localize) {
     const era: Era = date.getFullYear() > 0 ? 1 : 0;
@@ -246,7 +244,10 @@ const formatters: { [token: string]: Formatter } = {
         });
       // J, F, ..., D
       case 'MMMMM':
-        return localize.month(month, { width: 'narrow', context: 'formatting' });
+        return localize.month(month, {
+          width: 'narrow',
+          context: 'formatting',
+        });
       // January, February, ..., December
       case 'MMMM':
       default:
@@ -275,7 +276,10 @@ const formatters: { [token: string]: Formatter } = {
         });
       // J, F, ..., D
       case 'LLLLL':
-        return localize.month(month, { width: 'narrow', context: 'standalone' });
+        return localize.month(month, {
+          width: 'narrow',
+          context: 'standalone',
+        });
       // January, February, ..., December
       case 'LLLL':
       default:
@@ -352,7 +356,10 @@ const formatters: { [token: string]: Formatter } = {
       // Tuesday
       case 'EEEE':
       default:
-        return localize.day(dayOfWeek, { width: 'wide', context: 'formatting' });
+        return localize.day(dayOfWeek, {
+          width: 'wide',
+          context: 'formatting',
+        });
     }
   },
 
@@ -390,7 +397,10 @@ const formatters: { [token: string]: Formatter } = {
       // Tuesday
       case 'eeee':
       default:
-        return localize.day(dayOfWeek, { width: 'wide', context: 'formatting' });
+        return localize.day(dayOfWeek, {
+          width: 'wide',
+          context: 'formatting',
+        });
     }
   },
 
@@ -428,7 +438,10 @@ const formatters: { [token: string]: Formatter } = {
       // Tuesday
       case 'cccc':
       default:
-        return localize.day(dayOfWeek, { width: 'wide', context: 'standalone' });
+        return localize.day(dayOfWeek, {
+          width: 'wide',
+          context: 'standalone',
+        });
     }
   },
 
@@ -467,7 +480,10 @@ const formatters: { [token: string]: Formatter } = {
       // Tuesday
       case 'iiii':
       default:
-        return localize.day(dayOfWeek, { width: 'wide', context: 'formatting' });
+        return localize.day(dayOfWeek, {
+          width: 'wide',
+          context: 'formatting',
+        });
     }
   },
 
@@ -647,9 +663,8 @@ const formatters: { [token: string]: Formatter } = {
   },
 
   // Timezone (ISO-8601. If offset is 0, output is always `'Z'`)
-  X: function (date, token, _localize, options) {
-    const originalDate = options._originalDate || date;
-    const timezoneOffset = originalDate.getTimezoneOffset();
+  X: function (date, token, _localize) {
+    const timezoneOffset = date.getTimezoneOffset();
 
     if (timezoneOffset === 0) {
       return 'Z';
@@ -678,9 +693,8 @@ const formatters: { [token: string]: Formatter } = {
   },
 
   // Timezone (ISO-8601. If offset is 0, output is `'+00:00'` or equivalent)
-  x: function (date, token, _localize, options) {
-    const originalDate = options._originalDate || date;
-    const timezoneOffset = originalDate.getTimezoneOffset();
+  x: function (date, token, _localize) {
+    const timezoneOffset = date.getTimezoneOffset();
 
     switch (token) {
       // Hours and optional minutes
@@ -705,9 +719,8 @@ const formatters: { [token: string]: Formatter } = {
   },
 
   // Timezone (GMT)
-  O: function (date, token, _localize, options) {
-    const originalDate = options._originalDate || date;
-    const timezoneOffset = originalDate.getTimezoneOffset();
+  O: function (date, token, _localize) {
+    const timezoneOffset = date.getTimezoneOffset();
 
     switch (token) {
       // Short
@@ -723,9 +736,8 @@ const formatters: { [token: string]: Formatter } = {
   },
 
   // Timezone (specific non-location)
-  z: function (date, token, _localize, options) {
-    const originalDate = options._originalDate || date;
-    const timezoneOffset = originalDate.getTimezoneOffset();
+  z: function (date, token, _localize) {
+    const timezoneOffset = date.getTimezoneOffset();
 
     switch (token) {
       // Short
@@ -741,16 +753,14 @@ const formatters: { [token: string]: Formatter } = {
   },
 
   // Seconds timestamp
-  t: function (date, token, _localize, options) {
-    const originalDate = options._originalDate || date;
-    const timestamp = Math.floor(originalDate.getTime() / 1000);
+  t: function (date, token, _localize) {
+    const timestamp = Math.trunc(date.getTime() / 1000);
     return addLeadingZeros(timestamp, token.length);
   },
 
   // Milliseconds timestamp
-  T: function (date, token, _localize, options) {
-    const originalDate = options._originalDate || date;
-    const timestamp = originalDate.getTime();
+  T: function (date, token, _localize) {
+    const timestamp = date.getTime();
     return addLeadingZeros(timestamp, token.length);
   },
 };
@@ -758,7 +768,7 @@ const formatters: { [token: string]: Formatter } = {
 function formatTimezoneShort(offset: number, delimiter: string = ''): string {
   const sign = offset > 0 ? '-' : '+';
   const absOffset = Math.abs(offset);
-  const hours = Math.floor(absOffset / 60);
+  const hours = Math.trunc(absOffset / 60);
   const minutes = absOffset % 60;
   if (minutes === 0) {
     return sign + String(hours);
@@ -777,9 +787,7 @@ function formatTimezoneWithOptionalMinutes(offset: number, delimiter?: string):
 function formatTimezone(offset: number, delimiter: string = ''): string {
   const sign = offset > 0 ? '-' : '+';
   const absOffset = Math.abs(offset);
-  const hours = addLeadingZeros(Math.floor(absOffset / 60), 2);
+  const hours = addLeadingZeros(Math.trunc(absOffset / 60), 2);
   const minutes = addLeadingZeros(absOffset % 60, 2);
   return sign + hours + delimiter + minutes;
 }
-
-export default formatters;

package/src/date-fns/_lib/format/lightFormatters/index.ts

@@ -1,4 +1,4 @@
-import addLeadingZeros from '../../addLeadingZeros/index';
+import { addLeadingZeros } from '../../addLeadingZeros/index';
 
 /*
  * |     | Unit                           |     | Unit                           |
@@ -13,7 +13,7 @@ import addLeadingZeros from '../../addLeadingZeros/index';
  * Letters marked by * are not implemented but reserved by Unicode standard.
  */
 
-const formatters = {
+export const lightFormatters = {
   // Year
   y(date: Date, token: string): string {
     // From http://www.unicode.org/reports/tr35/tr35-31/tr35-dates.html#Date_Format_tokens
@@ -44,8 +44,10 @@ const formatters = {
 
   // AM or PM
   a(date: Date, token: string): string {
-    // this hack is required because setHours doesn't work for hours that are spring-forward
+    // [PATCH:] this hack is required because setHours doesn't work for hours that are spring-forward
     const dayPeriodEnumValue = ((date as any)[Symbol.for('UTCHours')] ?? date.getHours()) / 12 >= 1 ? 'pm' : 'am';
+    // original:
+    // const dayPeriodEnumValue = date.getHours() / 12 >= 1 ? "pm" : "am";
 
     switch (token) {
       case 'a':
@@ -54,7 +56,7 @@ const formatters = {
       case 'aaa':
         return dayPeriodEnumValue;
       case 'aaaaa':
-        return dayPeriodEnumValue[0] as string;
+        return dayPeriodEnumValue[0]!;
       case 'aaaa':
       default:
         return dayPeriodEnumValue === 'am' ? 'a.m.' : 'p.m.';
@@ -63,14 +65,18 @@ const formatters = {
 
   // Hour [1-12]
   h(date: Date, token: string): string {
-    // this hack is required because setHours doesn't work for hours that are spring-forward
+    // [PATCH:] this hack is required because setHours doesn't work for hours that are spring-forward
     return addLeadingZeros(((date as any)[Symbol.for('UTCHours')] ?? date.getHours()) % 12 || 12, token.length);
+    // original:
+    // return addLeadingZeros(date.getHours() % 12 || 12, token.length);
   },
 
   // Hour [0-23]
   H(date: Date, token: string): string {
-    // this hack is required because setHours doesn't work for hours that are spring-forward
+    // [PATCH:] this hack is required because setHours doesn't work for hours that are spring-forward
     return addLeadingZeros((date as any)[Symbol.for('UTCHours')] ?? date.getHours(), token.length);
+    // original:
+    // return addLeadingZeros(date.getHours(), token.length);
   },
 
   // Minute
@@ -87,9 +93,7 @@ const formatters = {
   S(date: Date, token: string): string {
     const numberOfDigits = token.length;
     const milliseconds = date.getMilliseconds();
-    const fractionalSeconds = Math.floor(milliseconds * Math.pow(10, numberOfDigits - 3));
+    const fractionalSeconds = Math.trunc(milliseconds * Math.pow(10, numberOfDigits - 3));
     return addLeadingZeros(fractionalSeconds, token.length);
   },
 };
-
-export default formatters;

package/src/date-fns/_lib/format/longFormatters/index.ts

@@ -32,7 +32,7 @@ const timeLongFormatter: LongFormatter = (pattern, formatLong) => {
 
 const dateTimeLongFormatter: LongFormatter = (pattern: string, formatLong: FormatLong) => {
   const matchResult = pattern.match(/(P+)(p+)?/) || [];
-  const datePattern = matchResult[1] as string;
+  const datePattern = matchResult[1];
   const timePattern = matchResult[2];
 
   if (!timePattern) {
@@ -58,13 +58,11 @@ const dateTimeLongFormatter: LongFormatter = (pattern: string, formatLong: Forma
   }
 
   return dateTimeFormat
-    .replace('{{date}}', dateLongFormatter(datePattern, formatLong))
+    .replace('{{date}}', dateLongFormatter(datePattern!, formatLong))
     .replace('{{time}}', timeLongFormatter(timePattern, formatLong));
 };
 
-const longFormatters: Record<string, LongFormatter> = {
+export const longFormatters: Record<string, LongFormatter> = {
   p: timeLongFormatter,
   P: dateTimeLongFormatter,
 };
-
-export default longFormatters;

package/src/date-fns/_lib/getRoundingMethod/index.ts

@@ -0,0 +1,10 @@
+import type { RoundingMethod } from '../../types';
+
+export function getRoundingMethod(method: RoundingMethod | undefined) {
+  return (number: number) => {
+    const round = method ? Math[method] : Math.trunc;
+    const result = round(number);
+    // Prevent negative zero
+    return result === 0 ? 0 : result;
+  };
+}

package/src/date-fns/_lib/getRoundingMethod/test.mts

@@ -0,0 +1,50 @@
+import { describe, expect, it } from 'vitest';
+import { getRoundingMethod } from '.';
+
+describe('getRoundingMethod', () => {
+  it('rounds with truncate by default', () => {
+    expect(getRoundingMethod(undefined)(2.9)).toBe(2);
+    expect(getRoundingMethod(undefined)(1.5)).toBe(1);
+    expect(getRoundingMethod(undefined)(-3.9)).toBe(-3);
+    expect(getRoundingMethod(undefined)(-14.1)).toBe(-14);
+  });
+
+  it('allows to specify "trunc" rounding method', () => {
+    expect(getRoundingMethod('trunc')(2.9)).toBe(2);
+    expect(getRoundingMethod('trunc')(1.5)).toBe(1);
+    expect(getRoundingMethod('trunc')(-3.9)).toBe(-3);
+    expect(getRoundingMethod('trunc')(-14.1)).toBe(-14);
+  });
+
+  it('allows to specify "ceil" rounding method', () => {
+    expect(getRoundingMethod('ceil')(2.9)).toBe(3);
+    expect(getRoundingMethod('ceil')(1.5)).toBe(2);
+    expect(getRoundingMethod('ceil')(-3.9)).toBe(-3);
+    expect(getRoundingMethod('ceil')(-14.1)).toBe(-14);
+  });
+
+  it('allows to specify "floor" rounding method', () => {
+    expect(getRoundingMethod('floor')(2.9)).toBe(2);
+    expect(getRoundingMethod('floor')(1.5)).toBe(1);
+    expect(getRoundingMethod('floor')(-3.9)).toBe(-4);
+    expect(getRoundingMethod('floor')(-14.1)).toBe(-15);
+  });
+
+  it('allows to specify "round" rounding method', () => {
+    expect(getRoundingMethod('round')(2.9)).toBe(3);
+    expect(getRoundingMethod('round')(1.5)).toBe(2);
+    expect(getRoundingMethod('round')(-3.9)).toBe(-4);
+    expect(getRoundingMethod('round')(-14.1)).toBe(-14);
+  });
+
+  it('prevents negative zero', () => {
+    expect(!isNegativeZero(getRoundingMethod('trunc')(-0.01))).toBe(true);
+    expect(!isNegativeZero(getRoundingMethod('floor')(-0.0))).toBe(true);
+    expect(!isNegativeZero(getRoundingMethod('ceil')(-0.9))).toBe(true);
+    expect(!isNegativeZero(getRoundingMethod('round')(-0.1))).toBe(true);
+  });
+});
+
+function isNegativeZero(x: number): boolean {
+  return x === 0 && 1 / x < 0;
+}

package/src/date-fns/_lib/getTimezoneOffsetInMilliseconds/index.ts

@@ -1,3 +1,5 @@
+import { toDate } from '../../toDate/index';
+
 /**
  * Google Chrome as of 67.0.3396.87 introduced timezones with offset that includes seconds.
  * They usually appear for dates that denote time before the timezones were introduced
@@ -9,18 +11,19 @@
  *
  * This function returns the timezone offset in milliseconds that takes seconds in account.
  */
-export default function getTimezoneOffsetInMilliseconds(date: Date): number {
+export function getTimezoneOffsetInMilliseconds(date: Date | number | string): number {
+  const _date = toDate(date);
   const utcDate = new Date(
     Date.UTC(
-      date.getFullYear(),
-      date.getMonth(),
-      date.getDate(),
-      date.getHours(),
-      date.getMinutes(),
-      date.getSeconds(),
-      date.getMilliseconds(),
+      _date.getFullYear(),
+      _date.getMonth(),
+      _date.getDate(),
+      _date.getHours(),
+      _date.getMinutes(),
+      _date.getSeconds(),
+      _date.getMilliseconds(),
     ),
   );
-  utcDate.setUTCFullYear(date.getFullYear());
-  return date.getTime() - utcDate.getTime();
+  utcDate.setUTCFullYear(_date.getFullYear());
+  return +date - +utcDate;
 }

package/src/date-fns/_lib/getTimezoneOffsetInMilliseconds/test.mts

@@ -0,0 +1,25 @@
+import { describe, expect, it } from 'vitest';
+import { getTimezoneOffsetInMilliseconds } from './index';
+
+describe('getTimezoneOffsetInMilliseconds', () => {
+  it('works for a modern date', () => {
+    const date = new Date(2018, 0 /* Jan */, 1, 12, 34, 56, 789);
+    const result = date.getTime() - getTimezoneOffsetInMilliseconds(date);
+    const expectedResult = Date.UTC(2018, 0 /* Jan */, 1, 12, 34, 56, 789);
+    expect(result).toBe(expectedResult);
+  });
+
+  it('works for a date before standardized timezones', () => {
+    const date = new Date(1800, 0 /* Jan */, 1, 12, 34, 56, 789);
+    const result = date.getTime() - getTimezoneOffsetInMilliseconds(date);
+    const expectedResult = Date.UTC(1800, 0 /* Jan */, 1, 12, 34, 56, 789);
+    expect(result).toBe(expectedResult);
+  });
+
+  it('works for a date BC', () => {
+    const date = new Date(-500, 0 /* Jan */, 1, 12, 34, 56, 789);
+    const result = date.getTime() - getTimezoneOffsetInMilliseconds(date);
+    const expectedResult = Date.UTC(-500, 0 /* Jan */, 1, 12, 34, 56, 789);
+    expect(result).toBe(expectedResult);
+  });
+});

package/src/date-fns/_lib/protectedTokens/index.ts

@@ -1,30 +1,23 @@
-const protectedDayOfYearTokens = ['D', 'DD'];
-const protectedWeekYearTokens = ['YY', 'YYYY'];
+const dayOfYearTokenRE = /^D+$/;
+const weekYearTokenRE = /^Y+$/;
 
-export function isProtectedDayOfYearToken(token: string): boolean {
-  return protectedDayOfYearTokens.indexOf(token) !== -1;
+const throwTokens = ['D', 'DD', 'YY', 'YYYY'];
+
+export function isProtectedDayOfYearToken(token: string) {
+  return dayOfYearTokenRE.test(token);
+}
+
+export function isProtectedWeekYearToken(token: string) {
+  return weekYearTokenRE.test(token);
 }
 
-export function isProtectedWeekYearToken(token: string): boolean {
-  return protectedWeekYearTokens.indexOf(token) !== -1;
+export function warnOrThrowProtectedError(token: string, format: string, input: string): void {
+  const _message = message(token, format, input);
+  console.warn(_message);
+  if (throwTokens.includes(token)) throw new RangeError(_message);
 }
 
-export function throwProtectedError(token: string, format: string, input: string): void {
-  if (token === 'YYYY') {
-    throw new RangeError(
-      `Use \`yyyy\` instead of \`YYYY\` (in \`${format}\`) for formatting years to the input \`${input}\`; see: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md`,
-    );
-  } else if (token === 'YY') {
-    throw new RangeError(
-      `Use \`yy\` instead of \`YY\` (in \`${format}\`) for formatting years to the input \`${input}\`; see: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md`,
-    );
-  } else if (token === 'D') {
-    throw new RangeError(
-      `Use \`d\` instead of \`D\` (in \`${format}\`) for formatting days of the month to the input \`${input}\`; see: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md`,
-    );
-  } else if (token === 'DD') {
-    throw new RangeError(
-      `Use \`dd\` instead of \`DD\` (in \`${format}\`) for formatting days of the month to the input \`${input}\`; see: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md`,
-    );
-  }
+function message(token: string, format: string, input: string) {
+  const subject = token[0] === 'Y' ? 'years' : 'days of the month';
+  return `Use \`${token.toLowerCase()}\` instead of \`${token}\` (in \`${format}\`) for formatting ${subject} to the input \`${input}\`; see: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md`;
 }

package/src/date-fns/_lib/test/index.ts

@@ -0,0 +1,29 @@
+import { addLeadingZeros } from '../addLeadingZeros/index';
+import { setDefaultOptions } from '../defaultOptions/index';
+
+export function assertType<T>(_: T): void {}
+
+export function resetDefaultOptions(): void {
+  setDefaultOptions({});
+}
+
+// This makes sure we create the consistent offsets across timezones, no matter where these tests are ran.
+export function generateOffset(originalDate: Date) {
+  // Add the timezone.
+  let offset = '';
+  const tzOffset = originalDate.getTimezoneOffset();
+
+  if (tzOffset !== 0) {
+    const absoluteOffset = Math.abs(tzOffset);
+    const hourOffset = addLeadingZeros(Math.trunc(absoluteOffset / 60), 2);
+    const minuteOffset = addLeadingZeros(absoluteOffset % 60, 2);
+    // If less than 0, the sign is +, because it is ahead of time.
+    const sign = tzOffset < 0 ? '+' : '-';
+
+    offset = `${sign}${hourOffset}:${minuteOffset}`;
+  } else {
+    offset = 'Z';
+  }
+
+  return offset;
+}

package/src/date-fns/_test/dst/addBusinessDays/basic.ts

@@ -0,0 +1,17 @@
+// This is basic DST test for addBusinessDays
+
+import assert from 'assert';
+import { addBusinessDays } from '../../../addBusinessDays/index.js';
+
+if (process.env.TZ !== 'America/Santiago') throw new Error('The test must be run with TZ=America/Santiago');
+
+if (parseInt(process.version.match(/^v(\d+)\./)?.[1] || '0') < 10)
+  throw new Error('The test must be run on Node.js version >= 10');
+
+console.log(addBusinessDays(new Date(2014, 8 /* Sep */, 1), 10).toString());
+
+assert.deepStrictEqual(
+  // new Date(2014, 8, 7) is the DST day
+  addBusinessDays(new Date(2014, 8 /* Sep */, 1), 10).toString(),
+  'Mon Sep 15 2014 00:00:00 GMT-0300 (Chile Summer Time)',
+);

package/src/date-fns/_test/dst/eachDayOfInterval/basic.ts

@@ -0,0 +1,21 @@
+// This is basic DST test for eachDayOfInterval
+
+import { eachDayOfInterval } from '../../../eachDayOfInterval/index.js';
+import assert from 'assert';
+
+if (process.env.TZ !== 'Asia/Damascus') throw new Error('The test must be run with TZ=Asia/Damascus');
+
+if (parseInt(process.version.match(/^v(\d+)\./)?.[1] || '0') < 10)
+  throw new Error('The test must be run on Node.js version >= 10');
+
+assert.deepStrictEqual(
+  eachDayOfInterval({
+    start: new Date(2020, 2, 26),
+    end: new Date(2020, 2, 28),
+  }).map((d) => d.toString()),
+  [
+    'Thu Mar 26 2020 00:00:00 GMT+0200 (GMT+03:00)',
+    'Fri Mar 27 2020 01:00:00 GMT+0300 (GMT+03:00)',
+    'Sat Mar 28 2020 00:00:00 GMT+0300 (GMT+03:00)',
+  ],
+);

package/src/date-fns/_test/dst/formatDistanceStrict/cairo.ts

@@ -0,0 +1,8 @@
+// This is DST test for formatDistanceStrict in the Cairo timezone
+
+import { formatDistanceStrict } from '../../../formatDistanceStrict/index.js';
+import assert from 'assert';
+
+if (process.env.TZ !== 'Africa/Cairo') throw new Error('The test must be run with TZ=Africa/Cairo');
+
+assert.strictEqual(formatDistanceStrict(new Date(1986, 3, 4, 10, 32, 0), new Date(1986, 4, 4, 10, 32, 0)), '1 month');

package/src/date-fns/_test/dst/formatDistanceStrict/melbourne.ts

@@ -0,0 +1,12 @@
+// This is DST test for formatDistanceStrict in the Melbourne timezone
+
+import { formatDistanceStrict } from '../../../formatDistanceStrict/index.js';
+import { parseISO } from '../../../parseISO/index.js';
+import assert from 'assert';
+
+if (process.env.TZ !== 'Australia/Melbourne') throw new Error('The test must be run with TZ=Australia/Melbourne');
+
+assert.strictEqual(
+  formatDistanceStrict(parseISO('2020-04-05T01:00:00+11:00'), parseISO('2020-04-05T03:00:00+10:00')),
+  '3 hours',
+);

package/src/date-fns/_test/dst/getOverlappingDaysInIntervals/basic.ts

@@ -0,0 +1,16 @@
+import assert from 'assert';
+import { getOverlappingDaysInIntervals } from '../../../getOverlappingDaysInIntervals/index.js';
+
+assert.strictEqual(
+  getOverlappingDaysInIntervals(
+    {
+      start: new Date(2001, 8 /* Sep */, 1, 16),
+      end: new Date(2023, 11 /* Dec */, 20, 16),
+    },
+    {
+      start: new Date(2023, 11 /* Dec */, 21, 16),
+      end: new Date(2001, 8 /* Sep */, 9, 16),
+    },
+  ),
+  8137,
+);

package/src/date-fns/_test/dst/parseISO/basic.ts

@@ -0,0 +1,23 @@
+// This is basic DST test for parseISO
+
+import { parseISO } from '../../../parseISO/index.js';
+import assert from 'assert';
+
+if (process.env.TZ !== 'America/Sao_Paulo') throw new Error('The test must be run with TZ=America/Sao_Paulo');
+
+if (parseInt(process.version.match(/^v(\d+)\./)?.[1] || '0') < 10)
+  throw new Error('The test must be run on Node.js version >= 10');
+
+// Test DST start edge
+assert.strictEqual(parseISO('2018-11-03').getDate(), 3);
+assert.strictEqual(parseISO('2018-11-04').getDate(), 4); // DST start
+assert.strictEqual(parseISO('2018-11-05').getDate(), 5);
+
+// Test DST end edge
+assert.strictEqual(parseISO('2019-02-15').getDate(), 15);
+assert.strictEqual(parseISO('2019-02-16').getDate(), 16); // DST end
+assert.strictEqual(parseISO('2019-02-17').getDate(), 17);
+
+// Test creation of nonexistent time
+assert.strictEqual(parseISO('2018-11-04T00:00').toString(), 'Sun Nov 04 2018 01:00:00 GMT-0200 (Brasilia Summer Time)');
+assert.strictEqual(parseISO('2018-11-04T00:30').toString(), 'Sun Nov 04 2018 01:30:00 GMT-0200 (Brasilia Summer Time)');

package/src/date-fns/_test/dst/parseISO/samoa.ts

@@ -0,0 +1,12 @@
+// This is an edge case DST test for parseISO
+
+import { parseISO } from '../../../parseISO/index.js';
+import assert from 'assert';
+
+if (process.env.TZ !== 'Pacific/Apia') throw new Error('The test must be run with TZ=Pacific/Apia');
+
+if (parseInt(process.version.match(/^v(\d+)\./)?.[1] || '0') < 10)
+  throw new Error('The test must be run on Node.js version >= 10');
+
+assert.strictEqual(parseISO('2011-12-30').getDate(), 31);
+assert.strictEqual(parseISO('2011-12-30T03:30').toString(), 'Sat Dec 31 2011 03:30:00 GMT+1400 (Apia Daylight Time)');