@btst/stack 1.4.1 → 1.5.0

package/dist/node_modules/.pnpm/react-day-picker@9.12.0_react@19.2.0/node_modules/react-day-picker/dist/esm/utils/addToRange.cjs

@@ -0,0 +1,97 @@
+'use strict';
+
+const DateLib = require('../classes/DateLib.cjs');
+
+/**
+ * Adds a date to an existing range, considering constraints like minimum and
+ * maximum range size.
+ *
+ * @param date - The date to add to the range.
+ * @param initialRange - The initial range to which the date will be added.
+ * @param min - The minimum number of days in the range.
+ * @param max - The maximum number of days in the range.
+ * @param required - Whether the range must always include at least one date.
+ * @param dateLib - The date utility library instance.
+ * @returns The updated date range, or `undefined` if the range is cleared.
+ * @group Utilities
+ */
+function addToRange(date, initialRange, min = 0, max = 0, required = false, dateLib = DateLib.defaultDateLib) {
+    const { from, to } = initialRange || {};
+    const { isSameDay, isAfter, isBefore } = dateLib;
+    let range;
+    if (!from && !to) {
+        // the range is empty, add the date
+        range = { from: date, to: min > 0 ? undefined : date };
+    }
+    else if (from && !to) {
+        // adding date to an incomplete range
+        if (isSameDay(from, date)) {
+            // adding a date equal to the start of the range
+            if (min === 0) {
+                range = { from, to: date };
+            }
+            else if (required) {
+                range = { from, to: undefined };
+            }
+            else {
+                range = undefined;
+            }
+        }
+        else if (isBefore(date, from)) {
+            // adding a date before the start of the range
+            range = { from: date, to: from };
+        }
+        else {
+            // adding a date after the start of the range
+            range = { from, to: date };
+        }
+    }
+    else if (from && to) {
+        // adding date to a complete range
+        if (isSameDay(from, date) && isSameDay(to, date)) {
+            // adding a date that is equal to both start and end of the range
+            if (required) {
+                range = { from, to };
+            }
+            else {
+                range = undefined;
+            }
+        }
+        else if (isSameDay(from, date)) {
+            // adding a date equal to the the start of the range
+            range = { from, to: min > 0 ? undefined : date };
+        }
+        else if (isSameDay(to, date)) {
+            // adding a dare equal to the end of the range
+            range = { from: date, to: min > 0 ? undefined : date };
+        }
+        else if (isBefore(date, from)) {
+            // adding a date before the start of the range
+            range = { from: date, to: to };
+        }
+        else if (isAfter(date, from)) {
+            // adding a date after the start of the range
+            range = { from, to: date };
+        }
+        else if (isAfter(date, to)) {
+            // adding a date after the end of the range
+            range = { from, to: date };
+        }
+        else {
+            throw new Error("Invalid range");
+        }
+    }
+    // check for min / max
+    if (range?.from && range?.to) {
+        const diff = dateLib.differenceInCalendarDays(range.to, range.from);
+        if (max > 0 && diff > max) {
+            range = { from: date, to: undefined };
+        }
+        else if (min > 1 && diff < min) {
+            range = { from: date, to: undefined };
+        }
+    }
+    return range;
+}
+
+exports.addToRange = addToRange;

package/dist/node_modules/.pnpm/react-day-picker@9.12.0_react@19.2.0/node_modules/react-day-picker/dist/esm/utils/addToRange.mjs

