@sbb-esta/lyne-elements-experimental 5.0.2 → 5.2.0

package/development/core.js

@@ -1,5 +1,1195 @@
-import { n as removeTimezoneFromISOTimeString, t as durationToTime } from "./date-helper-BcTDWVeP.js";
-import { extractTimeAndStringFromNoticeText, isConnectionLeg, isRideLeg } from "./core/timetable/timetable-helper.js";
-import { getDepartureArrivalTimeAttribute } from "./core/timetable/access-leg-helper.js";
-import "./core/timetable/timetable-properties.js";
-export { durationToTime, extractTimeAndStringFromNoticeText, getDepartureArrivalTimeAttribute, isConnectionLeg, isRideLeg, removeTimezoneFromISOTimeString };
+import { i18nDurationDay, i18nDurationHour, i18nDurationMinute, i18nWalkingDistanceArrival, i18nWalkingDistanceDeparture } from "@sbb-esta/lyne-elements/core.js";
+import { html, nothing } from "lit";
+import "@sbb-esta/lyne-elements/icon.pure.js";
+
+//#region node_modules/date-fns/constants.js
+/**
+* @constant
+* @name daysInYear
+* @summary Days in 1 year.
+*
+* @description
+* How many days in a year.
+*
+* One years equals 365.2425 days according to the formula:
+*
+* > Leap year occurs every 4 years, except for years that are divisible by 100 and not divisible by 400.
+* > 1 mean year = (365+1/4-1/100+1/400) days = 365.2425 days
+*/
+const daysInYear = 365.2425;
+/**
+* @constant
+* @name maxTime
+* @summary Maximum allowed time.
+*
+* @example
+* import { maxTime } from "./constants/date-fns/constants";
+*
+* const isValid = 8640000000000001 <= maxTime;
+* //=> false
+*
+* new Date(8640000000000001);
+* //=> Invalid Date
+*/
+const maxTime = Math.pow(10, 8) * 24 * 60 * 60 * 1e3;
+/**
+* @constant
+* @name minTime
+* @summary Minimum allowed time.
+*
+* @example
+* import { minTime } from "./constants/date-fns/constants";
+*
+* const isValid = -8640000000000001 >= minTime;
+* //=> false
+*
+* new Date(-8640000000000001)
+* //=> Invalid Date
+*/
+const minTime = -maxTime;
+/**
+* @constant
+* @name millisecondsInDay
+* @summary Milliseconds in 1 day.
+*/
+const millisecondsInDay = 864e5;
+/**
+* @constant
+* @name millisecondsInMinute
+* @summary Milliseconds in 1 minute
+*/
+const millisecondsInMinute = 6e4;
+/**
+* @constant
+* @name millisecondsInHour
+* @summary Milliseconds in 1 hour
+*/
+const millisecondsInHour = 36e5;
+/**
+* @constant
+* @name secondsInHour
+* @summary Seconds in 1 hour.
+*/
+const secondsInHour = 3600;
+/**
+* @constant
+* @name secondsInDay
+* @summary Seconds in 1 day.
+*/
+const secondsInDay = secondsInHour * 24;
+/**
+* @constant
+* @name secondsInWeek
+* @summary Seconds in 1 week.
+*/
+const secondsInWeek = secondsInDay * 7;
+/**
+* @constant
+* @name secondsInYear
+* @summary Seconds in 1 year.
+*/
+const secondsInYear = secondsInDay * daysInYear;
+/**
+* @constant
+* @name secondsInMonth
+* @summary Seconds in 1 month
+*/
+const secondsInMonth = secondsInYear / 12;
+/**
+* @constant
+* @name secondsInQuarter
+* @summary Seconds in 1 quarter.
+*/
+const secondsInQuarter = secondsInMonth * 3;
+/**
+* @constant
+* @name constructFromSymbol
+* @summary Symbol enabling Date extensions to inherit properties from the reference date.
+*
+* The symbol is used to enable the `constructFrom` function to construct a date
+* using a reference date and a value. It allows to transfer extra properties
+* from the reference date to the new date. It's useful for extensions like
+* [`TZDate`](https://github.com/date-fns/tz) that accept a time zone as
+* a constructor argument.
+*/
+const constructFromSymbol = Symbol.for("constructDateFrom");
+
+//#endregion
+//#region node_modules/date-fns/constructFrom.js
+/**
+* @name constructFrom
+* @category Generic Helpers
+* @summary Constructs a date using the reference date and the value
+*
+* @description
+* The function constructs a new date using the constructor from the reference
+* date and the given value. It helps to build generic functions that accept
+* date extensions.
+*
+* It defaults to `Date` if the passed reference date is a number or a string.
+*
+* Starting from v3.7.0, it allows to construct a date using `[Symbol.for("constructDateFrom")]`
+* enabling to transfer extra properties from the reference date to the new date.
+* It's useful for extensions like [`TZDate`](https://github.com/date-fns/tz)
+* that accept a time zone as a constructor argument.
+*
+* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+*
+* @param date - The reference date to take constructor from
+* @param value - The value to create the date
+*
+* @returns Date initialized using the given date and value
+*
+* @example
+* import { constructFrom } from "./constructFrom/date-fns";
+*
+* // A function that clones a date preserving the original type
+* function cloneDate<DateType extends Date>(date: DateType): DateType {
+*   return constructFrom(
+*     date, // Use constructor from the given date
+*     date.getTime() // Use the date value to create a new date
+*   );
+* }
+*/
+function constructFrom(date, value) {
+	if (typeof date === "function") return date(value);
+	if (date && typeof date === "object" && constructFromSymbol in date) return date[constructFromSymbol](value);
+	if (date instanceof Date) return new date.constructor(value);
+	return new Date(value);
+}
+
+//#endregion
+//#region node_modules/date-fns/toDate.js
+/**
+* @name toDate
+* @category Common Helpers
+* @summary Convert the given argument to an instance of Date.
+*
+* @description
+* Convert the given argument to an instance of Date.
+*
+* If the argument is an instance of Date, the function returns its clone.
+*
+* If the argument is a number, it is treated as a timestamp.
+*
+* If the argument is none of the above, the function returns Invalid Date.
+*
+* Starting from v3.7.0, it clones a date using `[Symbol.for("constructDateFrom")]`
+* enabling to transfer extra properties from the reference date to the new date.
+* It's useful for extensions like [`TZDate`](https://github.com/date-fns/tz)
+* that accept a time zone as a constructor argument.
+*
+* **Note**: *all* Date arguments passed to any *date-fns* function is processed by `toDate`.
+*
+* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+* @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+*
+* @param argument - The value to convert
+*
+* @returns The parsed date in the local time zone
+*
+* @example
+* // Clone the date:
+* const result = toDate(new Date(2014, 1, 11, 11, 30, 30))
+* //=> Tue Feb 11 2014 11:30:30
+*
+* @example
+* // Convert the timestamp to date:
+* const result = toDate(1392098430000)
+* //=> Tue Feb 11 2014 11:30:30
+*/
+function toDate(argument, context) {
+	return constructFrom(context || argument, argument);
+}
+
+//#endregion
+//#region node_modules/date-fns/addDays.js
+/**
+* The {@link addDays} function options.
+*/
+/**
+* @name addDays
+* @category Day Helpers
+* @summary Add the specified number of days to the given date.
+*
+* @description
+* Add the specified number of days to the given date.
+*
+* **You don't need date-fns\***:
+*
+* Temporal has a built-in `add` method on all its classes:
+*
+* - [`Temporal.Instant.prototype.add()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Temporal/Instant/add)
+* - [`Temporal.PlainDate.prototype.add()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Temporal/PlainDate/add)
+* - [`Temporal.PlainDateTime.prototype.add()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Temporal/PlainDateTime/add)
+* - [`Temporal.PlainTime.prototype.add()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Temporal/PlainTime/add)
+* - [`Temporal.PlainYearMonth.prototype.add()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Temporal/PlainYearMonth/add)
+* - [`Temporal.ZonedDateTime.prototype.add()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Temporal/ZonedDateTime/add)
+*
+* \* **Not really**, see: https://date-fns.org/you-dont-need-date-fns
+*
+* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+* @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+*
+* @param date - The date to be changed
+* @param amount - The amount of days to be added.
+* @param options - An object with options
+*
+* @returns The new date with the days added
+*
+* @example
+* // Add 10 days to 1 September 2014:
+* const result = addDays(new Date(2014, 8, 1), 10)
+* //=> Thu Sep 11 2014 00:00:00
+*
+* @example
+* // Using Temporal:
+* // Add 10 days to 1 September 2014:
+* Temporal.PlainDate.from("2014-09-01").add({ days: 10 }).toString();
+* //=> "2014-09-11"
+*/
+function addDays(date, amount, options) {
+	const _date = toDate(date, options?.in);
+	if (isNaN(amount)) return constructFrom(options?.in || date, NaN);
+	if (!amount) return _date;
+	_date.setDate(_date.getDate() + amount);
+	return _date;
+}
+
+//#endregion
+//#region node_modules/date-fns/addMilliseconds.js
+/**
+* The {@link addMilliseconds} function options.
+*/
+/**
+* @name addMilliseconds
+* @category Millisecond Helpers
+* @summary Add the specified number of milliseconds to the given date.
+*
+* @description
+* Add the specified number of milliseconds to the given date.
+*
+* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+* @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+*
+* @param date - The date to be changed
+* @param amount - The amount of milliseconds to be added.
+* @param options - The options object
+*
+* @returns The new date with the milliseconds added
+*
+* @example
+* // Add 750 milliseconds to 10 July 2014 12:45:30.000:
+* const result = addMilliseconds(new Date(2014, 6, 10, 12, 45, 30, 0), 750)
+* //=> Thu Jul 10 2014 12:45:30.750
+*/
+function addMilliseconds(date, amount, options) {
+	return constructFrom(options?.in || date, +toDate(date) + amount);
+}
+
+//#endregion
+//#region node_modules/date-fns/addHours.js
+/**
+* The {@link addHours} function options.
+*/
+/**
+* @name addHours
+* @category Hour Helpers
+* @summary Add the specified number of hours to the given date.
+*
+* @description
+* Add the specified number of hours to the given date.
+*
+* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+* @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+*
+* @param date - The date to be changed
+* @param amount - The amount of hours to be added
+* @param options - An object with options
+*
+* @returns The new date with the hours added
+*
+* @example
+* // Add 2 hours to 10 July 2014 23:00:00:
+* const result = addHours(new Date(2014, 6, 10, 23, 0), 2)
+* //=> Fri Jul 11 2014 01:00:00
+*/
+function addHours(date, amount, options) {
+	return addMilliseconds(date, amount * millisecondsInHour, options);
+}
+
+//#endregion
+//#region node_modules/date-fns/_lib/getTimezoneOffsetInMilliseconds.js
+/**
+* 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) {
+	const _date = toDate(date);
+	const 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;
+}
+
+//#endregion
+//#region node_modules/date-fns/_lib/normalizeDates.js
+function normalizeDates(context, ...dates) {
+	const normalize = constructFrom.bind(null, context || dates.find((date) => typeof date === "object"));
+	return dates.map(normalize);
+}
+
+//#endregion
+//#region node_modules/date-fns/startOfDay.js
+/**
+* The {@link startOfDay} function options.
+*/
+/**
+* @name startOfDay
+* @category Day Helpers
+* @summary Return the start of a day for the given date.
+*
+* @description
+* Return the start of a day for the given date.
+* The result will be in the local timezone.
+*
+* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+* @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+*
+* @param date - The original date
+* @param options - The options
+*
+* @returns The start of a day
+*
+* @example
+* // The start of a day for 2 September 2014 11:55:00:
+* const result = startOfDay(new Date(2014, 8, 2, 11, 55, 0))
+* //=> Tue Sep 02 2014 00:00:00
+*/
+function startOfDay(date, options) {
+	const _date = toDate(date, options?.in);
+	_date.setHours(0, 0, 0, 0);
+	return _date;
+}
+
+//#endregion
+//#region node_modules/date-fns/differenceInCalendarDays.js
+/**
+* The {@link differenceInCalendarDays} function options.
+*/
+/**
+* @name differenceInCalendarDays
+* @category Day Helpers
+* @summary Get the number of calendar days between the given dates.
+*
+* @description
+* Get the number of calendar days between the given dates. This means that the times are removed
+* from the dates and then the difference in days is calculated.
+*
+* @param laterDate - The later date
+* @param earlierDate - The earlier date
+* @param options - The options object
+*
+* @returns The number of calendar days
+*
+* @example
+* // How many calendar days are between
+* // 2 July 2011 23:00:00 and 2 July 2012 00:00:00?
+* const result = differenceInCalendarDays(
+*   new Date(2012, 6, 2, 0, 0),
+*   new Date(2011, 6, 2, 23, 0)
+* )
+* //=> 366
+* // How many calendar days are between
+* // 2 July 2011 23:59:00 and 3 July 2011 00:01:00?
+* const result = differenceInCalendarDays(
+*   new Date(2011, 6, 3, 0, 1),
+*   new Date(2011, 6, 2, 23, 59)
+* )
+* //=> 1
+*/
+function differenceInCalendarDays(laterDate, earlierDate, options) {
+	const [laterDate_, earlierDate_] = normalizeDates(options?.in, laterDate, earlierDate);
+	const laterStartOfDay = startOfDay(laterDate_);
+	const earlierStartOfDay = startOfDay(earlierDate_);
+	const laterTimestamp = +laterStartOfDay - getTimezoneOffsetInMilliseconds(laterStartOfDay);
+	const earlierTimestamp = +earlierStartOfDay - getTimezoneOffsetInMilliseconds(earlierStartOfDay);
+	return Math.round((laterTimestamp - earlierTimestamp) / millisecondsInDay);
+}
+
+//#endregion
+//#region node_modules/date-fns/addMinutes.js
+/**
+* The {@link addMinutes} function options.
+*/
+/**
+* @name addMinutes
+* @category Minute Helpers
+* @summary Add the specified number of minutes to the given date.
+*
+* @description
+* Add the specified number of minutes to the given date.
+*
+* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+* @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+*
+* @param date - The date to be changed
+* @param amount - The amount of minutes to be added.
+* @param options - An object with options
+*
+* @returns The new date with the minutes added
+*
+* @example
+* // Add 30 minutes to 10 July 2014 12:00:00:
+* const result = addMinutes(new Date(2014, 6, 10, 12, 0), 30)
+* //=> Thu Jul 10 2014 12:30:00
+*/
+function addMinutes(date, amount, options) {
+	const _date = toDate(date, options?.in);
+	_date.setTime(_date.getTime() + amount * millisecondsInMinute);
+	return _date;
+}
+
+//#endregion
+//#region node_modules/date-fns/isDate.js
+/**
+* @name isDate
+* @category Common Helpers
+* @summary Is the given value a date?
+*
+* @description
+* Returns true if the given value is an instance of Date. The function works for dates transferred across iframes.
+*
+* @param value - The value to check
+*
+* @returns True if the given value is a date
+*
+* @example
+* // For a valid date:
+* const result = isDate(new Date())
+* //=> true
+*
+* @example
+* // For an invalid date:
+* const result = isDate(new Date(NaN))
+* //=> true
+*
+* @example
+* // For some value:
+* const result = isDate('2014-02-31')
+* //=> false
+*
+* @example
+* // For an object:
+* const result = isDate({})
+* //=> false
+*/
+function isDate(value) {
+	return value instanceof Date || typeof value === "object" && Object.prototype.toString.call(value) === "[object Date]";
+}
+
+//#endregion
+//#region node_modules/date-fns/isValid.js
+/**
+* @name isValid
+* @category Common Helpers
+* @summary Is the given date valid?
+*
+* @description
+* Returns false if argument is Invalid Date and true otherwise.
+* Argument is converted to Date using `toDate`. See [toDate](https://date-fns.org/docs/toDate)
+* Invalid Date is a Date, whose time value is NaN.
+*
+* Time value of Date: http://es5.github.io/#x15.9.1.1
+*
+* @param date - The date to check
+*
+* @returns The date is valid
+*
+* @example
+* // For the valid date:
+* const result = isValid(new Date(2014, 1, 31))
+* //=> true
+*
+* @example
+* // For the value, convertible into a date:
+* const result = isValid(1393804800000)
+* //=> true
+*
+* @example
+* // For the invalid date:
+* const result = isValid(new Date(''))
+* //=> false
+*/
+function isValid(date) {
+	return !(!isDate(date) && typeof date !== "number" || isNaN(+toDate(date)));
+}
+
+//#endregion
+//#region node_modules/date-fns/differenceInDays.js
+/**
+* The {@link differenceInDays} function options.
+*/
+/**
+* @name differenceInDays
+* @category Day Helpers
+* @summary Get the number of full days between the given dates.
+*
+* @description
+* Get the number of full day periods between two dates. Fractional days are
+* truncated towards zero.
+*
+* One "full day" is the distance between a local time in one day to the same
+* local time on the next or previous day. A full day can sometimes be less than
+* or more than 24 hours if a daylight savings change happens between two dates.
+*
+* To ignore DST and only measure exact 24-hour periods, use this instead:
+* `Math.trunc(differenceInHours(dateLeft, dateRight)/24)|0`.
+*
+* @param laterDate - The later date
+* @param earlierDate - The earlier date
+* @param options - An object with options
+*
+* @returns The number of full days according to the local timezone
+*
+* @example
+* // How many full days are between
+* // 2 July 2011 23:00:00 and 2 July 2012 00:00:00?
+* const result = differenceInDays(
+*   new Date(2012, 6, 2, 0, 0),
+*   new Date(2011, 6, 2, 23, 0)
+* )
+* //=> 365
+*
+* @example
+* // How many full days are between
+* // 2 July 2011 23:59:00 and 3 July 2011 00:01:00?
+* const result = differenceInDays(
+*   new Date(2011, 6, 3, 0, 1),
+*   new Date(2011, 6, 2, 23, 59)
+* )
+* //=> 0
+*
+* @example
+* // How many full days are between
+* // 1 March 2020 0:00 and 1 June 2020 0:00 ?
+* // Note: because local time is used, the
+* // result will always be 92 days, even in
+* // time zones where DST starts and the
+* // period has only 92*24-1 hours.
+* const result = differenceInDays(
+*   new Date(2020, 5, 1),
+*   new Date(2020, 2, 1)
+* )
+* //=> 92
+*/
+function differenceInDays(laterDate, earlierDate, options) {
+	const [laterDate_, earlierDate_] = normalizeDates(options?.in, laterDate, earlierDate);
+	const sign = compareLocalAsc(laterDate_, earlierDate_);
+	const difference = Math.abs(differenceInCalendarDays(laterDate_, earlierDate_));
+	laterDate_.setDate(laterDate_.getDate() - sign * difference);
+	const result = sign * (difference - Number(compareLocalAsc(laterDate_, earlierDate_) === -sign));
+	return result === 0 ? 0 : result;
+}
+function compareLocalAsc(laterDate, earlierDate) {
+	const diff = laterDate.getFullYear() - earlierDate.getFullYear() || laterDate.getMonth() - earlierDate.getMonth() || laterDate.getDate() - earlierDate.getDate() || laterDate.getHours() - earlierDate.getHours() || laterDate.getMinutes() - earlierDate.getMinutes() || laterDate.getSeconds() - earlierDate.getSeconds() || laterDate.getMilliseconds() - earlierDate.getMilliseconds();
+	if (diff < 0) return -1;
+	if (diff > 0) return 1;
+	return diff;
+}
+
+//#endregion
+//#region node_modules/date-fns/_lib/getRoundingMethod.js
+function getRoundingMethod(method) {
+	return (number) => {
+		const result = (method ? Math[method] : Math.trunc)(number);
+		return result === 0 ? 0 : result;
+	};
+}
+
+//#endregion
+//#region node_modules/date-fns/differenceInHours.js
+/**
+* The {@link differenceInHours} function options.
+*/
+/**
+* @name differenceInHours
+* @category Hour Helpers
+* @summary Get the number of hours between the given dates.
+*
+* @description
+* Get the number of hours between the given dates.
+*
+* @param laterDate - The later date
+* @param earlierDate - The earlier date
+* @param options - An object with options.
+*
+* @returns The number of hours
+*
+* @example
+* // How many hours are between 2 July 2014 06:50:00 and 2 July 2014 19:00:00?
+* const result = differenceInHours(
+*   new Date(2014, 6, 2, 19, 0),
+*   new Date(2014, 6, 2, 6, 50)
+* )
+* //=> 12
+*/
+function differenceInHours(laterDate, earlierDate, options) {
+	const [laterDate_, earlierDate_] = normalizeDates(options?.in, laterDate, earlierDate);
+	const diff = (+laterDate_ - +earlierDate_) / millisecondsInHour;
+	return getRoundingMethod(options?.roundingMethod)(diff);
+}
+
+//#endregion
+//#region node_modules/date-fns/differenceInMilliseconds.js
+/**
+* @name differenceInMilliseconds
+* @category Millisecond Helpers
+* @summary Get the number of milliseconds between the given dates.
+*
+* @description
+* Get the number of milliseconds between the given dates.
+*
+* @param laterDate - The later date
+* @param earlierDate - The earlier date
+*
+* @returns The number of milliseconds
+*
+* @example
+* // How many milliseconds are between
+* // 2 July 2014 12:30:20.600 and 2 July 2014 12:30:21.700?
+* const result = differenceInMilliseconds(
+*   new Date(2014, 6, 2, 12, 30, 21, 700),
+*   new Date(2014, 6, 2, 12, 30, 20, 600)
+* )
+* //=> 1100
+*/
+function differenceInMilliseconds(laterDate, earlierDate) {
+	return +toDate(laterDate) - +toDate(earlierDate);
+}
+
+//#endregion
+//#region node_modules/date-fns/differenceInMinutes.js
+/**
+* The {@link differenceInMinutes} function options.
+*/
+/**
+* @name differenceInMinutes
+* @category Minute Helpers
+* @summary Get the number of minutes between the given dates.
+*
+* @description
+* Get the signed number of full (rounded towards 0) minutes between the given dates.
+*
+* @param dateLeft - The later date
+* @param dateRight - The earlier date
+* @param options - An object with options.
+*
+* @returns The number of minutes
+*
+* @example
+* // How many minutes are between 2 July 2014 12:07:59 and 2 July 2014 12:20:00?
+* const result = differenceInMinutes(
+*   new Date(2014, 6, 2, 12, 20, 0),
+*   new Date(2014, 6, 2, 12, 7, 59)
+* )
+* //=> 12
+*
+* @example
+* // How many minutes are between 10:01:59 and 10:00:00
+* const result = differenceInMinutes(
+*   new Date(2000, 0, 1, 10, 0, 0),
+*   new Date(2000, 0, 1, 10, 1, 59)
+* )
+* //=> -1
+*/
+function differenceInMinutes(dateLeft, dateRight, options) {
+	const diff = differenceInMilliseconds(dateLeft, dateRight) / millisecondsInMinute;
+	return getRoundingMethod(options?.roundingMethod)(diff);
+}
+
+//#endregion
+//#region node_modules/date-fns/subDays.js
+/**
+* The {@link subDays} function options.
+*/
+/**
+* @name subDays
+* @category Day Helpers
+* @summary Subtract the specified number of days from the given date.
+*
+* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+* @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+*
+* @param date - The date to be changed
+* @param amount - The amount of days to be subtracted.
+* @param options - An object with options
+*
+* @returns The new date with the days subtracted
+*
+* @example
+* // Subtract 10 days from 1 September 2014:
+* const result = subDays(new Date(2014, 8, 1), 10)
+* //=> Fri Aug 22 2014 00:00:00
+*/
+function subDays(date, amount, options) {
+	return addDays(date, -amount, options);
+}
+
+//#endregion
+//#region node_modules/date-fns/parseISO.js
+/**
+* The {@link parseISO} function options.
+*/
+/**
+* @name parseISO
+* @category Common Helpers
+* @summary Parse ISO string
+*
+* @description
+* Parse the given string in ISO 8601 format and return an instance of Date.
+*
+* Function accepts complete ISO 8601 formats as well as partial implementations.
+* ISO 8601: http://en.wikipedia.org/wiki/ISO_8601
+*
+* If the argument isn't a string, the function cannot parse the string or
+* the values are invalid, it returns Invalid Date.
+*
+* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+* @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+*
+* @param argument - The value to convert
+* @param options - An object with options
+*
+* @returns The parsed date in the local time zone
+*
+* @example
+* // Convert string '2014-02-11T11:30:30' to date:
+* const result = parseISO('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 = parseISO('+02014101', { additionalDigits: 1 })
+* //=> Fri Apr 11 2014 00:00:00
+*/
+function parseISO(argument, options) {
+	const invalidDate = () => constructFrom(options?.in, NaN);
+	const additionalDigits = options?.additionalDigits ?? 2;
+	const dateStrings = splitDateString(argument);
+	let date;
+	if (dateStrings.date) {
+		const parseYearResult = parseYear(dateStrings.date, additionalDigits);
+		date = parseDate(parseYearResult.restDateString, parseYearResult.year);
+	}
+	if (!date || isNaN(+date)) return invalidDate();
+	const timestamp = +date;
+	let time = 0;
+	let offset;
+	if (dateStrings.time) {
+		time = parseTime(dateStrings.time);
+		if (isNaN(time)) return invalidDate();
+	}
+	if (dateStrings.timezone) {
+		offset = parseTimezone(dateStrings.timezone);
+		if (isNaN(offset)) return invalidDate();
+	} else {
+		const tmpDate = new Date(timestamp + time);
+		const result = toDate(0, options?.in);
+		result.setFullYear(tmpDate.getUTCFullYear(), tmpDate.getUTCMonth(), tmpDate.getUTCDate());
+		result.setHours(tmpDate.getUTCHours(), tmpDate.getUTCMinutes(), tmpDate.getUTCSeconds(), tmpDate.getUTCMilliseconds());
+		return result;
+	}
+	return toDate(timestamp + time + offset, options?.in);
+}
+const patterns = {
+	dateTimeDelimiter: /[T ]/,
+	timeZoneDelimiter: /[Z ]/i,
+	timezone: /([Z+-].*)$/
+};
+const dateRegex = /^-?(?:(\d{3})|(\d{2})(?:-?(\d{2}))?|W(\d{2})(?:-?(\d{1}))?|)$/;
+const timeRegex = /^(\d{2}(?:[.,]\d*)?)(?::?(\d{2}(?:[.,]\d*)?))?(?::?(\d{2}(?:[.,]\d*)?))?$/;
+const timezoneRegex = /^([+-])(\d{2})(?::?(\d{2}))?$/;
+function splitDateString(dateString) {
+	const dateStrings = {};
+	const array = dateString.split(patterns.dateTimeDelimiter);
+	let timeString;
+	if (array.length > 2) return dateStrings;
+	if (/:/.test(array[0])) timeString = array[0];
+	else {
+		dateStrings.date = array[0];
+		timeString = array[1];
+		if (patterns.timeZoneDelimiter.test(dateStrings.date)) {
+			dateStrings.date = dateString.split(patterns.timeZoneDelimiter)[0];
+			timeString = dateString.substr(dateStrings.date.length, dateString.length);
+		}
+	}
+	if (timeString) {
+		const token = patterns.timezone.exec(timeString);
+		if (token) {
+			dateStrings.time = timeString.replace(token[1], "");
+			dateStrings.timezone = token[1];
+		} else dateStrings.time = timeString;
+	}
+	return dateStrings;
+}
+function parseYear(dateString, additionalDigits) {
+	const regex = new RegExp("^(?:(\\d{4}|[+-]\\d{" + (4 + additionalDigits) + "})|(\\d{2}|[+-]\\d{" + (2 + additionalDigits) + "})$)");
+	const captures = dateString.match(regex);
+	if (!captures) return {
+		year: NaN,
+		restDateString: ""
+	};
+	const year = captures[1] ? parseInt(captures[1]) : null;
+	const century = captures[2] ? parseInt(captures[2]) : null;
+	return {
+		year: century === null ? year : century * 100,
+		restDateString: dateString.slice((captures[1] || captures[2]).length)
+	};
+}
+function parseDate(dateString, year) {
+	if (year === null) return /* @__PURE__ */ new Date(NaN);
+	const captures = dateString.match(dateRegex);
+	if (!captures) return /* @__PURE__ */ new Date(NaN);
+	const isWeekDate = !!captures[4];
+	const dayOfYear = parseDateUnit(captures[1]);
+	const month = parseDateUnit(captures[2]) - 1;
+	const day = parseDateUnit(captures[3]);
+	const week = parseDateUnit(captures[4]);
+	const dayOfWeek = parseDateUnit(captures[5]) - 1;
+	if (isWeekDate) {
+		if (!validateWeekDate(year, week, dayOfWeek)) return /* @__PURE__ */ new Date(NaN);
+		return dayOfISOWeekYear(year, week, dayOfWeek);
+	} else {
+		const date = /* @__PURE__ */ new Date(0);
+		if (!validateDate(year, month, day) || !validateDayOfYearDate(year, dayOfYear)) return /* @__PURE__ */ new Date(NaN);
+		date.setUTCFullYear(year, month, Math.max(dayOfYear, day));
+		return date;
+	}
+}
+function parseDateUnit(value) {
+	return value ? parseInt(value) : 1;
+}
+function parseTime(timeString) {
+	const captures = timeString.match(timeRegex);
+	if (!captures) return NaN;
+	const hours = parseTimeUnit(captures[1]);
+	const minutes = parseTimeUnit(captures[2]);
+	const seconds = parseTimeUnit(captures[3]);
+	if (!validateTime(hours, minutes, seconds)) return NaN;
+	return hours * millisecondsInHour + minutes * millisecondsInMinute + seconds * 1e3;
+}
+function parseTimeUnit(value) {
+	return value && parseFloat(value.replace(",", ".")) || 0;
+}
+function parseTimezone(timezoneString) {
+	if (timezoneString === "Z") return 0;
+	const captures = timezoneString.match(timezoneRegex);
+	if (!captures) return 0;
+	const sign = captures[1] === "+" ? -1 : 1;
+	const hours = parseInt(captures[2]);
+	const minutes = captures[3] && parseInt(captures[3]) || 0;
+	if (!validateTimezone(hours, minutes)) return NaN;
+	return sign * (hours * millisecondsInHour + minutes * millisecondsInMinute);
+}
+function dayOfISOWeekYear(isoWeekYear, week, day) {
+	const date = /* @__PURE__ */ new Date(0);
+	date.setUTCFullYear(isoWeekYear, 0, 4);
+	const fourthOfJanuaryDay = date.getUTCDay() || 7;
+	const diff = (week - 1) * 7 + day + 1 - fourthOfJanuaryDay;
+	date.setUTCDate(date.getUTCDate() + diff);
+	return date;
+}
+const daysInMonths = [
+	31,
+	null,
+	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) {
+	return month >= 0 && month <= 11 && date >= 1 && date <= (daysInMonths[month] || (isLeapYearIndex(year) ? 29 : 28));
+}
+function validateDayOfYearDate(year, dayOfYear) {
+	return dayOfYear >= 1 && dayOfYear <= (isLeapYearIndex(year) ? 366 : 365);
+}
+function validateWeekDate(_year, week, day) {
+	return week >= 1 && week <= 53 && day >= 0 && day <= 6;
+}
+function validateTime(hours, minutes, seconds) {
+	if (hours === 24) return minutes === 0 && seconds === 0;
+	return seconds >= 0 && seconds < 60 && minutes >= 0 && minutes < 60 && hours >= 0 && hours < 25;
+}
+function validateTimezone(_hours, minutes) {
+	return minutes >= 0 && minutes <= 59;
+}
+
+//#endregion
+//#region node_modules/date-fns/subHours.js
+/**
+* The {@link subHours} function options.
+*/
+/**
+* @name subHours
+* @category Hour Helpers
+* @summary Subtract the specified number of hours from the given date.
+*
+* @description
+* Subtract the specified number of hours from the given date.
+*
+* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+* @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+*
+* @param date - The date to be changed
+* @param amount - The amount of hours to be subtracted.
+* @param options - The options
+*
+* @returns The new date with the hours subtracted
+*
+* @example
+* // Subtract 2 hours from 11 July 2014 01:00:00:
+* const result = subHours(new Date(2014, 6, 11, 1, 0), 2)
+* //=> Thu Jul 10 2014 23:00:00
+*/
+function subHours(date, amount, options) {
+	return addHours(date, -amount, options);
+}
+
+//#endregion
+//#region src/elements-experimental/core/datetime/date-helper.ts
+/**
+* This function removes the offset of a ISO date string. This needs to be done to make sure that the offset is ignored.
+* If it is not removed the time would be converted to the browsers local time.
+* Example: "2022-08-29T09:30:00+03:00" would be changed to "2022-08-29T08:30:00+02:00" --> not the desired outcome, as we want to use the time in the timezone and not the local time.
+*
+* After the offset is removed a new date is created in the browsers local time. This ensures that the time of the ISO date string is displayed and not a converted time.
+* Example: "2022-08-29T09:30:00+03:00" would be changed to "2022-08-29T09:30:00+02:00" --> desired outcome
+* Attention: This function does not convert the time to the correct time in the local timezone. It is a workaround to make sure, that the given time is displayed without being converted.
+*
+* Offset: Difference between the timezone and Coordinated Universal Time.
+*
+* @param isoTime - the iso time with the timezone offset
+* @returns a new date with the local timezone with the local offset
+*/
+function removeTimezoneFromISOTimeString(isoTime) {
+	if (!isoTime) return;
+	if (!isValid(parseISO(isoTime))) return;
+	if (isoTime.includes("Z")) return new Date(isoTime.replace("Z", ""));
+	if (isoTime.includes("T")) {
+		const dateTime = isoTime.split("T");
+		if (dateTime[1] && (dateTime[1].includes("+") || dateTime[1].includes("-"))) return /* @__PURE__ */ new Date(`${dateTime[0]}T${dateTime[1].split(/[+-]/)[0]}`);
+	}
+	return new Date(isoTime);
+}
+/**
+* This function converts a duration number to date string with specific format
+*
+* @param duration - duration in minutes
+* @param currentLanguage - currentLanguage
+* @returns an Object with two strings in the format "dd hh mm" (short) an "x Day(s) x Hour(s) x Minute(s) (long)"
+* */
+const durationToTime = (duration, currentLanguage) => {
+	const short = [];
+	const long = [];
+	const now = 0;
+	let future = addMinutes(now, duration);
+	const days = differenceInDays(future, now);
+	if (days > 0) {
+		short.push(`${days} d`);
+		if (currentLanguage) long.push(`${days} ${days > 1 ? i18nDurationDay.multiple.long[currentLanguage] : i18nDurationDay.single.long[currentLanguage]}`);
+		future = subDays(future, days);
+	}
+	const hours = differenceInHours(future, now);
+	if (hours > 0) {
+		short.push(`${hours} h`);
+		if (currentLanguage) long.push(`${hours} ${hours > 1 ? i18nDurationHour.multiple.long[currentLanguage] : i18nDurationHour.single.long[currentLanguage]}`);
+		future = subHours(future, hours);
+	}
+	const minutes = differenceInMinutes(future, now);
+	if (minutes > 0) {
+		short.push(`${minutes} min`);
+		if (currentLanguage) long.push(`${minutes} ${minutes > 1 ? i18nDurationMinute.multiple.long[currentLanguage] : i18nDurationMinute.single.long[currentLanguage]}`);
+	}
+	return {
+		short: short.join(" "),
+		long: long.join(" ")
+	};
+};
+
+//#endregion
+//#region src/elements-experimental/core/timetable/timetable-helper.ts
+const isRideLeg = (leg) => {
+	return leg?.__typename === "PTRideLeg";
+};
+const isConnectionLeg = (leg) => {
+	return leg?.__typename === "PTConnectionLeg";
+};
+const extractTimeAndStringFromNoticeText = (notice) => {
+	const firstIndex = notice?.text?.template && notice.text.template.indexOf("(") + 1;
+	const noticeDuration = notice?.text?.template?.substring(firstIndex || 0, notice?.text?.template.indexOf(")"));
+	return {
+		duration: noticeDuration && +noticeDuration.substring(0, noticeDuration.length - 1) || 0,
+		text: notice?.text?.template?.split("(")[0] || ""
+	};
+};
+
+//#endregion
+//#region src/elements-experimental/core/timetable/access-leg-helper.ts
+/**
+* @returns the attribute of a ConnectionLeg
+*/
+function getPTConnectionAttribute(leg, connectionLegNotice) {
+	const connectionFirstLeg = isConnectionLeg(leg) ? leg : null;
+	const connectionFirstLegNotice = connectionFirstLeg ? connectionFirstLeg?.notices?.filter((notice) => connectionLegNotice.includes(notice.name))[0] : null;
+	return connectionFirstLegNotice ? {
+		duration: connectionFirstLeg?.duration || 0,
+		text: connectionFirstLegNotice?.text?.template || "",
+		icon: "walk-small"
+	} : null;
+}
+/**
+* @returns the extended enter attribute of the PTRideLeg
+*/
+function getFirstExtendedLegAttribute(leg, departureWalk, a11yFootpath, currentLanguage) {
+	const extendedFirstLeg = isRideLeg(leg) ? leg?.serviceJourney?.notices?.filter((notice) => ["CI"].includes(notice.name))[0] : null;
+	const extractTimeAndString = extendedFirstLeg && extractTimeAndStringFromNoticeText(extendedFirstLeg);
+	return extendedFirstLeg ? {
+		duration: (extractTimeAndString?.duration || 0) + (departureWalk || 0),
+		text: a11yFootpath ? i18nWalkingDistanceDeparture[currentLanguage] : extractTimeAndString?.text || "",
+		icon: a11yFootpath ? "wheelchair-small" : `sa-${extendedFirstLeg?.name?.toLowerCase()}`
+	} : null;
+}
+/**
+* @returns the extended exit attribute of the PTRideLeg
+*/
+function getLastExtendedLegAttribute(leg, arrivalWalk, a11yFootpath, currentLanguage) {
+	const extendedLastLeg = isRideLeg(leg) ? leg?.serviceJourney?.notices?.filter((notice) => ["CO"].includes(notice.name))[0] : null;
+	const extractTimeAndString = extendedLastLeg && extractTimeAndStringFromNoticeText(extendedLastLeg);
+	return extendedLastLeg ? {
+		duration: (extractTimeAndString?.duration || 0) + (arrivalWalk || 0),
+		text: a11yFootpath ? i18nWalkingDistanceArrival[currentLanguage] : extractTimeAndString?.text || "",
+		icon: a11yFootpath ? "wheelchair-small" : `sa-${extendedLastLeg?.name?.toLowerCase()}`
+	} : null;
+}
+/**
+* renders the extended exit/enter icon with the duration
+*/
+function renderTransferTime(duration, icon, currentLanguage, label, type) {
+	return html`
+    <span class="sbb-pearl-chain__time-transfer sbb-pearl-chain__time-transfer--${icon}-${type}">
+      <sbb-icon name=${icon}></sbb-icon>
+      <time datetime=${duration + "M"}>
+        <span class="sbb-screen-reader-only">
+          ${!label && type ? type === "departure" ? i18nWalkingDistanceDeparture[currentLanguage] : i18nWalkingDistanceArrival[currentLanguage] : nothing}
+          ${label ? html`<span>${label}</span>` : nothing}&nbsp;
+        </span>
+        ${duration}
+        <span class="sbb-pearl-chain__time-walktime-prime-symbol" aria-hidden="true">'</span>
+        <span class="sbb-screen-reader-only">min</span>
+      </time>
+    </span>
+  `;
+}
+/**
+* renders a walk-time icon with the walk duration
+*/
+function renderWalkTime(duration, label, variant, icon) {
+	return html`
+    <span class="sbb-pearl-chain__time-walktime sbb-pearl-chain__time-walktime--${icon}-${variant}">
+      <sbb-icon name=${icon}></sbb-icon>
+      <time datetime=${duration + "M"}>
+        <span class="sbb-screen-reader-only">${label}</span>
+        ${duration}
+        <span class="sbb-pearl-chain__time-walktime-prime-symbol" aria-hidden="true">'</span>
+      </time>
+    </span>
+  `;
+}
+/**
+* @returns renderDepartureTimeAttribute: A function that renders the element for the departure time attribute.
+* @returns renderArrivalTimeAttribute: A function that renders the element for the arrival time attribute.
+* @returns arrivalTimeAttribute: The access attribute for the arrival time.
+* @returns departureTimeAttribute: The access attribute for the departure time.
+* @param legs An array of Leg objects representing the journey legs.
+* @param departureWalk The walking distance in minutes from the departure point to the first leg.
+* @param arrivalWalk The walking distance in minutes from the last leg to the arrival point.
+* @param currentLanguage The current language for localization.
+* @param a11yFootpath Whether the a11y-icon should be shown.
+*/
+function getDepartureArrivalTimeAttribute(legs, departureWalk, arrivalWalk, currentLanguage, a11yFootpath) {
+	const connectionRideLeg = legs && legs.filter((leg) => isRideLeg(leg) || isConnectionLeg(leg))[0];
+	const connectionLegNotice = [
+		"YM",
+		"YB",
+		"Y",
+		"YT"
+	];
+	const connectionFirstLeg = getPTConnectionAttribute(connectionRideLeg, connectionLegNotice);
+	const extendedFirstLeg = getFirstExtendedLegAttribute(connectionRideLeg, departureWalk, a11yFootpath, currentLanguage);
+	const departureWalkAttribute = departureWalk ? {
+		text: i18nWalkingDistanceDeparture[currentLanguage],
+		duration: departureWalk,
+		icon: a11yFootpath ? "wheelchair-small" : "walk-small"
+	} : null;
+	const getDepartureType = () => {
+		if (connectionFirstLeg) return connectionFirstLeg;
+		else if (departureWalkAttribute && !extendedFirstLeg && !connectionFirstLeg) return departureWalkAttribute;
+		else if (extendedFirstLeg) return extendedFirstLeg;
+		else return null;
+	};
+	function renderDepartureTimeAttribute() {
+		return html`
+      ${connectionFirstLeg ? renderWalkTime(connectionFirstLeg.duration, connectionFirstLeg.text, "left", connectionFirstLeg.icon) : nothing}
+      ${departureWalkAttribute && !extendedFirstLeg && !connectionFirstLeg ? renderWalkTime(departureWalkAttribute.duration, departureWalkAttribute.text, "left", departureWalkAttribute.icon) : nothing}
+      ${extendedFirstLeg ? a11yFootpath ? renderWalkTime(extendedFirstLeg.duration, extendedFirstLeg.text, "left", extendedFirstLeg.icon) : renderTransferTime(extendedFirstLeg.duration, extendedFirstLeg.icon, currentLanguage, extendedFirstLeg.text, "departure") : nothing}
+    `;
+	}
+	const lastLeg = legs && legs[legs.length - 1];
+	const lastConnectionRideLeg = (isConnectionLeg(lastLeg) || isRideLeg(lastLeg)) && lastLeg;
+	const connectionLastLeg = lastConnectionRideLeg && getPTConnectionAttribute(lastConnectionRideLeg, connectionLegNotice);
+	const extendedLastLeg = lastConnectionRideLeg && getLastExtendedLegAttribute(lastConnectionRideLeg, arrivalWalk, a11yFootpath, currentLanguage);
+	const arrivalWalkAttribute = arrivalWalk ? {
+		text: i18nWalkingDistanceArrival[currentLanguage],
+		duration: arrivalWalk,
+		icon: a11yFootpath ? "wheelchair-small" : "walk-small"
+	} : null;
+	const getArrivalType = () => {
+		if (connectionLastLeg) return connectionLastLeg;
+		else if (arrivalWalkAttribute && !extendedLastLeg && !connectionLastLeg) return arrivalWalkAttribute;
+		else if (extendedLastLeg) return extendedLastLeg;
+		else return null;
+	};
+	function renderArrivalTimeAttribute() {
+		return html`
+      ${connectionLastLeg ? renderWalkTime(connectionLastLeg.duration, connectionLastLeg.text, "right", connectionLastLeg.icon) : nothing}
+      ${arrivalWalkAttribute && !extendedLastLeg && !connectionLastLeg ? renderWalkTime(arrivalWalkAttribute.duration, arrivalWalkAttribute.text, "right", arrivalWalkAttribute.icon) : nothing}
+      ${extendedLastLeg ? a11yFootpath ? renderWalkTime(extendedLastLeg.duration, extendedLastLeg.text, "right", extendedLastLeg.icon) : renderTransferTime(extendedLastLeg.duration, extendedLastLeg.icon, currentLanguage, extendedLastLeg.text, "arrival") : nothing}
+    `;
+	}
+	return {
+		renderDepartureTimeAttribute,
+		renderArrivalTimeAttribute,
+		departureTimeAttribute: getDepartureType(),
+		arrivalTimeAttribute: getArrivalType()
+	};
+}
+
+//#endregion
+export { durationToTime, extractTimeAndStringFromNoticeText, getDepartureArrivalTimeAttribute, isConnectionLeg, isRideLeg, removeTimezoneFromISOTimeString };