@checkdigit/time 1.1.0 → 2.0.0-PR.14-c36c

package/src/date-fns/subMilliseconds/index.ts

@@ -0,0 +1,22 @@
+import addMilliseconds from '../addMilliseconds/index';
+
+/**
+ * @name subMilliseconds
+ * @category Millisecond Helpers
+ * @summary Subtract the specified number of milliseconds from the given date.
+ *
+ * @description
+ * Subtract the specified number of milliseconds from the given date.
+ *
+ * @param date - the date to be changed
+ * @param amount - the amount of milliseconds to be subtracted. Positive decimals will be rounded using `Math.floor`, decimals less than zero will be rounded using `Math.ceil`.
+ * @returns the new date with the milliseconds subtracted
+ *
+ * @example
+ * // Subtract 750 milliseconds from 10 July 2014 12:45:30.000:
+ * const result = subMilliseconds(new Date(2014, 6, 10, 12, 45, 30, 0), 750)
+ * //=> Thu Jul 10 2014 12:45:29.250
+ */
+export default function subMilliseconds<DateType extends Date>(dirtyDate: DateType | number, amount: number): DateType {
+  return addMilliseconds(dirtyDate, -amount);
+}

package/src/date-fns/subMinutes/index.ts

@@ -0,0 +1,22 @@
+import addMinutes from '../addMinutes/index';
+
+/**
+ * @name subMinutes
+ * @category Minute Helpers
+ * @summary Subtract the specified number of minutes from the given date.
+ *
+ * @description
+ * Subtract the specified number of minutes from the given date.
+ *
+ * @param date - the date to be changed
+ * @param amount - the amount of minutes to be subtracted. Positive decimals will be rounded using `Math.floor`, decimals less than zero will be rounded using `Math.ceil`.
+ * @returns the new date with the minutes subtracted
+ *
+ * @example
+ * // Subtract 30 minutes from 10 July 2014 12:00:00:
+ * const result = subMinutes(new Date(2014, 6, 10, 12, 0), 30)
+ * //=> Thu Jul 10 2014 11:30:00
+ */
+export default function subMinutes<DateType extends Date>(dirtyDate: DateType | number, amount: number): DateType {
+  return addMinutes(dirtyDate, -amount);
+}

package/src/date-fns/subMonths/index.ts

@@ -0,0 +1,22 @@
+import addMonths from '../addMonths/index';
+
+/**
+ * @name subMonths
+ * @category Month Helpers
+ * @summary Subtract the specified number of months from the given date.
+ *
+ * @description
+ * Subtract the specified number of months from the given date.
+ *
+ * @param date - the date to be changed
+ * @param amount - the amount of months to be subtracted. Positive decimals will be rounded using `Math.floor`, decimals less than zero will be rounded using `Math.ceil`.
+ * @returns the new date with the months subtracted
+ *
+ * @example
+ * // Subtract 5 months from 1 February 2015:
+ * const result = subMonths(new Date(2015, 1, 1), 5)
+ * //=> Mon Sep 01 2014 00:00:00
+ */
+export default function subMonths<DateType extends Date>(dirtyDate: DateType | number, amount: number): DateType {
+  return addMonths(dirtyDate, -amount);
+}

package/src/date-fns/subQuarters/index.ts

@@ -0,0 +1,22 @@
+import addQuarters from '../addQuarters/index';
+
+/**
+ * @name subQuarters
+ * @category Quarter Helpers
+ * @summary Subtract the specified number of year quarters from the given date.
+ *
+ * @description
+ * Subtract the specified number of year quarters from the given date.
+ *
+ * @param date - the date to be changed
+ * @param amount - the amount of quarters to be subtracted. Positive decimals will be rounded using `Math.floor`, decimals less than zero will be rounded using `Math.ceil`.
+ * @returns the new date with the quarters subtracted
+ *
+ * @example
+ * // Subtract 3 quarters from 1 September 2014:
+ * const result = subQuarters(new Date(2014, 8, 1), 3)
+ * //=> Sun Dec 01 2013 00:00:00
+ */
+export default function subQuarters<DateType extends Date>(dirtyDate: DateType | number, amount: number): DateType {
+  return addQuarters(dirtyDate, -amount);
+}

