@koine/browser 2.0.0-beta.121 → 2.0.0-beta.123

package/getZonedDate.cjs.js

@@ -2,9 +2,659 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var dateFnsTz = require('date-fns-tz');
 var utils = require('@koine/utils');
 
+/**
+ * Returns the [year, month, day, hour, minute, seconds] tokens of the provided
+ * `date` as it will be rendered in the `timeZone`.
+ */ function _instanceof$1(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function tzTokenizeDate(date, timeZone) {
+    var dtf = getDateTimeFormat(timeZone);
+    return 'formatToParts' in dtf ? partsOffset(dtf, date) : hackyOffset(dtf, date);
+}
+var typeToPos = {
+    year: 0,
+    month: 1,
+    day: 2,
+    hour: 3,
+    minute: 4,
+    second: 5
+};
+function partsOffset(dtf, date) {
+    try {
+        var formatted = dtf.formatToParts(date);
+        var filled = [];
+        for(var i = 0; i < formatted.length; i++){
+            var pos = typeToPos[formatted[i].type];
+            if (pos !== undefined) {
+                filled[pos] = parseInt(formatted[i].value, 10);
+            }
+        }
+        return filled;
+    } catch (error) {
+        if (_instanceof$1(error, RangeError)) {
+            return [
+                NaN
+            ];
+        }
+        throw error;
+    }
+}
+function hackyOffset(dtf, date) {
+    var formatted = dtf.format(date);
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    var 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.
+var dtfCache = {};
+function getDateTimeFormat(timeZone) {
+    if (!dtfCache[timeZone]) {
+        // New browsers use `hourCycle`, IE and Chrome <73 does not support it and uses `hour12`
+        var 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'));
+        var hourCycleSupported = testDateFormatted === '06/25/2014, 00:00:00' || testDateFormatted === '‎06‎/‎25‎/‎2014‎ ‎00‎:‎00‎:‎00';
+        dtfCache[timeZone] = hourCycleSupported ? new Intl.DateTimeFormat('en-US', {
+            hourCycle: 'h23',
+            timeZone: timeZone,
+            year: 'numeric',
+            month: 'numeric',
+            day: '2-digit',
+            hour: '2-digit',
+            minute: '2-digit',
+            second: '2-digit'
+        }) : new Intl.DateTimeFormat('en-US', {
+            hour12: false,
+            timeZone: timeZone,
+            year: 'numeric',
+            month: 'numeric',
+            day: '2-digit',
+            hour: '2-digit',
+            minute: '2-digit',
+            second: '2-digit'
+        });
+    }
+    return dtfCache[timeZone];
+}
+
+/**
+ * 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()`.
+ */ function newDateUTC(fullYear, month, day, hour, minute, second, millisecond) {
+    var utcDate = new Date(0);
+    utcDate.setUTCFullYear(fullYear, month, day);
+    utcDate.setUTCHours(hour, minute, second, millisecond);
+    return utcDate;
+}
+
+var MILLISECONDS_IN_HOUR$1 = 3600000;
+var MILLISECONDS_IN_MINUTE$1 = 60000;
+var patterns$1 = {
+    timezone: /([Z+-].*)$/,
+    timezoneZ: /^(Z)$/,
+    timezoneHH: /^([+-]\d{2})$/,
+    timezoneHHMM: /^([+-])(\d{2}):?(\d{2})$/
+};
+// Parse constious time zone offset formats to an offset in milliseconds
+function tzParseTimezone(timezoneString, date, isUtcDate) {
+    // Empty string
+    if (!timezoneString) {
+        return 0;
+    }
+    // Z
+    var token = patterns$1.timezoneZ.exec(timezoneString);
+    if (token) {
+        return 0;
+    }
+    var hours;
+    var absoluteOffset;
+    // ±hh
+    token = patterns$1.timezoneHH.exec(timezoneString);
+    if (token) {
+        hours = parseInt(token[1], 10);
+        if (!validateTimezone(hours)) {
+            return NaN;
+        }
+        return -(hours * MILLISECONDS_IN_HOUR$1);
+    }
+    // ±hh:mm or ±hhmm
+    token = patterns$1.timezoneHHMM.exec(timezoneString);
+    if (token) {
+        hours = parseInt(token[2], 10);
+        var minutes = parseInt(token[3], 10);
+        if (!validateTimezone(hours, minutes)) {
+            return NaN;
+        }
+        absoluteOffset = Math.abs(hours) * MILLISECONDS_IN_HOUR$1 + minutes * MILLISECONDS_IN_MINUTE$1;
+        return token[1] === '+' ? -absoluteOffset : absoluteOffset;
+    }
+    // IANA time zone
+    if (isValidTimezoneIANAString(timezoneString)) {
+        date = new Date(date || Date.now());
+        var utcDate = isUtcDate ? date : toUtcDate(date);
+        var offset = calcOffset(utcDate, timezoneString);
+        var fixedOffset = isUtcDate ? offset : fixOffset(date, offset, timezoneString);
+        return -fixedOffset;
+    }
+    return NaN;
+}
+function toUtcDate(date) {
+    return newDateUTC(date.getFullYear(), date.getMonth(), date.getDate(), date.getHours(), date.getMinutes(), date.getSeconds(), date.getMilliseconds());
+}
+function calcOffset(date, timezoneString) {
+    var tokens = tzTokenizeDate(date, timezoneString);
+    // ms dropped because it's not provided by tzTokenizeDate
+    var asUTC = newDateUTC(tokens[0], tokens[1] - 1, tokens[2], tokens[3] % 24, tokens[4], tokens[5], 0).getTime();
+    var asTS = date.getTime();
+    var over = asTS % 1000;
+    asTS -= over >= 0 ? over : 1000 + over;
+    return asUTC - asTS;
+}
+function fixOffset(date, offset, timezoneString) {
+    var localTS = date.getTime();
+    // Our UTC time is just a guess because our offset is just a guess
+    var utcGuess = localTS - offset;
+    // Test whether the zone matches the offset for this ts
+    var o2 = calcOffset(new Date(utcGuess), timezoneString);
+    // If so, offset didn't change, and we're done
+    if (offset === o2) {
+        return offset;
+    }
+    // If not, change the ts by the difference in the offset
+    utcGuess -= o2 - offset;
+    // If that gives us the local time we want, we're done
+    var o3 = calcOffset(new Date(utcGuess), timezoneString);
+    if (o2 === o3) {
+        return o2;
+    }
+    // If it's different, we're in a hole time. The offset has changed, but we don't adjust the time
+    return Math.max(o2, o3);
+}
+function validateTimezone(hours, minutes) {
+    return -23 <= hours && hours <= 23 && (minutes == null || 0 <= minutes && minutes <= 59);
+}
+var validIANATimezoneCache = {};
+function isValidTimezoneIANAString(timeZoneString) {
+    if (validIANATimezoneCache[timeZoneString]) return true;
+    try {
+        new Intl.DateTimeFormat(undefined, {
+            timeZone: timeZoneString
+        });
+        validIANATimezoneCache[timeZoneString] = true;
+        return true;
+    } catch (error) {
+        return false;
+    }
+}
+
+/**
+ * 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
+ * (e.g. for 'Europe/Prague' timezone the offset is GMT+00:57:44 before 1 October 1891
+ * and GMT+01:00:00 after that date)
+ *
+ * Date#getTimezoneOffset returns the offset in minutes and would return 57 for the example above,
+ * which would lead to incorrect calculations.
+ *
+ * This function returns the timezone offset in milliseconds that takes seconds in account.
+ */ function getTimezoneOffsetInMilliseconds(date) {
+    var utcDate = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate(), date.getHours(), date.getMinutes(), date.getSeconds(), date.getMilliseconds()));
+    utcDate.setUTCFullYear(date.getFullYear());
+    return +date - +utcDate;
+}
+
+/** Regex to identify the presence of a time zone specifier in a date string */ var tzPattern = /(Z|[+-]\d{2}(?::?\d{2})?| UTC| [a-zA-Z]+\/[a-zA-Z_]+(?:\/[a-zA-Z_]+)?)$/;
+
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+var MILLISECONDS_IN_HOUR = 3600000;
+var MILLISECONDS_IN_MINUTE = 60000;
+var DEFAULT_ADDITIONAL_DIGITS = 2;
+var patterns = {
+    dateTimePattern: /^([0-9W+-]+)(T| )(.*)/,
+    datePattern: /^([0-9W+-]+)(.*)/,
+    plainTime: /:/,
+    // year tokens
+    YY: /^(\d{2})$/,
+    YYY: [
+        /^([+-]\d{2})$/,
+        /^([+-]\d{3})$/,
+        /^([+-]\d{4})$/
+    ],
+    YYYY: /^(\d{4})/,
+    YYYYY: [
+        /^([+-]\d{4})/,
+        /^([+-]\d{5})/,
+        /^([+-]\d{6})/
+    ],
+    // date tokens
+    MM: /^-(\d{2})$/,
+    DDD: /^-?(\d{3})$/,
+    MMDD: /^-?(\d{2})-?(\d{2})$/,
+    Www: /^-?W(\d{2})$/,
+    WwwD: /^-?W(\d{2})-?(\d{1})$/,
+    HH: /^(\d{2}([.,]\d*)?)$/,
+    HHMM: /^(\d{2}):?(\d{2}([.,]\d*)?)$/,
+    HHMMSS: /^(\d{2}):?(\d{2}):?(\d{2}([.,]\d*)?)$/,
+    // time zone tokens (to identify the presence of a tz)
+    timeZone: tzPattern
+};
+/**
+ * @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 an argument is a string, the function tries to parse it.
+ * Function accepts complete ISO 8601 formats as well as partial implementations.
+ * ISO 8601: http://en.wikipedia.org/wiki/ISO_8601
+ * If the function cannot parse the string or the values are invalid, it returns Invalid Date.
+ *
+ * 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`.
+ * All *date-fns* functions will throw `RangeError` if `options.additionalDigits` is not 0, 1, 2 or undefined.
+ *
+ * @param argument the value to convert
+ * @param options the object with options. See [Options]{@link https://date-fns.org/docs/Options}
+ * @param {0|1|2} [options.additionalDigits=2] - the additional number of digits in the extended year format
+ * @param {string} [options.timeZone=''] - used to specify the IANA time zone offset of a date String.
+ *
+ * @returns the parsed date in the local time zone
+ * @throws {TypeError} 1 argument required
+ * @throws {RangeError} `options.additionalDigits` must be 0, 1 or 2
+ *
+ * @example
+ * // Convert string '2014-02-11T11:30:30' to date:
+ * const result = toDate('2014-02-11T11:30:30')
+ * //=> Tue Feb 11 2014 11:30:30
+ *
+ * @example
+ * // Convert string '+02014101' to date,
+ * // if the additional number of digits in the extended year format is 1:
+ * const result = toDate('+02014101', {additionalDigits: 1})
+ * //=> Fri Apr 11 2014 00:00:00
+ */ function toDate(argument) {
+    var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+    if (arguments.length < 1) {
+        throw new TypeError('1 argument required, but only ' + arguments.length + ' present');
+    }
+    if (argument === null) {
+        return new Date(NaN);
+    }
+    var additionalDigits = options.additionalDigits == null ? DEFAULT_ADDITIONAL_DIGITS : Number(options.additionalDigits);
+    if (additionalDigits !== 2 && additionalDigits !== 1 && additionalDigits !== 0) {
+        throw new RangeError('additionalDigits must be 0, 1 or 2');
+    }
+    // Clone the date
+    if (_instanceof(argument, Date) || typeof argument === 'object' && Object.prototype.toString.call(argument) === '[object Date]') {
+        // Prevent the date to lose the milliseconds when passed to new Date() in IE10
+        return new Date(argument.getTime());
+    } else if (typeof argument === 'number' || Object.prototype.toString.call(argument) === '[object Number]') {
+        return new Date(argument);
+    } else if (!(Object.prototype.toString.call(argument) === '[object String]')) {
+        return new Date(NaN);
+    }
+    var dateStrings = splitDateString(argument);
+    var _parseYear = parseYear(dateStrings.date, additionalDigits), year = _parseYear.year, restDateString = _parseYear.restDateString;
+    var date = parseDate(restDateString, year);
+    if (date === null || isNaN(date.getTime())) {
+        return new Date(NaN);
+    }
+    if (date) {
+        var timestamp = date.getTime();
+        var time = 0;
+        var offset;
+        if (dateStrings.time) {
+            time = parseTime(dateStrings.time);
+            if (time === null || isNaN(time)) {
+                return new Date(NaN);
+            }
+        }
+        if (dateStrings.timeZone || options.timeZone) {
+            offset = tzParseTimezone(dateStrings.timeZone || options.timeZone, new Date(timestamp + time));
+            if (isNaN(offset)) {
+                return new Date(NaN);
+            }
+        } else {
+            // get offset accurate to hour in time zones that change offset
+            offset = getTimezoneOffsetInMilliseconds(new Date(timestamp + time));
+            offset = getTimezoneOffsetInMilliseconds(new Date(timestamp + time + offset));
+        }
+        return new Date(timestamp + time + offset);
+    } else {
+        return new Date(NaN);
+    }
+}
+function splitDateString(dateString) {
+    var dateStrings = {};
+    var parts = patterns.dateTimePattern.exec(dateString);
+    var timeString;
+    if (!parts) {
+        parts = patterns.datePattern.exec(dateString);
+        if (parts) {
+            dateStrings.date = parts[1];
+            timeString = parts[2];
+        } else {
+            dateStrings.date = null;
+            timeString = dateString;
+        }
+    } else {
+        dateStrings.date = parts[1];
+        timeString = parts[3];
+    }
+    if (timeString) {
+        var token = patterns.timeZone.exec(timeString);
+        if (token) {
+            dateStrings.time = timeString.replace(token[1], '');
+            dateStrings.timeZone = token[1].trim();
+        } else {
+            dateStrings.time = timeString;
+        }
+    }
+    return dateStrings;
+}
+function parseYear(dateString, additionalDigits) {
+    if (dateString) {
+        var patternYYY = patterns.YYY[additionalDigits];
+        var patternYYYYY = patterns.YYYYY[additionalDigits];
+        // YYYY or ±YYYYY
+        var token = patterns.YYYY.exec(dateString) || patternYYYYY.exec(dateString);
+        if (token) {
+            var yearString = token[1];
+            return {
+                year: parseInt(yearString, 10),
+                restDateString: dateString.slice(yearString.length)
+            };
+        }
+        // YY or ±YYY
+        token = patterns.YY.exec(dateString) || patternYYY.exec(dateString);
+        if (token) {
+            var centuryString = token[1];
+            return {
+                year: parseInt(centuryString, 10) * 100,
+                restDateString: dateString.slice(centuryString.length)
+            };
+        }
+    }
+    // Invalid ISO-formatted year
+    return {
+        year: null
+    };
+}
+function parseDate(dateString, year) {
+    // Invalid ISO-formatted year
+    if (year === null) {
+        return null;
+    }
+    var date;
+    var month;
+    var week;
+    // YYYY
+    if (!dateString || !dateString.length) {
+        date = new Date(0);
+        date.setUTCFullYear(year);
+        return date;
+    }
+    // YYYY-MM
+    var token = patterns.MM.exec(dateString);
+    if (token) {
+        date = new Date(0);
+        month = parseInt(token[1], 10) - 1;
+        if (!validateDate(year, month)) {
+            return new Date(NaN);
+        }
+        date.setUTCFullYear(year, month);
+        return date;
+    }
+    // YYYY-DDD or YYYYDDD
+    token = patterns.DDD.exec(dateString);
+    if (token) {
+        date = new Date(0);
+        var dayOfYear = parseInt(token[1], 10);
+        if (!validateDayOfYearDate(year, dayOfYear)) {
+            return new Date(NaN);
+        }
+        date.setUTCFullYear(year, 0, dayOfYear);
+        return date;
+    }
+    // yyyy-MM-dd or YYYYMMDD
+    token = patterns.MMDD.exec(dateString);
+    if (token) {
+        date = new Date(0);
+        month = parseInt(token[1], 10) - 1;
+        var day = parseInt(token[2], 10);
+        if (!validateDate(year, month, day)) {
+            return new Date(NaN);
+        }
+        date.setUTCFullYear(year, month, day);
+        return date;
+    }
+    // YYYY-Www or YYYYWww
+    token = patterns.Www.exec(dateString);
+    if (token) {
+        week = parseInt(token[1], 10) - 1;
+        if (!validateWeekDate(week)) {
+            return new Date(NaN);
+        }
+        return dayOfISOWeekYear(year, week);
+    }
+    // YYYY-Www-D or YYYYWwwD
+    token = patterns.WwwD.exec(dateString);
+    if (token) {
+        week = parseInt(token[1], 10) - 1;
+        var dayOfWeek = parseInt(token[2], 10) - 1;
+        if (!validateWeekDate(week, dayOfWeek)) {
+            return new Date(NaN);
+        }
+        return dayOfISOWeekYear(year, week, dayOfWeek);
+    }
+    // Invalid ISO-formatted date
+    return null;
+}
+function parseTime(timeString) {
+    var hours;
+    var minutes;
+    // hh
+    var token = patterns.HH.exec(timeString);
+    if (token) {
+        hours = parseFloat(token[1].replace(',', '.'));
+        if (!validateTime(hours)) {
+            return NaN;
+        }
+        return hours % 24 * MILLISECONDS_IN_HOUR;
+    }
+    // hh:mm or hhmm
+    token = patterns.HHMM.exec(timeString);
+    if (token) {
+        hours = parseInt(token[1], 10);
+        minutes = parseFloat(token[2].replace(',', '.'));
+        if (!validateTime(hours, minutes)) {
+            return NaN;
+        }
+        return hours % 24 * MILLISECONDS_IN_HOUR + minutes * MILLISECONDS_IN_MINUTE;
+    }
+    // hh:mm:ss or hhmmss
+    token = patterns.HHMMSS.exec(timeString);
+    if (token) {
+        hours = parseInt(token[1], 10);
+        minutes = parseInt(token[2], 10);
+        var seconds = parseFloat(token[3].replace(',', '.'));
+        if (!validateTime(hours, minutes, seconds)) {
+            return NaN;
+        }
+        return hours % 24 * MILLISECONDS_IN_HOUR + minutes * MILLISECONDS_IN_MINUTE + seconds * 1000;
+    }
+    // Invalid ISO-formatted time
+    return null;
+}
+function dayOfISOWeekYear(isoWeekYear, week, day) {
+    week = week || 0;
+    day = day || 0;
+    var date = new Date(0);
+    date.setUTCFullYear(isoWeekYear, 0, 4);
+    var fourthOfJanuaryDay = date.getUTCDay() || 7;
+    var diff = week * 7 + day + 1 - fourthOfJanuaryDay;
+    date.setUTCDate(date.getUTCDate() + diff);
+    return date;
+}
+// Validation functions
+var DAYS_IN_MONTH = [
+    31,
+    28,
+    31,
+    30,
+    31,
+    30,
+    31,
+    31,
+    30,
+    31,
+    30,
+    31
+];
+var DAYS_IN_MONTH_LEAP_YEAR = [
+    31,
+    29,
+    31,
+    30,
+    31,
+    30,
+    31,
+    31,
+    30,
+    31,
+    30,
+    31
+];
+function isLeapYearIndex(year) {
+    return year % 400 === 0 || year % 4 === 0 && year % 100 !== 0;
+}
+function validateDate(year, month, date) {
+    if (month < 0 || month > 11) {
+        return false;
+    }
+    if (date != null) {
+        if (date < 1) {
+            return false;
+        }
+        var isLeapYear = isLeapYearIndex(year);
+        if (isLeapYear && date > DAYS_IN_MONTH_LEAP_YEAR[month]) {
+            return false;
+        }
+        if (!isLeapYear && date > DAYS_IN_MONTH[month]) {
+            return false;
+        }
+    }
+    return true;
+}
+function validateDayOfYearDate(year, dayOfYear) {
+    if (dayOfYear < 1) {
+        return false;
+    }
+    var isLeapYear = isLeapYearIndex(year);
+    if (isLeapYear && dayOfYear > 366) {
+        return false;
+    }
+    if (!isLeapYear && dayOfYear > 365) {
+        return false;
+    }
+    return true;
+}
+function validateWeekDate(week, day) {
+    if (week < 0 || week > 52) {
+        return false;
+    }
+    if (day != null && (day < 0 || day > 6)) {
+        return false;
+    }
+    return true;
+}
+function validateTime(hours, minutes, seconds) {
+    if (hours < 0 || hours >= 25) {
+        return false;
+    }
+    if (minutes != null && (minutes < 0 || minutes >= 60)) {
+        return false;
+    }
+    if (seconds != null && (seconds < 0 || seconds >= 60)) {
+        return false;
+    }
+    return true;
+}
+
+/**
+ * @name toZonedTime
+ * @category Time Zone Helpers
+ * @summary Get a date/time representing local time in a given time zone from the UTC date
+ *
+ * @description
+ * Returns a date instance with values representing the local time in the time zone
+ * specified of the UTC time from the date provided. In other words, when the new date
+ * is formatted it will show the equivalent hours in the target time zone regardless
+ * of the current system time zone.
+ *
+ * @param date the date with the relevant UTC time
+ * @param timeZone the time zone to get local time for, 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 UTC is 6am in New York (-04:00)
+ * const result = toZonedTime('2014-06-25T10:00:00.000Z', 'America/New_York')
+ * //=> Jun 25 2014 06:00:00
+ */ function toZonedTime(date, timeZone, options) {
+    date = toDate(date, options);
+    var offsetMilliseconds = tzParseTimezone(timeZone, date, true);
+    var d = new Date(date.getTime() - offsetMilliseconds);
+    var resultDate = new Date(0);
+    resultDate.setFullYear(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate());
+    resultDate.setHours(d.getUTCHours(), d.getUTCMinutes(), d.getUTCSeconds(), d.getUTCMilliseconds());
+    return resultDate;
+}
+
 /**
  * It returns a `Date` object from a date `string` adjusted on the user timeZone,
  * if a timeZone is not provided we try getting it from the `Intl` browwser native
@@ -20,7 +670,7 @@ var utils = require('@koine/utils');
  * @param timeZone Optionally pass a timeZone (e.g. from user preference or from the server), it falls back trying to read it from the `Intl` browwser native API.
  */let getZonedDate=(o="",n)=>{if(o.endsWith("Z")||(o+="Z"),!n&&utils.isBrowser)try{n=Intl.DateTimeFormat().resolvedOptions().timeZone;}catch(e){"development"===process.env.NODE_ENV&&console.warn("[@koine/browser:getZonedDate] failed reading timeZone, error",e);}// no need to do anything here, it just means `Intl` failed, probably
 // because the browser does not support it
-return n?dateFnsTz.toZonedTime(new Date(o),n):new Date(o)};
+return n?toZonedTime(new Date(o),n):new Date(o)};
 
 exports.default = getZonedDate;
 exports.getZonedDate = getZonedDate;

