tp-react-elements-dev 1.14.2 → 1.14.4

package/dist/node_modules/date-fns/formatDistanceStrict.esm.js

@@ -0,0 +1,205 @@
+import { __exports as formatDistanceStrict } from '../../_virtual/formatDistanceStrict.esm.js';
+import { __require as requireDefaultLocale } from './_lib/defaultLocale.esm.js';
+import { __require as requireDefaultOptions } from './_lib/defaultOptions.esm2.js';
+import { __require as requireGetRoundingMethod } from './_lib/getRoundingMethod.esm.js';
+import { __require as requireGetTimezoneOffsetInMilliseconds } from './_lib/getTimezoneOffsetInMilliseconds.esm2.js';
+import { __require as requireNormalizeDates } from './_lib/normalizeDates.esm2.js';
+import { __require as requireCompareAsc } from './compareAsc.esm.js';
+import { __require as requireConstants } from './constants.esm2.js';
+
+var hasRequiredFormatDistanceStrict;
+
+function requireFormatDistanceStrict () {
+	if (hasRequiredFormatDistanceStrict) return formatDistanceStrict;
+	hasRequiredFormatDistanceStrict = 1;
+	formatDistanceStrict.formatDistanceStrict = formatDistanceStrict$1;
+	var _index = /*@__PURE__*/ requireDefaultLocale();
+	var _index2 = /*@__PURE__*/ requireDefaultOptions();
+	var _index3 = /*@__PURE__*/ requireGetRoundingMethod();
+	var _index4 = /*@__PURE__*/ requireGetTimezoneOffsetInMilliseconds();
+	var _index5 = /*@__PURE__*/ requireNormalizeDates();
+	var _index6 = /*@__PURE__*/ requireCompareAsc();
+	var _index7 = /*@__PURE__*/ requireConstants();
+
+	/**
+	 * The {@link formatDistanceStrict} function options.
+	 */
+
+	/**
+	 * The unit used to format the distance in {@link formatDistanceStrict}.
+	 */
+
+	/**
+	 * @name formatDistanceStrict
+	 * @category Common Helpers
+	 * @summary Return the distance between the given dates in words.
+	 *
+	 * @description
+	 * Return the distance between the given dates in words, using strict units.
+	 * This is like `formatDistance`, but does not use helpers like 'almost', 'over',
+	 * 'less than' and the like.
+	 *
+	 * | Distance between dates | Result              |
+	 * |------------------------|---------------------|
+	 * | 0 ... 59 secs          | [0..59] seconds     |
+	 * | 1 ... 59 mins          | [1..59] minutes     |
+	 * | 1 ... 23 hrs           | [1..23] hours       |
+	 * | 1 ... 29 days          | [1..29] days        |
+	 * | 1 ... 11 months        | [1..11] months      |
+	 * | 1 ... N years          | [1..N]  years       |
+	 *
+	 * @param laterDate - The date
+	 * @param earlierDate - The date to compare with
+	 * @param options - An object with options
+	 *
+	 * @returns The distance in words
+	 *
+	 * @throws `date` must not be Invalid Date
+	 * @throws `baseDate` must not be Invalid Date
+	 * @throws `options.unit` must be 'second', 'minute', 'hour', 'day', 'month' or 'year'
+	 * @throws `options.locale` must contain `formatDistance` property
+	 *
+	 * @example
+	 * // What is the distance between 2 July 2014 and 1 January 2015?
+	 * const result = formatDistanceStrict(new Date(2014, 6, 2), new Date(2015, 0, 2))
+	 * //=> '6 months'
+	 *
+	 * @example
+	 * // What is the distance between 1 January 2015 00:00:15
+	 * // and 1 January 2015 00:00:00?
+	 * const result = formatDistanceStrict(
+	 *   new Date(2015, 0, 1, 0, 0, 15),
+	 *   new Date(2015, 0, 1, 0, 0, 0)
+	 * )
+	 * //=> '15 seconds'
+	 *
+	 * @example
+	 * // What is the distance from 1 January 2016
+	 * // to 1 January 2015, with a suffix?
+	 * const result = formatDistanceStrict(new Date(2015, 0, 1), new Date(2016, 0, 1), {
+	 *   addSuffix: true
+	 * })
+	 * //=> '1 year ago'
+	 *
+	 * @example
+	 * // What is the distance from 1 January 2016
+	 * // to 1 January 2015, in minutes?
+	 * const result = formatDistanceStrict(new Date(2016, 0, 1), new Date(2015, 0, 1), {
+	 *   unit: 'minute'
+	 * })
+	 * //=> '525600 minutes'
+	 *
+	 * @example
+	 * // What is the distance from 1 January 2015
+	 * // to 28 January 2015, in months, rounded up?
+	 * const result = formatDistanceStrict(new Date(2015, 0, 28), new Date(2015, 0, 1), {
+	 *   unit: 'month',
+	 *   roundingMethod: 'ceil'
+	 * })
+	 * //=> '1 month'
+	 *
+	 * @example
+	 * // What is the distance between 1 August 2016 and 1 January 2015 in Esperanto?
+	 * import { eoLocale } from 'date-fns/locale/eo'
+	 * const result = formatDistanceStrict(new Date(2016, 7, 1), new Date(2015, 0, 1), {
+	 *   locale: eoLocale
+	 * })
+	 * //=> '1 jaro'
+	 */
+
+	function formatDistanceStrict$1(laterDate, earlierDate, options) {
+	  const defaultOptions = (0, _index2.getDefaultOptions)();
+	  const locale =
+	    options?.locale ?? defaultOptions.locale ?? _index.defaultLocale;
+
+	  const comparison = (0, _index6.compareAsc)(laterDate, earlierDate);
+
+	  if (isNaN(comparison)) {
+	    throw new RangeError("Invalid time value");
+	  }
+
+	  const localizeOptions = Object.assign({}, options, {
+	    addSuffix: options?.addSuffix,
+	    comparison: comparison,
+	  });
+
+	  const [laterDate_, earlierDate_] = (0, _index5.normalizeDates)(
+	    options?.in,
+	    ...(comparison > 0 ? [earlierDate, laterDate] : [laterDate, earlierDate]),
+	  );
+
+	  const roundingMethod = (0, _index3.getRoundingMethod)(
+	    options?.roundingMethod ?? "round",
+	  );
+
+	  const milliseconds = earlierDate_.getTime() - laterDate_.getTime();
+	  const minutes = milliseconds / _index7.millisecondsInMinute;
+
+	  const timezoneOffset =
+	    (0, _index4.getTimezoneOffsetInMilliseconds)(earlierDate_) -
+	    (0, _index4.getTimezoneOffsetInMilliseconds)(laterDate_);
+
+	  // Use DST-normalized difference in minutes for years, months and days;
+	  // use regular difference in minutes for hours, minutes and seconds.
+	  const dstNormalizedMinutes =
+	    (milliseconds - timezoneOffset) / _index7.millisecondsInMinute;
+
+	  const defaultUnit = options?.unit;
+	  let unit;
+	  if (!defaultUnit) {
+	    if (minutes < 1) {
+	      unit = "second";
+	    } else if (minutes < 60) {
+	      unit = "minute";
+	    } else if (minutes < _index7.minutesInDay) {
+	      unit = "hour";
+	    } else if (dstNormalizedMinutes < _index7.minutesInMonth) {
+	      unit = "day";
+	    } else if (dstNormalizedMinutes < _index7.minutesInYear) {
+	      unit = "month";
+	    } else {
+	      unit = "year";
+	    }
+	  } else {
+	    unit = defaultUnit;
+	  }
+
+	  // 0 up to 60 seconds
+	  if (unit === "second") {
+	    const seconds = roundingMethod(milliseconds / 1000);
+	    return locale.formatDistance("xSeconds", seconds, localizeOptions);
+
+	    // 1 up to 60 mins
+	  } else if (unit === "minute") {
+	    const roundedMinutes = roundingMethod(minutes);
+	    return locale.formatDistance("xMinutes", roundedMinutes, localizeOptions);
+
+	    // 1 up to 24 hours
+	  } else if (unit === "hour") {
+	    const hours = roundingMethod(minutes / 60);
+	    return locale.formatDistance("xHours", hours, localizeOptions);
+
+	    // 1 up to 30 days
+	  } else if (unit === "day") {
+	    const days = roundingMethod(dstNormalizedMinutes / _index7.minutesInDay);
+	    return locale.formatDistance("xDays", days, localizeOptions);
+
+	    // 1 up to 12 months
+	  } else if (unit === "month") {
+	    const months = roundingMethod(
+	      dstNormalizedMinutes / _index7.minutesInMonth,
+	    );
+	    return months === 12 && defaultUnit !== "month"
+	      ? locale.formatDistance("xYears", 1, localizeOptions)
+	      : locale.formatDistance("xMonths", months, localizeOptions);
+
+	    // 1 year up to max Date
+	  } else {
+	    const years = roundingMethod(dstNormalizedMinutes / _index7.minutesInYear);
+	    return locale.formatDistance("xYears", years, localizeOptions);
+	  }
+	}
+	return formatDistanceStrict;
+}
+
+export { requireFormatDistanceStrict as __require };