package/src/date-fns/subSeconds/index.ts

@@ -0,0 +1,22 @@
+import addSeconds from '../addSeconds/index';
+
+/**
+ * @name subSeconds
+ * @category Second Helpers
+ * @summary Subtract the specified number of seconds from the given date.
+ *
+ * @description
+ * Subtract the specified number of seconds from the given date.
+ *
+ * @param date - the date to be changed
+ * @param amount - the amount of seconds to be subtracted. Positive decimals will be rounded using `Math.floor`, decimals less than zero will be rounded using `Math.ceil`.
+ * @returns the new date with the seconds subtracted
+ *
+ * @example
+ * // Subtract 30 seconds from 10 July 2014 12:45:00:
+ * const result = subSeconds(new Date(2014, 6, 10, 12, 45, 0), 30)
+ * //=> Thu Jul 10 2014 12:44:30
+ */
+export default function subSeconds<DateType extends Date>(dirtyDate: DateType | number, amount: number): DateType {
+  return addSeconds(dirtyDate, -amount);
+}

package/src/date-fns/subWeeks/index.ts

@@ -0,0 +1,22 @@
+import addWeeks from '../addWeeks/index';
+
+/**
+ * @name subWeeks
+ * @category Week Helpers
+ * @summary Subtract the specified number of weeks from the given date.
+ *
+ * @description
+ * Subtract the specified number of weeks from the given date.
+ *
+ * @param date - the date to be changed
+ * @param amount - the amount of weeks to be subtracted. Positive decimals will be rounded using `Math.floor`, decimals less than zero will be rounded using `Math.ceil`.
+ * @returns the new date with the weeks subtracted
+ *
+ * @example
+ * // Subtract 4 weeks from 1 September 2014:
+ * const result = subWeeks(new Date(2014, 8, 1), 4)
+ * //=> Mon Aug 04 2014 00:00:00
+ */
+export default function subWeeks<DateType extends Date>(dirtyDate: DateType | number, amount: number): DateType {
+  return addWeeks(dirtyDate, -amount);
+}

package/src/date-fns/subYears/index.ts

@@ -0,0 +1,22 @@
+import addYears from '../addYears/index';
+
+/**
+ * @name subYears
+ * @category Year Helpers
+ * @summary Subtract the specified number of years from the given date.
+ *
+ * @description
+ * Subtract the specified number of years from the given date.
+ *
+ * @param date - the date to be changed
+ * @param amount - the amount of years to be subtracted. Positive decimals will be rounded using `Math.floor`, decimals less than zero will be rounded using `Math.ceil`.
+ * @returns the new date with the years subtracted
+ *
+ * @example
+ * // Subtract 5 years from 1 September 2014:
+ * const result = subYears(new Date(2014, 8, 1), 5)
+ * //=> Tue Sep 01 2009 00:00:00
+ */
+export default function subYears<DateType extends Date>(dirtyDate: DateType | number, amount: number): DateType {
+  return addYears(dirtyDate, -amount);
+}

package/src/date-fns/toDate/index.ts