@@ -0,0 +1,95 @@
+import { defaultDateLib } from '../classes/DateLib.mjs';
+
+/**
+ * Adds a date to an existing range, considering constraints like minimum and
+ * maximum range size.
+ *
+ * @param date - The date to add to the range.
+ * @param initialRange - The initial range to which the date will be added.
+ * @param min - The minimum number of days in the range.
+ * @param max - The maximum number of days in the range.
+ * @param required - Whether the range must always include at least one date.
+ * @param dateLib - The date utility library instance.
+ * @returns The updated date range, or `undefined` if the range is cleared.
+ * @group Utilities
+ */
+function addToRange(date, initialRange, min = 0, max = 0, required = false, dateLib = defaultDateLib) {
+    const { from, to } = initialRange || {};
+    const { isSameDay, isAfter, isBefore } = dateLib;
+    let range;
+    if (!from && !to) {
+        // the range is empty, add the date
+        range = { from: date, to: min > 0 ? undefined : date };
+    }
+    else if (from && !to) {
+        // adding date to an incomplete range
+        if (isSameDay(from, date)) {
+            // adding a date equal to the start of the range
+            if (min === 0) {
+                range = { from, to: date };
+            }
+            else if (required) {
+                range = { from, to: undefined };
+            }
+            else {
+                range = undefined;
+            }
+        }
+        else if (isBefore(date, from)) {
+            // adding a date before the start of the range
+            range = { from: date, to: from };
+        }
+        else {
+            // adding a date after the start of the range
+            range = { from, to: date };
+        }
+    }
+    else if (from && to) {
+        // adding date to a complete range
+        if (isSameDay(from, date) && isSameDay(to, date)) {
+            // adding a date that is equal to both start and end of the range
+            if (required) {
+                range = { from, to };
+            }
+            else {
+                range = undefined;
+            }
+        }
+        else if (isSameDay(from, date)) {
+            // adding a date equal to the the start of the range
+            range = { from, to: min > 0 ? undefined : date };
+        }
+        else if (isSameDay(to, date)) {
+            // adding a dare equal to the end of the range
+            range = { from: date, to: min > 0 ? undefined : date };
+        }
+        else if (isBefore(date, from)) {
+            // adding a date before the start of the range
+            range = { from: date, to: to };
+        }
+        else if (isAfter(date, from)) {
+            // adding a date after the start of the range
+            range = { from, to: date };
+        }
+        else if (isAfter(date, to)) {
+            // adding a date after the end of the range
+            range = { from, to: date };
+        }
+        else {
+            throw new Error("Invalid range");
+        }
+    }
+    // check for min / max
+    if (range?.from && range?.to) {
+        const diff = dateLib.differenceInCalendarDays(range.to, range.from);
+        if (max > 0 && diff > max) {
+            range = { from: date, to: undefined };
+        }
+        else if (min > 1 && diff < min) {
+            range = { from: date, to: undefined };
+        }
+    }
+    return range;
+}
+
+export { addToRange };

package/dist/node_modules/.pnpm/react-day-picker@9.12.0_react@19.2.0/node_modules/react-day-picker/dist/esm/utils/convertMatchersToTimeZone.cjs

@@ -0,0 +1,59 @@
+'use strict';
+
+const toTimeZone = require('./toTimeZone.cjs');
+const typeguards = require('./typeguards.cjs');
+
+function convertMatcher(matcher, timeZone) {
+    if (typeof matcher === "boolean" || typeof matcher === "function") {
+        return matcher;
+    }
+    if (matcher instanceof Date) {
+        return toTimeZone.toTimeZone(matcher, timeZone);
+    }
+    if (Array.isArray(matcher)) {
+        return matcher.map((value) => value instanceof Date ? toTimeZone.toTimeZone(value, timeZone) : value);
+    }
+    if (typeguards.isDateRange(matcher)) {
+        return {
+            ...matcher,
+            from: matcher.from ? toTimeZone.toTimeZone(matcher.from, timeZone) : matcher.from,
+            to: matcher.to ? toTimeZone.toTimeZone(matcher.to, timeZone) : matcher.to,
+        };
+    }
+    if (typeguards.isDateInterval(matcher)) {
+        return {
+            before: toTimeZone.toTimeZone(matcher.before, timeZone),
+            after: toTimeZone.toTimeZone(matcher.after, timeZone),
+        };
+    }
+    if (typeguards.isDateAfterType(matcher)) {
+        return {
+            after: toTimeZone.toTimeZone(matcher.after, timeZone),
+        };
+    }
+    if (typeguards.isDateBeforeType(matcher)) {
+        return {
+            before: toTimeZone.toTimeZone(matcher.before, timeZone),
+        };
+    }
+    return matcher;
+}
+/**
+ * Convert any {@link Matcher} or array of matchers to the specified time zone.
+ *
+ * @param matchers - The matcher or matchers to convert.
+ * @param timeZone - The target IANA time zone.
+ * @returns The converted matcher(s).
+ * @group Utilities
+ */
+function convertMatchersToTimeZone(matchers, timeZone) {
+    if (!matchers) {
+        return matchers;
+    }
+    if (Array.isArray(matchers)) {
+        return matchers.map((matcher) => convertMatcher(matcher, timeZone));
+    }
+    return convertMatcher(matchers, timeZone);
+}
+
+exports.convertMatchersToTimeZone = convertMatchersToTimeZone;

