@credo-ts/askar-to-drizzle-storage-migration 0.6.0-alpha-20251010154241 → 0.6.0-alpha-20251010171953

package/build/node_modules/.pnpm/luxon@3.5.0/node_modules/luxon/src/interval.mjs

@@ -0,0 +1,530 @@
+import { InvalidArgumentError, InvalidIntervalError } from "./errors.mjs";
+import { DATE_SHORT } from "./impl/formats.mjs";
+import Settings from "./settings.mjs";
+import Invalid from "./impl/invalid.mjs";
+import Formatter from "./impl/formatter.mjs";
+import Duration from "./duration.mjs";
+import DateTime, { friendlyDateTime } from "./datetime.mjs";
+
+//#region ../../node_modules/.pnpm/luxon@3.5.0/node_modules/luxon/src/interval.js
+const INVALID = "Invalid Interval";
+function validateStartEnd(start, end) {
+	if (!start || !start.isValid) return Interval.invalid("missing or invalid start");
+	else if (!end || !end.isValid) return Interval.invalid("missing or invalid end");
+	else if (end < start) return Interval.invalid("end before start", `The end of an interval must be after its start, but you had start=${start.toISO()} and end=${end.toISO()}`);
+	else return null;
+}
+/**
+* An Interval object represents a half-open interval of time, where each endpoint is a {@link DateTime}. Conceptually, it's a container for those two endpoints, accompanied by methods for creating, parsing, interrogating, comparing, transforming, and formatting them.
+*
+* Here is a brief overview of the most commonly used methods and getters in Interval:
+*
+* * **Creation** To create an Interval, use {@link Interval.fromDateTimes}, {@link Interval.after}, {@link Interval.before}, or {@link Interval.fromISO}.
+* * **Accessors** Use {@link Interval#start} and {@link Interval#end} to get the start and end.
+* * **Interrogation** To analyze the Interval, use {@link Interval#count}, {@link Interval#length}, {@link Interval#hasSame}, {@link Interval#contains}, {@link Interval#isAfter}, or {@link Interval#isBefore}.
+* * **Transformation** To create other Intervals out of this one, use {@link Interval#set}, {@link Interval#splitAt}, {@link Interval#splitBy}, {@link Interval#divideEqually}, {@link Interval.merge}, {@link Interval.xor}, {@link Interval#union}, {@link Interval#intersection}, or {@link Interval#difference}.
+* * **Comparison** To compare this Interval to another one, use {@link Interval#equals}, {@link Interval#overlaps}, {@link Interval#abutsStart}, {@link Interval#abutsEnd}, {@link Interval#engulfs}
+* * **Output** To convert the Interval into other representations, see {@link Interval#toString}, {@link Interval#toLocaleString}, {@link Interval#toISO}, {@link Interval#toISODate}, {@link Interval#toISOTime}, {@link Interval#toFormat}, and {@link Interval#toDuration}.
+*/
+var Interval = class Interval {
+	/**
+	* @private
+	*/
+	constructor(config) {
+		/**
+		* @access private
+		*/
+		this.s = config.start;
+		/**
+		* @access private
+		*/
+		this.e = config.end;
+		/**
+		* @access private
+		*/
+		this.invalid = config.invalid || null;
+		/**
+		* @access private
+		*/
+		this.isLuxonInterval = true;
+	}
+	/**
+	* Create an invalid Interval.
+	* @param {string} reason - simple string of why this Interval is invalid. Should not contain parameters or anything else data-dependent
+	* @param {string} [explanation=null] - longer explanation, may include parameters and other useful debugging information
+	* @return {Interval}
+	*/
+	static invalid(reason, explanation = null) {
+		if (!reason) throw new InvalidArgumentError("need to specify a reason the Interval is invalid");
+		const invalid = reason instanceof Invalid ? reason : new Invalid(reason, explanation);
+		if (Settings.throwOnInvalid) throw new InvalidIntervalError(invalid);
+		else return new Interval({ invalid });
+	}
+	/**
+	* Create an Interval from a start DateTime and an end DateTime. Inclusive of the start but not the end.
+	* @param {DateTime|Date|Object} start
+	* @param {DateTime|Date|Object} end
+	* @return {Interval}
+	*/
+	static fromDateTimes(start, end) {
+		const builtStart = friendlyDateTime(start), builtEnd = friendlyDateTime(end);
+		const validateError = validateStartEnd(builtStart, builtEnd);
+		if (validateError == null) return new Interval({
+			start: builtStart,
+			end: builtEnd
+		});
+		else return validateError;
+	}
+	/**
+	* Create an Interval from a start DateTime and a Duration to extend to.
+	* @param {DateTime|Date|Object} start
+	* @param {Duration|Object|number} duration - the length of the Interval.
+	* @return {Interval}
+	*/
+	static after(start, duration) {
+		const dur = Duration.fromDurationLike(duration), dt = friendlyDateTime(start);
+		return Interval.fromDateTimes(dt, dt.plus(dur));
+	}
+	/**
+	* Create an Interval from an end DateTime and a Duration to extend backwards to.
+	* @param {DateTime|Date|Object} end
+	* @param {Duration|Object|number} duration - the length of the Interval.
+	* @return {Interval}
+	*/
+	static before(end, duration) {
+		const dur = Duration.fromDurationLike(duration), dt = friendlyDateTime(end);
+		return Interval.fromDateTimes(dt.minus(dur), dt);
+	}
+	/**
+	* Create an Interval from an ISO 8601 string.
+	* Accepts `<start>/<end>`, `<start>/<duration>`, and `<duration>/<end>` formats.
+	* @param {string} text - the ISO string to parse
+	* @param {Object} [opts] - options to pass {@link DateTime#fromISO} and optionally {@link Duration#fromISO}
+	* @see https://en.wikipedia.org/wiki/ISO_8601#Time_intervals
+	* @return {Interval}
+	*/
+	static fromISO(text, opts) {
+		const [s, e] = (text || "").split("/", 2);
+		if (s && e) {
+			let start, startIsValid;
+			try {
+				start = DateTime.fromISO(s, opts);
+				startIsValid = start.isValid;
+			} catch (e$1) {
+				startIsValid = false;
+			}
+			let end, endIsValid;
+			try {
+				end = DateTime.fromISO(e, opts);
+				endIsValid = end.isValid;
+			} catch (e$1) {
+				endIsValid = false;
+			}
+			if (startIsValid && endIsValid) return Interval.fromDateTimes(start, end);
+			if (startIsValid) {
+				const dur = Duration.fromISO(e, opts);
+				if (dur.isValid) return Interval.after(start, dur);
+			} else if (endIsValid) {
+				const dur = Duration.fromISO(s, opts);
+				if (dur.isValid) return Interval.before(end, dur);
+			}
+		}
+		return Interval.invalid("unparsable", `the input "${text}" can't be parsed as ISO 8601`);
+	}
+	/**
+	* Check if an object is an Interval. Works across context boundaries
+	* @param {object} o
+	* @return {boolean}
+	*/
+	static isInterval(o) {
+		return o && o.isLuxonInterval || false;
+	}
+	/**
+	* Returns the start of the Interval
+	* @type {DateTime}
+	*/
+	get start() {
+		return this.isValid ? this.s : null;
+	}
+	/**
+	* Returns the end of the Interval
+	* @type {DateTime}
+	*/
+	get end() {
+		return this.isValid ? this.e : null;
+	}
+	/**
+	* Returns whether this Interval's end is at least its start, meaning that the Interval isn't 'backwards'.
+	* @type {boolean}
+	*/
+	get isValid() {
+		return this.invalidReason === null;
+	}
+	/**
+	* Returns an error code if this Interval is invalid, or null if the Interval is valid
+	* @type {string}
+	*/
+	get invalidReason() {
+		return this.invalid ? this.invalid.reason : null;
+	}
+	/**
+	* Returns an explanation of why this Interval became invalid, or null if the Interval is valid
+	* @type {string}
+	*/
+	get invalidExplanation() {
+		return this.invalid ? this.invalid.explanation : null;
+	}
+	/**
+	* Returns the length of the Interval in the specified unit.
+	* @param {string} unit - the unit (such as 'hours' or 'days') to return the length in.
+	* @return {number}
+	*/
+	length(unit = "milliseconds") {
+		return this.isValid ? this.toDuration(...[unit]).get(unit) : NaN;
+	}
+	/**
+	* Returns the count of minutes, hours, days, months, or years included in the Interval, even in part.
+	* Unlike {@link Interval#length} this counts sections of the calendar, not periods of time, e.g. specifying 'day'
+	* asks 'what dates are included in this interval?', not 'how many days long is this interval?'
+	* @param {string} [unit='milliseconds'] - the unit of time to count.
+	* @param {Object} opts - options
+	* @param {boolean} [opts.useLocaleWeeks=false] - If true, use weeks based on the locale, i.e. use the locale-dependent start of the week; this operation will always use the locale of the start DateTime
+	* @return {number}
+	*/
+	count(unit = "milliseconds", opts) {
+		if (!this.isValid) return NaN;
+		const start = this.start.startOf(unit, opts);
+		let end;
+		if (opts?.useLocaleWeeks) end = this.end.reconfigure({ locale: start.locale });
+		else end = this.end;
+		end = end.startOf(unit, opts);
+		return Math.floor(end.diff(start, unit).get(unit)) + (end.valueOf() !== this.end.valueOf());
+	}
+	/**
+	* Returns whether this Interval's start and end are both in the same unit of time
+	* @param {string} unit - the unit of time to check sameness on
+	* @return {boolean}
+	*/
+	hasSame(unit) {
+		return this.isValid ? this.isEmpty() || this.e.minus(1).hasSame(this.s, unit) : false;
+	}
+	/**
+	* Return whether this Interval has the same start and end DateTimes.
+	* @return {boolean}
+	*/
+	isEmpty() {
+		return this.s.valueOf() === this.e.valueOf();
+	}
+	/**
+	* Return whether this Interval's start is after the specified DateTime.
+	* @param {DateTime} dateTime
+	* @return {boolean}
+	*/
+	isAfter(dateTime) {
+		if (!this.isValid) return false;
+		return this.s > dateTime;
+	}
+	/**
+	* Return whether this Interval's end is before the specified DateTime.
+	* @param {DateTime} dateTime
+	* @return {boolean}
+	*/
+	isBefore(dateTime) {
+		if (!this.isValid) return false;
+		return this.e <= dateTime;
+	}
+	/**
+	* Return whether this Interval contains the specified DateTime.
+	* @param {DateTime} dateTime
+	* @return {boolean}
+	*/
+	contains(dateTime) {
+		if (!this.isValid) return false;
+		return this.s <= dateTime && this.e > dateTime;
+	}
+	/**
+	* "Sets" the start and/or end dates. Returns a newly-constructed Interval.
+	* @param {Object} values - the values to set
+	* @param {DateTime} values.start - the starting DateTime
+	* @param {DateTime} values.end - the ending DateTime
+	* @return {Interval}
+	*/
+	set({ start, end } = {}) {
+		if (!this.isValid) return this;
+		return Interval.fromDateTimes(start || this.s, end || this.e);
+	}
+	/**
+	* Split this Interval at each of the specified DateTimes
+	* @param {...DateTime} dateTimes - the unit of time to count.
+	* @return {Array}
+	*/
+	splitAt(...dateTimes) {
+		if (!this.isValid) return [];
+		const sorted = dateTimes.map(friendlyDateTime).filter((d) => this.contains(d)).sort((a, b) => a.toMillis() - b.toMillis()), results = [];
+		let { s } = this, i = 0;
+		while (s < this.e) {
+			const added = sorted[i] || this.e, next = +added > +this.e ? this.e : added;
+			results.push(Interval.fromDateTimes(s, next));
+			s = next;
+			i += 1;
+		}
+		return results;
+	}
+	/**
+	* Split this Interval into smaller Intervals, each of the specified length.
+	* Left over time is grouped into a smaller interval
+	* @param {Duration|Object|number} duration - The length of each resulting interval.
+	* @return {Array}
+	*/
+	splitBy(duration) {
+		const dur = Duration.fromDurationLike(duration);
+		if (!this.isValid || !dur.isValid || dur.as("milliseconds") === 0) return [];
+		let { s } = this, idx = 1, next;
+		const results = [];
+		while (s < this.e) {
+			const added = this.start.plus(dur.mapUnits((x) => x * idx));
+			next = +added > +this.e ? this.e : added;
+			results.push(Interval.fromDateTimes(s, next));
+			s = next;
+			idx += 1;
+		}
+		return results;
+	}
+	/**
+	* Split this Interval into the specified number of smaller intervals.
+	* @param {number} numberOfParts - The number of Intervals to divide the Interval into.
+	* @return {Array}
+	*/
+	divideEqually(numberOfParts) {
+		if (!this.isValid) return [];
+		return this.splitBy(this.length() / numberOfParts).slice(0, numberOfParts);
+	}
+	/**
+	* Return whether this Interval overlaps with the specified Interval
+	* @param {Interval} other
+	* @return {boolean}
+	*/
+	overlaps(other) {
+		return this.e > other.s && this.s < other.e;
+	}
+	/**
+	* Return whether this Interval's end is adjacent to the specified Interval's start.
+	* @param {Interval} other
+	* @return {boolean}
+	*/
+	abutsStart(other) {
+		if (!this.isValid) return false;
+		return +this.e === +other.s;
+	}
+	/**
+	* Return whether this Interval's start is adjacent to the specified Interval's end.
+	* @param {Interval} other
+	* @return {boolean}
+	*/
+	abutsEnd(other) {
+		if (!this.isValid) return false;
+		return +other.e === +this.s;
+	}
+	/**
+	* Returns true if this Interval fully contains the specified Interval, specifically if the intersect (of this Interval and the other Interval) is equal to the other Interval; false otherwise.
+	* @param {Interval} other
+	* @return {boolean}
+	*/
+	engulfs(other) {
+		if (!this.isValid) return false;
+		return this.s <= other.s && this.e >= other.e;
+	}
+	/**
+	* Return whether this Interval has the same start and end as the specified Interval.
+	* @param {Interval} other
+	* @return {boolean}
+	*/
+	equals(other) {
+		if (!this.isValid || !other.isValid) return false;
+		return this.s.equals(other.s) && this.e.equals(other.e);
+	}
+	/**
+	* Return an Interval representing the intersection of this Interval and the specified Interval.
+	* Specifically, the resulting Interval has the maximum start time and the minimum end time of the two Intervals.
+	* Returns null if the intersection is empty, meaning, the intervals don't intersect.
+	* @param {Interval} other
+	* @return {Interval}
+	*/
+	intersection(other) {
+		if (!this.isValid) return this;
+		const s = this.s > other.s ? this.s : other.s, e = this.e < other.e ? this.e : other.e;
+		if (s >= e) return null;
+		else return Interval.fromDateTimes(s, e);
+	}
+	/**
+	* Return an Interval representing the union of this Interval and the specified Interval.
+	* Specifically, the resulting Interval has the minimum start time and the maximum end time of the two Intervals.
+	* @param {Interval} other
+	* @return {Interval}
+	*/
+	union(other) {
+		if (!this.isValid) return this;
+		const s = this.s < other.s ? this.s : other.s, e = this.e > other.e ? this.e : other.e;
+		return Interval.fromDateTimes(s, e);
+	}
+	/**
+	* Merge an array of Intervals into a equivalent minimal set of Intervals.
+	* Combines overlapping and adjacent Intervals.
+	* @param {Array} intervals
+	* @return {Array}
+	*/
+	static merge(intervals) {
+		const [found, final] = intervals.sort((a, b) => a.s - b.s).reduce(([sofar, current], item) => {
+			if (!current) return [sofar, item];
+			else if (current.overlaps(item) || current.abutsStart(item)) return [sofar, current.union(item)];
+			else return [sofar.concat([current]), item];
+		}, [[], null]);
+		if (final) found.push(final);
+		return found;
+	}
+	/**
+	* Return an array of Intervals representing the spans of time that only appear in one of the specified Intervals.
+	* @param {Array} intervals
+	* @return {Array}
+	*/
+	static xor(intervals) {
+		let start = null, currentCount = 0;
+		const results = [], ends = intervals.map((i) => [{
+			time: i.s,
+			type: "s"
+		}, {
+			time: i.e,
+			type: "e"
+		}]), arr = Array.prototype.concat(...ends).sort((a, b) => a.time - b.time);
+		for (const i of arr) {
+			currentCount += i.type === "s" ? 1 : -1;
+			if (currentCount === 1) start = i.time;
+			else {
+				if (start && +start !== +i.time) results.push(Interval.fromDateTimes(start, i.time));
+				start = null;
+			}
+		}
+		return Interval.merge(results);
+	}
+	/**
+	* Return an Interval representing the span of time in this Interval that doesn't overlap with any of the specified Intervals.
+	* @param {...Interval} intervals
+	* @return {Array}
+	*/
+	difference(...intervals) {
+		return Interval.xor([this].concat(intervals)).map((i) => this.intersection(i)).filter((i) => i && !i.isEmpty());
+	}
+	/**
+	* Returns a string representation of this Interval appropriate for debugging.
+	* @return {string}
+	*/
+	toString() {
+		if (!this.isValid) return INVALID;
+		return `[${this.s.toISO()} – ${this.e.toISO()})`;
+	}
+	/**
+	* Returns a string representation of this Interval appropriate for the REPL.
+	* @return {string}
+	*/
+	[Symbol.for("nodejs.util.inspect.custom")]() {
+		if (this.isValid) return `Interval { start: ${this.s.toISO()}, end: ${this.e.toISO()} }`;
+		else return `Interval { Invalid, reason: ${this.invalidReason} }`;
+	}
+	/**
+	* Returns a localized string representing this Interval. Accepts the same options as the
+	* Intl.DateTimeFormat constructor and any presets defined by Luxon, such as
+	* {@link DateTime.DATE_FULL} or {@link DateTime.TIME_SIMPLE}. The exact behavior of this method
+	* is browser-specific, but in general it will return an appropriate representation of the
+	* Interval in the assigned locale. Defaults to the system's locale if no locale has been
+	* specified.
+	* @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat
+	* @param {Object} [formatOpts=DateTime.DATE_SHORT] - Either a DateTime preset or
+	* Intl.DateTimeFormat constructor options.
+	* @param {Object} opts - Options to override the configuration of the start DateTime.
+	* @example Interval.fromISO('2022-11-07T09:00Z/2022-11-08T09:00Z').toLocaleString(); //=> 11/7/2022 – 11/8/2022
+	* @example Interval.fromISO('2022-11-07T09:00Z/2022-11-08T09:00Z').toLocaleString(DateTime.DATE_FULL); //=> November 7 – 8, 2022
+	* @example Interval.fromISO('2022-11-07T09:00Z/2022-11-08T09:00Z').toLocaleString(DateTime.DATE_FULL, { locale: 'fr-FR' }); //=> 7–8 novembre 2022
+	* @example Interval.fromISO('2022-11-07T17:00Z/2022-11-07T19:00Z').toLocaleString(DateTime.TIME_SIMPLE); //=> 6:00 – 8:00 PM
+	* @example Interval.fromISO('2022-11-07T17:00Z/2022-11-07T19:00Z').toLocaleString({ weekday: 'short', month: 'short', day: '2-digit', hour: '2-digit', minute: '2-digit' }); //=> Mon, Nov 07, 6:00 – 8:00 p
+	* @return {string}
+	*/
+	toLocaleString(formatOpts = DATE_SHORT, opts = {}) {
+		return this.isValid ? Formatter.create(this.s.loc.clone(opts), formatOpts).formatInterval(this) : INVALID;
+	}
+	/**
+	* Returns an ISO 8601-compliant string representation of this Interval.
+	* @see https://en.wikipedia.org/wiki/ISO_8601#Time_intervals
+	* @param {Object} opts - The same options as {@link DateTime#toISO}
+	* @return {string}
+	*/
+	toISO(opts) {
+		if (!this.isValid) return INVALID;
+		return `${this.s.toISO(opts)}/${this.e.toISO(opts)}`;
+	}
+	/**
+	* Returns an ISO 8601-compliant string representation of date of this Interval.
+	* The time components are ignored.
+	* @see https://en.wikipedia.org/wiki/ISO_8601#Time_intervals
+	* @return {string}
+	*/
+	toISODate() {
+		if (!this.isValid) return INVALID;
+		return `${this.s.toISODate()}/${this.e.toISODate()}`;
+	}
+	/**
+	* Returns an ISO 8601-compliant string representation of time of this Interval.
+	* The date components are ignored.
+	* @see https://en.wikipedia.org/wiki/ISO_8601#Time_intervals
+	* @param {Object} opts - The same options as {@link DateTime#toISO}
+	* @return {string}
+	*/
+	toISOTime(opts) {
+		if (!this.isValid) return INVALID;
+		return `${this.s.toISOTime(opts)}/${this.e.toISOTime(opts)}`;
+	}
+	/**
+	* Returns a string representation of this Interval formatted according to the specified format
+	* string. **You may not want this.** See {@link Interval#toLocaleString} for a more flexible
+	* formatting tool.
+	* @param {string} dateFormat - The format string. This string formats the start and end time.
+	* See {@link DateTime#toFormat} for details.
+	* @param {Object} opts - Options.
+	* @param {string} [opts.separator =  ' – '] - A separator to place between the start and end
+	* representations.
+	* @return {string}
+	*/
+	toFormat(dateFormat, { separator = " – " } = {}) {
+		if (!this.isValid) return INVALID;
+		return `${this.s.toFormat(dateFormat)}${separator}${this.e.toFormat(dateFormat)}`;
+	}
+	/**
+	* Return a Duration representing the time spanned by this interval.
+	* @param {string|string[]} [unit=['milliseconds']] - the unit or units (such as 'hours' or 'days') to include in the duration.
+	* @param {Object} opts - options that affect the creation of the Duration
+	* @param {string} [opts.conversionAccuracy='casual'] - the conversion system to use
+	* @example Interval.fromDateTimes(dt1, dt2).toDuration().toObject() //=> { milliseconds: 88489257 }
+	* @example Interval.fromDateTimes(dt1, dt2).toDuration('days').toObject() //=> { days: 1.0241812152777778 }
+	* @example Interval.fromDateTimes(dt1, dt2).toDuration(['hours', 'minutes']).toObject() //=> { hours: 24, minutes: 34.82095 }
+	* @example Interval.fromDateTimes(dt1, dt2).toDuration(['hours', 'minutes', 'seconds']).toObject() //=> { hours: 24, minutes: 34, seconds: 49.257 }
+	* @example Interval.fromDateTimes(dt1, dt2).toDuration('seconds').toObject() //=> { seconds: 88489.257 }
+	* @return {Duration}
+	*/
+	toDuration(unit, opts) {
+		if (!this.isValid) return Duration.invalid(this.invalidReason);
+		return this.e.diff(this.s, unit, opts);
+	}
+	/**
+	* Run mapFn on the interval start and end, returning a new Interval from the resulting DateTimes
+	* @param {function} mapFn
+	* @return {Interval}
+	* @example Interval.fromDateTimes(dt1, dt2).mapEndpoints(endpoint => endpoint.toUTC())
+	* @example Interval.fromDateTimes(dt1, dt2).mapEndpoints(endpoint => endpoint.plus({ hours: 2 }))
+	*/
+	mapEndpoints(mapFn) {
+		return Interval.fromDateTimes(mapFn(this.s), mapFn(this.e));
+	}
+};
+
+//#endregion
+export { Interval as default };
+//# sourceMappingURL=interval.mjs.map

