@stokr/components-library 3.0.67 → 3.0.68

package/dist/node_modules/date-fns-tz/dist/esm/_lib/tzParseTimezone/index.js

@@ -1,89 +0,0 @@
-import { tzTokenizeDate } from "../tzTokenizeDate/index.js";
-import { newDateUTC } from "../newDateUTC/index.js";
-const MILLISECONDS_IN_HOUR = 36e5;
-const MILLISECONDS_IN_MINUTE = 6e4;
-const patterns = {
-  timezoneZ: /^(Z)$/,
-  timezoneHH: /^([+-]\d{2})$/,
-  timezoneHHMM: /^([+-])(\d{2}):?(\d{2})$/
-};
-function tzParseTimezone(timezoneString, date, isUtcDate) {
-  if (!timezoneString) {
-    return 0;
-  }
-  let token = patterns.timezoneZ.exec(timezoneString);
-  if (token) {
-    return 0;
-  }
-  let hours;
-  let absoluteOffset;
-  token = patterns.timezoneHH.exec(timezoneString);
-  if (token) {
-    hours = parseInt(token[1], 10);
-    if (!validateTimezone(hours)) {
-      return NaN;
-    }
-    return -(hours * MILLISECONDS_IN_HOUR);
-  }
-  token = patterns.timezoneHHMM.exec(timezoneString);
-  if (token) {
-    hours = parseInt(token[2], 10);
-    const minutes = parseInt(token[3], 10);
-    if (!validateTimezone(hours, minutes)) {
-      return NaN;
-    }
-    absoluteOffset = Math.abs(hours) * MILLISECONDS_IN_HOUR + minutes * MILLISECONDS_IN_MINUTE;
-    return token[1] === "+" ? -absoluteOffset : absoluteOffset;
-  }
-  if (isValidTimezoneIANAString(timezoneString)) {
-    date = new Date(date || Date.now());
-    const utcDate = isUtcDate ? date : toUtcDate(date);
-    const offset = calcOffset(utcDate, timezoneString);
-    const 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) {
-  const tokens = tzTokenizeDate(date, timezoneString);
-  const asUTC = newDateUTC(tokens[0], tokens[1] - 1, tokens[2], tokens[3] % 24, tokens[4], tokens[5], 0).getTime();
-  let asTS = date.getTime();
-  const over = asTS % 1e3;
-  asTS -= over >= 0 ? over : 1e3 + over;
-  return asUTC - asTS;
-}
-function fixOffset(date, offset, timezoneString) {
-  const localTS = date.getTime();
-  let utcGuess = localTS - offset;
-  const o2 = calcOffset(new Date(utcGuess), timezoneString);
-  if (offset === o2) {
-    return offset;
-  }
-  utcGuess -= o2 - offset;
-  const o3 = calcOffset(new Date(utcGuess), timezoneString);
-  if (o2 === o3) {
-    return o2;
-  }
-  return Math.max(o2, o3);
-}
-function validateTimezone(hours, minutes) {
-  return -23 <= hours && hours <= 23 && (minutes == null || 0 <= minutes && minutes <= 59);
-}
-const validIANATimezoneCache = {};
-function isValidTimezoneIANAString(timeZoneString) {
-  if (validIANATimezoneCache[timeZoneString])
-    return true;
-  try {
-    new Intl.DateTimeFormat(void 0, { timeZone: timeZoneString });
-    validIANATimezoneCache[timeZoneString] = true;
-    return true;
-  } catch (error) {
-    return false;
-  }
-}
-export {
-  tzParseTimezone
-};

package/dist/node_modules/date-fns-tz/dist/esm/_lib/tzPattern/index.js

@@ -1,4 +0,0 @@
-const tzPattern = /(Z|[+-]\d{2}(?::?\d{2})?| UTC| [a-zA-Z]+\/[a-zA-Z_]+(?:\/[a-zA-Z_]+)?)$/;
-export {
-  tzPattern
-};

package/dist/node_modules/date-fns-tz/dist/esm/_lib/tzTokenizeDate/index.js

@@ -1,81 +0,0 @@
-function tzTokenizeDate(date, timeZone) {
-  const dtf = getDateTimeFormat(timeZone);
-  return "formatToParts" in dtf ? partsOffset(dtf, date) : hackyOffset(dtf, date);
-}
-const typeToPos = {
-  year: 0,
-  month: 1,
-  day: 2,
-  hour: 3,
-  minute: 4,
-  second: 5
-};
-function partsOffset(dtf, date) {
-  try {
-    const formatted = dtf.formatToParts(date);
-    const filled = [];
-    for (let i = 0; i < formatted.length; i++) {
-      const pos = typeToPos[formatted[i].type];
-      if (pos !== void 0) {
-        filled[pos] = parseInt(formatted[i].value, 10);
-      }
-    }
-    return filled;
-  } catch (error) {
-    if (error instanceof RangeError) {
-      return [NaN];
-    }
-    throw error;
-  }
-}
-function hackyOffset(dtf, date) {
-  const formatted = dtf.format(date);
-  const parsed = /(\d+)\/(\d+)\/(\d+),? (\d+):(\d+):(\d+)/.exec(formatted);
-  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)
-  ];
-}
-const dtfCache = {};
-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(/* @__PURE__ */ 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) {
-  if (!dtfCache[timeZone]) {
-    dtfCache[timeZone] = hourCycleSupported ? new Intl.DateTimeFormat("en-US", {
-      hourCycle: "h23",
-      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,
-      year: "numeric",
-      month: "numeric",
-      day: "2-digit",
-      hour: "2-digit",
-      minute: "2-digit",
-      second: "2-digit"
-    });
-  }
-  return dtfCache[timeZone];
-}
-export {
-  tzTokenizeDate
-};