package/dist/node_modules/.pnpm/react-day-picker@9.12.0_react@19.2.0/node_modules/react-day-picker/dist/esm/utils/convertMatchersToTimeZone.mjs

@@ -0,0 +1,57 @@
+import { toTimeZone } from './toTimeZone.mjs';
+import { isDateRange, isDateInterval, isDateAfterType, isDateBeforeType } from './typeguards.mjs';
+
+function convertMatcher(matcher, timeZone) {
+    if (typeof matcher === "boolean" || typeof matcher === "function") {
+        return matcher;
+    }
+    if (matcher instanceof Date) {
+        return toTimeZone(matcher, timeZone);
+    }
+    if (Array.isArray(matcher)) {
+        return matcher.map((value) => value instanceof Date ? toTimeZone(value, timeZone) : value);
+    }
+    if (isDateRange(matcher)) {
+        return {
+            ...matcher,
+            from: matcher.from ? toTimeZone(matcher.from, timeZone) : matcher.from,
+            to: matcher.to ? toTimeZone(matcher.to, timeZone) : matcher.to,
+        };
+    }
+    if (isDateInterval(matcher)) {
+        return {
+            before: toTimeZone(matcher.before, timeZone),
+            after: toTimeZone(matcher.after, timeZone),
+        };
+    }
+    if (isDateAfterType(matcher)) {
+        return {
+            after: toTimeZone(matcher.after, timeZone),
+        };
+    }
+    if (isDateBeforeType(matcher)) {
+        return {
+            before: toTimeZone(matcher.before, timeZone),
+        };
+    }
+    return matcher;
+}
+/**
+ * Convert any {@link Matcher} or array of matchers to the specified time zone.
+ *
+ * @param matchers - The matcher or matchers to convert.
+ * @param timeZone - The target IANA time zone.
+ * @returns The converted matcher(s).
+ * @group Utilities
+ */
+function convertMatchersToTimeZone(matchers, timeZone) {
+    if (!matchers) {
+        return matchers;
+    }
+    if (Array.isArray(matchers)) {
+        return matchers.map((matcher) => convertMatcher(matcher, timeZone));
+    }
+    return convertMatcher(matchers, timeZone);
+}
+
+export { convertMatchersToTimeZone };

package/dist/node_modules/.pnpm/react-day-picker@9.12.0_react@19.2.0/node_modules/react-day-picker/dist/esm/utils/dateMatchModifiers.cjs