@@ -0,0 +1,50 @@
+/**
+ * @name toDate
+ * @category Common Helpers
+ * @summary Convert the given argument to an instance of Date.
+ *
+ * @description
+ * Convert the given argument to an instance of Date.
+ *
+ * If the argument is an instance of Date, the function returns its clone.
+ *
+ * If the argument is a number, it is treated as a timestamp.
+ *
+ * If the argument is none of the above, the function returns Invalid Date.
+ *
+ * **Note**: *all* Date arguments passed to any *date-fns* function is processed by `toDate`.
+ *
+ * @param argument - the value to convert
+ * @returns the parsed date in the local time zone
+ *
+ * @example
+ * // Clone the date:
+ * const result = toDate(new Date(2014, 1, 11, 11, 30, 30))
+ * //=> Tue Feb 11 2014 11:30:30
+ *
+ * @example
+ * // Convert the timestamp to date:
+ * const result = toDate(1392098430000)
+ * //=> Tue Feb 11 2014 11:30:30
+ */
+import type { Instant } from '../../instant';
+
+export default function toDate<DateType extends Date = Date>(argument: Instant | DateType | number): DateType {
+  let modifiedArgument: Instant | DateType | number | Date = argument;
+  if (typeof (modifiedArgument as Instant)?.epochNanoseconds === 'bigint') {
+    modifiedArgument = new Date(Number((modifiedArgument as Instant).epochNanoseconds / 1000000n));
+  }
+
+  const argStr = Object.prototype.toString.call(modifiedArgument);
+
+  // Clone the date
+  if (modifiedArgument instanceof Date || (typeof modifiedArgument === 'object' && argStr === '[object Date]')) {
+    return modifiedArgument as DateType;
+  } else if (typeof modifiedArgument === 'number' || argStr === '[object Number]') {
+    // TODO: Can we get rid of as?
+    return new Date(modifiedArgument as number) as DateType;
+  } else {
+    // TODO: Can we get rid of as?
+    return new Date(NaN) as DateType;
+  }
+}

package/src/date-fns/transpose/index.ts

@@ -0,0 +1,35 @@
+import type { GenericDateConstructor } from '../types';
+import constructFrom from '../constructFrom/index';
+
+/**
+ * @name transpose
+ * @category Generic Helpers
+ * @summary Transpose the date to the given constructor.
+ *
+ * @description
+ * The function transposes the date to the given constructor. It helps you
+ * to transpose the date in the system time zone to say `UTCDate` or any other
+ * date extension.
+ *
+ * @param fromDate {Date|number} - the date to use values from
+ * @param constructor {Date|DateConstructor} - the date constructor to use
+ * @returns date transposed to the given constructor
+ *
+ * @example
+ * // Create July 10, 2022 00:00 in locale time zone
+ * const date = new Date(2022, 6, 10)
+ * //=> 'Sun Jul 10 2022 00:00:00 GMT+0800 (Singapore Standard Time)'
+ *
+ * // Transpose the date to July 10, 2022 00:00 in UTC
+ * transpose(date, UTCDate)
+ * //=> 'Sun Jul 10 2022 00:00:00 GMT+0000 (Coordinated Universal Time)'
+ */
+export default function transpose<DateInputType extends Date, DateOutputType extends Date>(
+  fromDate: DateInputType,
+  constructor: DateOutputType | GenericDateConstructor<DateOutputType>,
+): DateOutputType {
+  const date = constructor instanceof Date ? constructFrom(constructor, 0) : new constructor(0);
+  date.setFullYear(fromDate.getFullYear(), fromDate.getMonth(), fromDate.getDate());
+  date.setHours(fromDate.getHours(), fromDate.getMinutes(), fromDate.getSeconds(), fromDate.getMilliseconds());
+  return date;
+}

package/src/date-fns/types.ts