package/dist/node_modules/date-fns/formatDistanceToNow.esm.js

@@ -0,0 +1,110 @@
+import { __exports as formatDistanceToNow } from '../../_virtual/formatDistanceToNow.esm.js';
+import { __require as requireConstructNow } from './constructNow.esm.js';
+import { __require as requireFormatDistance } from './formatDistance.esm.js';
+
+var hasRequiredFormatDistanceToNow;
+
+function requireFormatDistanceToNow () {
+	if (hasRequiredFormatDistanceToNow) return formatDistanceToNow;
+	hasRequiredFormatDistanceToNow = 1;
+	formatDistanceToNow.formatDistanceToNow = formatDistanceToNow$1;
+	var _index = /*@__PURE__*/ requireConstructNow();
+
+	var _index2 = /*@__PURE__*/ requireFormatDistance();
+
+	/**
+	 * The {@link formatDistanceToNow} function options.
+	 */
+
+	/**
+	 * @name formatDistanceToNow
+	 * @category Common Helpers
+	 * @summary Return the distance between the given date and now in words.
+	 * @pure false
+	 *
+	 * @description
+	 * Return the distance between the given date and now in words.
+	 *
+	 * | Distance to now                                                   | Result              |
+	 * |-------------------------------------------------------------------|---------------------|
+	 * | 0 ... 30 secs                                                     | less than a minute  |
+	 * | 30 secs ... 1 min 30 secs                                         | 1 minute            |
+	 * | 1 min 30 secs ... 44 mins 30 secs                                 | [2..44] minutes     |
+	 * | 44 mins ... 30 secs ... 89 mins 30 secs                           | about 1 hour        |
+	 * | 89 mins 30 secs ... 23 hrs 59 mins 30 secs                        | about [2..24] hours |
+	 * | 23 hrs 59 mins 30 secs ... 41 hrs 59 mins 30 secs                 | 1 day               |
+	 * | 41 hrs 59 mins 30 secs ... 29 days 23 hrs 59 mins 30 secs         | [2..30] days        |
+	 * | 29 days 23 hrs 59 mins 30 secs ... 44 days 23 hrs 59 mins 30 secs | about 1 month       |
+	 * | 44 days 23 hrs 59 mins 30 secs ... 59 days 23 hrs 59 mins 30 secs | about 2 months      |
+	 * | 59 days 23 hrs 59 mins 30 secs ... 1 yr                           | [2..12] months      |
+	 * | 1 yr ... 1 yr 3 months                                            | about 1 year        |
+	 * | 1 yr 3 months ... 1 yr 9 month s                                  | over 1 year         |
+	 * | 1 yr 9 months ... 2 yrs                                           | almost 2 years      |
+	 * | N yrs ... N yrs 3 months                                          | about N years       |
+	 * | N yrs 3 months ... N yrs 9 months                                 | over N years        |
+	 * | N yrs 9 months ... N+1 yrs                                        | almost N+1 years    |
+	 *
+	 * With `options.includeSeconds == true`:
+	 * | Distance to now     | Result               |
+	 * |---------------------|----------------------|
+	 * | 0 secs ... 5 secs   | less than 5 seconds  |
+	 * | 5 secs ... 10 secs  | less than 10 seconds |
+	 * | 10 secs ... 20 secs | less than 20 seconds |
+	 * | 20 secs ... 40 secs | half a minute        |
+	 * | 40 secs ... 60 secs | less than a minute   |
+	 * | 60 secs ... 90 secs | 1 minute             |
+	 *
+	 * @param date - The given date
+	 * @param options - The object with options
+	 *
+	 * @returns The distance in words
+	 *
+	 * @throws `date` must not be Invalid Date
+	 * @throws `options.locale` must contain `formatDistance` property
+	 *
+	 * @example
+	 * // If today is 1 January 2015, what is the distance to 2 July 2014?
+	 * const result = formatDistanceToNow(
+	 *   new Date(2014, 6, 2)
+	 * )
+	 * //=> '6 months'
+	 *
+	 * @example
+	 * // If now is 1 January 2015 00:00:00,
+	 * // what is the distance to 1 January 2015 00:00:15, including seconds?
+	 * const result = formatDistanceToNow(
+	 *   new Date(2015, 0, 1, 0, 0, 15),
+	 *   {includeSeconds: true}
+	 * )
+	 * //=> 'less than 20 seconds'
+	 *
+	 * @example
+	 * // If today is 1 January 2015,
+	 * // what is the distance to 1 January 2016, with a suffix?
+	 * const result = formatDistanceToNow(
+	 *   new Date(2016, 0, 1),
+	 *   {addSuffix: true}
+	 * )
+	 * //=> 'in about 1 year'
+	 *
+	 * @example
+	 * // If today is 1 January 2015,
+	 * // what is the distance to 1 August 2016 in Esperanto?
+	 * const eoLocale = require('date-fns/locale/eo')
+	 * const result = formatDistanceToNow(
+	 *   new Date(2016, 7, 1),
+	 *   {locale: eoLocale}
+	 * )
+	 * //=> 'pli ol 1 jaro'
+	 */
+	function formatDistanceToNow$1(date, options) {
+	  return (0, _index2.formatDistance)(
+	    date,
+	    (0, _index.constructNow)(date),
+	    options,
+	  );
+	}
+	return formatDistanceToNow;
+}
+
+export { requireFormatDistanceToNow as __require };

