@checkdigit/time 4.0.0 → 5.0.0-PR.21-7813

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

@@ -1,13 +1,17 @@
+/* eslint-disable eslint-comments/no-unlimited-disable */
+/* eslint-disable */
+// @ts-nocheck
+
 /**
  * Returns the [year, month, day, hour, minute, seconds] tokens of the provided
  * `date` as it will be rendered in the `timeZone`.
  */
-export default function tzTokenizeDate(date: Date, timeZone: string) {
+export function tzTokenizeDate(date: Date, timeZone: string): number[] {
   const dtf = getDateTimeFormat(timeZone);
-  return partsOffset(dtf, date);
+  return 'formatToParts' in dtf ? partsOffset(dtf, date) : hackyOffset(dtf, date);
 }
 
-const typeToPos = {
+const typeToPos: { [type in keyof Intl.DateTimeFormatPartTypesRegistry]?: number } = {
   year: 0,
   month: 1,
   day: 2,
@@ -19,11 +23,12 @@ const typeToPos = {
 function partsOffset(dtf: Intl.DateTimeFormat, date: Date) {
   try {
     const formatted = dtf.formatToParts(date);
-    const filled = [];
+    const filled: number[] = [];
     for (let i = 0; i < formatted.length; i++) {
-      const pos = typeToPos[formatted[i]?.type as 'year'] as number;
-      if (pos >= 0) {
-        filled[pos] = parseInt(formatted[i]?.value as keyof typeof typeToPos, 10);
+      const pos = typeToPos[formatted[i].type];
+
+      if (pos !== undefined) {
+        filled[pos] = parseInt(formatted[i].value, 10);
       }
     }
     return filled;
@@ -35,28 +40,45 @@ function partsOffset(dtf: Intl.DateTimeFormat, date: Date) {
   }
 }
 
+function hackyOffset(dtf: Intl.DateTimeFormat, date: Date) {
+  const formatted = dtf.format(date);
+
+  const parsed = /(\d+)\/(\d+)\/(\d+),? (\d+):(\d+):(\d+)/.exec(formatted)!;
+  // const [, fMonth, fDay, fYear, fHour, fMinute, fSecond] = parsed
+  // return [fYear, fMonth, fDay, fHour, fMinute, fSecond]
+  return [
+    parseInt(parsed[3], 10),
+    parseInt(parsed[1], 10),
+    parseInt(parsed[2], 10),
+    parseInt(parsed[4], 10),
+    parseInt(parsed[5], 10),
+    parseInt(parsed[6], 10),
+  ];
+}
+
+// Get a cached Intl.DateTimeFormat instance for the IANA `timeZone`. This can be used
 // to get deterministic local date/time output according to the `en-US` locale which
 // can be used to extract local time parts as necessary.
-const dtfCache = {} as Record<string, Intl.DateTimeFormat>;
-function getDateTimeFormat(timeZone: string): Intl.DateTimeFormat {
-  if (!dtfCache[timeZone]) {
-    // New browsers use `hourCycle`, IE and Chrome <73 does not support it and uses `hour12`
-    const testDateFormatted = new Intl.DateTimeFormat('en-US', {
-      hour12: false,
-      timeZone: 'America/New_York',
-      year: 'numeric',
-      month: 'numeric',
-      day: '2-digit',
-      hour: '2-digit',
-      minute: '2-digit',
-      second: '2-digit',
-    }).format(new Date('2014-06-25T04:00:00.123Z'));
-    const hourCycleSupported =
-      testDateFormatted === '06/25/2014, 00:00:00' || testDateFormatted === '‎06‎/‎25‎/‎2014‎ ‎00‎:‎00‎:‎00';
+const dtfCache: Record<string, Intl.DateTimeFormat> = {};
+// New browsers use `hourCycle`, IE and Chrome <73 does not support it and uses `hour12`
+const testDateFormatted = new Intl.DateTimeFormat('en-US', {
+  hourCycle: 'h23',
+  timeZone: 'America/New_York',
+  year: 'numeric',
+  month: '2-digit',
+  day: '2-digit',
+  hour: '2-digit',
+  minute: '2-digit',
+  second: '2-digit',
+}).format(new Date('2014-06-25T04:00:00.123Z'));
+const hourCycleSupported =
+  testDateFormatted === '06/25/2014, 00:00:00' || testDateFormatted === '‎06‎/‎25‎/‎2014‎ ‎00‎:‎00‎:‎00';
 
+function getDateTimeFormat(timeZone: string) {
+  if (!dtfCache[timeZone]) {
     dtfCache[timeZone] = hourCycleSupported
       ? new Intl.DateTimeFormat('en-US', {
-          hour12: false,
+          hourCycle: 'h23',
           timeZone: timeZone,
           year: 'numeric',
           month: 'numeric',
@@ -66,7 +88,7 @@ function getDateTimeFormat(timeZone: string): Intl.DateTimeFormat {
           second: '2-digit',
         })
       : new Intl.DateTimeFormat('en-US', {
-          hourCycle: 'h23',
+          hour12: false,
           timeZone: timeZone,
           year: 'numeric',
           month: 'numeric',
@@ -76,5 +98,7 @@ function getDateTimeFormat(timeZone: string): Intl.DateTimeFormat {
           second: '2-digit',
         });
   }
-  return dtfCache[timeZone] as Intl.DateTimeFormat;
+  return dtfCache[timeZone];
 }
+
+/* eslint-enable */

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

@@ -1,17 +1,20 @@
-import tzIntlTimeZoneName from '../../_lib/tzIntlTimeZoneName';
-import tzParseTimezone from '../../_lib/tzParseTimezone';
+/* eslint-disable eslint-comments/no-unlimited-disable */
+/* eslint-disable */
+// @ts-nocheck
+
+import { tzIntlTimeZoneName } from '../../_lib/tzIntlTimeZoneName/index.ts';
+import { tzParseTimezone } from '../../_lib/tzParseTimezone/index.ts';
+import type { FormatOptionsWithTZ } from '../../index.ts';
 
 const MILLISECONDS_IN_MINUTE = 60 * 1000;
 
-const formatters = {
+export const formatters: Record<
+  string,
+  (date: Date, token: string, options: FormatOptionsWithTZ) => string | undefined
+> = {
   // Timezone (ISO-8601. If offset is 0, output is always `'Z'`)
-  X: function (
-    date: Date,
-    token: string,
-    _localize: boolean | null,
-    options: { timeZone: string; _originalDate?: Date },
-  ) {
-    const timezoneOffset = getTimeZoneOffset(options.timeZone, options._originalDate || date);
+  X: function (date, token, options) {
+    const timezoneOffset = getTimeZoneOffset(options.timeZone, date);
 
     if (timezoneOffset === 0) {
       return 'Z';
@@ -40,13 +43,8 @@ const formatters = {
   },
 
   // Timezone (ISO-8601. If offset is 0, output is `'+00:00'` or equivalent)
-  x: function (
-    date: Date,
-    token: string,
-    _localize: boolean | null,
-    options: { timeZone: string; _originalDate?: Date },
-  ) {
-    const timezoneOffset = getTimeZoneOffset(options.timeZone, options._originalDate || date);
+  x: function (date, token, options) {
+    const timezoneOffset = getTimeZoneOffset(options.timeZone, date);
 
     switch (token) {
       // Hours and optional minutes
@@ -71,13 +69,8 @@ const formatters = {
   },
 
   // Timezone (GMT)
-  O: function (
-    date: Date,
-    token: string,
-    _localize: boolean | null,
-    options: { timeZone: string; _originalDate?: Date },
-  ) {
-    const timezoneOffset = getTimeZoneOffset(options.timeZone, options._originalDate || date);
+  O: function (date, token, options) {
+    const timezoneOffset = getTimeZoneOffset(options.timeZone, date);
 
     switch (token) {
       // Short
@@ -93,65 +86,57 @@ const formatters = {
   },
 
   // Timezone (specific non-location)
-  z: function (
-    date: Date,
-    token: string,
-    _localize: boolean | null,
-    options: { timeZone: string; _originalDate?: Date },
-  ) {
-    const originalDate = options._originalDate || date;
-
+  z: function (date, token, options) {
     switch (token) {
       // Short
       case 'z':
       case 'zz':
       case 'zzz':
-        return tzIntlTimeZoneName('short', originalDate, options);
+        return tzIntlTimeZoneName('short', date, options);
       // Long
       case 'zzzz':
       default:
-        return tzIntlTimeZoneName('long', originalDate, options);
+        return tzIntlTimeZoneName('long', date, options);
     }
   },
 };
 
-function getTimeZoneOffset(timeZone: string, originalDate: Date) {
+function getTimeZoneOffset(timeZone: string | undefined, originalDate?: Date) {
   const timeZoneOffset = timeZone
     ? tzParseTimezone(timeZone, originalDate, true) / MILLISECONDS_IN_MINUTE
-    : originalDate.getTimezoneOffset();
+    : (originalDate?.getTimezoneOffset() ?? 0);
   if (Number.isNaN(timeZoneOffset)) {
     throw new RangeError('Invalid time zone specified: ' + timeZone);
   }
   return timeZoneOffset;
 }
 
-function addLeadingZeros(num: number, targetLength: number) {
-  const sign = num < 0 ? '-' : '';
-  let output = Math.abs(num).toString();
+function addLeadingZeros(number: number, targetLength: number) {
+  const sign = number < 0 ? '-' : '';
+  let output = Math.abs(number).toString();
   while (output.length < targetLength) {
     output = '0' + output;
   }
   return sign + output;
 }
 
-function formatTimezone(offset: number, dirtyDelimeter?: string) {
-  const delimeter = dirtyDelimeter || '';
+function formatTimezone(offset: number, delimiter = '') {
   const sign = offset > 0 ? '-' : '+';
   const absOffset = Math.abs(offset);
   const hours = addLeadingZeros(Math.floor(absOffset / 60), 2);
   const minutes = addLeadingZeros(Math.floor(absOffset % 60), 2);
-  return sign + hours + delimeter + minutes;
+  return sign + hours + delimiter + minutes;
 }
 
-function formatTimezoneWithOptionalMinutes(offset: number, dirtyDelimeter?: string) {
+function formatTimezoneWithOptionalMinutes(offset: number, delimiter?: string) {
   if (offset % 60 === 0) {
     const sign = offset > 0 ? '-' : '+';
     return sign + addLeadingZeros(Math.abs(offset) / 60, 2);
   }
-  return formatTimezone(offset, dirtyDelimeter);
+  return formatTimezone(offset, delimiter);
 }
 
-function formatTimezoneShort(offset: number, dirtyDelimeter: string) {
+function formatTimezoneShort(offset: number, delimiter = '') {
   const sign = offset > 0 ? '-' : '+';
   const absOffset = Math.abs(offset);
   const hours = Math.floor(absOffset / 60);
@@ -159,8 +144,7 @@ function formatTimezoneShort(offset: number, dirtyDelimeter: string) {
   if (minutes === 0) {
     return sign + String(hours);
   }
-  const delimeter = dirtyDelimeter || '';
-  return sign + String(hours) + delimeter + addLeadingZeros(minutes, 2);
+  return sign + String(hours) + delimiter + addLeadingZeros(minutes, 2);
 }
 
-export default formatters;
+/* eslint-enable */

package/src/date-fns-tz/format/index.ts

@@ -1,9 +1,13 @@
-import { format as dateFnsFormat, type FormatOptions } from '../../date-fns/format';
-import type { OptionsWithTZ } from '../types';
-import formatters from './formatters';
-import toDate from '../toDate';
+/* eslint-disable eslint-comments/no-unlimited-disable */
+/* eslint-disable */
+// @ts-nocheck
 
-var tzFormattingTokensRegExp = /([xXOz]+)|''|'(''|[^'])+('|$)/g;
+import { format as dateFnsFormat } from '../../date-fns/format/index.ts';
+import { formatters } from './formatters/index.ts';
+import { toDate } from '../toDate/index.ts';
+import type { FormatOptionsWithTZ } from '../index.ts';
+
+const tzFormattingTokensRegExp = /([xXOz]+)|''|'(''|[^'])+('|$)/g;
 
 /**
  * @name format
@@ -273,9 +277,9 @@ var tzFormattingTokensRegExp = /([xXOz]+)|''|'(''|[^'])+('|$)/g;
  *
  * - Characters are now escaped using single quote symbols (`'`) instead of square brackets.
  *
- * @param {Date|String|Number} date - the original date
- * @param {String} format - the string of tokens
- * @param {OptionsWithTZ} [options] - the object with options. See [Options]{@link https://date-fns.org/docs/Options}
+ * @param date the original date
+ * @param formatStr the string of tokens
+ * @param options the object with options. See [Options]{@link https://date-fns.org/docs/Options}
  * @param {0|1|2} [options.additionalDigits=2] - passed to `toDate`. See [toDate]{@link
  *   https://date-fns.org/docs/toDate}
  * @param {0|1|2|3|4|5|6} [options.weekStartsOn=0] - the index of the first day of the week (0 - Sunday)
@@ -287,7 +291,8 @@ var tzFormattingTokensRegExp = /([xXOz]+)|''|'(''|[^'])+('|$)/g;
  *   - Some of the local week-numbering year tokens (`YY`, `YYYY`) that are confused with the calendar year tokens
  *   (`yy`, `yyyy`). See: https://git.io/fxCyr
  * @param {String} [options.timeZone=''] - used to specify the IANA time zone offset of a date String.
- * @returns {String} the formatted date string
+ * @param {Date|Number} [options.originalDate] - can be used to pass the original unmodified date to `format` to
+ *   improve correctness of the replaced timezone token close to the DST threshold.
  * @throws {TypeError} 2 arguments required
  * @throws {RangeError} `options.additionalDigits` must be 0, 1 or 2
  * @throws {RangeError} `options.locale` must contain `localize` property
@@ -299,50 +304,44 @@ var tzFormattingTokensRegExp = /([xXOz]+)|''|'(''|[^'])+('|$)/g;
  *
  * @example
  * // Represent 11 February 2014 in middle-endian format:
- * var result = format(new Date(2014, 1, 11), 'MM/dd/yyyy')
+ * const result = format(new Date(2014, 1, 11), 'MM/dd/yyyy')
  * //=> '02/11/2014'
  *
  * @example
  * // Represent 2 July 2014 in Esperanto:
  * import { eoLocale } from 'date-fns/locale/eo'
- * var result = format(new Date(2014, 6, 2), "do 'de' MMMM yyyy", {
+ * const result = format(new Date(2014, 6, 2), "do 'de' MMMM yyyy", {
  *   locale: eoLocale
  * })
  * //=> '2-a de julio 2014'
  *
  * @example
  * // Escape string by single quote characters:
- * var result = format(new Date(2014, 6, 2, 15), "h 'o''clock'")
+ * const result = format(new Date(2014, 6, 2, 15), "h 'o''clock'")
  * //=> "3 o'clock"
  */
-export default function format(
-  dirtyDate: Date | string | number,
-  dirtyFormatStr: string,
-  dirtyOptions?: OptionsWithTZ,
-): string {
-  var formatStr = String(dirtyFormatStr);
-  var options = dirtyOptions || ({} as OptionsWithTZ);
+export function format(date: Date | string | number, formatStr: string, options: FormatOptionsWithTZ = {}): string {
+  formatStr = String(formatStr);
 
-  var matches = formatStr.match(tzFormattingTokensRegExp);
+  const matches = formatStr.match(tzFormattingTokensRegExp);
   if (matches) {
-    var date = toDate(dirtyDate, options);
+    const d = toDate(options.originalDate || date, options);
     // Work through each match and replace the tz token in the format string with the quoted
     // formatted time zone so the remaining tokens can be filled in by date-fns#format.
     formatStr = matches.reduce(function (result, token) {
       if (token[0] === "'") {
         return result; // This is a quoted portion, matched only to ensure we don't match inside it
       }
-      var pos = result.indexOf(token);
-      var precededByQuotedSection = result[pos - 1] === "'";
-      var replaced = result.replace(
-        token,
-        "'" + formatters[token[0] as keyof typeof formatters](date, token, null, options) + "'",
-      );
+      const pos = result.indexOf(token);
+      const precededByQuotedSection = result[pos - 1] === "'";
+      const replaced = result.replace(token, "'" + formatters[token[0]](d, token, options) + "'");
       // If the replacement results in two adjoining quoted strings, the back to back quotes
       // are removed, so it doesn't look like an escaped quote.
       return precededByQuotedSection ? replaced.substring(0, pos - 1) + replaced.substring(pos + 1) : replaced;
     }, formatStr);
   }
 
-  return dateFnsFormat(dirtyDate as Date, formatStr, options as FormatOptions);
+  return dateFnsFormat(date, formatStr, options);
 }
+
+/* eslint-enable */

package/src/date-fns-tz/formatInTimeZone/index.ts

@@ -1,17 +1,20 @@
-import cloneObject from '../date-fns-v2-lib/cloneObject';
-import format from '../format';
-import type { OptionsWithTZ } from '../types';
-import utcToZonedTime from '../utcToZonedTime';
+/* eslint-disable eslint-comments/no-unlimited-disable */
+/* eslint-disable */
+// @ts-nocheck
+
+import { format } from '../format/index.ts';
+import { toZonedTime } from '../toZonedTime/index.ts';
+import type { FormatOptionsWithTZ } from '../index.ts';
 
 /**
  * @name formatInTimeZone
  * @category Time Zone Helpers
  * @summary Gets the offset in milliseconds between the time zone and Universal Coordinated Time (UTC)
  *
- * @param {Date|String|Number} date - the date representing the local time / real UTC time
- * @param {String} timeZone - the time zone this date should be formatted for; can be an offset or IANA time zone
- * @param {String} formatStr - the string of tokens
- * @param {OptionsWithTZ} [options] - the object with options. See [Options]{@link https://date-fns.org/docs/Options}
+ * @param date the date representing the local time / real UTC time
+ * @param timeZone the time zone this date should be formatted for; can be an offset or IANA time zone
+ * @param formatStr the string of tokens
+ * @param options the object with options. See [Options]{@link https://date-fns.org/docs/Options}
  * @param {0|1|2} [options.additionalDigits=2] - passed to `toDate`. See [toDate]{@link
  *   https://date-fns.org/docs/toDate}
  * @param {0|1|2|3|4|5|6} [options.weekStartsOn=0] - the index of the first day of the week (0 - Sunday)
@@ -23,15 +26,19 @@ import utcToZonedTime from '../utcToZonedTime';
  *   - Some of the local week-numbering year tokens (`YY`, `YYYY`) that are confused with the calendar year tokens
  *   (`yy`, `yyyy`). See: https://git.io/fxCyr
  * @param {String} [options.timeZone=''] - used to specify the IANA time zone offset of a date String.
- * @returns {String} the formatted date string
  */
-export default function formatInTimeZone(
+export function formatInTimeZone(
   date: Date | string | number,
   timeZone: string,
   formatStr: string,
-  options?: OptionsWithTZ,
+  options?: FormatOptionsWithTZ,
 ): string {
-  const extendedOptions = cloneObject(options) as OptionsWithTZ;
-  extendedOptions.timeZone = timeZone;
-  return format(utcToZonedTime(date, timeZone), formatStr, extendedOptions);
+  options = {
+    ...options,
+    timeZone,
+    originalDate: date,
+  };
+  return format(toZonedTime(date, timeZone, { timeZone: options.timeZone }), formatStr, options);
 }
+
+/* eslint-enable */

package/src/date-fns-tz/fromZonedTime/index.ts

@@ -0,0 +1,56 @@
+/* eslint-disable eslint-comments/no-unlimited-disable */
+/* eslint-disable */
+// @ts-nocheck
+
+import { toDate } from '../toDate/index.ts';
+import { tzPattern } from '../_lib/tzPattern/index.ts';
+import { tzParseTimezone } from '../_lib/tzParseTimezone/index.ts';
+import { newDateUTC } from '../_lib/newDateUTC/index.ts';
+import type { ToDateOptionsWithTZ } from '../index.ts';
+
+/**
+ * @name fromZonedTime
+ * @category Time Zone Helpers
+ * @summary Get the UTC date/time from a date representing local time in a given time zone
+ *
+ * @description
+ * Returns a date instance with the UTC time of the provided date of which the values
+ * represented the local time in the time zone specified. In other words, if the input
+ * date represented local time in time zone, the timestamp of the output date will
+ * give the equivalent UTC of that local time regardless of the current system time zone.
+ *
+ * @param date the date with values representing the local time
+ * @param timeZone the time zone of this local time, can be an offset or IANA time zone
+ * @param options the object with options. See [Options]{@link https://date-fns.org/docs/Options}
+ * @param {0|1|2} [options.additionalDigits=2] - passed to `toDate`. See [toDate]{@link https://date-fns.org/docs/toDate}
+ * @throws {TypeError} 2 arguments required
+ * @throws {RangeError} `options.additionalDigits` must be 0, 1 or 2
+ *
+ * @example
+ * // In June 10am in Los Angeles is 5pm UTC
+ * const result = fromZonedTime(new Date(2014, 5, 25, 10, 0, 0), 'America/Los_Angeles')
+ * //=> 2014-06-25T17:00:00.000Z
+ */
+export function fromZonedTime(date: Date | string | number, timeZone: string, options?: ToDateOptionsWithTZ): Date {
+  if (typeof date === 'string' && !date.match(tzPattern)) {
+    return toDate(date, { ...options, timeZone });
+  }
+
+  date = toDate(date, options);
+
+  const utc = newDateUTC(
+    date.getFullYear(),
+    date.getMonth(),
+    date.getDate(),
+    date.getHours(),
+    date.getMinutes(),
+    date.getSeconds(),
+    date.getMilliseconds(),
+  ).getTime();
+
+  const offsetMilliseconds = tzParseTimezone(timeZone, new Date(utc));
+
+  return new Date(utc + offsetMilliseconds);
+}
+
+/* eslint-enable */

package/src/date-fns-tz/getTimezoneOffset/index.ts

@@ -1,4 +1,8 @@
-import tzParseTimezone from '../_lib/tzParseTimezone';
+/* eslint-disable eslint-comments/no-unlimited-disable */
+/* eslint-disable */
+// @ts-nocheck
+
+import { tzParseTimezone } from '../_lib/tzParseTimezone/index.ts';
 
 /**
  * @name getTimezoneOffset
@@ -13,9 +17,8 @@ import tzParseTimezone from '../_lib/tzParseTimezone';
  * the second parameter to ensure the offset correctly accounts for DST at that time of
  * year. When omitted, the current date is used.
  *
- * @param {String} timeZone - the time zone of this local time, can be an offset or IANA time zone
- * @param {Date|Number} [date] - the date with values representing the local time
- * @returns {Number} the time zone offset in milliseconds
+ * @param timeZone the time zone of this local time, can be an offset or IANA time zone
+ * @param date the date with values representing the local time
  *
  * @example
  * const result = getTimezoneOffset('-07:00')
@@ -27,6 +30,8 @@ import tzParseTimezone from '../_lib/tzParseTimezone';
  * const result = getTimezoneOffset('America/New_York', new Date(2016, 6, 1))
  *   //=> -14400000 (-4 * 60 * 60 * 1000)
  */
-export default function getTimezoneOffset(timeZone: string, date: Date | number): number {
-  return -tzParseTimezone(timeZone, date as Date);
+export function getTimezoneOffset(timeZone: string, date?: Date | number): number {
+  return -tzParseTimezone(timeZone, date);
 }
+
+/* eslint-enable */

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

@@ -1,6 +1,24 @@
-export { default as tzFormat } from './format';
-export { default as tzFormatInTimeZone } from './formatInTimeZone';
-export { default as tzGetTimezoneOffset } from './getTimezoneOffset';
-export { default as tzToDate } from './toDate';
-export { default as tzUtcToZonedTime } from './utcToZonedTime';
-export { default as tzZonedTimeToUtc } from './zonedTimeToUtc';
+/* eslint-disable eslint-comments/no-unlimited-disable */
+/* eslint-disable */
+// @ts-nocheck
+
+import type { FormatOptions, ParseISOOptions, Locale } from '../date-fns/index.ts';
+
+export interface FormatOptionsWithTZ extends Omit<FormatOptions, 'locale'> {
+  locale?: FormatOptions['locale'] & Pick<Locale, 'code'>;
+  timeZone?: string;
+  originalDate?: Date | string | number;
+}
+
+export interface ToDateOptionsWithTZ extends ParseISOOptions {
+  timeZone?: string;
+}
+
+export { format as tzFormat } from './format/index.ts';
+export { formatInTimeZone as tzFormatInTimeZone } from './formatInTimeZone/index.ts';
+export { fromZonedTime as tzZonedTimeToUtc } from './fromZonedTime/index.ts';
+export { toZonedTime as tzUtcToZonedTime } from './toZonedTime/index.ts';
+export { getTimezoneOffset as getTimezoneOffset } from './getTimezoneOffset/index.ts';
+export { toDate as tzToDate } from './toDate/index.ts';
+
+/* eslint-enable */