package/dist/node_modules/date-fns-tz/dist/esm/format/formatters/index.js

@@ -1,125 +0,0 @@
-import { tzIntlTimeZoneName } from "../../_lib/tzIntlTimeZoneName/index.js";
-import { tzParseTimezone } from "../../_lib/tzParseTimezone/index.js";
-const MILLISECONDS_IN_MINUTE = 60 * 1e3;
-const formatters = {
-  // Timezone (ISO-8601. If offset is 0, output is always `'Z'`)
-  X: function(date, token, options) {
-    const timezoneOffset = getTimeZoneOffset(options.timeZone, date);
-    if (timezoneOffset === 0) {
-      return "Z";
-    }
-    switch (token) {
-      // Hours and optional minutes
-      case "X":
-        return formatTimezoneWithOptionalMinutes(timezoneOffset);
-      // Hours, minutes and optional seconds without `:` delimeter
-      // Note: neither ISO-8601 nor JavaScript supports seconds in timezone offsets
-      // so this token always has the same output as `XX`
-      case "XXXX":
-      case "XX":
-        return formatTimezone(timezoneOffset);
-      // Hours, minutes and optional seconds with `:` delimeter
-      // Note: neither ISO-8601 nor JavaScript supports seconds in timezone offsets
-      // so this token always has the same output as `XXX`
-      case "XXXXX":
-      case "XXX":
-      // Hours and minutes with `:` delimeter
-      default:
-        return formatTimezone(timezoneOffset, ":");
-    }
-  },
-  // Timezone (ISO-8601. If offset is 0, output is `'+00:00'` or equivalent)
-  x: function(date, token, options) {
-    const timezoneOffset = getTimeZoneOffset(options.timeZone, date);
-    switch (token) {
-      // Hours and optional minutes
-      case "x":
-        return formatTimezoneWithOptionalMinutes(timezoneOffset);
-      // Hours, minutes and optional seconds without `:` delimeter
-      // Note: neither ISO-8601 nor JavaScript supports seconds in timezone offsets
-      // so this token always has the same output as `xx`
-      case "xxxx":
-      case "xx":
-        return formatTimezone(timezoneOffset);
-      // Hours, minutes and optional seconds with `:` delimeter
-      // Note: neither ISO-8601 nor JavaScript supports seconds in timezone offsets
-      // so this token always has the same output as `xxx`
-      case "xxxxx":
-      case "xxx":
-      // Hours and minutes with `:` delimeter
-      default:
-        return formatTimezone(timezoneOffset, ":");
-    }
-  },
-  // Timezone (GMT)
-  O: function(date, token, options) {
-    const timezoneOffset = getTimeZoneOffset(options.timeZone, date);
-    switch (token) {
-      // Short
-      case "O":
-      case "OO":
-      case "OOO":
-        return "GMT" + formatTimezoneShort(timezoneOffset, ":");
-      // Long
-      case "OOOO":
-      default:
-        return "GMT" + formatTimezone(timezoneOffset, ":");
-    }
-  },
-  // Timezone (specific non-location)
-  z: function(date, token, options) {
-    switch (token) {
-      // Short
-      case "z":
-      case "zz":
-      case "zzz":
-        return tzIntlTimeZoneName("short", date, options);
-      // Long
-      case "zzzz":
-      default:
-        return tzIntlTimeZoneName("long", date, options);
-    }
-  }
-};
-function getTimeZoneOffset(timeZone, originalDate) {
-  const timeZoneOffset = timeZone ? tzParseTimezone(timeZone, originalDate, true) / MILLISECONDS_IN_MINUTE : originalDate?.getTimezoneOffset() ?? 0;
-  if (Number.isNaN(timeZoneOffset)) {
-    throw new RangeError("Invalid time zone specified: " + timeZone);
-  }
-  return timeZoneOffset;
-}
-function addLeadingZeros(number, targetLength) {
-  const sign = number < 0 ? "-" : "";
-  let output = Math.abs(number).toString();
-  while (output.length < targetLength) {
-    output = "0" + output;
-  }
-  return sign + output;
-}
-function formatTimezone(offset, 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 + delimiter + minutes;
-}
-function formatTimezoneWithOptionalMinutes(offset, delimiter) {
-  if (offset % 60 === 0) {
-    const sign = offset > 0 ? "-" : "+";
-    return sign + addLeadingZeros(Math.abs(offset) / 60, 2);
-  }
-  return formatTimezone(offset, delimiter);
-}
-function formatTimezoneShort(offset, delimiter = "") {
-  const sign = offset > 0 ? "-" : "+";
-  const absOffset = Math.abs(offset);
-  const hours = Math.floor(absOffset / 60);
-  const minutes = absOffset % 60;
-  if (minutes === 0) {
-    return sign + String(hours);
-  }
-  return sign + String(hours) + delimiter + addLeadingZeros(minutes, 2);
-}
-export {
-  formatters
-};