@@ -0,0 +1,64 @@
+'use strict';
+
+const DateLib = require('../classes/DateLib.cjs');
+const rangeIncludesDate = require('./rangeIncludesDate.cjs');
+const typeguards = require('./typeguards.cjs');
+
+/**
+ * Checks if a given date matches at least one of the specified {@link Matcher}.
+ *
+ * @param date - The date to check.
+ * @param matchers - The matchers to check against.
+ * @param dateLib - The date utility library instance.
+ * @returns `true` if the date matches any of the matchers, otherwise `false`.
+ * @group Utilities
+ */
+function dateMatchModifiers(date, matchers, dateLib = DateLib.defaultDateLib) {
+    const matchersArr = !Array.isArray(matchers) ? [matchers] : matchers;
+    const { isSameDay, differenceInCalendarDays, isAfter } = dateLib;
+    return matchersArr.some((matcher) => {
+        if (typeof matcher === "boolean") {
+            return matcher;
+        }
+        if (dateLib.isDate(matcher)) {
+            return isSameDay(date, matcher);
+        }
+        if (typeguards.isDatesArray(matcher, dateLib)) {
+            return matcher.some((matcherDate) => isSameDay(date, matcherDate));
+        }
+        if (typeguards.isDateRange(matcher)) {
+            return rangeIncludesDate.rangeIncludesDate(matcher, date, false, dateLib);
+        }
+        if (typeguards.isDayOfWeekType(matcher)) {
+            if (!Array.isArray(matcher.dayOfWeek)) {
+                return matcher.dayOfWeek === date.getDay();
+            }
+            return matcher.dayOfWeek.includes(date.getDay());
+        }
+        if (typeguards.isDateInterval(matcher)) {
+            const diffBefore = differenceInCalendarDays(matcher.before, date);
+            const diffAfter = differenceInCalendarDays(matcher.after, date);
+            const isDayBefore = diffBefore > 0;
+            const isDayAfter = diffAfter < 0;
+            const isClosedInterval = isAfter(matcher.before, matcher.after);
+            if (isClosedInterval) {
+                return isDayAfter && isDayBefore;
+            }
+            else {
+                return isDayBefore || isDayAfter;
+            }
+        }
+        if (typeguards.isDateAfterType(matcher)) {
+            return differenceInCalendarDays(date, matcher.after) > 0;
+        }
+        if (typeguards.isDateBeforeType(matcher)) {
+            return differenceInCalendarDays(matcher.before, date) > 0;
+        }
+        if (typeof matcher === "function") {
+            return matcher(date);
+        }
+        return false;
+    });
+}
+
+exports.dateMatchModifiers = dateMatchModifiers;

package/dist/node_modules/.pnpm/react-day-picker@9.12.0_react@19.2.0/node_modules/react-day-picker/dist/esm/utils/dateMatchModifiers.mjs

@@ -0,0 +1,62 @@
+import { defaultDateLib } from '../classes/DateLib.mjs';
+import { rangeIncludesDate } from './rangeIncludesDate.mjs';
+import { isDatesArray, isDateRange, isDayOfWeekType, isDateInterval, isDateAfterType, isDateBeforeType } from './typeguards.mjs';
+
+/**
+ * Checks if a given date matches at least one of the specified {@link Matcher}.
+ *
+ * @param date - The date to check.
+ * @param matchers - The matchers to check against.
+ * @param dateLib - The date utility library instance.
+ * @returns `true` if the date matches any of the matchers, otherwise `false`.
+ * @group Utilities
+ */
+function dateMatchModifiers(date, matchers, dateLib = defaultDateLib) {
+    const matchersArr = !Array.isArray(matchers) ? [matchers] : matchers;
+    const { isSameDay, differenceInCalendarDays, isAfter } = dateLib;
+    return matchersArr.some((matcher) => {
+        if (typeof matcher === "boolean") {
+            return matcher;
+        }
+        if (dateLib.isDate(matcher)) {
+            return isSameDay(date, matcher);
+        }
+        if (isDatesArray(matcher, dateLib)) {
+            return matcher.some((matcherDate) => isSameDay(date, matcherDate));
+        }
+        if (isDateRange(matcher)) {
+            return rangeIncludesDate(matcher, date, false, dateLib);
+        }
+        if (isDayOfWeekType(matcher)) {
+            if (!Array.isArray(matcher.dayOfWeek)) {
+                return matcher.dayOfWeek === date.getDay();
+            }
+            return matcher.dayOfWeek.includes(date.getDay());
+        }
+        if (isDateInterval(matcher)) {
+            const diffBefore = differenceInCalendarDays(matcher.before, date);
+            const diffAfter = differenceInCalendarDays(matcher.after, date);
+            const isDayBefore = diffBefore > 0;
+            const isDayAfter = diffAfter < 0;
+            const isClosedInterval = isAfter(matcher.before, matcher.after);
+            if (isClosedInterval) {
+                return isDayAfter && isDayBefore;
+            }
+            else {
+                return isDayBefore || isDayAfter;
+            }
+        }
+        if (isDateAfterType(matcher)) {
+            return differenceInCalendarDays(date, matcher.after) > 0;
+        }
+        if (isDateBeforeType(matcher)) {
+            return differenceInCalendarDays(matcher.before, date) > 0;
+        }
+        if (typeof matcher === "function") {
+            return matcher(date);
+        }
+        return false;
+    });
+}
+
+export { dateMatchModifiers };

