polite-crawler 0.0.0-stage → 0.1.0

package/build/hours.mjs

@@ -0,0 +1,905 @@
+//#region src/hours.ts
+const DAYS = [
+	"mon",
+	"tue",
+	"wed",
+	"thu",
+	"fri",
+	"sat",
+	"sun"
+];
+const DAY_WORDS = {
+	m: "mon",
+	mo: "mon",
+	mon: "mon",
+	monday: "mon",
+	mondays: "mon",
+	tu: "tue",
+	tue: "tue",
+	tues: "tue",
+	tuesday: "tue",
+	tuesdays: "tue",
+	w: "wed",
+	we: "wed",
+	wed: "wed",
+	weds: "wed",
+	wednesday: "wed",
+	wednesdays: "wed",
+	th: "thu",
+	thu: "thu",
+	thur: "thu",
+	thurs: "thu",
+	thursday: "thu",
+	thursdays: "thu",
+	f: "fri",
+	fr: "fri",
+	fri: "fri",
+	friday: "fri",
+	fridays: "fri",
+	sa: "sat",
+	sat: "sat",
+	saturday: "sat",
+	saturdays: "sat",
+	su: "sun",
+	sun: "sun",
+	sunday: "sun",
+	sundays: "sun"
+};
+const dayOf = (word) => {
+	const clean = word.toLowerCase().replace(/\.$/, "");
+	return DAY_WORDS[clean] ?? DAY_WORDS[clean.replace(/s$/, "")] ?? DAY_WORDS[clean.slice(0, 3)];
+};
+/** This function gives the days from one day to another, with the two days. It continues past Sunday (Fri-Mon). */
+const dayRange = (from, to) => {
+	const out = [];
+	for (let index = DAYS.indexOf(from);; index = (index + 1) % 7) {
+		out.push(DAYS[index]);
+		if (DAYS[index] === to || out.length === 7) return out;
+	}
+};
+const pad = (value) => String(value).padStart(2, "0");
+const hhmm = (hour, minute) => `${pad(hour % 24)}:${pad(minute)}`;
+const minutesOf = (clock) => Number(clock.slice(0, 2)) * 60 + Number(clock.slice(3, 5));
+/** This function gives the minutes from the start of the day. A close at or before the open is on the next day ("17:00-02:00" ends at 26:00). */
+const spanOf = ([open, close]) => {
+	const start = minutesOf(open);
+	const end = minutesOf(close);
+	return [start, end <= start ? end + 1440 : end];
+};
+const fromMinutes = (minutes) => hhmm(Math.floor(minutes / 60), minutes % 60);
+/** This function gives the length of an interval in minutes: 1440 for open 24 hours. */
+const lengthOf = (open, close) => {
+	const length = (close - open + 1440) % 1440;
+	return length === 0 ? 1440 : length;
+};
+const ALL_DAY = ["00:00", "00:00"];
+/** No real day has more intervals than this. More is a list of something else, and the reader stops. */
+const MAX_INTERVALS = 8;
+const addInterval = (week, days, interval) => {
+	for (const day of days) {
+		let list = week[day] ?? [];
+		if (list.length >= MAX_INTERVALS) continue;
+		if (!list.some(([open, close]) => open === interval[0] && close === interval[1])) {
+			const [start, end] = spanOf(interval);
+			const overlaps = (other) => {
+				const [otherStart, otherEnd] = spanOf(other);
+				return otherStart <= end && start <= otherEnd;
+			};
+			const [first, last] = list.filter(overlaps).reduce(([low, high], other) => {
+				const [otherStart, otherEnd] = spanOf(other);
+				return [Math.min(low, otherStart), Math.max(high, otherEnd)];
+			}, [start, end]);
+			const merged = [fromMinutes(first), fromMinutes(last - first >= 1440 ? first : last)];
+			list = [...list.filter((other) => !overlaps(other)), merged];
+		}
+		list.sort((a, b) => a[0].localeCompare(b[0]));
+		week[day] = list;
+	}
+};
+/** This function closes the days that nothing has stated. */
+const closeDays = (week, days) => {
+	for (const day of days) if (week[day] === void 0) week[day] = [];
+};
+/** These words name a month. */
+const MONTH = "(?:jan(?:uary)?|feb(?:ruary)?|mar(?:ch)?|apr(?:il)?|may|june?|july?|aug(?:ust)?|sep(?:t(?:ember)?)?|oct(?:ober)?|nov(?:ember)?|dec(?:ember)?)\\.?";
+const OSM_DAYS = /^(Mo|Tu|We|Th|Fr|Sa|Su)(?:-(Mo|Tu|We|Th|Fr|Sa|Su))?$/i;
+const NAMED_DAYS = /^([a-z]{2,9})(?:-([a-z]{2,9}))?$/i;
+const OSM_TIME = /^(\d{1,2}):(\d{2})-(\d{1,2}):(\d{2})\+?$/;
+/** A rule for dates, not for a week: months, weeks, a year, an nth weekday, Easter. */
+const DATED_RULE = new RegExp(`\\b${MONTH}(?![a-z])|\\bweek\\b|\\[|\\beaster\\b|\\b\\d{4}\\b`, "i");
+const MAX_COMPACT_CHARS = 2e3;
+/** This function reads one OSM interval, "09:00-17:00", or gives undefined. A close past 24:00 is on the next day. */
+const osmInterval = (span) => {
+	const time = OSM_TIME.exec(span);
+	if (time === null) return void 0;
+	const [openHour, openMinute, closeHour, closeMinute] = [
+		time[1],
+		time[2],
+		time[3],
+		time[4]
+	].map(Number);
+	if (openMinute > 59 || closeMinute > 59 || openHour > 24 || closeHour > 48) return void 0;
+	return [hhmm(openHour, openMinute), hhmm(closeHour, closeMinute)];
+};
+/**
+* This function reads the `opening_hours` notation of OpenStreetMap, for example
+* "Mo-Th 11:00-23:00; Fr,Sa 11:00-01:00; Su off". The `openingHours` of schema.org uses the same
+* notation. A later rule replaces an earlier rule for the same days, as OpenStreetMap specifies.
+* The reader leaves out a rule for dates or holidays, and the days of a rule that it cannot read
+* stay unknown. In both cases the result is `partial`.
+*/
+const fromCompact = (value, from = "osm") => {
+	if (value.length > MAX_COMPACT_CHARS) return void 0;
+	const text = value.replace(/\s+/g, " ").trim();
+	if (text.length === 0) return void 0;
+	const week = {};
+	if (text === "24/7") {
+		addInterval(week, DAYS, ALL_DAY);
+		return {
+			week,
+			from,
+			raw: value,
+			inferred: false
+		};
+	}
+	let partial = false;
+	let inferred = false;
+	const rules = text.replace(/"[^"]*"/g, " ").replace(/(\d) (?=(?:Mo|Tu|We|Th|Fr|Sa|Su|PH|SH)\b)/gi, "$1; ").split(/ ?(?:;|\|\|) ?/).flatMap((rule) => rule.split(/(?<=\d:\d{2}\+?) ?, ?(?=(?:Mo|Tu|We|Th|Fr|Sa|Su|PH|SH)\b)/i).map((part, index) => ({
+		part: part.trim(),
+		additional: index > 0
+	}))).filter(({ part }) => part.length > 0);
+	let read = false;
+	for (const { part: rule, additional } of rules) {
+		if (DATED_RULE.test(rule)) {
+			partial = true;
+			continue;
+		}
+		const parts = /^[\s,]*([A-Za-z]{1,9}(?:-[A-Za-z]{1,9})?(?: ?, ?[A-Za-z]{1,9}(?:-[A-Za-z]{1,9})?)*)? ?:? ?(.*)$/s.exec(rule);
+		let dayPart = (parts?.[1] ?? "").replace(/\s/g, "");
+		let timePart = (parts?.[2] ?? "").trim();
+		if (timePart.length === 0 && /^(off|closed|open)$/i.test(dayPart)) {
+			timePart = dayPart;
+			dayPart = "";
+		}
+		let days = [...DAYS];
+		if (dayPart.length > 0) {
+			days = [];
+			let holidays = false;
+			let unreadable = false;
+			for (const piece of dayPart.split(",").filter((part) => part.length > 0)) {
+				if (/^(PH|SH)$/i.test(piece)) {
+					holidays = true;
+					continue;
+				}
+				const range = OSM_DAYS.exec(piece) ?? NAMED_DAYS.exec(piece);
+				const first = range === null ? void 0 : dayOf(range[1]);
+				const last = range === null ? void 0 : dayOf(range[2] ?? range[1]);
+				if (first === void 0 || last === void 0) {
+					unreadable = true;
+					break;
+				}
+				days.push(...dayRange(first, last));
+			}
+			if (unreadable) {
+				partial = true;
+				continue;
+			}
+			if (days.length === 0) {
+				if (holidays) partial = true;
+				continue;
+			}
+		}
+		if (timePart.length === 0 || /^open$/i.test(timePart)) {
+			partial = true;
+			continue;
+		}
+		if (!additional) for (const day of days) delete week[day];
+		if (/^(off|closed)$/i.test(timePart)) {
+			for (const day of days) delete week[day];
+			closeDays(week, days);
+			read = true;
+			continue;
+		}
+		const intervals = [];
+		for (const span of timePart.split(/ ?, ?/).filter((part) => part.length > 0)) {
+			const interval = osmInterval(span);
+			if (interval !== void 0) {
+				intervals.push(interval);
+				continue;
+			}
+			const parts = splitRange(span);
+			const range = parts === void 0 ? void 0 : readRange(parts[0], parts[1]);
+			if (range === void 0) {
+				intervals.length = 0;
+				break;
+			}
+			inferred ||= range.inferred;
+			intervals.push(range.interval);
+		}
+		if (intervals.length === 0) {
+			for (const day of days) delete week[day];
+			partial = true;
+			continue;
+		}
+		for (const interval of intervals) addInterval(week, days, interval);
+		read = true;
+	}
+	if (!read || Object.keys(week).length === 0) return void 0;
+	return {
+		week,
+		from,
+		raw: value,
+		inferred,
+		...partial ? { partial } : {}
+	};
+};
+const SCHEMA_DAY = /(Monday|Tuesday|Wednesday|Thursday|Friday|Saturday|Sunday)$/i;
+/** This function reads a schema.org time: "17:00", "17:00:00", "17:00:00-05:00" or "5:00 PM". */
+const clockOf = (value) => {
+	if (typeof value !== "string") return void 0;
+	const raw = value.trim().slice(0, 40);
+	const match = /^(\d{1,2})(?::(\d{2}))?(?::\d{2}(?:\.\d+)?)?\s*(a\.?m\.?|p\.?m\.?)?\s*(?:z|[+-]\d{2}:?\d{2})?$/i.exec(raw);
+	if (match === null) return void 0;
+	let hour = Number(match[1]);
+	const minute = Number(match[2] ?? 0);
+	if (minute > 59 || hour > 24 || hour === 24 && minute > 0) return void 0;
+	const meridiem = match[3]?.toLowerCase().startsWith("p") === true ? "pm" : match[3] === void 0 ? void 0 : "am";
+	if (meridiem !== void 0) {
+		if (hour === 0 || hour > 12) return void 0;
+		hour = meridiem === "am" ? hour % 12 : hour % 12 + 12;
+	}
+	return {
+		minutes: hour * 60 + minute,
+		raw
+	};
+};
+/** This function gives the days of a `dayOfWeek`: a name, a URL, an `@id` or a short name. */
+const daysOfSpec = (raw) => {
+	const values = Array.isArray(raw) ? raw : [raw];
+	const days = [];
+	let holidays = false;
+	for (const value of values) {
+		const name = typeof value === "string" ? value : value !== null && typeof value === "object" ? value["@id"] : void 0;
+		if (typeof name !== "string") continue;
+		if (/PublicHolidays$/i.test(name.trim())) {
+			holidays = true;
+			continue;
+		}
+		const full = SCHEMA_DAY.exec(name.trim());
+		const day = full === null ? dayOf(name.trim().replace(/^.*[/#:]/, "")) : dayOf(full[1]);
+		if (day !== void 0) days.push(day);
+	}
+	return {
+		days,
+		holidays
+	};
+};
+/** The text of a date of schema.org, or an empty string for a value that is not text. */
+const dateText = (value) => typeof value === "string" ? value : "";
+const dateOf = (value) => {
+	if (typeof value !== "string") return void 0;
+	const time = Date.parse(value.trim().slice(0, 40));
+	return Number.isNaN(time) ? void 0 : time;
+};
+/**
+* This function reads the hours of one JSON-LD object, for example a `Restaurant`. It reads the
+* `openingHoursSpecification` first, and the `openingHours` when there is no specification. In
+* schema.org, a closed day has the same opening and closing time, 00:00, and 00:00 to 24:00 is
+* open 24 hours.
+*
+* A specification for less than a week (`validFrom` to `validThrough`) is a holiday: the reader
+* leaves it out. When specifications hold for different seasons, the option `at` picks the
+* season of that date. With no date, the reader keeps the specifications with no season, or else
+* the first season, and it names the season.
+*/
+const fromSchemaOrg = (record, options = {}) => {
+	const specs = record["openingHoursSpecification"];
+	const list = (Array.isArray(specs) ? specs : specs !== void 0 && specs !== null ? [specs] : []).slice(0, 200).filter((spec) => spec !== null && typeof spec === "object");
+	if (list.length > 0) {
+		let partial = false;
+		const at = options.at === void 0 ? void 0 : new Date(options.at).getTime();
+		const windowed = list.map((entry) => {
+			const fromDate = dateOf(entry["validFrom"]);
+			const throughDate = dateOf(entry["validThrough"]);
+			return {
+				entry,
+				key: fromDate === void 0 && throughDate === void 0 ? void 0 : `${dateText(entry["validFrom"])}/${dateText(entry["validThrough"])}`,
+				fromDate,
+				throughDate,
+				short: fromDate !== void 0 && throughDate !== void 0 && throughDate - fromDate < 6048e5
+			};
+		});
+		if (windowed.some(({ short }) => short)) partial = true;
+		const seasonal = windowed.filter(({ short }) => !short);
+		let season;
+		let chosen = seasonal.filter(({ key }) => key === void 0);
+		if (at !== void 0 && !Number.isNaN(at)) {
+			const now = seasonal.filter(({ key, fromDate, throughDate }) => key !== void 0 && (fromDate ?? -Infinity) <= at && at <= (throughDate ?? Infinity) + 86399999);
+			if (now.length > 0) {
+				season = now[0].key;
+				chosen = [...chosen, ...now.filter(({ key }) => key === season)];
+			}
+		} else if (chosen.length === 0) {
+			season = seasonal.find(({ key }) => key !== void 0)?.key;
+			chosen = seasonal.filter(({ key }) => key === season);
+		}
+		if (seasonal.some(({ key }) => key !== void 0 && key !== season)) partial = true;
+		const week = {};
+		for (const { entry } of chosen) {
+			const { days, holidays } = daysOfSpec(entry["dayOfWeek"]);
+			if (holidays) partial = true;
+			const opens = clockOf(entry["opens"]);
+			const closes = clockOf(entry["closes"]);
+			if (days.length === 0 || opens === void 0 || closes === void 0) {
+				if (days.length > 0) partial = true;
+				continue;
+			}
+			if (opens.minutes === 0 && (closes.raw.startsWith("24:00") || closes.minutes === 1439)) addInterval(week, days, ALL_DAY);
+			else if (opens.minutes === closes.minutes) {
+				if (opens.minutes === 0) {
+					for (const day of days) delete week[day];
+					closeDays(week, days);
+				} else partial = true;
+			} else addInterval(week, days, [fromMinutes(opens.minutes), fromMinutes(closes.minutes % 1440)]);
+		}
+		if (Object.keys(week).length > 0) return {
+			week,
+			from: "jsonld",
+			raw: JSON.stringify(list).slice(0, 500),
+			inferred: false,
+			...partial ? { partial } : {},
+			...season !== void 0 ? { season } : {}
+		};
+	}
+	const compact = record["openingHours"];
+	const strings = (Array.isArray(compact) ? compact : [compact]).filter((value) => typeof value === "string").slice(0, 50);
+	if (strings.length === 0) return void 0;
+	const joined = strings.join("; ");
+	const parsed = fromCompact(joined, "jsonld") ?? textFallback(joined);
+	return parsed === void 0 ? void 0 : {
+		...parsed,
+		raw: strings.join(", ")
+	};
+};
+/** This function reads an `openingHours` value that is not in the compact notation ("Monday-Friday 9am-5pm"). */
+const textFallback = (value) => {
+	const [found] = fromText(value.replace(/;/g, "\n"));
+	if (found === void 0) return void 0;
+	const { label: _label, ...hours } = found;
+	return {
+		...hours,
+		from: "jsonld"
+	};
+};
+const DAY_WORD = "(?:mon(?:day)?s?|tue(?:s(?:day)?)?s?|wed(?:s|nesday)?s?|thu(?:r(?:s(?:day)?)?)?s?|fri(?:day)?s?|sat(?:urday)?s?|sun(?:day)?s?)\\.?";
+/** These short day names count only in a span with a dash ("M-F", "Tu-Th", "Mo-Fr"). */
+const SHORT_DAY = "(?:mo|tu|we|th|fr|sa|su|m|w|f)";
+/** A dash of any kind joins a range. U+FFFD is a dash that a wrong decoder lost. */
+const DASH = "[-\\u2010-\\u2015\\u2212~\\u301c\\ufffd]";
+const RANGE_SEP = `\\s?(?:${DASH}|to|thru|through|until|till|['’]til|til)\\s?`;
+const TIME = "(?:12\\s?(?:midnight|noon|mn|nn)\\b|\\d{1,2}(?:[:.]\\d{2}|h(?:\\d{2})?(?![a-z]))?(?:\\s?(?:a\\.?m\\.?|p\\.?m\\.?))?|noon|midnight)";
+const TOKEN = new RegExp([
+	`(?<allday>\\b(?:open\\s)?(?<!(?:within|in|for|last|past|next|every|after|than)\\s)(?:24\\s?(?:hours|hrs?|h)\\b(?!\\s?(?:notice|in advance|advance|prior|before|ahead|later|turnaround|delivery|of|to|from))|24\\s?\\/\\s?7\\b|around the clock))`,
+	`(?<every>\\b(?:daily|every\\s?day|everyday|7\\s?days(?:\\s?a\\s?week)?|seven\\s?days(?:\\s?a\\s?week)?)\\b)`,
+	`(?<weekdays>\\bweekdays?\\b)`,
+	`(?<weekends>\\bweekends?\\b)`,
+	`(?<except>\\b(?:except(?:\\s(?:on|for))?|but(?:\\snot)?(?:\\son)?|excluding|other\\sthan|apart\\sfrom)(?=\\s(?:${DAY_WORD}|weekends?|weekdays?)(?![a-z])))`,
+	`(?<span>\\b(?:${DAY_WORD}${RANGE_SEP}${DAY_WORD}|(?:${DAY_WORD}|${SHORT_DAY})\\s?${DASH}\\s?(?:${DAY_WORD}|${SHORT_DAY}))(?![a-z]))`,
+	`(?<day>\\b${DAY_WORD}(?![a-z])(?!-(?!closed)[a-z])(?!['’]s\\b))`,
+	`(?<times>(?<![\\d:.$€£¥])${TIME}${RANGE_SEP}${TIME}(?!\\d))`,
+	`(?<clock>(?<![\\d:.$€£¥])(?:12\\s?(?:midnight|noon)\\b|\\d{1,2}(?:[:.]\\d{2})?\\s?(?:a\\.?m\\.?|p\\.?m\\.?)|noon|midnight)(?![a-z\\d]))`,
+	`(?<closed>\\bclosed\\b)`
+].join("|"), "gi");
+const readClock = (value) => {
+	const text = value.trim().toLowerCase();
+	if (/^(?:12\s?)?(?:noon|nn)$/.test(text)) return {
+		hour: 12,
+		minute: 0,
+		meridiem: "pm",
+		h24: false
+	};
+	if (/^(?:12\s?)?(?:midnight|mn)$/.test(text)) return {
+		hour: 12,
+		minute: 0,
+		meridiem: "am",
+		h24: false
+	};
+	const match = /^(\d{1,2})(?:[:.](\d{2})|(h)(\d{2})?)?\s?(a\.?m\.?|p\.?m\.?)?$/.exec(text);
+	if (match === null) return void 0;
+	const hour = Number(match[1]);
+	const minute = Number(match[2] ?? match[4] ?? 0);
+	if (hour > 24 || minute > 59 || hour === 24 && minute > 0) return void 0;
+	let meridiem = match[5] === void 0 ? void 0 : match[5].startsWith("a") ? "am" : "pm";
+	if (meridiem !== void 0 && (hour === 0 || hour > 12)) meridiem = void 0;
+	return {
+		hour,
+		minute,
+		meridiem,
+		h24: meridiem === void 0 && (hour > 12 || hour === 0 || match[1].startsWith("0") || match[3] !== void 0)
+	};
+};
+const to24 = (clock, meridiem) => meridiem === "am" ? clock.hour === 12 ? 0 : clock.hour : clock.hour === 12 ? 12 : clock.hour + 12;
+const flip = (meridiem) => meridiem === "am" ? "pm" : "am";
+/** The longest opening that a guess can give, in minutes. */
+const MAX_GUESS_MINUTES = 960;
+/** This function reads a range with a 24-hour time. A bare number on the other side is the reading that makes sense. */
+const read24 = (a, b) => {
+	const options = (clock) => clock.h24 || clock.meridiem !== void 0 ? [clock.meridiem === void 0 ? clock.hour % 24 : to24(clock, clock.meridiem)] : clock.hour === 12 ? [12, 0] : [clock.hour, clock.hour + 12];
+	const candidates = [];
+	for (const [aIndex, openHour] of options(a).entries()) for (const [bIndex, closeHour] of options(b).entries()) {
+		const open = openHour * 60 + a.minute;
+		const close = closeHour * 60 + b.minute;
+		candidates.push({
+			open,
+			close,
+			length: lengthOf(open, close),
+			written: aIndex === 0 && bIndex === 0
+		});
+	}
+	if (a.h24 && b.h24) {
+		const [only] = candidates;
+		if (only === void 0 || only.close <= only.open && only.close > 720) return void 0;
+		return {
+			interval: [fromMinutes(only.open), fromMinutes(only.close)],
+			inferred: false
+		};
+	}
+	const sensible = candidates.filter(({ length }) => length >= 60 && length <= MAX_GUESS_MINUTES).sort((x, y) => Number(y.written) - Number(x.written));
+	const best = sensible.find(({ close, open, length }) => close > open && length >= 180) ?? sensible.find(({ length }) => length >= 180) ?? sensible.find(({ close, open }) => close > open) ?? sensible[0];
+	if (best === void 0) return void 0;
+	return {
+		interval: [fromMinutes(best.open), fromMinutes(best.close)],
+		inferred: !best.written
+	};
+};
+/**
+* This function reads a range of two times, as a restaurant writes it:
+*
+* - "5-10pm" is 17:00-22:00, and "11-3pm" is 11:00-15:00. The opening gets the am or pm of the
+*   close, but not when that puts the opening after the close.
+* - "11-1am" is 11:00-01:00, because 23:00-01:00 is too short to be the meaning. The result is
+*   then `inferred`.
+* - "11am-10" closes at 22:00.
+* - With no am, pm or 24-hour time ("11-9"), an opening before 7 is pm, but "6-2" is 06:00-14:00.
+*   A close at or before the opening is pm, and "7-12" closes at noon. The result is then
+*   `inferred`, and it is not longer than 16 hours.
+* - "21-14" is no range: a 24-hour opening past midnight does not end after noon.
+*/
+const readRange = (start, end) => {
+	const a = readClock(start);
+	const b = readClock(end);
+	if (a === void 0 || b === void 0) return void 0;
+	if (a.h24 || b.h24) return read24(a, b);
+	let open;
+	let close;
+	let inferred = false;
+	if (a.meridiem !== void 0 && b.meridiem !== void 0) {
+		open = to24(a, a.meridiem);
+		close = to24(b, b.meridiem);
+	} else if (b.meridiem !== void 0) {
+		close = to24(b, b.meridiem);
+		const same = to24(a, b.meridiem);
+		const other = to24(a, flip(b.meridiem));
+		const closeAt = close * 60 + b.minute;
+		if (same * 60 + a.minute < closeAt) {
+			open = same;
+			if (a.hour === 12 && b.meridiem === "am" && lengthOf(same * 60 + a.minute, closeAt) <= 120) {
+				open = 12;
+				inferred = true;
+			}
+		} else if (lengthOf(other * 60 + a.minute, closeAt) <= 180 && lengthOf(same * 60 + a.minute, closeAt) <= 1080) {
+			open = same;
+			inferred = true;
+		} else open = other;
+	} else if (a.meridiem !== void 0) {
+		open = to24(a, a.meridiem);
+		const same = to24(b, a.meridiem);
+		close = same > open ? same : to24(b, flip(a.meridiem));
+	} else {
+		inferred = true;
+		open = a.hour === 12 ? 12 : a.hour >= 7 || a.hour >= 5 && b.hour >= 1 && b.hour <= 3 ? a.hour : a.hour + 12;
+		if (b.hour === 12) close = open < 12 ? 12 : 0;
+		else if (open < 12) close = b.hour <= a.hour || b.hour - open < 3 ? b.hour + 12 : b.hour;
+		else close = b.hour + 12 > open ? b.hour + 12 : b.hour;
+	}
+	const openAt = open * 60 + a.minute;
+	const closeAt = close * 60 + b.minute;
+	if (inferred && lengthOf(openAt, closeAt) > MAX_GUESS_MINUTES) return void 0;
+	return {
+		interval: [fromMinutes(openAt % 1440), fromMinutes(closeAt % 1440)],
+		inferred
+	};
+};
+const splitRange = (value) => {
+	const match = new RegExp(`^(${TIME})${RANGE_SEP}(${TIME})$`, "i").exec(value.replace(/\s+/g, " ").trim().slice(0, 80));
+	return match === null ? void 0 : [match[1], match[2]];
+};
+/** This function gives the days of a token and how specific it is: 0 for "daily", 1 for a span, 2 for one day. */
+const daysOfToken = (groups) => {
+	if (groups["every"] !== void 0) return {
+		days: [...DAYS],
+		spec: 0
+	};
+	if (groups["weekdays"] !== void 0) return {
+		days: [
+			"mon",
+			"tue",
+			"wed",
+			"thu",
+			"fri"
+		],
+		spec: 0
+	};
+	if (groups["weekends"] !== void 0) return {
+		days: ["sat", "sun"],
+		spec: 0
+	};
+	if (groups["span"] !== void 0) {
+		const [from, to] = groups["span"].split(new RegExp(RANGE_SEP, "i"));
+		const first = from === void 0 ? void 0 : dayOf(from.trim());
+		const last = to === void 0 ? void 0 : dayOf(to.trim());
+		return first === void 0 || last === void 0 ? void 0 : {
+			days: dayRange(first, last),
+			spec: 1
+		};
+	}
+	if (groups["day"] !== void 0) {
+		const day = dayOf(groups["day"]);
+		return day === void 0 ? void 0 : {
+			days: [day],
+			spec: 2
+		};
+	}
+};
+/** A date names one day of the year, not a day of the week: "Dec 24", "24 December", "12/24", "2026-12-24". */
+const DATE = new RegExp(`\\b${MONTH}\\s?\\d{1,2}(?:st|nd|rd|th)?\\b(?!:\\d|\\s?[ap]\\.?m\\b)|\\b\\d{1,2}(?:st|nd|rd|th)?\\s(?:of\\s)?${MONTH}(?![a-z])|(?<![\\d/])\\d{1,2}\\/\\d{1,2}(?:\\/\\d{2,4})?(?![\\d/])|\\b\\d{4}-\\d{2}-\\d{2}\\b`, "i");
+const DATE_RANGE = new RegExp(`\\b${MONTH}(?:\\s?\\d{1,2}(?:st|nd|rd|th)?)?${RANGE_SEP}${MONTH}(?:\\s?\\d{1,2}(?:st|nd|rd|th)?)?(?![a-z])`, "i");
+/** These words tell that a line is for one occasion, not for the week. */
+const OCCASION = /\b(?:holidays?|christmas|xmas|thanksgiving|easter|hanukkah|new year['’]?s?|nye|memorial day|labou?r day|independence day|valentine['’]?s|mother['’]?s day|father['’]?s day|private (?:events?|parties|party|hire|dining)|special events?|events? only|today|tonight)\b/i;
+/**
+* These words name a service or an event beside the opening hours ("Happy hour 6-8pm", "Delivery
+* 6pm-9pm", "Live music 9pm-12am"). Some lines have no day and name a service before their hours.
+* Under a line with days and hours, such a line is not the week. A meal ("Lunch", "Dinner") or
+* "Kitchen" stays a part of the opening hours.
+*/
+const SERVICE = /\b(?:happy hours?|delivery|deliveries|take[- ]?out|take[- ]?away|pick[- ]?up|curbside|drive[- ]?(?:thru|through)|live (?:music|jazz|band)|music|dj|karaoke|trivia|bingo|open mic|brunch|bottomless)\b/i;
+const SEASON = /^(?:summer|winter|spring|autumn|fall|off[- ]?season|high season|low season|peak season)\b|\b(?:summer|winter|spring|autumn|fall|off[- ]?season)(?=\s?(?:hours|schedule|season|:|\())/i;
+/** This function names the season of a line ("Summer", "June-August"), or gives undefined. */
+const seasonOf = (line) => (SEASON.exec(line) ?? DATE_RANGE.exec(line))?.[0].trim();
+/** The longest line that can hold hours. A longer line is prose, and the reader does not read it. */
+const MAX_LINE = 1e3;
+/** A block of hours longer than this is a list of something else. */
+const MAX_BLOCK_LINES = 100;
+const normalize = (line) => line.normalize("NFKC").replace(/[\u200b-\u200d\u2060\ufeff\u00ad]/g, "").replace(/\s+/g, " ").trim();
+const tokensOf = (line, at) => line.length > MAX_LINE ? [] : [...line.matchAll(TOKEN)].map((match) => {
+	const groups = match.groups ?? {};
+	const days = daysOfToken(groups);
+	return {
+		groups,
+		line: at,
+		start: match.index ?? 0,
+		end: (match.index ?? 0) + match[0].length,
+		days: days?.days,
+		spec: days?.spec ?? 2
+	};
+});
+/** A range with no am, pm, minutes or "h" is a bare range ("5-10"): it can be a price, an age or a score. */
+const isStrong = (times) => /[ap]\.?m|[:.]\d{2}|noon|midnight|\dh/i.test(times);
+/** The words that join days or a day and its hours, and say nothing more. */
+const JOINERS = /^(?:[\s,&/:;.()|–—-]|\band\b|\bor\b|\bfrom\b|\bopen\b|\bhours\b)*$/i;
+/**
+* This function reads the hours in the text of a page. It reads the lines with days and times as
+* one stream. Thus "Monday – Thursday" on one line and "11:30am – 9pm" on the next line go
+* together. A list of days ("Mon, Wed & Fri") waits for a time or for "closed".
+*
+* Each group of these lines is a candidate. Its label is the short line above it ("Hours",
+* "Dinner", "Happy hour"). A page often shows more than one schedule, and the choice between them
+* is a judgment, not a parse. A season ("Summer:", "June-August") starts a new candidate.
+*
+* A line about a date or an occasion ("Dec 24: 9am-2pm", "New Year's Eve 8pm-1am", "Private events
+* 11am-3pm") is not the week. A line with no day that names a service before its hours ("Happy hour
+* 6-8pm") under a line with days and hours is not the week either. The reader leaves it out, and
+* the candidate is `partial`.
+*/
+const fromText = (text) => {
+	const original = text.split(/\n+/).map((line) => line.trim());
+	const lines = original.map((line) => line.length > MAX_LINE ? line : normalize(line));
+	const out = [];
+	/** A season or the size can cut a block from the block before it. Then the line above the block is not its label. */
+	let block;
+	const flush = () => {
+		if (block === void 0) return;
+		const current = block;
+		block = void 0;
+		const above = current.cut ? "" : lines[current.start - 1] ?? "";
+		const label = current.cut ? void 0 : original[current.start - 1];
+		const week = {};
+		let inferred = false;
+		let partial = false;
+		const closedBy = /* @__PURE__ */ new Map();
+		const openedBy = /* @__PURE__ */ new Map();
+		const heading = /hour|open/i.test(above);
+		const perLine = current.lines.map((index, at) => tokensOf(lines[index], at));
+		const oneOff = current.lines.map((index, at) => {
+			const line = lines[index].replace(/\b24 ?\/ ?7\b/g, "    ");
+			const onLine = perLine[at];
+			const weekly = onLine.some((token) => token.days !== void 0);
+			const date = DATE_RANGE.test(line) ? null : DATE.exec(line);
+			const value = onLine.find((token) => token.groups["times"] !== void 0 || token.groups["clock"] !== void 0);
+			const above = at > 0 ? perLine[at - 1] : [];
+			const service = !weekly && value !== void 0 && SERVICE.test(line.slice(0, value.start)) && above.some((token) => token.days !== void 0) && above.some((token) => token.groups["times"] !== void 0 || token.groups["closed"] !== void 0);
+			return date !== null && (value === void 0 || date.index < value.start) || !weekly && OCCASION.test(line) || service;
+		});
+		const tokens = [];
+		const breaks = /* @__PURE__ */ new Set();
+		perLine.forEach((onLine, at) => {
+			if (oneOff[at]) {
+				partial = true;
+				breaks.add(at);
+				return;
+			}
+			const line = lines[current.lines[at]];
+			const dayTokens = onLine.filter((token) => token.days !== void 0);
+			const broad = dayTokens.length >= 2 || dayTokens.some((token) => token.spec < 2) || heading || /^(?:hours|open)\b/i.test(line);
+			const daysOnlyAbove = at > 0 && !breaks.has(at - 1) && perLine[at - 1].length > 0 && perLine[at - 1].every((token) => token.days !== void 0);
+			onLine.forEach((token, index) => {
+				const times = token.groups["times"];
+				if (times !== void 0 && !isStrong(times) && !broad) {
+					const before = onLine[index - 1];
+					const after = onLine[index + 1];
+					if (!(before?.days !== void 0 && JOINERS.test(line.slice(before.end, token.start)) || after?.days !== void 0 && JOINERS.test(line.slice(token.end, after.start)) || index === 0 && daysOnlyAbove && JOINERS.test(line.slice(0, token.start)))) return;
+				}
+				tokens.push(token);
+			});
+		});
+		const isDays = (token) => token?.days !== void 0;
+		const isValue = (token) => token.groups["times"] !== void 0 || token.groups["closed"] !== void 0 || token.groups["allday"] !== void 0;
+		const dangling = /* @__PURE__ */ new Set();
+		perLine.forEach((onLine, at) => {
+			const last = onLine.at(-1);
+			if (last?.days === void 0) return;
+			const line = lines[current.lines[at]];
+			if (!JOINERS.test(line.slice(last.end))) dangling.add(at);
+		});
+		const valueFirst = /* @__PURE__ */ new Set();
+		const firstOnLine = /* @__PURE__ */ new Map();
+		const lineHasDays = /* @__PURE__ */ new Set();
+		for (const token of tokens) {
+			if (isDays(token)) lineHasDays.add(token.line);
+			if (!firstOnLine.has(token.line) && (isDays(token) || isValue(token))) firstOnLine.set(token.line, token);
+		}
+		for (const [line, first] of firstOnLine) if (isValue(first) && lineHasDays.has(line)) valueFirst.add(line);
+		const apply = (value, days, spec, explicit) => {
+			for (const day of days) {
+				if (value === "closed") {
+					if (!explicit) {
+						if (week[day] === void 0) {
+							week[day] = [];
+							closedBy.set(day, -1);
+						}
+						continue;
+					}
+					if ((openedBy.get(day) ?? -1) > spec) continue;
+					week[day] = [];
+					openedBy.delete(day);
+					closedBy.set(day, Math.max(closedBy.get(day) ?? -1, spec));
+					continue;
+				}
+				const closed = closedBy.get(day);
+				if (closed !== void 0 && closed >= spec) continue;
+				if (closed !== void 0) {
+					week[day] = [];
+					closedBy.delete(day);
+				}
+				addInterval(week, [day], value);
+				openedBy.set(day, Math.max(openedBy.get(day) ?? -1, spec));
+			}
+		};
+		const valueOf = (token) => {
+			if (token.groups["closed"] !== void 0) return {
+				value: "closed",
+				inferred: false
+			};
+			if (token.groups["allday"] !== void 0) return {
+				value: ALL_DAY,
+				inferred: false
+			};
+			const parts = token.groups["times"] === void 0 ? void 0 : splitRange(token.groups["times"]);
+			const range = parts === void 0 ? void 0 : readRange(parts[0], parts[1]);
+			return range === void 0 ? void 0 : {
+				value: range.interval,
+				inferred: range.inferred
+			};
+		};
+		/** This function gives the tokens of one kind in sequence from `start`, each on a separate line. */
+		const runOf = (start, kind) => {
+			let end = start;
+			while (tokens[end + 1] !== void 0 && kind(tokens[end + 1]) && tokens[end + 1].line !== tokens[end].line && !breaks.has(tokens[end + 1].line - 1)) end += 1;
+			return end;
+		};
+		let currentDays = [];
+		let currentSpec = 2;
+		let lastWasDay = false;
+		let pending = [];
+		let excepting = false;
+		let previous;
+		for (let at = 0; at < tokens.length; at += 1) {
+			const token = tokens[at];
+			if (previous !== void 0 && token.line !== previous.line) {
+				excepting = false;
+				let broken = dangling.has(previous.line) && lastWasDay;
+				for (let line = previous.line; line < token.line && !broken; line += 1) broken = breaks.has(line);
+				if (broken) {
+					currentDays = [];
+					lastWasDay = false;
+					pending = [];
+				}
+			}
+			previous = token;
+			if (token.groups["except"] !== void 0) {
+				excepting = true;
+				continue;
+			}
+			const days = token.days;
+			if (days !== void 0) {
+				if (excepting) {
+					apply("closed", days, 2, true);
+					currentDays = currentDays.filter((day) => !days.includes(day));
+					continue;
+				}
+				if (!lastWasDay && pending.length === 0) {
+					const lastDay = runOf(at, isDays);
+					const firstValue = tokens[lastDay + 1];
+					if (lastDay > at && firstValue !== void 0 && isValue(firstValue) && firstValue.line !== tokens[lastDay].line) {
+						const lastValue = runOf(lastDay + 1, isValue);
+						const dayRun = tokens.slice(at, lastDay + 1);
+						const valueRun = tokens.slice(lastDay + 1, lastValue + 1);
+						if (valueRun.length >= 2) {
+							if (valueRun.length === dayRun.length) dayRun.forEach((dayToken, index) => {
+								const read = valueOf(valueRun[index]);
+								if (read === void 0) return;
+								inferred ||= read.inferred;
+								apply(read.value, dayToken.days, dayToken.spec, true);
+							});
+							at = lastValue;
+							previous = tokens[at];
+							continue;
+						}
+					}
+				}
+				currentDays = lastWasDay ? [.../* @__PURE__ */ new Set([...currentDays, ...days])] : [...days];
+				currentSpec = lastWasDay ? Math.min(currentSpec, token.spec) : token.spec;
+				lastWasDay = true;
+				const next = tokens[at + 1];
+				if (pending.length > 0 && !(isDays(next) && next.line === token.line)) {
+					for (const read of pending) {
+						inferred ||= read.inferred;
+						apply(read.value, currentDays, currentSpec, true);
+					}
+					pending = [];
+					lastWasDay = false;
+				}
+				continue;
+			}
+			excepting = false;
+			const wasDay = lastWasDay;
+			lastWasDay = false;
+			let read = isValue(token) ? valueOf(token) : void 0;
+			if (read === void 0 && token.groups["clock"] !== void 0 && wasDay) {
+				const close = tokens[at + 1]?.groups["clock"];
+				const range = close === void 0 ? void 0 : readRange(token.groups["clock"], close);
+				if (range !== void 0) {
+					read = {
+						value: range.interval,
+						inferred: range.inferred
+					};
+					at += 1;
+					previous = tokens[at];
+				}
+			}
+			if (read === void 0) continue;
+			const next = tokens[at + 1];
+			if (isDays(next) && next.line === tokens[at].line && (valueFirst.has(token.line) || read.value === "closed" && !wasDay)) {
+				pending.push(read);
+				continue;
+			}
+			if (currentDays.length > 0) {
+				inferred ||= read.inferred;
+				apply(read.value, currentDays, currentSpec, wasDay);
+			}
+		}
+		if (Object.keys(week).length === 0 && !tokens.some(isDays)) {
+			const ranges = tokens.filter((token) => token.groups["times"] !== void 0 || token.groups["allday"] !== void 0);
+			const body = current.lines.map((index) => lines[index]);
+			const opens = !/\b(today|tonight|now)\b/i.test(`${above} ${body.join(" ")}`) && (heading || /^open\b/i.test(body[0] ?? ""));
+			const said = new Set(ranges.map((token) => (token.groups["times"] ?? "24h").replace(/\s+/g, "")));
+			const first = ranges[0] === void 0 ? void 0 : valueOf(ranges[0]);
+			if (opens && said.size === 1 && first !== void 0 && first.value !== "closed") {
+				addInterval(week, DAYS, first.value);
+				inferred = !/24 ?\/ ?7/.test(ranges[0].groups["allday"] ?? "");
+			}
+		}
+		if (Object.keys(week).length === 0) return;
+		const season = current.season ?? (label !== void 0 ? seasonOf(above) : void 0);
+		out.push({
+			week,
+			from: "text",
+			raw: current.lines.map((index) => original[index]).join("\n"),
+			inferred,
+			...partial ? { partial } : {},
+			...season !== void 0 ? { season } : {},
+			label: label !== void 0 && label.length > 0 && label.length <= 40 ? label : null
+		});
+	};
+	lines.forEach((line, index) => {
+		const tokens = tokensOf(line, 0);
+		const names = tokens.some((token) => token.days !== void 0 || token.groups["closed"] !== void 0 || token.groups["allday"] !== void 0);
+		const clock = tokens.some((token) => token.groups["clock"] !== void 0 || token.groups["times"] !== void 0 && isStrong(token.groups["times"]));
+		const ranges = tokens.filter((token) => token.groups["times"] !== void 0).length;
+		if ((names || clock) && (line.length <= 160 || ranges >= 2)) {
+			const season = seasonOf(line);
+			const cut = block !== void 0 && (season !== void 0 || block.lines.length >= MAX_BLOCK_LINES);
+			if (cut) flush();
+			block ??= {
+				start: index,
+				lines: [],
+				season,
+				cut
+			};
+			block.lines.push(index);
+		} else flush();
+	});
+	flush();
+	return out;
+};
+const LABEL = {
+	mon: "Mon",
+	tue: "Tue",
+	wed: "Wed",
+	thu: "Thu",
+	fri: "Fri",
+	sat: "Sat",
+	sun: "Sun"
+};
+const sameDay = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+/** This function writes a week as text, for example `Mon–Thu 11:00–22:00, Fri–Sat 11:00–23:00`. */
+const describeWeek = (week) => {
+	const parts = [];
+	let index = 0;
+	while (index < 7) {
+		const day = DAYS[index];
+		const value = week[day];
+		let end = index;
+		while (end + 1 < 7 && sameDay(week[DAYS[end + 1]], value)) end += 1;
+		const span = end === index ? LABEL[day] : `${LABEL[day]}–${LABEL[DAYS[end]]}`;
+		if (value !== void 0) parts.push(value.length === 0 ? `${span} closed` : `${span} ${value.map(([open, close]) => open === "00:00" && close === "00:00" ? "open 24 hours" : `${open}–${close}`).join(", ")}`);
+		index = end + 1;
+	}
+	return parts.join("; ");
+};
+/**
+* This function gives one interval for each day (`hours_week`), and null for a closed day. One
+* interval cannot show a day with two intervals and a gap between them. Thus such a day is not in
+* `hours_week`, and `split` names it.
+*/
+const toHoursWeek = (week) => {
+	const hoursWeek = {};
+	const split = [];
+	for (const day of DAYS) {
+		const value = week[day];
+		if (value === void 0) continue;
+		if (value.length === 0) hoursWeek[day] = null;
+		else if (value.length === 1) hoursWeek[day] = value[0];
+		else split.push(day);
+	}
+	return {
+		hours_week: hoursWeek,
+		split
+	};
+};
+/** This function gives the days where two readings disagree, from the days that the two readings state. */
+const disagreements = (a, b) => DAYS.filter((day) => a[day] !== void 0 && b[day] !== void 0 && !sameDay(a[day], b[day]));
+//#endregion
+export { DAYS, dayRange, describeWeek, disagreements, fromCompact, fromSchemaOrg, fromText, readRange, toHoursWeek };
+
+//# sourceMappingURL=hours.mjs.map