chronolizer 0.1.0 → 0.3.0

package/dist/locales/en.d.mts

@@ -0,0 +1,10 @@
+import { LanguageConflictError, LanguageRegistrationError } from "../language/errors.mjs";
+import { BaseLanguageContribution, LanguagePlugin } from "../language/model.mjs";
+import { LanguageRegistry } from "../language/registry.mjs";
+import "../index.mjs";
+//#region src/locales/en.d.ts
+declare const EnglishContribution: BaseLanguageContribution;
+declare const EnglishLanguage: LanguagePlugin;
+declare const EnglishLanguageLayer: import("effect/Layer").Layer<LanguageRegistry, LanguageConflictError | LanguageRegistrationError, never>;
+//#endregion
+export { EnglishContribution, EnglishLanguage, EnglishLanguageLayer };

package/dist/locales/en.mjs

@@ -0,0 +1,598 @@
+import { BaseLanguageContribution } from "../language/model.mjs";
+import { normalizeNaturalText } from "../natural/text.mjs";
+import { defineLanguagePlugin, languagePluginsLayer } from "../language/registry.mjs";
+import { correctWhitespaceSeparatedText } from "../natural/correction.mjs";
+import { completeNaturalPhrases, fixedCalendarPeriodPhrases, naturalCount, prefixNaturalPhrases } from "../natural/suggestion.mjs";
+import { absoluteDatePeriod, calendarPeriodOffset, candidate, currentYearDatePeriods, datedPeriods, datedQuarterPeriods, fixedMonthPeriod, fixedQuarterPeriod, fixedYearPeriod, fromNowRange, futurePeriod, futureRange, joinedNowCandidate, joinedPeriodCandidate, monthOfRelativeYear, namedCurrentYearDatePeriod, namedDatePeriod, openBoundaryCandidate, parseTrailingCount, periodEndDay, periodPreviousDay, periodRange, periodStartDay, periodToDateRange, periodsFromPhrases, quarterOfRelativeYear, relativePeriod, relativeWeekend, remainingPeriodRange, renderPeriodRange, textAt, trailingPeriod, trailingRange, untilNowRange, validYear } from "./shared.mjs";
+import { Effect, Option, String as String$1 } from "effect";
+//#region src/locales/en.ts
+const months = [
+	"january",
+	"february",
+	"march",
+	"april",
+	"may",
+	"june",
+	"july",
+	"august",
+	"september",
+	"october",
+	"november",
+	"december"
+];
+const monthAbbreviations = [
+	["jan"],
+	["feb"],
+	["mar"],
+	["apr"],
+	["may"],
+	["jun"],
+	["jul"],
+	["aug"],
+	["sep", "sept"],
+	["oct"],
+	["nov"],
+	["dec"]
+];
+const quarterNames = [
+	"first",
+	"second",
+	"third",
+	"fourth"
+];
+const units = [
+	[
+		"day",
+		"day",
+		"days"
+	],
+	[
+		"week",
+		"week",
+		"weeks"
+	],
+	[
+		"month",
+		"month",
+		"months"
+	],
+	[
+		"quarter",
+		"quarter",
+		"quarters"
+	],
+	[
+		"year",
+		"year",
+		"years"
+	]
+];
+const title = (value) => `${value.slice(0, 1).toLocaleUpperCase("en")}${value.slice(1)}`;
+const currentPeriod = (unit) => unit === "day" ? "today" : `this ${unit}`;
+const remainingPeriodPhrases = units.flatMap((entry) => [
+	`rest of the ${entry[0]}`,
+	`rest of ${entry[0]}`,
+	`rest of ${currentPeriod(entry[0])}`,
+	`remainder of the ${entry[0]}`,
+	`remaining ${entry[0]}`
+].map((phrase) => ({
+	entry,
+	phrase
+})));
+const toDateAbbreviations = [
+	"dtd",
+	"wtd",
+	"mtd",
+	"qtd",
+	"ytd"
+];
+const toDatePhrases = units.flatMap((entry, index) => [
+	`${entry[0]} to date`,
+	`${entry[0]}-to-date`,
+	toDateAbbreviations[index] ?? "",
+	`since the start of the ${entry[0]}`,
+	`since the beginning of the ${entry[0]}`,
+	`from the start of the ${entry[0]} to now`,
+	`from the beginning of the ${entry[0]} to now`,
+	`${currentPeriod(entry[0])} so far`,
+	`so far ${currentPeriod(entry[0])}`,
+	`${currentPeriod(entry[0])} until now`,
+	`${currentPeriod(entry[0])} up to now`
+].map((phrase) => ({
+	entry,
+	phrase
+})));
+const monthNumber = (value) => {
+	const normalized = value.endsWith(".") ? value.slice(0, -1) : value;
+	const fullIndex = months.findIndex((month) => month === normalized);
+	if (fullIndex !== -1) return fullIndex + 1;
+	const shortIndex = monthAbbreviations.findIndex((aliases) => aliases.some((alias) => alias === normalized));
+	return shortIndex === -1 ? void 0 : shortIndex + 1;
+};
+const relativeDirection = (value) => {
+	if (value === "last" || value === "previous") return -1;
+	if (value === "next" || value === "coming" || value === "upcoming") return 1;
+	return 0;
+};
+const relativeDirectionName = (direction) => {
+	if (direction < 0) return "last";
+	if (direction > 0) return "next";
+	return "this";
+};
+const quarterNumber = (value) => {
+	if (value.startsWith("q")) return Number(value.slice(1));
+	const index = quarterNames.findIndex((name) => name === value);
+	return index === -1 ? void 0 : index + 1;
+};
+const parseQuarter = (input) => {
+	const fixed = String$1.match(/^(q[1-4])(?: of)? (\d{4})$/u)(input);
+	const reversed = String$1.match(/^(\d{4}) (q[1-4])$/u)(input);
+	const namedFixed = String$1.match(/^(first|second|third|fourth) quarter(?: of)? (\d{4})$/u)(input);
+	const relative = String$1.match(/^(q[1-4])(?: of)? (last|this|next) year$/u)(input);
+	const namedRelative = String$1.match(/^(first|second|third|fourth) quarter(?: of)? (last|this|next) year$/u)(input);
+	const standalone = String$1.match(/^(q[1-4])$/u)(input);
+	const namedStandalone = String$1.match(/^(first|second|third|fourth) quarter$/u)(input);
+	const fixedMatch = Option.firstSomeOf([
+		fixed,
+		reversed,
+		namedFixed
+	]);
+	if (Option.isSome(fixedMatch)) {
+		const quarterText = textAt(fixedMatch.value, Option.isSome(reversed) ? 2 : 1);
+		const yearText = textAt(fixedMatch.value, Option.isSome(reversed) ? 1 : 2);
+		const quarter = quarterNumber(quarterText);
+		const year = validYear(yearText);
+		if (quarter !== void 0 && year !== void 0) return Option.some(fixedQuarterPeriod(year, quarter, `Q${quarter} ${year}`));
+	}
+	const relativeMatch = Option.firstSomeOf([relative, namedRelative]);
+	if (Option.isSome(relativeMatch)) {
+		const directionText = textAt(relativeMatch.value, 2);
+		const quarter = quarterNumber(textAt(relativeMatch.value, 1));
+		if (quarter !== void 0) {
+			const direction = relativeDirection(directionText);
+			return Option.some(quarterOfRelativeYear(quarter, direction, `Q${quarter} of ${directionText} year`));
+		}
+	}
+	const standaloneMatch = Option.firstSomeOf([standalone, namedStandalone]);
+	if (Option.isNone(standaloneMatch)) return Option.none();
+	const quarter = quarterNumber(textAt(standaloneMatch.value, 1));
+	return quarter === void 0 ? Option.none() : Option.some(quarterOfRelativeYear(quarter, 0, `Q${quarter}`));
+};
+const currentDateLabel = (day, month) => `${day} ${title(textAt(months, month - 1))}`;
+const parseNamedDate = (input) => {
+	const dayFirst = String$1.match(/^(?:the )?([0-3]?\d)(?:st|nd|rd|th)?(?: of)? ([a-z]+\.?),? (\d{4})$/u)(input);
+	if (Option.isSome(dayFirst)) return namedDatePeriod(textAt(dayFirst.value, 3), textAt(dayFirst.value, 2), textAt(dayFirst.value, 1), monthNumber, (day, month, year) => `${day} ${title(textAt(months, month - 1))} ${year}`);
+	const monthFirst = String$1.match(/^([a-z]+\.?) (?:the )?([0-3]?\d)(?:st|nd|rd|th)?,? (\d{4})$/u)(input);
+	if (Option.isSome(monthFirst)) return namedDatePeriod(textAt(monthFirst.value, 3), textAt(monthFirst.value, 1), textAt(monthFirst.value, 2), monthNumber, (day, month, year) => `${day} ${title(textAt(months, month - 1))} ${year}`);
+	const currentDayFirst = String$1.match(/^(?:the )?([0-3]?\d)(?:st|nd|rd|th)?(?: of)? ([a-z]+\.?)$/u)(input);
+	const currentMonthFirst = String$1.match(/^([a-z]+\.?) (?:the )?([0-3]?\d)(?:st|nd|rd|th)?$/u)(input);
+	const current = Option.firstSomeOf([currentDayFirst, currentMonthFirst]);
+	if (Option.isNone(current)) return Option.none();
+	return Option.isSome(currentDayFirst) ? namedCurrentYearDatePeriod(textAt(current.value, 2), textAt(current.value, 1), monthNumber, currentDateLabel) : namedCurrentYearDatePeriod(textAt(current.value, 1), textAt(current.value, 2), monthNumber, currentDateLabel);
+};
+const parseBasePeriod = (input) => {
+	const absoluteDate = absoluteDatePeriod(input, "en");
+	if (Option.isSome(absoluteDate)) return absoluteDate;
+	const namedDate = parseNamedDate(input);
+	if (Option.isSome(namedDate)) return namedDate;
+	const quarter = parseQuarter(input);
+	if (Option.isSome(quarter)) return quarter;
+	const yearMatch = String$1.match(/^(?:(?:the )?(?:calendar )?year )?(\d{4})$/u)(input);
+	if (Option.isSome(yearMatch)) {
+		const year = validYear(textAt(yearMatch.value, 1));
+		if (year !== void 0) return Option.some(fixedYearPeriod(year, String(year)));
+	}
+	const monthYear = String$1.match(/^([a-z]+\.?) (\d{4})$/u)(input);
+	if (Option.isSome(monthYear)) {
+		const month = monthNumber(textAt(monthYear.value, 1));
+		const year = validYear(textAt(monthYear.value, 2));
+		if (month !== void 0 && year !== void 0) return Option.some(fixedMonthPeriod(year, month, `${title(textAt(months, month - 1))} ${year}`));
+	}
+	const relativeMonth = String$1.match(/^([a-z]+\.?) (?:of )?(last|this|next) year$/u)(input);
+	if (Option.isSome(relativeMonth)) {
+		const directionText = textAt(relativeMonth.value, 2);
+		const month = monthNumber(textAt(relativeMonth.value, 1));
+		const direction = relativeDirection(directionText);
+		if (month !== void 0) return Option.some(monthOfRelativeYear(month, direction, `${title(textAt(months, month - 1))} of ${directionText} year`));
+	}
+	const standaloneMonth = monthNumber(input);
+	if (standaloneMonth !== void 0) return Option.some(monthOfRelativeYear(standaloneMonth, 0, title(textAt(months, standaloneMonth - 1))));
+	if (input === "today") return Option.some(relativePeriod("day", 0, "today"));
+	if (input === "yesterday") return Option.some(relativePeriod("day", -1, "yesterday"));
+	if (input === "tomorrow") return Option.some(relativePeriod("day", 1, "tomorrow"));
+	if (input === "weekend" || input === "the weekend" || input === "this weekend") return Option.some(relativeWeekend(0, "this weekend"));
+	if (input === "last weekend" || input === "previous weekend") return Option.some(relativeWeekend(-1, "last weekend"));
+	if (input === "next weekend" || input === "coming weekend") return Option.some(relativeWeekend(1, "next weekend"));
+	if (input === "the weekend before last") return Option.some(relativeWeekend(-2, "the weekend before last"));
+	if (input === "the weekend after next") return Option.some(relativeWeekend(2, "the weekend after next"));
+	const articlePeriod = String$1.match(/^the (day|week|month|quarter|year)$/u)(input);
+	if (Option.isSome(articlePeriod)) {
+		const entry = units.find((unit) => unit[0] === textAt(articlePeriod.value, 1));
+		if (entry !== void 0) return Option.some(relativePeriod(entry[1], 0, currentPeriod(entry[0])));
+	}
+	const outerRelative = String$1.match(/^(?:the )?(day|week|month|quarter|year) (before last|after next)$/u)(input);
+	if (Option.isSome(outerRelative)) {
+		const entry = units.find((unit) => unit[0] === textAt(outerRelative.value, 1));
+		if (entry !== void 0) {
+			const direction = textAt(outerRelative.value, 2) === "before last" ? -2 : 2;
+			return Option.some(relativePeriod(entry[1], direction, input));
+		}
+	}
+	const relative = String$1.match(/^(?:the )?(last|previous|this|current|next|coming|upcoming) (?:calendar )?([a-z]+)$/u)(input);
+	if (Option.isSome(relative)) {
+		const unitText = textAt(relative.value, 2);
+		const unit = units.find((entry) => entry[0] === unitText)?.[1];
+		if (unit !== void 0) {
+			const direction = relativeDirection(textAt(relative.value, 1));
+			const canonicalDirection = relativeDirectionName(direction);
+			return Option.some(relativePeriod(unit, direction, `${canonicalDirection} ${unitText}`));
+		}
+	}
+	return Option.none();
+};
+const parsePeriod = (input) => {
+	const previousDay = String$1.match(/^(?:the )?day before (.+)$/u)(input);
+	if (Option.isSome(previousDay)) {
+		const period = parseBasePeriod(textAt(previousDay.value, 1));
+		if (Option.isSome(period)) return Option.some(periodPreviousDay(period.value, `the day before ${period.value.canonical}`));
+	}
+	const edge = String$1.match(/^(?:the )?(start|beginning|end) of (.+)$/u)(input);
+	if (Option.isSome(edge)) {
+		const period = parseBasePeriod(textAt(edge.value, 2));
+		if (Option.isSome(period)) {
+			const edgeName = textAt(edge.value, 1);
+			const name = edgeName === "beginning" ? "start" : edgeName;
+			const canonical = `${name} of ${period.value.canonical}`;
+			return Option.some(name === "end" ? periodEndDay(period.value, canonical) : periodStartDay(period.value, canonical));
+		}
+	}
+	const wrapper = [
+		"during ",
+		"in ",
+		"for ",
+		"all of ",
+		"the whole of "
+	].find((prefix) => input.startsWith(prefix));
+	return parseBasePeriod(wrapper === void 0 ? input : input.slice(wrapper.length));
+};
+const boundaryCandidate = (input) => openBoundaryCandidate(input, [
+	["up to and including ", "through"],
+	["on or before ", "through"],
+	["on or after ", "since"],
+	["up to including ", "through"],
+	["since the beginning of ", "since"],
+	["since the start of ", "since"],
+	["from the beginning of ", "since"],
+	["from the start of ", "since"],
+	["starting from ", "since"],
+	["through the end of ", "through"],
+	["until the end of ", "through"],
+	["after the end of ", "after"],
+	["until the start of ", "before"],
+	["before the beginning of ", "before"],
+	["before the start of ", "before"],
+	["before beginning of ", "before"],
+	["before start of ", "before"],
+	["starting ", "since"],
+	["through ", "through"],
+	["earlier than ", "before"],
+	["later than ", "after"],
+	["before ", "before"],
+	["since ", "since"],
+	["after ", "after"],
+	["until ", "before"],
+	["till ", "before"],
+	["up to ", "before"],
+	["from ", "since"]
+], parsePeriod);
+const countedUnit = (value, amount) => units.find((entry) => value === (amount === 1 ? entry[0] : entry[2]));
+const parseCalendarOffset = (input) => {
+	const singular = String$1.match(/^(?:(?:a|one) (day|week|month|quarter|year) (ago|prior|from now)|in (?:a|one) (day|week|month|quarter|year))$/u)(input);
+	if (Option.isSome(singular)) {
+		const unitText = textAt(singular.value, 1) || textAt(singular.value, 3);
+		const entry = units.find((unit) => unit[0] === unitText);
+		if (entry !== void 0) {
+			const directionText = textAt(singular.value, 2);
+			const isPast = directionText === "ago" || directionText === "prior";
+			const direction = isPast ? -1 : 1;
+			const canonical = isPast ? `1 ${entry[0]} ago` : `in 1 ${entry[0]}`;
+			return Option.some(candidate(periodRange(relativePeriod(entry[1], direction, canonical)), canonical));
+		}
+	}
+	const past = String$1.match(/^([1-9]\d*) (day|days|week|weeks|month|months|quarter|quarters|year|years) (?:ago|prior)$/u)(input);
+	const futureIn = String$1.match(/^in ([1-9]\d*) (day|days|week|weeks|month|months|quarter|quarters|year|years)$/u)(input);
+	const futureFromNow = String$1.match(/^([1-9]\d*) (day|days|week|weeks|month|months|quarter|quarters|year|years) from now$/u)(input);
+	const match = Option.firstSomeOf([
+		past,
+		futureIn,
+		futureFromNow
+	]);
+	if (Option.isNone(match)) return Option.none();
+	const amount = parseTrailingCount(textAt(match.value, 1));
+	if (Option.isNone(amount)) return Option.none();
+	const unitText = textAt(match.value, 2);
+	const entry = countedUnit(unitText, amount.value);
+	if (entry === void 0) return Option.none();
+	const direction = Option.isSome(past) ? -amount.value : amount.value;
+	const canonical = direction < 0 ? `${amount.value} ${unitText} ago` : `in ${amount.value} ${unitText}`;
+	return Option.some(candidate(periodRange(relativePeriod(entry[1], direction, canonical)), canonical));
+};
+const parseRollingPeriod = (input) => {
+	const past = String$1.match(/^(?:(?:last|previous|past) |(?:in|over) the (?:last|previous|past) )?([1-9]\d*) (day|days|week|weeks|month|months|quarter|quarters|year|years)$/u)(input);
+	const singularPast = String$1.match(/^(?:past|the past|in the past|over the past|this past) (day|week|month|quarter|year)$/u)(input);
+	const future = String$1.match(/^(?:(?:next|coming|within) |(?:in|over|within) the (?:next|coming) )([1-9]\d*) (day|days|week|weeks|month|months|quarter|quarters|year|years)$/u)(input);
+	const singularFuture = String$1.match(/^(?:in|over|within) the (?:next|coming) (day|week|month|quarter|year)$/u)(input);
+	const match = Option.firstSomeOf([
+		past,
+		singularPast,
+		future,
+		singularFuture
+	]);
+	if (Option.isNone(match)) return Option.none();
+	const singular = Option.isSome(singularPast) || Option.isSome(singularFuture);
+	const amount = parseTrailingCount(singular ? "1" : textAt(match.value, 1));
+	if (Option.isNone(amount)) return Option.none();
+	const unitText = textAt(match.value, singular ? 1 : 2);
+	const entry = countedUnit(unitText, amount.value);
+	if (entry === void 0) return Option.none();
+	const isFuture = Option.isSome(future) || Option.isSome(singularFuture);
+	const range = isFuture ? futureRange(amount.value, entry[1]) : trailingRange(amount.value, entry[1]);
+	if (amount.value === 1) {
+		const canonical = isFuture ? `within the next ${entry[0]}` : `past ${entry[0]}`;
+		return Option.some(candidate(range, canonical));
+	}
+	const direction = isFuture ? "next" : "last";
+	return Option.some(candidate(range, `${direction} ${amount.value} ${entry[2]}`));
+};
+const parseElidedDateRange = (input) => {
+	const monthFirst = String$1.match(/^([a-z]+\.?) ([0-3]?\d)(?:st|nd|rd|th)?(?: (?:to|through) |[–—-])([0-3]?\d)(?:st|nd|rd|th)?,?(?: (\d{4}))?$/u)(input);
+	const dayFirst = String$1.match(/^([0-3]?\d)(?:st|nd|rd|th)?(?: (?:to|through) |[–—-])([0-3]?\d)(?:st|nd|rd|th)? ([a-z]+\.?)(?: (\d{4}))?$/u)(input);
+	const match = Option.firstSomeOf([monthFirst, dayFirst]);
+	if (Option.isNone(match)) return Option.none();
+	const isMonthFirst = Option.isSome(monthFirst);
+	const month = textAt(match.value, isMonthFirst ? 1 : 3);
+	const lowerDay = textAt(match.value, isMonthFirst ? 2 : 1);
+	const upperDay = textAt(match.value, isMonthFirst ? 3 : 2);
+	const year = textAt(match.value, 4);
+	const suffix = year.length === 0 ? "" : ` ${year}`;
+	return joinedPeriodCandidate(`from ${lowerDay} ${month}${suffix} to ${upperDay} ${month}${suffix}`, [["from ", " to "]], parsePeriod, (lower, upper) => `from ${lower} to ${upper}`);
+};
+const parseEnglish = (input) => {
+	const remaining = remainingPeriodPhrases.find((entry) => entry.phrase === input);
+	if (remaining !== void 0) return Option.some(candidate(remainingPeriodRange(remaining.entry[1]), `rest of the ${remaining.entry[0]}`));
+	if ([
+		"until now",
+		"till now",
+		"up to now",
+		"through now"
+	].includes(input)) return Option.some(candidate(untilNowRange(), "until now"));
+	if ([
+		"from now",
+		"from now on",
+		"starting now"
+	].includes(input)) return Option.some(candidate(fromNowRange(), "from now"));
+	const offset = parseCalendarOffset(input);
+	if (Option.isSome(offset)) return offset;
+	const rolling = parseRollingPeriod(input);
+	if (Option.isSome(rolling)) return rolling;
+	const toDate = toDatePhrases.find((entry) => entry.phrase === input);
+	if (toDate !== void 0) return Option.some(candidate(periodToDateRange(toDate.entry[1]), `${toDate.entry[0]} to date`));
+	const elided = parseElidedDateRange(input);
+	if (Option.isSome(elided)) return elided;
+	const nowBounded = joinedNowCandidate(input, [
+		["from ", " to now"],
+		["from ", " until now"],
+		["from ", " through now"],
+		["from ", " to date"],
+		["between ", " and now"]
+	], [
+		"from now to ",
+		"from now until ",
+		"from now through ",
+		"between now and "
+	], parsePeriod, (period) => `from ${period} to now`, (period) => `from now to ${period}`);
+	if (Option.isSome(nowBounded)) return nowBounded;
+	const bounded = joinedPeriodCandidate(input, [
+		["from ", " to and including "],
+		["from ", " through and including "],
+		["from ", " to "],
+		["from ", " until "],
+		["from ", " through "],
+		["from ", " till "],
+		["between ", " and "],
+		["between ", " through "],
+		["", " to and including "],
+		["", " through and including "],
+		["", " to "],
+		["", " until "],
+		["", " through "],
+		["", " till "],
+		["", " - "],
+		["", " – "],
+		["", " — "],
+		["between ", "-"],
+		["", "-"],
+		["between ", "–"],
+		["", "–"],
+		["between ", "—"],
+		["", "—"],
+		["between ", "~"],
+		["", "~"]
+	], parsePeriod, (lower, upper) => `from ${lower} to ${upper}`);
+	if (Option.isSome(bounded)) return bounded;
+	const boundary = boundaryCandidate(input);
+	if (Option.isSome(boundary)) return boundary;
+	return parsePeriod(input).pipe(Option.map((period) => candidate(periodRange(period), period.canonical)));
+};
+const staticPeriodPhrases = [
+	"today",
+	"yesterday",
+	"the day before yesterday",
+	"tomorrow",
+	"this weekend",
+	"last weekend",
+	"next weekend",
+	"the weekend before last",
+	"the weekend after next",
+	...units.filter((entry) => entry[1] !== "day").flatMap((entry) => [
+		`this ${entry[0]}`,
+		`last ${entry[0]}`,
+		`next ${entry[0]}`,
+		`start of this ${entry[0]}`,
+		`end of this ${entry[0]}`,
+		`start of last ${entry[0]}`,
+		`end of last ${entry[0]}`,
+		`start of next ${entry[0]}`,
+		`end of next ${entry[0]}`
+	]),
+	...[
+		1,
+		2,
+		3,
+		4
+	].flatMap((quarter) => [
+		`q${quarter}`,
+		`q${quarter} of last year`,
+		`q${quarter} of next year`
+	]),
+	...months.flatMap((month) => [
+		month,
+		`${month} of last year`,
+		`${month} of next year`
+	])
+];
+const staticPeriods = periodsFromPhrases(staticPeriodPhrases, parsePeriod);
+const boundaryPrefixes = [
+	"since ",
+	"before ",
+	"through ",
+	"after "
+];
+const countedSuggestions = (input) => {
+	const amount = naturalCount(input);
+	if (amount === void 0) return [];
+	return units.flatMap((entry) => {
+		const noun = amount === 1 ? entry[0] : entry[2];
+		return [
+			`last ${amount} ${noun}`,
+			`${amount} ${noun}`,
+			`next ${amount} ${noun}`,
+			`${amount} ${noun} ago`,
+			`in ${amount} ${noun}`
+		];
+	});
+};
+const englishSuggestionPhrases = [
+	...units.map((entry) => `${entry[0]} to date`),
+	...remainingPeriodPhrases.map((entry) => entry.phrase),
+	...units.flatMap((entry) => [`past ${entry[0]}`, `within the next ${entry[0]}`]),
+	...staticPeriodPhrases,
+	...prefixNaturalPhrases(staticPeriodPhrases, boundaryPrefixes),
+	"until now",
+	"from now"
+];
+const suggestEnglish = (input, limit) => {
+	const fixed = fixedCalendarPeriodPhrases(input, months);
+	return completeNaturalPhrases(input, [
+		...englishSuggestionPhrases,
+		...fixed,
+		...prefixNaturalPhrases(fixed, boundaryPrefixes),
+		...countedSuggestions(input)
+	], limit);
+};
+const renderEnglish = (range) => {
+	const offset = calendarPeriodOffset(range);
+	if (Option.isSome(offset) && Math.abs(offset.value.amount) > 1) {
+		const entry = units.find((unit) => unit[1] === offset.value.unit);
+		if (entry !== void 0) {
+			const noun = offset.value.amount === -1 || offset.value.amount === 1 ? entry[0] : entry[2];
+			return Option.some(offset.value.amount < 0 ? `${-offset.value.amount} ${noun} ago` : `in ${offset.value.amount} ${noun}`);
+		}
+	}
+	const future = futurePeriod(range);
+	if (Option.isSome(future)) {
+		const entry = units.find((unit) => unit[1] === future.value.unit);
+		if (entry !== void 0) return Option.some(future.value.amount === 1 ? `within the next ${entry[0]}` : `next ${future.value.amount} ${entry[2]}`);
+	}
+	const trailing = trailingPeriod(range);
+	if (Option.isSome(trailing)) {
+		const entry = units.find((unit) => unit[1] === trailing.value.unit);
+		if (entry !== void 0) return Option.some(trailing.value.amount === 1 ? `past ${entry[0]}` : `last ${trailing.value.amount} ${entry[2]}`);
+	}
+	const periods = [
+		...staticPeriods,
+		...currentYearDatePeriods(range, currentDateLabel),
+		...periodsFromPhrases([...datedPeriods(range, months), ...datedQuarterPeriods(range)], parsePeriod)
+	];
+	return renderPeriodRange(range, [...units.map((entry) => candidate(periodToDateRange(entry[1]), `${entry[0]} to date`)), ...units.map((entry) => candidate(remainingPeriodRange(entry[1]), `rest of the ${entry[0]}`))], periods, (period) => `since ${period}`, (period) => `before ${period}`, (period) => `through ${period}`, (period) => `after ${period}`, (lower, upper) => `from ${lower} to ${upper}`, (period) => `from ${period} to now`, (period) => `from now to ${period}`, () => "until now", () => "from now");
+};
+const EnglishContribution = new BaseLanguageContribution({
+	locale: "en",
+	vocabulary: [
+		...months,
+		...quarterNames,
+		"q1",
+		"q2",
+		"q3",
+		"q4",
+		...monthAbbreviations.flatMap((aliases) => aliases),
+		...toDatePhrases.flatMap((entry) => entry.phrase.split(" ")),
+		...remainingPeriodPhrases.flatMap((entry) => entry.phrase.split(" ")),
+		...units.flatMap((entry) => [entry[0], entry[2]]),
+		"after",
+		"ago",
+		"all",
+		"one",
+		"and",
+		"beginning",
+		"before",
+		"calendar",
+		"coming",
+		"current",
+		"date",
+		"during",
+		"end",
+		"far",
+		"for",
+		"from",
+		"in",
+		"including",
+		"last",
+		"next",
+		"now",
+		"on",
+		"over",
+		"of",
+		"past",
+		"previous",
+		"prior",
+		"since",
+		"so",
+		"start",
+		"starting",
+		"this",
+		"through",
+		"till",
+		"whole",
+		"to",
+		"until",
+		"upcoming",
+		"within",
+		"today",
+		"tomorrow",
+		"weekend",
+		"yesterday"
+	],
+	normalize: normalizeNaturalText,
+	correct: correctWhitespaceSeparatedText,
+	parseExact: parseEnglish,
+	suggest: suggestEnglish,
+	render: renderEnglish
+});
+const EnglishLanguage = defineLanguagePlugin({
+	id: "chronolizer/language-en",
+	effect: (context) => Effect.asVoid(context.register("chronolizer/language-en", EnglishContribution))
+});
+const EnglishLanguageLayer = languagePluginsLayer([EnglishLanguage]);
+//#endregion
+export { EnglishContribution, EnglishLanguage, EnglishLanguageLayer };

package/dist/locales/es.d.mts

@@ -0,0 +1,10 @@
+import { LanguageConflictError, LanguageRegistrationError } from "../language/errors.mjs";
+import { BaseLanguageContribution, LanguagePlugin } from "../language/model.mjs";
+import { LanguageRegistry } from "../language/registry.mjs";
+import "../index.mjs";
+//#region src/locales/es.d.ts
+declare const SpanishContribution: BaseLanguageContribution;
+declare const SpanishLanguage: LanguagePlugin;
+declare const SpanishLanguageLayer: import("effect/Layer").Layer<LanguageRegistry, LanguageConflictError | LanguageRegistrationError, never>;
+//#endregion
+export { SpanishContribution, SpanishLanguage, SpanishLanguageLayer };