package/dist/node_modules/date-fns/formatDistanceToNowStrict.esm.js

@@ -0,0 +1,100 @@
+import { __exports as formatDistanceToNowStrict } from '../../_virtual/formatDistanceToNowStrict.esm.js';
+import { __require as requireConstructNow } from './constructNow.esm.js';
+import { __require as requireFormatDistanceStrict } from './formatDistanceStrict.esm.js';
+
+var hasRequiredFormatDistanceToNowStrict;
+
+function requireFormatDistanceToNowStrict () {
+	if (hasRequiredFormatDistanceToNowStrict) return formatDistanceToNowStrict;
+	hasRequiredFormatDistanceToNowStrict = 1;
+	formatDistanceToNowStrict.formatDistanceToNowStrict = formatDistanceToNowStrict$1;
+	var _index = /*@__PURE__*/ requireConstructNow();
+
+	var _index2 = /*@__PURE__*/ requireFormatDistanceStrict();
+
+	/**
+	 * The {@link formatDistanceToNowStrict} function options.
+	 */
+
+	/**
+	 * @name formatDistanceToNowStrict
+	 * @category Common Helpers
+	 * @summary Return the distance between the given date and now in words.
+	 * @pure false
+	 *
+	 * @description
+	 * Return the distance between the given dates in words, using strict units.
+	 * This is like `formatDistance`, but does not use helpers like 'almost', 'over',
+	 * 'less than' and the like.
+	 *
+	 * | Distance between dates | Result              |
+	 * |------------------------|---------------------|
+	 * | 0 ... 59 secs          | [0..59] seconds     |
+	 * | 1 ... 59 mins          | [1..59] minutes     |
+	 * | 1 ... 23 hrs           | [1..23] hours       |
+	 * | 1 ... 29 days          | [1..29] days        |
+	 * | 1 ... 11 months        | [1..11] months      |
+	 * | 1 ... N years          | [1..N]  years       |
+	 *
+	 * @param date - The given date
+	 * @param options - An object with options.
+	 *
+	 * @returns The distance in words
+	 *
+	 * @throws `date` must not be Invalid Date
+	 * @throws `options.locale` must contain `formatDistance` property
+	 *
+	 * @example
+	 * // If today is 1 January 2015, what is the distance to 2 July 2014?
+	 * const result = formatDistanceToNowStrict(
+	 *   new Date(2014, 6, 2)
+	 * )
+	 * //=> '6 months'
+	 *
+	 * @example
+	 * // If now is 1 January 2015 00:00:00,
+	 * // what is the distance to 1 January 2015 00:00:15, including seconds?
+	 * const result = formatDistanceToNowStrict(
+	 *   new Date(2015, 0, 1, 0, 0, 15)
+	 * )
+	 * //=> '15 seconds'
+	 *
+	 * @example
+	 * // If today is 1 January 2015,
+	 * // what is the distance to 1 January 2016, with a suffix?
+	 * const result = formatDistanceToNowStrict(
+	 *   new Date(2016, 0, 1),
+	 *   {addSuffix: true}
+	 * )
+	 * //=> 'in 1 year'
+	 *
+	 * @example
+	 * // If today is 28 January 2015,
+	 * // what is the distance to 1 January 2015, in months, rounded up??
+	 * const result = formatDistanceToNowStrict(new Date(2015, 0, 1), {
+	 *   unit: 'month',
+	 *   roundingMethod: 'ceil'
+	 * })
+	 * //=> '1 month'
+	 *
+	 * @example
+	 * // If today is 1 January 2015,
+	 * // what is the distance to 1 January 2016 in Esperanto?
+	 * const eoLocale = require('date-fns/locale/eo')
+	 * const result = formatDistanceToNowStrict(
+	 *   new Date(2016, 0, 1),
+	 *   {locale: eoLocale}
+	 * )
+	 * //=> '1 jaro'
+	 */
+	function formatDistanceToNowStrict$1(date, options) {
+	  return (0, _index2.formatDistanceStrict)(
+	    date,
+	    (0, _index.constructNow)(date),
+	    options,
+	  );
+	}
+	return formatDistanceToNowStrict;
+}
+
+export { requireFormatDistanceToNowStrict as __require };