package/dist/node_modules/.pnpm/react-day-picker@9.12.0_react@19.2.0/node_modules/react-day-picker/dist/esm/utils/rangeContainsDayOfWeek.cjs

@@ -0,0 +1,32 @@
+'use strict';
+
+const DateLib = require('../classes/DateLib.cjs');
+
+/**
+ * Checks if a date range contains one or more specified days of the week.
+ *
+ * @since 9.2.2
+ * @param range - The date range to check.
+ * @param dayOfWeek - The day(s) of the week to check for (`0-6`, where `0` is
+ *   Sunday).
+ * @param dateLib - The date utility library instance.
+ * @returns `true` if the range contains the specified day(s) of the week,
+ *   otherwise `false`.
+ * @group Utilities
+ */
+function rangeContainsDayOfWeek(range, dayOfWeek, dateLib = DateLib.defaultDateLib) {
+    const dayOfWeekArr = !Array.isArray(dayOfWeek) ? [dayOfWeek] : dayOfWeek;
+    let date = range.from;
+    const totalDays = dateLib.differenceInCalendarDays(range.to, range.from);
+    // iterate at maximum one week or the total days if the range is shorter than one week
+    const totalDaysLimit = Math.min(totalDays, 6);
+    for (let i = 0; i <= totalDaysLimit; i++) {
+        if (dayOfWeekArr.includes(date.getDay())) {
+            return true;
+        }
+        date = dateLib.addDays(date, 1);
+    }
+    return false;
+}
+
+exports.rangeContainsDayOfWeek = rangeContainsDayOfWeek;

package/dist/node_modules/.pnpm/react-day-picker@9.12.0_react@19.2.0/node_modules/react-day-picker/dist/esm/utils/rangeContainsDayOfWeek.mjs

@@ -0,0 +1,30 @@
+import { defaultDateLib } from '../classes/DateLib.mjs';
+
+/**
+ * Checks if a date range contains one or more specified days of the week.
+ *
+ * @since 9.2.2
+ * @param range - The date range to check.
+ * @param dayOfWeek - The day(s) of the week to check for (`0-6`, where `0` is
+ *   Sunday).
+ * @param dateLib - The date utility library instance.
+ * @returns `true` if the range contains the specified day(s) of the week,
+ *   otherwise `false`.
+ * @group Utilities
+ */
+function rangeContainsDayOfWeek(range, dayOfWeek, dateLib = defaultDateLib) {
+    const dayOfWeekArr = !Array.isArray(dayOfWeek) ? [dayOfWeek] : dayOfWeek;
+    let date = range.from;
+    const totalDays = dateLib.differenceInCalendarDays(range.to, range.from);
+    // iterate at maximum one week or the total days if the range is shorter than one week
+    const totalDaysLimit = Math.min(totalDays, 6);
+    for (let i = 0; i <= totalDaysLimit; i++) {
+        if (dayOfWeekArr.includes(date.getDay())) {
+            return true;
+        }
+        date = dateLib.addDays(date, 1);
+    }
+    return false;
+}
+
+export { rangeContainsDayOfWeek };

