@checkdigit/time 3.0.0-PR.17-58cd → 4.0.0-PR.18-9134

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
@@ -28,13 +28,13 @@ const formatters = {
     const signedYear = date.getFullYear();
     // Returns 1 for 1 BC (which is year 0 in JavaScript)
     const year = signedYear > 0 ? signedYear : 1 - signedYear;
-    return addLeadingZeros(token === 'yy' ? year % 100 : year, token.length);
+    return addLeadingZeros(token === "yy" ? year % 100 : year, token.length);
   },
 
   // Month
   M(date: Date, token: string): string {
     const month = date.getMonth();
-    return token === 'M' ? String(month + 1) : addLeadingZeros(month + 1, 2);
+    return token === "M" ? String(month + 1) : addLeadingZeros(month + 1, 2);
   },
 
   // Day of the month
@@ -44,33 +44,39 @@ 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':
-      case 'aa':
+      case "a":
+      case "aa":
         return dayPeriodEnumValue.toUpperCase();
-      case 'aaa':
+      case "aaa":
         return dayPeriodEnumValue;
-      case 'aaaaa':
-        return dayPeriodEnumValue[0] as string;
-      case 'aaaa':
+      case "aaaaa":
+        return dayPeriodEnumValue[0]!;
+      case "aaaa":
       default:
-        return dayPeriodEnumValue === 'am' ? 'a.m.' : 'p.m.';
+        return dayPeriodEnumValue === "am" ? "a.m." : "p.m.";
     }
   },
 
   // 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,9 @@ 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

@@ -1,38 +1,41 @@
-import type { FormatLong } from '../../../locale/types';
+import type { FormatLong } from "../../../locale/types";
 
 type LongFormatter = (pattern: string, formatLong: FormatLong) => string;
 
 const dateLongFormatter: LongFormatter = (pattern, formatLong) => {
   switch (pattern) {
-    case 'P':
-      return formatLong.date({ width: 'short' });
-    case 'PP':
-      return formatLong.date({ width: 'medium' });
-    case 'PPP':
-      return formatLong.date({ width: 'long' });
-    case 'PPPP':
+    case "P":
+      return formatLong.date({ width: "short" });
+    case "PP":
+      return formatLong.date({ width: "medium" });
+    case "PPP":
+      return formatLong.date({ width: "long" });
+    case "PPPP":
     default:
-      return formatLong.date({ width: 'full' });
+      return formatLong.date({ width: "full" });
   }
 };
 
 const timeLongFormatter: LongFormatter = (pattern, formatLong) => {
   switch (pattern) {
-    case 'p':
-      return formatLong.time({ width: 'short' });
-    case 'pp':
-      return formatLong.time({ width: 'medium' });
-    case 'ppp':
-      return formatLong.time({ width: 'long' });
-    case 'pppp':
+    case "p":
+      return formatLong.time({ width: "short" });
+    case "pp":
+      return formatLong.time({ width: "medium" });
+    case "ppp":
+      return formatLong.time({ width: "long" });
+    case "pppp":
     default:
-      return formatLong.time({ width: 'full' });
+      return formatLong.time({ width: "full" });
   }
 };
 
-const dateTimeLongFormatter: LongFormatter = (pattern: string, formatLong: 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) {
@@ -42,29 +45,27 @@ const dateTimeLongFormatter: LongFormatter = (pattern: string, formatLong: Forma
   let dateTimeFormat: string;
 
   switch (datePattern) {
-    case 'P':
-      dateTimeFormat = formatLong.dateTime({ width: 'short' });
+    case "P":
+      dateTimeFormat = formatLong.dateTime({ width: "short" });
       break;
-    case 'PP':
-      dateTimeFormat = formatLong.dateTime({ width: 'medium' });
+    case "PP":
+      dateTimeFormat = formatLong.dateTime({ width: "medium" });
       break;
-    case 'PPP':
-      dateTimeFormat = formatLong.dateTime({ width: 'long' });
+    case "PPP":
+      dateTimeFormat = formatLong.dateTime({ width: "long" });
       break;
-    case 'PPPP':
+    case "PPPP":
     default:
-      dateTimeFormat = formatLong.dateTime({ width: 'full' });
+      dateTimeFormat = formatLong.dateTime({ width: "full" });
       break;
   }
 
   return dateTimeFormat
-    .replace('{{date}}', dateLongFormatter(datePattern, formatLong))
-    .replace('{{time}}', timeLongFormatter(timePattern, 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,21 @@
  *
  * 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,27 @@
-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,18 @@
+// 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,22 @@
+// 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,15 @@
+// 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,16 @@
+// 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,30 @@
+// 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,16 @@
+// 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)",
+);

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

@@ -0,0 +1,58 @@
+// This is basic DST test for parseISO
+
+import { parseISO } from "../../../parseISO/index.js";
+import assert from "assert";
+
+if (process.env.TZ !== "Australia/Sydney")
+  throw new Error("The test must be run with TZ=Australia/Sydney");
+
+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("2019-10-06").getDate(), 6); // DST start
+assert.strictEqual(parseISO("2019-10-07").getDate(), 7);
+assert.strictEqual(
+  parseISO("2019-10-06T01:00:00").toString(),
+  "Sun Oct 06 2019 01:00:00 GMT+1000 (Australian Eastern Standard Time)",
+);
+assert.strictEqual(
+  parseISO("2019-10-06T02:00:00").toString(),
+  "Sun Oct 06 2019 03:00:00 GMT+1100 (Australian Eastern Daylight Time)",
+);
+
+assert.strictEqual(
+  parseISO("2019-10-06T05:00:00").toString(),
+  "Sun Oct 06 2019 05:00:00 GMT+1100 (Australian Eastern Daylight Time)",
+);
+
+// Test DST end edge
+assert.strictEqual(parseISO("2019-04-06").getDate(), 6);
+assert.strictEqual(parseISO("2019-04-07").getDate(), 7); // DST end
+assert.strictEqual(
+  parseISO("2019-04-06T11:00:00").toString(),
+  "Sat Apr 06 2019 11:00:00 GMT+1100 (Australian Eastern Daylight Time)",
+);
+assert.strictEqual(
+  parseISO("2019-04-07T11:00:00").toString(),
+  "Sun Apr 07 2019 11:00:00 GMT+1000 (Australian Eastern Standard Time)",
+);
+
+assert.strictEqual(
+  parseISO("2019-04-07T00:00:00").toString(),
+  "Sun Apr 07 2019 00:00:00 GMT+1100 (Australian Eastern Daylight Time)",
+);
+
+// test edge cases for months, years
+assert.strictEqual(
+  parseISO("2020-01-01T00:00:00").toString(),
+  "Wed Jan 01 2020 00:00:00 GMT+1100 (Australian Eastern Daylight Time)",
+);
+assert.strictEqual(
+  parseISO("2019-12-31T23:59:59").toString(),
+  "Tue Dec 31 2019 23:59:59 GMT+1100 (Australian Eastern Daylight Time)",
+);
+assert.strictEqual(
+  parseISO("2020-02-29T23:59:59").toString(),
+  "Sat Feb 29 2020 23:59:59 GMT+1100 (Australian Eastern Daylight Time)",
+);