package/dist/node_modules/date-fns/formatDuration.esm.js

@@ -0,0 +1,115 @@
+import { __exports as formatDuration } from '../../_virtual/formatDuration.esm.js';
+import { __require as requireDefaultLocale } from './_lib/defaultLocale.esm.js';
+import { __require as requireDefaultOptions } from './_lib/defaultOptions.esm2.js';
+
+var hasRequiredFormatDuration;
+
+function requireFormatDuration () {
+	if (hasRequiredFormatDuration) return formatDuration;
+	hasRequiredFormatDuration = 1;
+	formatDuration.formatDuration = formatDuration$1;
+
+	var _index = /*@__PURE__*/ requireDefaultLocale();
+	var _index2 = /*@__PURE__*/ requireDefaultOptions();
+
+	/**
+	 * The {@link formatDuration} function options.
+	 */
+
+	const defaultFormat = [
+	  "years",
+	  "months",
+	  "weeks",
+	  "days",
+	  "hours",
+	  "minutes",
+	  "seconds",
+	];
+
+	/**
+	 * @name formatDuration
+	 * @category Common Helpers
+	 * @summary Formats a duration in human-readable format
+	 *
+	 * @description
+	 * Return human-readable duration string i.e. "9 months 2 days"
+	 *
+	 * @param duration - The duration to format
+	 * @param options - An object with options.
+	 *
+	 * @returns The formatted date string
+	 *
+	 * @example
+	 * // Format full duration
+	 * formatDuration({
+	 *   years: 2,
+	 *   months: 9,
+	 *   weeks: 1,
+	 *   days: 7,
+	 *   hours: 5,
+	 *   minutes: 9,
+	 *   seconds: 30
+	 * })
+	 * //=> '2 years 9 months 1 week 7 days 5 hours 9 minutes 30 seconds'
+	 *
+	 * @example
+	 * // Format partial duration
+	 * formatDuration({ months: 9, days: 2 })
+	 * //=> '9 months 2 days'
+	 *
+	 * @example
+	 * // Customize the format
+	 * formatDuration(
+	 *   {
+	 *     years: 2,
+	 *     months: 9,
+	 *     weeks: 1,
+	 *     days: 7,
+	 *     hours: 5,
+	 *     minutes: 9,
+	 *     seconds: 30
+	 *   },
+	 *   { format: ['months', 'weeks'] }
+	 * ) === '9 months 1 week'
+	 *
+	 * @example
+	 * // Customize the zeros presence
+	 * formatDuration({ years: 0, months: 9 })
+	 * //=> '9 months'
+	 * formatDuration({ years: 0, months: 9 }, { zero: true })
+	 * //=> '0 years 9 months'
+	 *
+	 * @example
+	 * // Customize the delimiter
+	 * formatDuration({ years: 2, months: 9, weeks: 3 }, { delimiter: ', ' })
+	 * //=> '2 years, 9 months, 3 weeks'
+	 */
+	function formatDuration$1(duration, options) {
+	  const defaultOptions = (0, _index2.getDefaultOptions)();
+	  const locale =
+	    options?.locale ?? defaultOptions.locale ?? _index.defaultLocale;
+	  const format = options?.format ?? defaultFormat;
+	  const zero = options?.zero ?? false;
+	  const delimiter = options?.delimiter ?? " ";
+
+	  if (!locale.formatDistance) {
+	    return "";
+	  }
+
+	  const result = format
+	    .reduce((acc, unit) => {
+	      const token = `x${unit.replace(/(^.)/, (m) => m.toUpperCase())}`;
+	      const value = duration[unit];
+	      if (value !== undefined && (zero || duration[unit])) {
+	        return acc.concat(locale.formatDistance(token, value));
+	      }
+	      return acc;
+	    }, [])
+	    .join(delimiter);
+
+	  return result;
+	}
+	return formatDuration;
+}
+
+export { requireFormatDuration as __require };