package/dist/node_modules/.pnpm/react-day-picker@9.12.0_react@19.2.0/node_modules/react-day-picker/dist/esm/utils/rangeContainsModifiers.cjs

@@ -0,0 +1,76 @@
+'use strict';
+
+const DateLib = require('../classes/DateLib.cjs');
+const dateMatchModifiers = require('./dateMatchModifiers.cjs');
+const rangeContainsDayOfWeek = require('./rangeContainsDayOfWeek.cjs');
+const rangeIncludesDate = require('./rangeIncludesDate.cjs');
+const rangeOverlaps = require('./rangeOverlaps.cjs');
+const typeguards = require('./typeguards.cjs');
+
+/**
+ * Checks if a date range contains dates that match the given modifiers.
+ *
+ * @since 9.2.2
+ * @param range - The date range to check.
+ * @param modifiers - The modifiers to match against.
+ * @param dateLib - The date utility library instance.
+ * @returns `true` if the range contains matching dates, otherwise `false`.
+ * @group Utilities
+ */
+function rangeContainsModifiers(range, modifiers, dateLib = DateLib.defaultDateLib) {
+    const matchers = Array.isArray(modifiers) ? modifiers : [modifiers];
+    // Defer function matchers evaluation as they are the least performant.
+    const nonFunctionMatchers = matchers.filter((matcher) => typeof matcher !== "function");
+    const nonFunctionMatchersResult = nonFunctionMatchers.some((matcher) => {
+        if (typeof matcher === "boolean")
+            return matcher;
+        if (dateLib.isDate(matcher)) {
+            return rangeIncludesDate.rangeIncludesDate(range, matcher, false, dateLib);
+        }
+        if (typeguards.isDatesArray(matcher, dateLib)) {
+            return matcher.some((date) => rangeIncludesDate.rangeIncludesDate(range, date, false, dateLib));
+        }
+        if (typeguards.isDateRange(matcher)) {
+            if (matcher.from && matcher.to) {
+                return rangeOverlaps.rangeOverlaps(range, { from: matcher.from, to: matcher.to }, dateLib);
+            }
+            return false;
+        }
+        if (typeguards.isDayOfWeekType(matcher)) {
+            return rangeContainsDayOfWeek.rangeContainsDayOfWeek(range, matcher.dayOfWeek, dateLib);
+        }
+        if (typeguards.isDateInterval(matcher)) {
+            const isClosedInterval = dateLib.isAfter(matcher.before, matcher.after);
+            if (isClosedInterval) {
+                return rangeOverlaps.rangeOverlaps(range, {
+                    from: dateLib.addDays(matcher.after, 1),
+                    to: dateLib.addDays(matcher.before, -1),
+                }, dateLib);
+            }
+            return (dateMatchModifiers.dateMatchModifiers(range.from, matcher, dateLib) ||
+                dateMatchModifiers.dateMatchModifiers(range.to, matcher, dateLib));
+        }
+        if (typeguards.isDateAfterType(matcher) || typeguards.isDateBeforeType(matcher)) {
+            return (dateMatchModifiers.dateMatchModifiers(range.from, matcher, dateLib) ||
+                dateMatchModifiers.dateMatchModifiers(range.to, matcher, dateLib));
+        }
+        return false;
+    });
+    if (nonFunctionMatchersResult) {
+        return true;
+    }
+    const functionMatchers = matchers.filter((matcher) => typeof matcher === "function");
+    if (functionMatchers.length) {
+        let date = range.from;
+        const totalDays = dateLib.differenceInCalendarDays(range.to, range.from);
+        for (let i = 0; i <= totalDays; i++) {
+            if (functionMatchers.some((matcher) => matcher(date))) {
+                return true;
+            }
+            date = dateLib.addDays(date, 1);
+        }
+    }
+    return false;
+}
+
+exports.rangeContainsModifiers = rangeContainsModifiers;