package/getZonedDate.esm.js

@@ -1,6 +1,656 @@
-import { toZonedTime } from 'date-fns-tz';
 import { isBrowser } from '@koine/utils';
 
+/**
+ * Returns the [year, month, day, hour, minute, seconds] tokens of the provided
+ * `date` as it will be rendered in the `timeZone`.
+ */ function _instanceof$1(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function tzTokenizeDate(date, timeZone) {
+    var dtf = getDateTimeFormat(timeZone);
+    return 'formatToParts' in dtf ? partsOffset(dtf, date) : hackyOffset(dtf, date);
+}
+var typeToPos = {
+    year: 0,
+    month: 1,
+    day: 2,
+    hour: 3,
+    minute: 4,
+    second: 5
+};
+function partsOffset(dtf, date) {
+    try {
+        var formatted = dtf.formatToParts(date);
+        var filled = [];
+        for(var i = 0; i < formatted.length; i++){
+            var pos = typeToPos[formatted[i].type];
+            if (pos !== undefined) {
+                filled[pos] = parseInt(formatted[i].value, 10);
+            }
+        }
+        return filled;
+    } catch (error) {
+        if (_instanceof$1(error, RangeError)) {
+            return [
+                NaN
+            ];
+        }
+        throw error;
+    }
+}
+function hackyOffset(dtf, date) {
+    var formatted = dtf.format(date);
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    var 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.
+var dtfCache = {};
+function getDateTimeFormat(timeZone) {
+    if (!dtfCache[timeZone]) {
+        // New browsers use `hourCycle`, IE and Chrome <73 does not support it and uses `hour12`
+        var 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'));
+        var hourCycleSupported = testDateFormatted === '06/25/2014, 00:00:00' || testDateFormatted === '‎06‎/‎25‎/‎2014‎ ‎00‎:‎00‎:‎00';
+        dtfCache[timeZone] = hourCycleSupported ? new Intl.DateTimeFormat('en-US', {
+            hourCycle: 'h23',
+            timeZone: timeZone,
+            year: 'numeric',
+            month: 'numeric',
+            day: '2-digit',
+            hour: '2-digit',
+            minute: '2-digit',
+            second: '2-digit'
+        }) : new Intl.DateTimeFormat('en-US', {
+            hour12: false,
+            timeZone: timeZone,
+            year: 'numeric',
+            month: 'numeric',
+            day: '2-digit',
+            hour: '2-digit',
+            minute: '2-digit',
+            second: '2-digit'
+        });
+    }
+    return dtfCache[timeZone];
+}
+
+/**
+ * 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()`.
+ */ function newDateUTC(fullYear, month, day, hour, minute, second, millisecond) {
+    var utcDate = new Date(0);
+    utcDate.setUTCFullYear(fullYear, month, day);
+    utcDate.setUTCHours(hour, minute, second, millisecond);
+    return utcDate;
+}
+
+var MILLISECONDS_IN_HOUR$1 = 3600000;
+var MILLISECONDS_IN_MINUTE$1 = 60000;
+var patterns$1 = {
+    timezone: /([Z+-].*)$/,
+    timezoneZ: /^(Z)$/,
+    timezoneHH: /^([+-]\d{2})$/,
+    timezoneHHMM: /^([+-])(\d{2}):?(\d{2})$/
+};
+// Parse constious time zone offset formats to an offset in milliseconds
+function tzParseTimezone(timezoneString, date, isUtcDate) {
+    // Empty string
+    if (!timezoneString) {
+        return 0;
+    }
+    // Z
+    var token = patterns$1.timezoneZ.exec(timezoneString);
+    if (token) {
+        return 0;
+    }
+    var hours;
+    var absoluteOffset;
+    // ±hh
+    token = patterns$1.timezoneHH.exec(timezoneString);
+    if (token) {
+        hours = parseInt(token[1], 10);
+        if (!validateTimezone(hours)) {
+            return NaN;
+        }
+        return -(hours * MILLISECONDS_IN_HOUR$1);
+    }
+    // ±hh:mm or ±hhmm
+    token = patterns$1.timezoneHHMM.exec(timezoneString);
+    if (token) {
+        hours = parseInt(token[2], 10);
+        var minutes = parseInt(token[3], 10);
+        if (!validateTimezone(hours, minutes)) {
+            return NaN;
+        }
+        absoluteOffset = Math.abs(hours) * MILLISECONDS_IN_HOUR$1 + minutes * MILLISECONDS_IN_MINUTE$1;
+        return token[1] === '+' ? -absoluteOffset : absoluteOffset;
+    }
+    // IANA time zone
+    if (isValidTimezoneIANAString(timezoneString)) {
+        date = new Date(date || Date.now());
+        var utcDate = isUtcDate ? date : toUtcDate(date);
+        var offset = calcOffset(utcDate, timezoneString);
+        var fixedOffset = isUtcDate ? offset : fixOffset(date, offset, timezoneString);
+        return -fixedOffset;
+    }
+    return NaN;
+}
+function toUtcDate(date) {
+    return newDateUTC(date.getFullYear(), date.getMonth(), date.getDate(), date.getHours(), date.getMinutes(), date.getSeconds(), date.getMilliseconds());
+}
+function calcOffset(date, timezoneString) {
+    var tokens = tzTokenizeDate(date, timezoneString);
+    // ms dropped because it's not provided by tzTokenizeDate
+    var asUTC = newDateUTC(tokens[0], tokens[1] - 1, tokens[2], tokens[3] % 24, tokens[4], tokens[5], 0).getTime();
+    var asTS = date.getTime();
+    var over = asTS % 1000;
+    asTS -= over >= 0 ? over : 1000 + over;
+    return asUTC - asTS;
+}
+function fixOffset(date, offset, timezoneString) {
+    var localTS = date.getTime();
+    // Our UTC time is just a guess because our offset is just a guess
+    var utcGuess = localTS - offset;
+    // Test whether the zone matches the offset for this ts
+    var o2 = calcOffset(new Date(utcGuess), timezoneString);
+    // If so, offset didn't change, and we're done
+    if (offset === o2) {
+        return offset;
+    }
+    // If not, change the ts by the difference in the offset
+    utcGuess -= o2 - offset;
+    // If that gives us the local time we want, we're done
+    var o3 = calcOffset(new Date(utcGuess), timezoneString);
+    if (o2 === o3) {
+        return o2;
+    }
+    // If it's different, we're in a hole time. The offset has changed, but we don't adjust the time
+    return Math.max(o2, o3);
+}
+function validateTimezone(hours, minutes) {
+    return -23 <= hours && hours <= 23 && (minutes == null || 0 <= minutes && minutes <= 59);
+}
+var validIANATimezoneCache = {};
+function isValidTimezoneIANAString(timeZoneString) {
+    if (validIANATimezoneCache[timeZoneString]) return true;
+    try {
+        new Intl.DateTimeFormat(undefined, {
+            timeZone: timeZoneString
+        });
+        validIANATimezoneCache[timeZoneString] = true;
+        return true;
+    } catch (error) {
+        return false;
+    }
+}
+
+/**
+ * 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
+ * (e.g. for 'Europe/Prague' timezone the offset is GMT+00:57:44 before 1 October 1891
+ * and GMT+01:00:00 after that date)
+ *
+ * Date#getTimezoneOffset returns the offset in minutes and would return 57 for the example above,
+ * which would lead to incorrect calculations.
+ *
+ * This function returns the timezone offset in milliseconds that takes seconds in account.
+ */ function getTimezoneOffsetInMilliseconds(date) {
+    var utcDate = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate(), date.getHours(), date.getMinutes(), date.getSeconds(), date.getMilliseconds()));
+    utcDate.setUTCFullYear(date.getFullYear());
+    return +date - +utcDate;
+}
+
+/** Regex to identify the presence of a time zone specifier in a date string */ var tzPattern = /(Z|[+-]\d{2}(?::?\d{2})?| UTC| [a-zA-Z]+\/[a-zA-Z_]+(?:\/[a-zA-Z_]+)?)$/;
+
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+var MILLISECONDS_IN_HOUR = 3600000;
+var MILLISECONDS_IN_MINUTE = 60000;
+var DEFAULT_ADDITIONAL_DIGITS = 2;
+var patterns = {
+    dateTimePattern: /^([0-9W+-]+)(T| )(.*)/,
+    datePattern: /^([0-9W+-]+)(.*)/,
+    plainTime: /:/,
+    // year tokens
+    YY: /^(\d{2})$/,
+    YYY: [
+        /^([+-]\d{2})$/,
+        /^([+-]\d{3})$/,
+        /^([+-]\d{4})$/
+    ],
+    YYYY: /^(\d{4})/,
+    YYYYY: [
+        /^([+-]\d{4})/,
+        /^([+-]\d{5})/,
+        /^([+-]\d{6})/
+    ],
+    // date tokens
+    MM: /^-(\d{2})$/,
+    DDD: /^-?(\d{3})$/,
+    MMDD: /^-?(\d{2})-?(\d{2})$/,
+    Www: /^-?W(\d{2})$/,
+    WwwD: /^-?W(\d{2})-?(\d{1})$/,
+    HH: /^(\d{2}([.,]\d*)?)$/,
+    HHMM: /^(\d{2}):?(\d{2}([.,]\d*)?)$/,
+    HHMMSS: /^(\d{2}):?(\d{2}):?(\d{2}([.,]\d*)?)$/,
+    // time zone tokens (to identify the presence of a tz)
+    timeZone: tzPattern
+};
+/**
+ * @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 an argument is a string, the function tries to parse it.
+ * Function accepts complete ISO 8601 formats as well as partial implementations.
+ * ISO 8601: http://en.wikipedia.org/wiki/ISO_8601
+ * If the function cannot parse the string or the values are invalid, it returns Invalid Date.
+ *
+ * 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`.
+ * All *date-fns* functions will throw `RangeError` if `options.additionalDigits` is not 0, 1, 2 or undefined.
+ *
+ * @param argument the value to convert
+ * @param options the object with options. See [Options]{@link https://date-fns.org/docs/Options}
+ * @param {0|1|2} [options.additionalDigits=2] - the additional number of digits in the extended year format
+ * @param {string} [options.timeZone=''] - used to specify the IANA time zone offset of a date String.
+ *
+ * @returns the parsed date in the local time zone
+ * @throws {TypeError} 1 argument required
+ * @throws {RangeError} `options.additionalDigits` must be 0, 1 or 2
+ *
+ * @example
+ * // Convert string '2014-02-11T11:30:30' to date:
+ * const result = toDate('2014-02-11T11:30:30')
+ * //=> Tue Feb 11 2014 11:30:30
+ *
+ * @example
+ * // Convert string '+02014101' to date,
+ * // if the additional number of digits in the extended year format is 1:
+ * const result = toDate('+02014101', {additionalDigits: 1})
+ * //=> Fri Apr 11 2014 00:00:00
+ */ function toDate(argument) {
+    var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+    if (arguments.length < 1) {
+        throw new TypeError('1 argument required, but only ' + arguments.length + ' present');
+    }
+    if (argument === null) {
+        return new Date(NaN);
+    }
+    var additionalDigits = options.additionalDigits == null ? DEFAULT_ADDITIONAL_DIGITS : Number(options.additionalDigits);
+    if (additionalDigits !== 2 && additionalDigits !== 1 && additionalDigits !== 0) {
+        throw new RangeError('additionalDigits must be 0, 1 or 2');
+    }
+    // Clone the date
+    if (_instanceof(argument, Date) || typeof argument === 'object' && Object.prototype.toString.call(argument) === '[object Date]') {
+        // Prevent the date to lose the milliseconds when passed to new Date() in IE10
+        return new Date(argument.getTime());
+    } else if (typeof argument === 'number' || Object.prototype.toString.call(argument) === '[object Number]') {
+        return new Date(argument);
+    } else if (!(Object.prototype.toString.call(argument) === '[object String]')) {
+        return new Date(NaN);
+    }
+    var dateStrings = splitDateString(argument);
+    var _parseYear = parseYear(dateStrings.date, additionalDigits), year = _parseYear.year, restDateString = _parseYear.restDateString;
+    var date = parseDate(restDateString, year);
+    if (date === null || isNaN(date.getTime())) {
+        return new Date(NaN);
+    }
+    if (date) {
+        var timestamp = date.getTime();
+        var time = 0;
+        var offset;
+        if (dateStrings.time) {
+            time = parseTime(dateStrings.time);
+            if (time === null || isNaN(time)) {
+                return new Date(NaN);
+            }
+        }
+        if (dateStrings.timeZone || options.timeZone) {
+            offset = tzParseTimezone(dateStrings.timeZone || options.timeZone, new Date(timestamp + time));
+            if (isNaN(offset)) {
+                return new Date(NaN);
+            }
+        } else {
+            // get offset accurate to hour in time zones that change offset
+            offset = getTimezoneOffsetInMilliseconds(new Date(timestamp + time));
+            offset = getTimezoneOffsetInMilliseconds(new Date(timestamp + time + offset));
+        }
+        return new Date(timestamp + time + offset);
+    } else {
+        return new Date(NaN);
+    }
+}
+function splitDateString(dateString) {
+    var dateStrings = {};
+    var parts = patterns.dateTimePattern.exec(dateString);
+    var timeString;
+    if (!parts) {
+        parts = patterns.datePattern.exec(dateString);
+        if (parts) {
+            dateStrings.date = parts[1];
+            timeString = parts[2];
+        } else {
+            dateStrings.date = null;
+            timeString = dateString;
+        }
+    } else {
+        dateStrings.date = parts[1];
+        timeString = parts[3];
+    }
+    if (timeString) {
+        var token = patterns.timeZone.exec(timeString);
+        if (token) {
+            dateStrings.time = timeString.replace(token[1], '');
+            dateStrings.timeZone = token[1].trim();
+        } else {
+            dateStrings.time = timeString;
+        }
+    }
+    return dateStrings;
+}
+function parseYear(dateString, additionalDigits) {
+    if (dateString) {
+        var patternYYY = patterns.YYY[additionalDigits];
+        var patternYYYYY = patterns.YYYYY[additionalDigits];
+        // YYYY or ±YYYYY
+        var token = patterns.YYYY.exec(dateString) || patternYYYYY.exec(dateString);
+        if (token) {
+            var yearString = token[1];
+            return {
+                year: parseInt(yearString, 10),
+                restDateString: dateString.slice(yearString.length)
+            };
+        }
+        // YY or ±YYY
+        token = patterns.YY.exec(dateString) || patternYYY.exec(dateString);
+        if (token) {
+            var centuryString = token[1];
+            return {
+                year: parseInt(centuryString, 10) * 100,
+                restDateString: dateString.slice(centuryString.length)
+            };
+        }
+    }
+    // Invalid ISO-formatted year
+    return {
+        year: null
+    };
+}
+function parseDate(dateString, year) {
+    // Invalid ISO-formatted year
+    if (year === null) {
+        return null;
+    }
+    var date;
+    var month;
+    var week;
+    // YYYY
+    if (!dateString || !dateString.length) {
+        date = new Date(0);
+        date.setUTCFullYear(year);
+        return date;
+    }
+    // YYYY-MM
+    var token = patterns.MM.exec(dateString);
+    if (token) {
+        date = new Date(0);
+        month = parseInt(token[1], 10) - 1;
+        if (!validateDate(year, month)) {
+            return new Date(NaN);
+        }
+        date.setUTCFullYear(year, month);
+        return date;
+    }
+    // YYYY-DDD or YYYYDDD
+    token = patterns.DDD.exec(dateString);
+    if (token) {
+        date = new Date(0);
+        var dayOfYear = parseInt(token[1], 10);
+        if (!validateDayOfYearDate(year, dayOfYear)) {
+            return new Date(NaN);
+        }
+        date.setUTCFullYear(year, 0, dayOfYear);
+        return date;
+    }
+    // yyyy-MM-dd or YYYYMMDD
+    token = patterns.MMDD.exec(dateString);
+    if (token) {
+        date = new Date(0);
+        month = parseInt(token[1], 10) - 1;
+        var day = parseInt(token[2], 10);
+        if (!validateDate(year, month, day)) {
+            return new Date(NaN);
+        }
+        date.setUTCFullYear(year, month, day);
+        return date;
+    }
+    // YYYY-Www or YYYYWww
+    token = patterns.Www.exec(dateString);
+    if (token) {
+        week = parseInt(token[1], 10) - 1;
+        if (!validateWeekDate(week)) {
+            return new Date(NaN);
+        }
+        return dayOfISOWeekYear(year, week);
+    }
+    // YYYY-Www-D or YYYYWwwD
+    token = patterns.WwwD.exec(dateString);
+    if (token) {
+        week = parseInt(token[1], 10) - 1;
+        var dayOfWeek = parseInt(token[2], 10) - 1;
+        if (!validateWeekDate(week, dayOfWeek)) {
+            return new Date(NaN);
+        }
+        return dayOfISOWeekYear(year, week, dayOfWeek);
+    }
+    // Invalid ISO-formatted date
+    return null;
+}
+function parseTime(timeString) {
+    var hours;
+    var minutes;
+    // hh
+    var token = patterns.HH.exec(timeString);
+    if (token) {
+        hours = parseFloat(token[1].replace(',', '.'));
+        if (!validateTime(hours)) {
+            return NaN;
+        }
+        return hours % 24 * MILLISECONDS_IN_HOUR;
+    }
+    // hh:mm or hhmm
+    token = patterns.HHMM.exec(timeString);
+    if (token) {
+        hours = parseInt(token[1], 10);
+        minutes = parseFloat(token[2].replace(',', '.'));
+        if (!validateTime(hours, minutes)) {
+            return NaN;
+        }
+        return hours % 24 * MILLISECONDS_IN_HOUR + minutes * MILLISECONDS_IN_MINUTE;
+    }
+    // hh:mm:ss or hhmmss
+    token = patterns.HHMMSS.exec(timeString);
+    if (token) {
+        hours = parseInt(token[1], 10);
+        minutes = parseInt(token[2], 10);
+        var seconds = parseFloat(token[3].replace(',', '.'));
+        if (!validateTime(hours, minutes, seconds)) {
+            return NaN;
+        }
+        return hours % 24 * MILLISECONDS_IN_HOUR + minutes * MILLISECONDS_IN_MINUTE + seconds * 1000;
+    }
+    // Invalid ISO-formatted time
+    return null;
+}
+function dayOfISOWeekYear(isoWeekYear, week, day) {
+    week = week || 0;
+    day = day || 0;
+    var date = new Date(0);
+    date.setUTCFullYear(isoWeekYear, 0, 4);
+    var fourthOfJanuaryDay = date.getUTCDay() || 7;
+    var diff = week * 7 + day + 1 - fourthOfJanuaryDay;
+    date.setUTCDate(date.getUTCDate() + diff);
+    return date;
+}
+// Validation functions
+var DAYS_IN_MONTH = [
+    31,
+    28,
+    31,
+    30,
+    31,
+    30,
+    31,
+    31,
+    30,
+    31,
+    30,
+    31
+];
+var DAYS_IN_MONTH_LEAP_YEAR = [
+    31,
+    29,
+    31,
+    30,
+    31,
+    30,
+    31,
+    31,
+    30,
+    31,
+    30,
+    31
+];
+function isLeapYearIndex(year) {
+    return year % 400 === 0 || year % 4 === 0 && year % 100 !== 0;
+}
+function validateDate(year, month, date) {
+    if (month < 0 || month > 11) {
+        return false;
+    }
+    if (date != null) {
+        if (date < 1) {
+            return false;
+        }
+        var isLeapYear = isLeapYearIndex(year);
+        if (isLeapYear && date > DAYS_IN_MONTH_LEAP_YEAR[month]) {
+            return false;
+        }
+        if (!isLeapYear && date > DAYS_IN_MONTH[month]) {
+            return false;
+        }
+    }
+    return true;
+}
+function validateDayOfYearDate(year, dayOfYear) {
+    if (dayOfYear < 1) {
+        return false;
+    }
+    var isLeapYear = isLeapYearIndex(year);
+    if (isLeapYear && dayOfYear > 366) {
+        return false;
+    }
+    if (!isLeapYear && dayOfYear > 365) {
+        return false;
+    }
+    return true;
+}
+function validateWeekDate(week, day) {
+    if (week < 0 || week > 52) {
+        return false;
+    }
+    if (day != null && (day < 0 || day > 6)) {
+        return false;
+    }
+    return true;
+}
+function validateTime(hours, minutes, seconds) {
+    if (hours < 0 || hours >= 25) {
+        return false;
+    }
+    if (minutes != null && (minutes < 0 || minutes >= 60)) {
+        return false;
+    }
+    if (seconds != null && (seconds < 0 || seconds >= 60)) {
+        return false;
+    }
+    return true;
+}
+
+/**
+ * @name toZonedTime
+ * @category Time Zone Helpers
+ * @summary Get a date/time representing local time in a given time zone from the UTC date
+ *
+ * @description
+ * Returns a date instance with values representing the local time in the time zone
+ * specified of the UTC time from the date provided. In other words, when the new date
+ * is formatted it will show the equivalent hours in the target time zone regardless
+ * of the current system time zone.
+ *
+ * @param date the date with the relevant UTC time
+ * @param timeZone the time zone to get local time for, 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 UTC is 6am in New York (-04:00)
+ * const result = toZonedTime('2014-06-25T10:00:00.000Z', 'America/New_York')
+ * //=> Jun 25 2014 06:00:00
+ */ function toZonedTime(date, timeZone, options) {
+    date = toDate(date, options);
+    var offsetMilliseconds = tzParseTimezone(timeZone, date, true);
+    var d = new Date(date.getTime() - offsetMilliseconds);
+    var resultDate = new Date(0);
+    resultDate.setFullYear(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate());
+    resultDate.setHours(d.getUTCHours(), d.getUTCMinutes(), d.getUTCSeconds(), d.getUTCMilliseconds());
+    return resultDate;
+}
+
 /**
  * It returns a `Date` object from a date `string` adjusted on the user timeZone,
  * if a timeZone is not provided we try getting it from the `Intl` browwser native

package/index.cjs.js

@@ -20,7 +20,6 @@ var redirectTo = require('./redirectTo.cjs.js');
 var storageClient = require('./storageClient.cjs.js');
 require('@koine/utils');
 require('@koine/dom');
-require('date-fns-tz');
 
 
 

package/index.esm.js

@@ -18,4 +18,3 @@ export { redirectTo } from './redirectTo.esm.js';
 export { storageClient } from './storageClient.esm.js';
 import '@koine/utils';
 import '@koine/dom';
-import 'date-fns-tz';

package/package.json

@@ -2,8 +2,8 @@
   "name": "@koine/browser",
   "sideEffects": false,
   "dependencies": {
-    "@koine/dom": "2.0.0-beta.121",
-    "@koine/utils": "2.0.0-beta.121"
+    "@koine/dom": "2.0.0-beta.123",
+    "@koine/utils": "2.0.0-beta.123"
   },
   "peerDependenciesMeta": {
     "date-fns-tz": {
@@ -110,5 +110,5 @@
   },
   "module": "./index.esm.js",
   "main": "./index.cjs.js",
-  "version": "2.0.0-beta.121"
+  "version": "2.0.0-beta.123"
 }