@@ -0,0 +1,102 @@
+import type { Locale } from './locale/types';
+
+export interface GenericDateConstructor<DateType> {
+  new (): DateType;
+
+  new (value: Date | number | string): DateType;
+
+  new (
+    year: number,
+    month: number,
+    date?: number,
+    hours?: number,
+    minutes?: number,
+    seconds?: number,
+    ms?: number,
+  ): DateType;
+}
+
+export interface Duration {
+  years?: number;
+  months?: number;
+  weeks?: number;
+  days?: number;
+  hours?: number;
+  minutes?: number;
+  seconds?: number;
+}
+
+export type DurationUnit = keyof Duration;
+
+export interface Interval<DateType extends Date = Date> {
+  start: DateType | number;
+  end: DateType | number;
+}
+
+export interface StepOptions {
+  step?: number;
+}
+
+export interface WeekStartOptions {
+  weekStartsOn?: Day;
+}
+
+export interface FirstWeekContainsDateOptions {
+  firstWeekContainsDate?: FirstWeekContainsDate;
+}
+
+export interface LocaleOptions {
+  locale?: Locale;
+}
+
+export interface FormatOptions {
+  format?: 'extended' | 'basic';
+}
+
+export interface RepresentationOptions {
+  representation?: 'complete' | 'date' | 'time';
+}
+
+export type Era = 0 | 1;
+
+export type Quarter = 1 | 2 | 3 | 4;
+
+export type Day = 0 | 1 | 2 | 3 | 4 | 5 | 6;
+
+export type Month = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11;
+
+/**
+ * FirstWeekContainsDate is used to determine which week is the first week of the year, based on what day the January, 1 is in that week.
+ *
+ * The day in that week can only be 1 (Monday) or 4 (Thursday).
+ *
+ * Please see https://en.wikipedia.org/wiki/Week#Week_numbering for more information.
+ */
+export type FirstWeekContainsDate = 1 | 4;
+
+export interface DateValues {
+  year?: number;
+  month?: number;
+  date?: number;
+  hours?: number;
+  minutes?: number;
+  seconds?: number;
+  milliseconds?: number;
+}
+
+export type RoundingMethod = 'ceil' | 'floor' | 'round' | 'trunc';
+
+export interface RoundingOptions {
+  roundingMethod?: RoundingMethod;
+}
+
+export type Unit = 'second' | 'minute' | 'hour' | 'day' | 'dayOfYear' | 'date' | 'week' | 'month' | 'quarter' | 'year';
+
+export type FormatDistanceStrictUnit = 'second' | 'minute' | 'hour' | 'day' | 'month' | 'year';
+
+export interface AdditionalTokensOptions {
+  useAdditionalWeekYearTokens?: boolean;
+  useAdditionalDayOfYearTokens?: boolean;
+}
+
+export type IntlOptionsUnit = 'year' | 'quarter' | 'month' | 'week' | 'day' | 'hour' | 'minute' | 'second';

package/src/date-fns/weeksToDays/index.ts

@@ -0,0 +1,22 @@
+import { daysInWeek } from '../constants/index';
+
+/**
+ * @name weeksToDays
+ * @category Conversion Helpers
+ * @summary Convert weeks to days.
+ *
+ * @description
+ * Convert a number of weeks to a full number of days.
+ *
+ * @param weeks - number of weeks to be converted
+ *
+ * @returns the number of weeks converted in days
+ *
+ * @example
+ * // Convert 2 weeks into days
+ * const result = weeksToDays(2)
+ * //=> 14
+ */
+export default function weeksToDays(weeks: number): number {
+  return Math.floor(weeks * daysInWeek);
+}

package/src/date-fns/yearsToMonths/index.ts

@@ -0,0 +1,22 @@
+import { monthsInYear } from '../constants/index';
+
+/**
+ * @name yearsToMonths
+ * @category Conversion Helpers
+ * @summary Convert years to months.
+ *
+ * @description
+ * Convert a number of years to a full number of months.
+ *
+ * @param years - number of years to be converted
+ *
+ * @returns the number of years converted in months
+ *
+ * @example
+ * // Convert 2 years into months
+ * const result = yearsToMonths(2)
+ * //=> 24
+ */
+export default function yearsToMonths(years: number): number {
+  return Math.floor(years * monthsInYear);
+}

package/src/date-fns/yearsToQuarters/index.ts

@@ -0,0 +1,22 @@
+import { quartersInYear } from '../constants/index';
+
+/**
+ * @name yearsToQuarters
+ * @category Conversion Helpers
+ * @summary Convert years to quarters.
+ *
+ * @description
+ * Convert a number of years to a full number of quarters.
+ *
+ * @param years - number of years to be converted
+ *
+ * @returns the number of years converted in quarters
+ *
+ * @example
+ * // Convert 2 years to quarters
+ * const result = yearsToQuarters(2)
+ * //=> 8
+ */
+export default function yearsToQuarters(years: number): number {
+  return Math.floor(years * quartersInYear);
+}

package/src/date-fns-tz/CHANGELOG.md