package/dist/node_modules/date-fns/formatISO.esm.js

@@ -0,0 +1,118 @@
+import { __exports as formatISO } from '../../_virtual/formatISO.esm.js';
+import { __require as requireAddLeadingZeros } from './_lib/addLeadingZeros.esm2.js';
+import { __require as requireToDate } from './toDate.esm2.js';
+
+var hasRequiredFormatISO;
+
+function requireFormatISO () {
+	if (hasRequiredFormatISO) return formatISO;
+	hasRequiredFormatISO = 1;
+	formatISO.formatISO = formatISO$1;
+	var _index = /*@__PURE__*/ requireAddLeadingZeros();
+	var _index2 = /*@__PURE__*/ requireToDate();
+
+	/**
+	 * The {@link formatISO} function options.
+	 */
+
+	/**
+	 * @name formatISO
+	 * @category Common Helpers
+	 * @summary Format the date according to the ISO 8601 standard (https://support.sas.com/documentation/cdl/en/lrdict/64316/HTML/default/viewer.htm#a003169814.htm).
+	 *
+	 * @description
+	 * Return the formatted date string in ISO 8601 format. Options may be passed to control the parts and notations of the date.
+	 *
+	 * @param date - The original date
+	 * @param options - An object with options.
+	 *
+	 * @returns The formatted date string (in local time zone)
+	 *
+	 * @throws `date` must not be Invalid Date
+	 *
+	 * @example
+	 * // Represent 18 September 2019 in ISO 8601 format (local time zone is UTC):
+	 * const result = formatISO(new Date(2019, 8, 18, 19, 0, 52))
+	 * //=> '2019-09-18T19:00:52Z'
+	 *
+	 * @example
+	 * // Represent 18 September 2019 in ISO 8601, short format (local time zone is UTC):
+	 * const result = formatISO(new Date(2019, 8, 18, 19, 0, 52), { format: 'basic' })
+	 * //=> '20190918T190052'
+	 *
+	 * @example
+	 * // Represent 18 September 2019 in ISO 8601 format, date only:
+	 * const result = formatISO(new Date(2019, 8, 18, 19, 0, 52), { representation: 'date' })
+	 * //=> '2019-09-18'
+	 *
+	 * @example
+	 * // Represent 18 September 2019 in ISO 8601 format, time only (local time zone is UTC):
+	 * const result = formatISO(new Date(2019, 8, 18, 19, 0, 52), { representation: 'time' })
+	 * //=> '19:00:52Z'
+	 */
+	function formatISO$1(date, options) {
+	  const date_ = (0, _index2.toDate)(date, options?.in);
+
+	  if (isNaN(+date_)) {
+	    throw new RangeError("Invalid time value");
+	  }
+
+	  const format = options?.format ?? "extended";
+	  const representation = options?.representation ?? "complete";
+
+	  let result = "";
+	  let tzOffset = "";
+
+	  const dateDelimiter = format === "extended" ? "-" : "";
+	  const timeDelimiter = format === "extended" ? ":" : "";
+
+	  // Representation is either 'date' or 'complete'
+	  if (representation !== "time") {
+	    const day = (0, _index.addLeadingZeros)(date_.getDate(), 2);
+	    const month = (0, _index.addLeadingZeros)(date_.getMonth() + 1, 2);
+	    const year = (0, _index.addLeadingZeros)(date_.getFullYear(), 4);
+
+	    // yyyyMMdd or yyyy-MM-dd.
+	    result = `${year}${dateDelimiter}${month}${dateDelimiter}${day}`;
+	  }
+
+	  // Representation is either 'time' or 'complete'
+	  if (representation !== "date") {
+	    // Add the timezone.
+	    const offset = date_.getTimezoneOffset();
+
+	    if (offset !== 0) {
+	      const absoluteOffset = Math.abs(offset);
+	      const hourOffset = (0, _index.addLeadingZeros)(
+	        Math.trunc(absoluteOffset / 60),
+	        2,
+	      );
+	      const minuteOffset = (0, _index.addLeadingZeros)(absoluteOffset % 60, 2);
+	      // If less than 0, the sign is +, because it is ahead of time.
+	      const sign = offset < 0 ? "+" : "-";
+
+	      tzOffset = `${sign}${hourOffset}:${minuteOffset}`;
+	    } else {
+	      tzOffset = "Z";
+	    }
+
+	    const hour = (0, _index.addLeadingZeros)(date_.getHours(), 2);
+	    const minute = (0, _index.addLeadingZeros)(date_.getMinutes(), 2);
+	    const second = (0, _index.addLeadingZeros)(date_.getSeconds(), 2);
+
+	    // If there's also date, separate it with time with 'T'
+	    const separator = result === "" ? "" : "T";
+
+	    // Creates a time string consisting of hour, minute, and second, separated by delimiters, if defined.
+	    const time = [hour, minute, second].join(timeDelimiter);
+
+	    // HHmmss or HH:mm:ss.
+	    result = `${result}${separator}${time}${tzOffset}`;
+	  }
+
+	  return result;
+	}
+	return formatISO;
+}
+
+export { requireFormatISO as __require };