package/dist/node_modules/.pnpm/react-day-picker@9.12.0_react@19.2.0/node_modules/react-day-picker/dist/esm/utils/rangeContainsModifiers.mjs

@@ -0,0 +1,74 @@
+import { defaultDateLib } from '../classes/DateLib.mjs';
+import { dateMatchModifiers } from './dateMatchModifiers.mjs';
+import { rangeContainsDayOfWeek } from './rangeContainsDayOfWeek.mjs';
+import { rangeIncludesDate } from './rangeIncludesDate.mjs';
+import { rangeOverlaps } from './rangeOverlaps.mjs';
+import { isDatesArray, isDateRange, isDayOfWeekType, isDateInterval, isDateAfterType, isDateBeforeType } from './typeguards.mjs';
+
+/**
+ * Checks if a date range contains dates that match the given modifiers.
+ *
+ * @since 9.2.2
+ * @param range - The date range to check.
+ * @param modifiers - The modifiers to match against.
+ * @param dateLib - The date utility library instance.
+ * @returns `true` if the range contains matching dates, otherwise `false`.
+ * @group Utilities
+ */
+function rangeContainsModifiers(range, modifiers, dateLib = defaultDateLib) {
+    const matchers = Array.isArray(modifiers) ? modifiers : [modifiers];
+    // Defer function matchers evaluation as they are the least performant.
+    const nonFunctionMatchers = matchers.filter((matcher) => typeof matcher !== "function");
+    const nonFunctionMatchersResult = nonFunctionMatchers.some((matcher) => {
+        if (typeof matcher === "boolean")
+            return matcher;
+        if (dateLib.isDate(matcher)) {
+            return rangeIncludesDate(range, matcher, false, dateLib);
+        }
+        if (isDatesArray(matcher, dateLib)) {
+            return matcher.some((date) => rangeIncludesDate(range, date, false, dateLib));
+        }
+        if (isDateRange(matcher)) {
+            if (matcher.from && matcher.to) {
+                return rangeOverlaps(range, { from: matcher.from, to: matcher.to }, dateLib);
+            }
+            return false;
+        }
+        if (isDayOfWeekType(matcher)) {
+            return rangeContainsDayOfWeek(range, matcher.dayOfWeek, dateLib);
+        }
+        if (isDateInterval(matcher)) {
+            const isClosedInterval = dateLib.isAfter(matcher.before, matcher.after);
+            if (isClosedInterval) {
+                return rangeOverlaps(range, {
+                    from: dateLib.addDays(matcher.after, 1),
+                    to: dateLib.addDays(matcher.before, -1),
+                }, dateLib);
+            }
+            return (dateMatchModifiers(range.from, matcher, dateLib) ||
+                dateMatchModifiers(range.to, matcher, dateLib));
+        }
+        if (isDateAfterType(matcher) || isDateBeforeType(matcher)) {
+            return (dateMatchModifiers(range.from, matcher, dateLib) ||
+                dateMatchModifiers(range.to, matcher, dateLib));
+        }
+        return false;
+    });
+    if (nonFunctionMatchersResult) {
+        return true;
+    }
+    const functionMatchers = matchers.filter((matcher) => typeof matcher === "function");
+    if (functionMatchers.length) {
+        let date = range.from;
+        const totalDays = dateLib.differenceInCalendarDays(range.to, range.from);
+        for (let i = 0; i <= totalDays; i++) {
+            if (functionMatchers.some((matcher) => matcher(date))) {
+                return true;
+            }
+            date = dateLib.addDays(date, 1);
+        }
+    }
+    return false;
+}
+
+export { rangeContainsModifiers };