@@ -0,0 +1,133 @@
+### v1.3.7 (31 August 2022)
+
+- [BUGFIX] Fixed getting the time zone name in `partsTimeZone` out of `formatToParts` (#196)
+- [BUGFIX] `tzTokenizeDate` uses `month: numeric` as a possible fix for #190
+
+### v1.3.6 (13 July 2022)
+
+- [BUGFIX] Remove the use of `const` (#192)
+
+### v1.3.5 (18 June 2022)
+
+- [BUGFIX] Fixed `utcToZonedTime` not working with year < 100; thanks @healqq (#185)
+
+### v1.3.4 (28 April 2022)
+
+- [BUGFIX] Add new to `DateTimeFormat` invocation to fix mocking it in tests (#181)
+- [DOCS] Add notes on usage with Android
+
+### v1.3.3 (1 April 2022)
+
+- [BUGFIX] Fix broken ESM import (#177)
+
+### v1.3.2 (31 March 2022)
+
+- [BUGFIX] Support tz offsets up to +/-23:59 (#171)
+- [BUGFIX] Fixed zonedTimeToUtc not working with year < 100 (#87, #170)
+
+### v1.3.1 (25 March 2022)
+
+- [BUGFIX] ESM export of package.json (#173)
+- [BUGFIX] Round tz offset correctly to format old dates (#169, #168)
+
+### v1.3.0 (24 February 2022)
+
+- [ENHANCEMENT] Native ESM support via `exports` configuration in `package.json` (#133, #150)
+- [DOCS] Clarify the use of ESM vs CommonJS import paths
+- [DOCS] Clarify when `format` throws a `RangeError` and fix the test for it
+- [ENHANCEMENT] More extensive validation of numeric time zone offsets
+- [BUGFIX] Fixed `zonedTimeToUtc` throwing `RangeError` instead of returning an Invalid Date (#151)
+- [BUGFIX] Fixed `format` not throwing `RangeError` for invalid time zones with offset tokens (#152)
+
+### v1.2.2 (21 December 2021)
+
+- [BUGFIX] Fix `formatInTimeZone` types and fp arguments
+
+### v1.2.1 (21 December 2021)
+
+- [DOCS] Fixed a broken link (#148)
+
+### v1.2.0 (18 December 2021)
+
+- [ENHANCEMENT] Add `formatInTimeZone`
+- [DOCS] Various improvements and corrections
+- [BUGFIX] Fixed `zonedTimeToUtc` parsing of date strings with time zone specifiers
+- [ENHANCEMENT] Functions that return dates will return `Invalid Date` for bad date / time zone
+  inputs, and `format` functions throw a `RangeError`
+- [BUGFIX] Fix `format` returning wrong time zone offset close to DST. (#138)
+
+### v1.1.7 (17 December 2021)
+
+- [PERFORMANCE] Improve performance when validating the same timezones many times through caching; thanks @billthornton (#135)
+- [TESTS] Added a test for #33 which now passes
+- [BUGFIX] Fix `format` handling of quoted text next to a time zone token (#136)
+
+### v1.1.6 (27 July 2021)
+
+- [BUGFIX] Added an error object to the catch of isValidTimezoneIANAString for older JS (#131)
+
+### v1.1.5 (27 July 2021)
+
+- [BUGFIX] Fixed parsing IANA strings (#129)
+
+### v1.1.4 (13 April 2021)
+
+- [UPGRADE] Use Yarn berry
+- [BUGFIX] Restore IE11 support (#112)
+
+### v1.1.3 (27 February 2021)
+
+- [BUGFIX] Support IANA timezones with a hyphen in the name! (#110)
+
+### v1.1.2 (20 February 2021)
+
+- [BUGFIX] Fix time zone offset around DST; thanks @bsvetlik & @yharaskrik! (#108, #99, #93)
+
+### v1.1.1 (30 January 2021)
+
+- [DOCS] Add `getTimezoneOffset` to TOC
+
+### v1.1.0 (30 January 2021)
+
+- [ENHANCEMENT] Add the `getTimezoneOffset` function (#100).
+- [UPGRADE] Upgrade dependencies
+
+### v1.0.12 (9 October 2020)
+
+- [BUGFIX] Improve the #46 fix for `toDate` using the UTC timestamp for determining offset (#86).
+
+### v1.0.11 (5 October 2020)
+
+- [BUGFIX] Fix uctToZonedTime during timezone changes (#80).
+- [BUGFIX] Fix `toDate` using the UTC timestamp for determining offset (#46).
+
+### v1.0.10 (10 February 2020)
+
+- [BUGFIX] Fix day wrapping when the result is midnight in new browsers supporting DTF `hourCycle` (#38, #41, #43).
+
+### v1.0.9 (28 December 2019)
+
+- [DOCS] Improve the documentation, particularly on the usage of `format`.
+
+### v1.0.8 (12 October 2019)
+
+- [BUGFIX] Not losing milliseconds when converting time zones. (#25)
+- [BUGFIX] Fix missing `_lib/convertToFP/index.js`. (#20)
+- [UPGRADE] Upgrade dependencies and match the `date-fns@2` build config.
+
+### v1.0.6 (2 February 2019)
+
+- [BUGFIX] Rewrite import paths in esm version to use esm version of date-fns. (#8 @pkaske)
+
+### v1.0.3 (21 January 2019)
+
+- [BUGFIX] Removed `const`, `let`, template string and arrow function syntax which is not transpiled in
+  the ems build to fix for IE11.
+
+### v1.0.0 (12 January 2019)
+
+- [ENHANCEMENT] Typescript typings.
+
+### v0.1.1 (13 November 2018)
+
+Initial release.

package/src/date-fns-tz/LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright © 2018 Marnus Weststrate
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the “Software”), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

package/src/date-fns-tz/_lib/newDateUTC/index.ts

@@ -0,0 +1,21 @@
+/**
+ * Use instead of `new Date(Date.UTC(...))` to support years below 100 which doesn't work
+ * otherwise due to the nature of the
+ * [`Date` constructor](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date#interpretation_of_two-digit_years.
+ *
+ * For `Date.UTC(...)`, use `newDateUTC(...).getTime()`.
+ */
+export default function newDateUTC(
+  fullYear: number,
+  month: number,
+  day: number,
+  hour: number,
+  minute: number,
+  second: number,
+  millisecond: number,
+) {
+  const utcDate = new Date(0);
+  utcDate.setUTCFullYear(fullYear, month, day);
+  utcDate.setUTCHours(hour, minute, second, millisecond);
+  return utcDate;
+}

package/src/date-fns-tz/_lib/tzIntlTimeZoneName/index.ts

@@ -0,0 +1,43 @@
+/**
+ * Returns the formatted time zone name of the provided `timeZone` or the current
+ * system time zone if omitted, accounting for DST according to the UTC value of
+ * the date.
+ */
+import type { Locale } from '../../../date-fns/locale/types';
+
+export default function tzIntlTimeZoneName(
+  length: 'short' | 'long' | 'shortOffset' | 'longOffset' | 'shortGeneric' | 'longGeneric',
+  date: Date,
+  options: { timeZone: string; locale?: Locale },
+) {
+  const dtf = getDTF(length, options.timeZone, options.locale);
+  return partsTimeZone(dtf, date);
+}
+
+function partsTimeZone(dtf: Intl.DateTimeFormat, date: Date) {
+  const formatted = dtf.formatToParts(date);
+  for (let i = formatted.length - 1; i >= 0; --i) {
+    if (formatted[i]?.type === 'timeZoneName') {
+      return formatted[i]?.value;
+    }
+  }
+  return undefined;
+}
+
+// If a locale has been provided `en-US` is used as a fallback in case it is an
+// invalid locale, otherwise the locale is left undefined to use the system locale.
+function getDTF(
+  length: 'short' | 'long' | 'shortOffset' | 'longOffset' | 'shortGeneric' | 'longGeneric',
+  timeZone: string,
+  locale?: Locale,
+): Intl.DateTimeFormat {
+  if (locale && !locale.code) {
+    throw new Error(
+      "date-fns-tz error: Please set a language code on the locale object imported from date-fns, e.g. `locale.code = 'en-US'`",
+    );
+  }
+  return new Intl.DateTimeFormat(locale ? [locale.code, 'en-US'] : undefined, {
+    timeZone: timeZone,
+    timeZoneName: length,
+  });
+}