package/dist/node_modules/date-fns-tz/dist/esm/format/index.js

@@ -1,24 +0,0 @@
-import { format as format$1 } from "../../../../date-fns/format.js";
-import { formatters } from "./formatters/index.js";
-import { toDate } from "../toDate/index.js";
-const tzFormattingTokensRegExp = /([xXOz]+)|''|'(''|[^'])+('|$)/g;
-function format(date, formatStr, options = {}) {
-  formatStr = String(formatStr);
-  const matches = formatStr.match(tzFormattingTokensRegExp);
-  if (matches) {
-    const d = toDate(options.originalDate || date, options);
-    formatStr = matches.reduce(function(result, token) {
-      if (token[0] === "'") {
-        return result;
-      }
-      const pos = result.indexOf(token);
-      const precededByQuotedSection = result[pos - 1] === "'";
-      const replaced = result.replace(token, "'" + formatters[token[0]](d, token, options) + "'");
-      return precededByQuotedSection ? replaced.substring(0, pos - 1) + replaced.substring(pos + 1) : replaced;
-    }, formatStr);
-  }
-  return format$1(date, formatStr, options);
-}
-export {
-  format
-};

package/dist/node_modules/date-fns-tz/dist/esm/formatInTimeZone/index.js

@@ -1,13 +0,0 @@
-import { format } from "../format/index.js";
-import { toZonedTime } from "../toZonedTime/index.js";
-function formatInTimeZone(date, timeZone, formatStr, options) {
-  options = {
-    ...options,
-    timeZone,
-    originalDate: date
-  };
-  return format(toZonedTime(date, timeZone, { timeZone: options.timeZone }), formatStr, options);
-}
-export {
-  formatInTimeZone
-};

package/dist/node_modules/date-fns-tz/dist/esm/toDate/index.js

@@ -1,305 +0,0 @@
-import { getTimezoneOffsetInMilliseconds } from "../_lib/getTimezoneOffsetInMilliseconds/index.js";
-import { tzParseTimezone } from "../_lib/tzParseTimezone/index.js";
-import { tzPattern } from "../_lib/tzPattern/index.js";
-const MILLISECONDS_IN_HOUR = 36e5;
-const MILLISECONDS_IN_MINUTE = 6e4;
-const DEFAULT_ADDITIONAL_DIGITS = 2;
-const patterns = {
-  dateTimePattern: /^([0-9W+-]+)(T| )(.*)/,
-  datePattern: /^([0-9W+-]+)(.*)/,
-  // year tokens
-  YY: /^(\d{2})$/,
-  YYY: [
-    /^([+-]\d{2})$/,
-    // 0 additional digits
-    /^([+-]\d{3})$/,
-    // 1 additional digit
-    /^([+-]\d{4})$/
-    // 2 additional digits
-  ],
-  YYYY: /^(\d{4})/,
-  YYYYY: [
-    /^([+-]\d{4})/,
-    // 0 additional digits
-    /^([+-]\d{5})/,
-    // 1 additional digit
-    /^([+-]\d{6})/
-    // 2 additional digits
-  ],
-  // 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
-};
-function toDate(argument, options = {}) {
-  if (arguments.length < 1) {
-    throw new TypeError("1 argument required, but only " + arguments.length + " present");
-  }
-  if (argument === null) {
-    return /* @__PURE__ */ new Date(NaN);
-  }
-  const 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");
-  }
-  if (argument instanceof Date || typeof argument === "object" && Object.prototype.toString.call(argument) === "[object Date]") {
-    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 /* @__PURE__ */ new Date(NaN);
-  }
-  const dateStrings = splitDateString(argument);
-  const { year, restDateString } = parseYear(dateStrings.date, additionalDigits);
-  const date = parseDate(restDateString, year);
-  if (date === null || isNaN(date.getTime())) {
-    return /* @__PURE__ */ new Date(NaN);
-  }
-  if (date) {
-    const timestamp = date.getTime();
-    let time = 0;
-    let offset;
-    if (dateStrings.time) {
-      time = parseTime(dateStrings.time);
-      if (time === null || isNaN(time)) {
-        return /* @__PURE__ */ new Date(NaN);
-      }
-    }
-    if (dateStrings.timeZone || options.timeZone) {
-      offset = tzParseTimezone(dateStrings.timeZone || options.timeZone, new Date(timestamp + time));
-      if (isNaN(offset)) {
-        return /* @__PURE__ */ new Date(NaN);
-      }
-    } else {
-      offset = getTimezoneOffsetInMilliseconds(new Date(timestamp + time));
-      offset = getTimezoneOffsetInMilliseconds(new Date(timestamp + time + offset));
-    }
-    return new Date(timestamp + time + offset);
-  } else {
-    return /* @__PURE__ */ new Date(NaN);
-  }
-}
-function splitDateString(dateString) {
-  const dateStrings = {};
-  let parts = patterns.dateTimePattern.exec(dateString);
-  let 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) {
-    const 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) {
-    const patternYYY = patterns.YYY[additionalDigits];
-    const patternYYYYY = patterns.YYYYY[additionalDigits];
-    let token = patterns.YYYY.exec(dateString) || patternYYYYY.exec(dateString);
-    if (token) {
-      const yearString = token[1];
-      return {
-        year: parseInt(yearString, 10),
-        restDateString: dateString.slice(yearString.length)
-      };
-    }
-    token = patterns.YY.exec(dateString) || patternYYY.exec(dateString);
-    if (token) {
-      const centuryString = token[1];
-      return {
-        year: parseInt(centuryString, 10) * 100,
-        restDateString: dateString.slice(centuryString.length)
-      };
-    }
-  }
-  return {
-    year: null
-  };
-}
-function parseDate(dateString, year) {
-  if (year === null) {
-    return null;
-  }
-  let date;
-  let month;
-  let week;
-  if (!dateString || !dateString.length) {
-    date = /* @__PURE__ */ new Date(0);
-    date.setUTCFullYear(year);
-    return date;
-  }
-  let token = patterns.MM.exec(dateString);
-  if (token) {
-    date = /* @__PURE__ */ new Date(0);
-    month = parseInt(token[1], 10) - 1;
-    if (!validateDate(year, month)) {
-      return /* @__PURE__ */ new Date(NaN);
-    }
-    date.setUTCFullYear(year, month);
-    return date;
-  }
-  token = patterns.DDD.exec(dateString);
-  if (token) {
-    date = /* @__PURE__ */ new Date(0);
-    const dayOfYear = parseInt(token[1], 10);
-    if (!validateDayOfYearDate(year, dayOfYear)) {
-      return /* @__PURE__ */ new Date(NaN);
-    }
-    date.setUTCFullYear(year, 0, dayOfYear);
-    return date;
-  }
-  token = patterns.MMDD.exec(dateString);
-  if (token) {
-    date = /* @__PURE__ */ new Date(0);
-    month = parseInt(token[1], 10) - 1;
-    const day = parseInt(token[2], 10);
-    if (!validateDate(year, month, day)) {
-      return /* @__PURE__ */ new Date(NaN);
-    }
-    date.setUTCFullYear(year, month, day);
-    return date;
-  }
-  token = patterns.Www.exec(dateString);
-  if (token) {
-    week = parseInt(token[1], 10) - 1;
-    if (!validateWeekDate(week)) {
-      return /* @__PURE__ */ new Date(NaN);
-    }
-    return dayOfISOWeekYear(year, week);
-  }
-  token = patterns.WwwD.exec(dateString);
-  if (token) {
-    week = parseInt(token[1], 10) - 1;
-    const dayOfWeek = parseInt(token[2], 10) - 1;
-    if (!validateWeekDate(week, dayOfWeek)) {
-      return /* @__PURE__ */ new Date(NaN);
-    }
-    return dayOfISOWeekYear(year, week, dayOfWeek);
-  }
-  return null;
-}
-function parseTime(timeString) {
-  let hours;
-  let minutes;
-  let token = patterns.HH.exec(timeString);
-  if (token) {
-    hours = parseFloat(token[1].replace(",", "."));
-    if (!validateTime(hours)) {
-      return NaN;
-    }
-    return hours % 24 * MILLISECONDS_IN_HOUR;
-  }
-  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;
-  }
-  token = patterns.HHMMSS.exec(timeString);
-  if (token) {
-    hours = parseInt(token[1], 10);
-    minutes = parseInt(token[2], 10);
-    const seconds = parseFloat(token[3].replace(",", "."));
-    if (!validateTime(hours, minutes, seconds)) {
-      return NaN;
-    }
-    return hours % 24 * MILLISECONDS_IN_HOUR + minutes * MILLISECONDS_IN_MINUTE + seconds * 1e3;
-  }
-  return null;
-}
-function dayOfISOWeekYear(isoWeekYear, week, day) {
-  week = week || 0;
-  day = day || 0;
-  const date = /* @__PURE__ */ new Date(0);
-  date.setUTCFullYear(isoWeekYear, 0, 4);
-  const fourthOfJanuaryDay = date.getUTCDay() || 7;
-  const diff = week * 7 + day + 1 - fourthOfJanuaryDay;
-  date.setUTCDate(date.getUTCDate() + diff);
-  return date;
-}
-const DAYS_IN_MONTH = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
-const 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;
-    }
-    const 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;
-  }
-  const 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;
-}
-export {
-  toDate
-};

package/dist/node_modules/date-fns-tz/dist/esm/toZonedTime/index.js

@@ -1,14 +0,0 @@
-import { tzParseTimezone } from "../_lib/tzParseTimezone/index.js";
-import { toDate } from "../toDate/index.js";
-function toZonedTime(date, timeZone, options) {
-  date = toDate(date, options);
-  const offsetMilliseconds = tzParseTimezone(timeZone, date, true);
-  const d = new Date(date.getTime() - offsetMilliseconds);
-  const resultDate = /* @__PURE__ */ new Date(0);
-  resultDate.setFullYear(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate());
-  resultDate.setHours(d.getUTCHours(), d.getUTCMinutes(), d.getUTCSeconds(), d.getUTCMilliseconds());
-  return resultDate;
-}
-export {
-  toZonedTime
-};