package/build/node_modules/.pnpm/luxon@3.5.0/node_modules/luxon/src/interval.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"interval.mjs","names":["e","Formats.DATE_SHORT"],"sources":["../../../../../../../../../node_modules/.pnpm/luxon@3.5.0/node_modules/luxon/src/interval.js"],"sourcesContent":["import DateTime, { friendlyDateTime } from \"./datetime.js\";\nimport Duration from \"./duration.js\";\nimport Settings from \"./settings.js\";\nimport { InvalidArgumentError, InvalidIntervalError } from \"./errors.js\";\nimport Invalid from \"./impl/invalid.js\";\nimport Formatter from \"./impl/formatter.js\";\nimport * as Formats from \"./impl/formats.js\";\n\nconst INVALID = \"Invalid Interval\";\n\n// checks if the start is equal to or before the end\nfunction validateStartEnd(start, end) {\n  if (!start || !start.isValid) {\n    return Interval.invalid(\"missing or invalid start\");\n  } else if (!end || !end.isValid) {\n    return Interval.invalid(\"missing or invalid end\");\n  } else if (end < start) {\n    return Interval.invalid(\n      \"end before start\",\n      `The end of an interval must be after its start, but you had start=${start.toISO()} and end=${end.toISO()}`\n    );\n  } else {\n    return null;\n  }\n}\n\n/**\n * An Interval object represents a half-open interval of time, where each endpoint is a {@link DateTime}. Conceptually, it's a container for those two endpoints, accompanied by methods for creating, parsing, interrogating, comparing, transforming, and formatting them.\n *\n * Here is a brief overview of the most commonly used methods and getters in Interval:\n *\n * * **Creation** To create an Interval, use {@link Interval.fromDateTimes}, {@link Interval.after}, {@link Interval.before}, or {@link Interval.fromISO}.\n * * **Accessors** Use {@link Interval#start} and {@link Interval#end} to get the start and end.\n * * **Interrogation** To analyze the Interval, use {@link Interval#count}, {@link Interval#length}, {@link Interval#hasSame}, {@link Interval#contains}, {@link Interval#isAfter}, or {@link Interval#isBefore}.\n * * **Transformation** To create other Intervals out of this one, use {@link Interval#set}, {@link Interval#splitAt}, {@link Interval#splitBy}, {@link Interval#divideEqually}, {@link Interval.merge}, {@link Interval.xor}, {@link Interval#union}, {@link Interval#intersection}, or {@link Interval#difference}.\n * * **Comparison** To compare this Interval to another one, use {@link Interval#equals}, {@link Interval#overlaps}, {@link Interval#abutsStart}, {@link Interval#abutsEnd}, {@link Interval#engulfs}\n * * **Output** To convert the Interval into other representations, see {@link Interval#toString}, {@link Interval#toLocaleString}, {@link Interval#toISO}, {@link Interval#toISODate}, {@link Interval#toISOTime}, {@link Interval#toFormat}, and {@link Interval#toDuration}.\n */\nexport default class Interval {\n  /**\n   * @private\n   */\n  constructor(config) {\n    /**\n     * @access private\n     */\n    this.s = config.start;\n    /**\n     * @access private\n     */\n    this.e = config.end;\n    /**\n     * @access private\n     */\n    this.invalid = config.invalid || null;\n    /**\n     * @access private\n     */\n    this.isLuxonInterval = true;\n  }\n\n  /**\n   * Create an invalid Interval.\n   * @param {string} reason - simple string of why this Interval is invalid. Should not contain parameters or anything else data-dependent\n   * @param {string} [explanation=null] - longer explanation, may include parameters and other useful debugging information\n   * @return {Interval}\n   */\n  static invalid(reason, explanation = null) {\n    if (!reason) {\n      throw new InvalidArgumentError(\"need to specify a reason the Interval is invalid\");\n    }\n\n    const invalid = reason instanceof Invalid ? reason : new Invalid(reason, explanation);\n\n    if (Settings.throwOnInvalid) {\n      throw new InvalidIntervalError(invalid);\n    } else {\n      return new Interval({ invalid });\n    }\n  }\n\n  /**\n   * Create an Interval from a start DateTime and an end DateTime. Inclusive of the start but not the end.\n   * @param {DateTime|Date|Object} start\n   * @param {DateTime|Date|Object} end\n   * @return {Interval}\n   */\n  static fromDateTimes(start, end) {\n    const builtStart = friendlyDateTime(start),\n      builtEnd = friendlyDateTime(end);\n\n    const validateError = validateStartEnd(builtStart, builtEnd);\n\n    if (validateError == null) {\n      return new Interval({\n        start: builtStart,\n        end: builtEnd,\n      });\n    } else {\n      return validateError;\n    }\n  }\n\n  /**\n   * Create an Interval from a start DateTime and a Duration to extend to.\n   * @param {DateTime|Date|Object} start\n   * @param {Duration|Object|number} duration - the length of the Interval.\n   * @return {Interval}\n   */\n  static after(start, duration) {\n    const dur = Duration.fromDurationLike(duration),\n      dt = friendlyDateTime(start);\n    return Interval.fromDateTimes(dt, dt.plus(dur));\n  }\n\n  /**\n   * Create an Interval from an end DateTime and a Duration to extend backwards to.\n   * @param {DateTime|Date|Object} end\n   * @param {Duration|Object|number} duration - the length of the Interval.\n   * @return {Interval}\n   */\n  static before(end, duration) {\n    const dur = Duration.fromDurationLike(duration),\n      dt = friendlyDateTime(end);\n    return Interval.fromDateTimes(dt.minus(dur), dt);\n  }\n\n  /**\n   * Create an Interval from an ISO 8601 string.\n   * Accepts `<start>/<end>`, `<start>/<duration>`, and `<duration>/<end>` formats.\n   * @param {string} text - the ISO string to parse\n   * @param {Object} [opts] - options to pass {@link DateTime#fromISO} and optionally {@link Duration#fromISO}\n   * @see https://en.wikipedia.org/wiki/ISO_8601#Time_intervals\n   * @return {Interval}\n   */\n  static fromISO(text, opts) {\n    const [s, e] = (text || \"\").split(\"/\", 2);\n    if (s && e) {\n      let start, startIsValid;\n      try {\n        start = DateTime.fromISO(s, opts);\n        startIsValid = start.isValid;\n      } catch (e) {\n        startIsValid = false;\n      }\n\n      let end, endIsValid;\n      try {\n        end = DateTime.fromISO(e, opts);\n        endIsValid = end.isValid;\n      } catch (e) {\n        endIsValid = false;\n      }\n\n      if (startIsValid && endIsValid) {\n        return Interval.fromDateTimes(start, end);\n      }\n\n      if (startIsValid) {\n        const dur = Duration.fromISO(e, opts);\n        if (dur.isValid) {\n          return Interval.after(start, dur);\n        }\n      } else if (endIsValid) {\n        const dur = Duration.fromISO(s, opts);\n        if (dur.isValid) {\n          return Interval.before(end, dur);\n        }\n      }\n    }\n    return Interval.invalid(\"unparsable\", `the input \"${text}\" can't be parsed as ISO 8601`);\n  }\n\n  /**\n   * Check if an object is an Interval. Works across context boundaries\n   * @param {object} o\n   * @return {boolean}\n   */\n  static isInterval(o) {\n    return (o && o.isLuxonInterval) || false;\n  }\n\n  /**\n   * Returns the start of the Interval\n   * @type {DateTime}\n   */\n  get start() {\n    return this.isValid ? this.s : null;\n  }\n\n  /**\n   * Returns the end of the Interval\n   * @type {DateTime}\n   */\n  get end() {\n    return this.isValid ? this.e : null;\n  }\n\n  /**\n   * Returns whether this Interval's end is at least its start, meaning that the Interval isn't 'backwards'.\n   * @type {boolean}\n   */\n  get isValid() {\n    return this.invalidReason === null;\n  }\n\n  /**\n   * Returns an error code if this Interval is invalid, or null if the Interval is valid\n   * @type {string}\n   */\n  get invalidReason() {\n    return this.invalid ? this.invalid.reason : null;\n  }\n\n  /**\n   * Returns an explanation of why this Interval became invalid, or null if the Interval is valid\n   * @type {string}\n   */\n  get invalidExplanation() {\n    return this.invalid ? this.invalid.explanation : null;\n  }\n\n  /**\n   * Returns the length of the Interval in the specified unit.\n   * @param {string} unit - the unit (such as 'hours' or 'days') to return the length in.\n   * @return {number}\n   */\n  length(unit = \"milliseconds\") {\n    return this.isValid ? this.toDuration(...[unit]).get(unit) : NaN;\n  }\n\n  /**\n   * Returns the count of minutes, hours, days, months, or years included in the Interval, even in part.\n   * Unlike {@link Interval#length} this counts sections of the calendar, not periods of time, e.g. specifying 'day'\n   * asks 'what dates are included in this interval?', not 'how many days long is this interval?'\n   * @param {string} [unit='milliseconds'] - the unit of time to count.\n   * @param {Object} opts - options\n   * @param {boolean} [opts.useLocaleWeeks=false] - If true, use weeks based on the locale, i.e. use the locale-dependent start of the week; this operation will always use the locale of the start DateTime\n   * @return {number}\n   */\n  count(unit = \"milliseconds\", opts) {\n    if (!this.isValid) return NaN;\n    const start = this.start.startOf(unit, opts);\n    let end;\n    if (opts?.useLocaleWeeks) {\n      end = this.end.reconfigure({ locale: start.locale });\n    } else {\n      end = this.end;\n    }\n    end = end.startOf(unit, opts);\n    return Math.floor(end.diff(start, unit).get(unit)) + (end.valueOf() !== this.end.valueOf());\n  }\n\n  /**\n   * Returns whether this Interval's start and end are both in the same unit of time\n   * @param {string} unit - the unit of time to check sameness on\n   * @return {boolean}\n   */\n  hasSame(unit) {\n    return this.isValid ? this.isEmpty() || this.e.minus(1).hasSame(this.s, unit) : false;\n  }\n\n  /**\n   * Return whether this Interval has the same start and end DateTimes.\n   * @return {boolean}\n   */\n  isEmpty() {\n    return this.s.valueOf() === this.e.valueOf();\n  }\n\n  /**\n   * Return whether this Interval's start is after the specified DateTime.\n   * @param {DateTime} dateTime\n   * @return {boolean}\n   */\n  isAfter(dateTime) {\n    if (!this.isValid) return false;\n    return this.s > dateTime;\n  }\n\n  /**\n   * Return whether this Interval's end is before the specified DateTime.\n   * @param {DateTime} dateTime\n   * @return {boolean}\n   */\n  isBefore(dateTime) {\n    if (!this.isValid) return false;\n    return this.e <= dateTime;\n  }\n\n  /**\n   * Return whether this Interval contains the specified DateTime.\n   * @param {DateTime} dateTime\n   * @return {boolean}\n   */\n  contains(dateTime) {\n    if (!this.isValid) return false;\n    return this.s <= dateTime && this.e > dateTime;\n  }\n\n  /**\n   * \"Sets\" the start and/or end dates. Returns a newly-constructed Interval.\n   * @param {Object} values - the values to set\n   * @param {DateTime} values.start - the starting DateTime\n   * @param {DateTime} values.end - the ending DateTime\n   * @return {Interval}\n   */\n  set({ start, end } = {}) {\n    if (!this.isValid) return this;\n    return Interval.fromDateTimes(start || this.s, end || this.e);\n  }\n\n  /**\n   * Split this Interval at each of the specified DateTimes\n   * @param {...DateTime} dateTimes - the unit of time to count.\n   * @return {Array}\n   */\n  splitAt(...dateTimes) {\n    if (!this.isValid) return [];\n    const sorted = dateTimes\n        .map(friendlyDateTime)\n        .filter((d) => this.contains(d))\n        .sort((a, b) => a.toMillis() - b.toMillis()),\n      results = [];\n    let { s } = this,\n      i = 0;\n\n    while (s < this.e) {\n      const added = sorted[i] || this.e,\n        next = +added > +this.e ? this.e : added;\n      results.push(Interval.fromDateTimes(s, next));\n      s = next;\n      i += 1;\n    }\n\n    return results;\n  }\n\n  /**\n   * Split this Interval into smaller Intervals, each of the specified length.\n   * Left over time is grouped into a smaller interval\n   * @param {Duration|Object|number} duration - The length of each resulting interval.\n   * @return {Array}\n   */\n  splitBy(duration) {\n    const dur = Duration.fromDurationLike(duration);\n\n    if (!this.isValid || !dur.isValid || dur.as(\"milliseconds\") === 0) {\n      return [];\n    }\n\n    let { s } = this,\n      idx = 1,\n      next;\n\n    const results = [];\n    while (s < this.e) {\n      const added = this.start.plus(dur.mapUnits((x) => x * idx));\n      next = +added > +this.e ? this.e : added;\n      results.push(Interval.fromDateTimes(s, next));\n      s = next;\n      idx += 1;\n    }\n\n    return results;\n  }\n\n  /**\n   * Split this Interval into the specified number of smaller intervals.\n   * @param {number} numberOfParts - The number of Intervals to divide the Interval into.\n   * @return {Array}\n   */\n  divideEqually(numberOfParts) {\n    if (!this.isValid) return [];\n    return this.splitBy(this.length() / numberOfParts).slice(0, numberOfParts);\n  }\n\n  /**\n   * Return whether this Interval overlaps with the specified Interval\n   * @param {Interval} other\n   * @return {boolean}\n   */\n  overlaps(other) {\n    return this.e > other.s && this.s < other.e;\n  }\n\n  /**\n   * Return whether this Interval's end is adjacent to the specified Interval's start.\n   * @param {Interval} other\n   * @return {boolean}\n   */\n  abutsStart(other) {\n    if (!this.isValid) return false;\n    return +this.e === +other.s;\n  }\n\n  /**\n   * Return whether this Interval's start is adjacent to the specified Interval's end.\n   * @param {Interval} other\n   * @return {boolean}\n   */\n  abutsEnd(other) {\n    if (!this.isValid) return false;\n    return +other.e === +this.s;\n  }\n\n  /**\n   * Returns true if this Interval fully contains the specified Interval, specifically if the intersect (of this Interval and the other Interval) is equal to the other Interval; false otherwise.\n   * @param {Interval} other\n   * @return {boolean}\n   */\n  engulfs(other) {\n    if (!this.isValid) return false;\n    return this.s <= other.s && this.e >= other.e;\n  }\n\n  /**\n   * Return whether this Interval has the same start and end as the specified Interval.\n   * @param {Interval} other\n   * @return {boolean}\n   */\n  equals(other) {\n    if (!this.isValid || !other.isValid) {\n      return false;\n    }\n\n    return this.s.equals(other.s) && this.e.equals(other.e);\n  }\n\n  /**\n   * Return an Interval representing the intersection of this Interval and the specified Interval.\n   * Specifically, the resulting Interval has the maximum start time and the minimum end time of the two Intervals.\n   * Returns null if the intersection is empty, meaning, the intervals don't intersect.\n   * @param {Interval} other\n   * @return {Interval}\n   */\n  intersection(other) {\n    if (!this.isValid) return this;\n    const s = this.s > other.s ? this.s : other.s,\n      e = this.e < other.e ? this.e : other.e;\n\n    if (s >= e) {\n      return null;\n    } else {\n      return Interval.fromDateTimes(s, e);\n    }\n  }\n\n  /**\n   * Return an Interval representing the union of this Interval and the specified Interval.\n   * Specifically, the resulting Interval has the minimum start time and the maximum end time of the two Intervals.\n   * @param {Interval} other\n   * @return {Interval}\n   */\n  union(other) {\n    if (!this.isValid) return this;\n    const s = this.s < other.s ? this.s : other.s,\n      e = this.e > other.e ? this.e : other.e;\n    return Interval.fromDateTimes(s, e);\n  }\n\n  /**\n   * Merge an array of Intervals into a equivalent minimal set of Intervals.\n   * Combines overlapping and adjacent Intervals.\n   * @param {Array} intervals\n   * @return {Array}\n   */\n  static merge(intervals) {\n    const [found, final] = intervals\n      .sort((a, b) => a.s - b.s)\n      .reduce(\n        ([sofar, current], item) => {\n          if (!current) {\n            return [sofar, item];\n          } else if (current.overlaps(item) || current.abutsStart(item)) {\n            return [sofar, current.union(item)];\n          } else {\n            return [sofar.concat([current]), item];\n          }\n        },\n        [[], null]\n      );\n    if (final) {\n      found.push(final);\n    }\n    return found;\n  }\n\n  /**\n   * Return an array of Intervals representing the spans of time that only appear in one of the specified Intervals.\n   * @param {Array} intervals\n   * @return {Array}\n   */\n  static xor(intervals) {\n    let start = null,\n      currentCount = 0;\n    const results = [],\n      ends = intervals.map((i) => [\n        { time: i.s, type: \"s\" },\n        { time: i.e, type: \"e\" },\n      ]),\n      flattened = Array.prototype.concat(...ends),\n      arr = flattened.sort((a, b) => a.time - b.time);\n\n    for (const i of arr) {\n      currentCount += i.type === \"s\" ? 1 : -1;\n\n      if (currentCount === 1) {\n        start = i.time;\n      } else {\n        if (start && +start !== +i.time) {\n          results.push(Interval.fromDateTimes(start, i.time));\n        }\n\n        start = null;\n      }\n    }\n\n    return Interval.merge(results);\n  }\n\n  /**\n   * Return an Interval representing the span of time in this Interval that doesn't overlap with any of the specified Intervals.\n   * @param {...Interval} intervals\n   * @return {Array}\n   */\n  difference(...intervals) {\n    return Interval.xor([this].concat(intervals))\n      .map((i) => this.intersection(i))\n      .filter((i) => i && !i.isEmpty());\n  }\n\n  /**\n   * Returns a string representation of this Interval appropriate for debugging.\n   * @return {string}\n   */\n  toString() {\n    if (!this.isValid) return INVALID;\n    return `[${this.s.toISO()} – ${this.e.toISO()})`;\n  }\n\n  /**\n   * Returns a string representation of this Interval appropriate for the REPL.\n   * @return {string}\n   */\n  [Symbol.for(\"nodejs.util.inspect.custom\")]() {\n    if (this.isValid) {\n      return `Interval { start: ${this.s.toISO()}, end: ${this.e.toISO()} }`;\n    } else {\n      return `Interval { Invalid, reason: ${this.invalidReason} }`;\n    }\n  }\n\n  /**\n   * Returns a localized string representing this Interval. Accepts the same options as the\n   * Intl.DateTimeFormat constructor and any presets defined by Luxon, such as\n   * {@link DateTime.DATE_FULL} or {@link DateTime.TIME_SIMPLE}. The exact behavior of this method\n   * is browser-specific, but in general it will return an appropriate representation of the\n   * Interval in the assigned locale. Defaults to the system's locale if no locale has been\n   * specified.\n   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat\n   * @param {Object} [formatOpts=DateTime.DATE_SHORT] - Either a DateTime preset or\n   * Intl.DateTimeFormat constructor options.\n   * @param {Object} opts - Options to override the configuration of the start DateTime.\n   * @example Interval.fromISO('2022-11-07T09:00Z/2022-11-08T09:00Z').toLocaleString(); //=> 11/7/2022 – 11/8/2022\n   * @example Interval.fromISO('2022-11-07T09:00Z/2022-11-08T09:00Z').toLocaleString(DateTime.DATE_FULL); //=> November 7 – 8, 2022\n   * @example Interval.fromISO('2022-11-07T09:00Z/2022-11-08T09:00Z').toLocaleString(DateTime.DATE_FULL, { locale: 'fr-FR' }); //=> 7–8 novembre 2022\n   * @example Interval.fromISO('2022-11-07T17:00Z/2022-11-07T19:00Z').toLocaleString(DateTime.TIME_SIMPLE); //=> 6:00 – 8:00 PM\n   * @example Interval.fromISO('2022-11-07T17:00Z/2022-11-07T19:00Z').toLocaleString({ weekday: 'short', month: 'short', day: '2-digit', hour: '2-digit', minute: '2-digit' }); //=> Mon, Nov 07, 6:00 – 8:00 p\n   * @return {string}\n   */\n  toLocaleString(formatOpts = Formats.DATE_SHORT, opts = {}) {\n    return this.isValid\n      ? Formatter.create(this.s.loc.clone(opts), formatOpts).formatInterval(this)\n      : INVALID;\n  }\n\n  /**\n   * Returns an ISO 8601-compliant string representation of this Interval.\n   * @see https://en.wikipedia.org/wiki/ISO_8601#Time_intervals\n   * @param {Object} opts - The same options as {@link DateTime#toISO}\n   * @return {string}\n   */\n  toISO(opts) {\n    if (!this.isValid) return INVALID;\n    return `${this.s.toISO(opts)}/${this.e.toISO(opts)}`;\n  }\n\n  /**\n   * Returns an ISO 8601-compliant string representation of date of this Interval.\n   * The time components are ignored.\n   * @see https://en.wikipedia.org/wiki/ISO_8601#Time_intervals\n   * @return {string}\n   */\n  toISODate() {\n    if (!this.isValid) return INVALID;\n    return `${this.s.toISODate()}/${this.e.toISODate()}`;\n  }\n\n  /**\n   * Returns an ISO 8601-compliant string representation of time of this Interval.\n   * The date components are ignored.\n   * @see https://en.wikipedia.org/wiki/ISO_8601#Time_intervals\n   * @param {Object} opts - The same options as {@link DateTime#toISO}\n   * @return {string}\n   */\n  toISOTime(opts) {\n    if (!this.isValid) return INVALID;\n    return `${this.s.toISOTime(opts)}/${this.e.toISOTime(opts)}`;\n  }\n\n  /**\n   * Returns a string representation of this Interval formatted according to the specified format\n   * string. **You may not want this.** See {@link Interval#toLocaleString} for a more flexible\n   * formatting tool.\n   * @param {string} dateFormat - The format string. This string formats the start and end time.\n   * See {@link DateTime#toFormat} for details.\n   * @param {Object} opts - Options.\n   * @param {string} [opts.separator =  ' – '] - A separator to place between the start and end\n   * representations.\n   * @return {string}\n   */\n  toFormat(dateFormat, { separator = \" – \" } = {}) {\n    if (!this.isValid) return INVALID;\n    return `${this.s.toFormat(dateFormat)}${separator}${this.e.toFormat(dateFormat)}`;\n  }\n\n  /**\n   * Return a Duration representing the time spanned by this interval.\n   * @param {string|string[]} [unit=['milliseconds']] - the unit or units (such as 'hours' or 'days') to include in the duration.\n   * @param {Object} opts - options that affect the creation of the Duration\n   * @param {string} [opts.conversionAccuracy='casual'] - the conversion system to use\n   * @example Interval.fromDateTimes(dt1, dt2).toDuration().toObject() //=> { milliseconds: 88489257 }\n   * @example Interval.fromDateTimes(dt1, dt2).toDuration('days').toObject() //=> { days: 1.0241812152777778 }\n   * @example Interval.fromDateTimes(dt1, dt2).toDuration(['hours', 'minutes']).toObject() //=> { hours: 24, minutes: 34.82095 }\n   * @example Interval.fromDateTimes(dt1, dt2).toDuration(['hours', 'minutes', 'seconds']).toObject() //=> { hours: 24, minutes: 34, seconds: 49.257 }\n   * @example Interval.fromDateTimes(dt1, dt2).toDuration('seconds').toObject() //=> { seconds: 88489.257 }\n   * @return {Duration}\n   */\n  toDuration(unit, opts) {\n    if (!this.isValid) {\n      return Duration.invalid(this.invalidReason);\n    }\n    return this.e.diff(this.s, unit, opts);\n  }\n\n  /**\n   * Run mapFn on the interval start and end, returning a new Interval from the resulting DateTimes\n   * @param {function} mapFn\n   * @return {Interval}\n   * @example Interval.fromDateTimes(dt1, dt2).mapEndpoints(endpoint => endpoint.toUTC())\n   * @example Interval.fromDateTimes(dt1, dt2).mapEndpoints(endpoint => endpoint.plus({ hours: 2 }))\n   */\n  mapEndpoints(mapFn) {\n    return Interval.fromDateTimes(mapFn(this.s), mapFn(this.e));\n  }\n}\n"],"x_google_ignoreList":[0],"mappings":"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"}