chronolizer 0.2.0 → 0.4.0

package/dist/locales/fr.mjs

@@ -4,7 +4,7 @@ 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 { calendarPeriodOffset, candidate, datedPeriods, datedQuarterPeriods, fixedDatePeriod, fixedMonthPeriod, fixedQuarterPeriod, fixedYearPeriod, fromNowRange, futurePeriod, futureRange, isoDate, joinedNowCandidate, joinedPeriodCandidate, monthOfRelativeYear, namedDatePeriod, openBoundaryCandidate, parseTrailingCount, periodBoundaryCandidate, periodEndDay, periodRange, periodStartDay, periodToDateRange, periodsFromPhrases, quarterOfRelativeYear, relativePeriod, relativeWeekend, remainingPeriodRange, renderPeriodRange, textAt, trailingPeriod, trailingRange, untilNowRange, validYear } from "./shared.mjs";
+import { absoluteDatePeriod, calendarPeriodOffset, candidate, compileCountAliasNormalizer, countAliasVocabulary, currentYearDatePeriods, datedPeriods, datedQuarterPeriods, decomposeShiftedPeriodRange, fixedDatePeriod, fixedMonthPeriod, fixedQuarterPeriod, fixedYearPeriod, fromNowRange, futurePeriod, futureRange, isoDate, joinedNowCandidate, joinedPeriodCandidate, monthOfRelativeYear, namedCurrentYearDatePeriod, namedDatePeriod, openBoundaryCandidate, parseTrailingCount, periodBoundaryCandidate, periodDay, periodEndDay, periodRange, periodStartDay, periodToDateRange, periodsFromPhrases, quarterOfRelativeYear, relativePeriod, relativeWeekday, relativeWeekend, remainingPeriodRange, renderPeriodRange, sequentialCountAliases, shiftPeriod, textAt, trailingPeriod, trailingRange, untilNowRange, validYear } from "./shared.mjs";
 import { Effect, Option, String as String$1 } from "effect";
 //#region src/locales/fr.ts
 const months = [
@@ -21,6 +21,89 @@ const months = [
 	"novembre",
 	"décembre"
 ];
+const weekdays = [
+	"lundi",
+	"mardi",
+	"mercredi",
+	"jeudi",
+	"vendredi",
+	"samedi",
+	"dimanche"
+];
+const nextWeekdayPhrases = weekdays.map((weekday) => `${weekday} prochain`);
+const frenchCountWords = [
+	["deux"],
+	["trois"],
+	["quatre"],
+	["cinq"],
+	["six"],
+	["sept"],
+	["huit"],
+	["neuf"],
+	["dix"],
+	["onze"],
+	["douze"],
+	["treize"],
+	["quatorze"],
+	["quinze"],
+	["seize"],
+	["dix-sept"],
+	["dix-huit"],
+	["dix-neuf"],
+	["vingt"]
+];
+const frenchCompoundCountAliases = () => {
+	const words = [
+		"",
+		"un",
+		"deux",
+		"trois",
+		"quatre",
+		"cinq",
+		"six",
+		"sept",
+		"huit",
+		"neuf",
+		"dix",
+		"onze",
+		"douze",
+		"treize",
+		"quatorze",
+		"quinze",
+		"seize",
+		"dix-sept",
+		"dix-huit",
+		"dix-neuf"
+	];
+	const aliases = [];
+	for (let amount = 21; amount <= 99; amount += 1) {
+		const tens = Math.floor(amount / 10);
+		const remainder = amount % 10;
+		let phrase = "";
+		if (tens <= 6) {
+			const tensWord = [
+				"",
+				"",
+				"vingt",
+				"trente",
+				"quarante",
+				"cinquante",
+				"soixante"
+			][tens];
+			if (tensWord === void 0) continue;
+			phrase = remainder === 1 ? `${tensWord} et un` : `${tensWord}-${words[remainder] ?? ""}`;
+		} else if (tens === 7) phrase = remainder === 1 ? "soixante et onze" : `soixante-${words[10 + remainder] ?? ""}`;
+		else if (tens === 8) phrase = remainder === 0 ? "quatre-vingts" : `quatre-vingt-${words[remainder] ?? ""}`;
+		else phrase = `quatre-vingt-${words[10 + remainder] ?? ""}`;
+		aliases.push([phrase, amount], [phrase.replaceAll("-", " "), amount]);
+		if (amount % 10 === 1) aliases.push([phrase.replace(/un$/u, "une"), amount]);
+	}
+	return aliases;
+};
+const frenchCountAliases = [...sequentialCountAliases(frenchCountWords, 2), ...frenchCompoundCountAliases()];
+const normalizeFrenchCounts = compileCountAliasNormalizer(frenchCountAliases);
+const frenchCountVocabulary = new Set(countAliasVocabulary(frenchCountAliases));
+const correctFrench = (input, vocabulary) => correctWhitespaceSeparatedText(input, vocabulary, frenchCountVocabulary);
 const monthAbbreviations = [
 	["jan", "janv"],
 	[
@@ -50,6 +133,9 @@ const units = [
 		unit: "day",
 		singular: "jour",
 		plural: "jours",
+		rollingSingular: "jour",
+		rollingPlural: "jours",
+		rollingGender: "masculine",
 		current: "aujourd'hui",
 		previous: "hier",
 		next: "demain",
@@ -60,6 +146,9 @@ const units = [
 		unit: "week",
 		singular: "semaine",
 		plural: "semaines",
+		rollingSingular: "semaine",
+		rollingPlural: "semaines",
+		rollingGender: "feminine",
 		current: "cette semaine",
 		previous: "la semaine dernière",
 		next: "la semaine prochaine",
@@ -70,6 +159,9 @@ const units = [
 		unit: "month",
 		singular: "mois",
 		plural: "mois",
+		rollingSingular: "mois",
+		rollingPlural: "mois",
+		rollingGender: "masculine",
 		current: "ce mois-ci",
 		previous: "le mois dernier",
 		next: "le mois prochain",
@@ -80,6 +172,9 @@ const units = [
 		unit: "quarter",
 		singular: "trimestre",
 		plural: "trimestres",
+		rollingSingular: "trimestre",
+		rollingPlural: "trimestres",
+		rollingGender: "masculine",
 		current: "ce trimestre",
 		previous: "le trimestre dernier",
 		next: "le trimestre prochain",
@@ -90,6 +185,9 @@ const units = [
 		unit: "year",
 		singular: "an",
 		plural: "ans",
+		rollingSingular: "année",
+		rollingPlural: "années",
+		rollingGender: "feminine",
 		current: "cette année",
 		previous: "l'année dernière",
 		next: "l'année prochaine",
@@ -97,7 +195,41 @@ const units = [
 		remaining: "reste de l'année"
 	}
 ];
-const title = (value) => `${value.slice(0, 1).toLocaleUpperCase("fr")}${value.slice(1)}`;
+const rollingArticle = (entry) => entry.rollingGender === "feminine" ? "la" : "le";
+const indefiniteArticle = (entry) => entry.unit === "week" ? "une" : "un";
+const rollingModifier = (entry, future, plural) => {
+	if (future) {
+		if (entry.rollingGender === "feminine") return plural ? "prochaines" : "prochaine";
+		return plural ? "prochains" : "prochain";
+	}
+	if (entry.rollingGender === "feminine") return plural ? "dernières" : "dernière";
+	return plural ? "derniers" : "dernier";
+};
+const withDe = (period) => {
+	if (period.startsWith("le ")) return `du ${period.slice(3)}`;
+	if (period.startsWith("les ")) return `des ${period.slice(4)}`;
+	if (period.startsWith("la ")) return `de la ${period.slice(3)}`;
+	if (period.startsWith("l'")) return `de ${period}`;
+	return `de ${period}`;
+};
+const withA = (period) => {
+	if (period.startsWith("le ")) return `au ${period.slice(3)}`;
+	if (period.startsWith("les ")) return `aux ${period.slice(4)}`;
+	if (period.startsWith("la ")) return `à la ${period.slice(3)}`;
+	if (period.startsWith("l'")) return `à ${period}`;
+	return `à ${period}`;
+};
+const afterDe = (period) => {
+	if (period.startsWith("du ")) return `le ${period.slice(3)}`;
+	if (period.startsWith("de la ")) return `la ${period.slice(6)}`;
+	if (period.startsWith("de l'")) return `l'${period.slice(5)}`;
+	return period.startsWith("de ") ? period.slice(3) : period;
+};
+const startsWithDay = (period) => period[0] !== void 0 && period[0] >= "0" && period[0] <= "9";
+const rangeLabel = (lower, upper) => {
+	return `${startsWithDay(lower) ? `du ${lower}` : withDe(lower)} ${startsWithDay(upper) ? `au ${upper}` : withA(upper)}`;
+};
+const untilLabel = (period) => `jusqu'${withA(period)}`;
 const unitAliases = [
 	["jour", "day"],
 	["jours", "day"],
@@ -362,17 +494,30 @@ const monthNumber = (value) => {
 	return short === -1 ? void 0 : short + 1;
 };
 const dateLabel = (day, month, year) => `${day === 1 ? "1er" : day} ${textAt(months, month - 1)} ${year}`;
+const currentDateLabel = (day, month) => `${day === 1 ? "1er" : day} ${textAt(months, month - 1)}`;
 const parseNamedDate = (input) => {
-	const named = String$1.match(/^(?:le )?(1er|[0-3]?\d)(?: de)? ([a-zàâçéèêëîïôûùüÿœ]+\.?)(?: de)? (\d{4})$/u)(input);
+	const named = String$1.match(/^(?:le )?(1er|[0-3]?\d)(?: de)? ([a-zàâçéèêëîïôûùüÿœ]+\.?),?(?: de)? (\d{4})$/u)(input);
 	if (Option.isSome(named)) return namedDatePeriod(textAt(named.value, 3), textAt(named.value, 2), textAt(named.value, 1).replace(/er$/u, ""), monthNumber, dateLabel);
 	const numeric = String$1.match(/^([0-3]?\d)[./-]([01]?\d)[./-](\d{4})$/u)(input);
-	if (Option.isNone(numeric)) return Option.none();
-	const year = validYear(textAt(numeric.value, 3));
-	const month = Number(textAt(numeric.value, 2));
-	const day = Number(textAt(numeric.value, 1));
-	if (year === void 0 || month < 1 || month > 12) return Option.none();
-	const value = isoDate(year, month, day);
-	return isIsoDate(value) && value !== "9999-12-31" ? Option.some(fixedDatePeriod(value, dateLabel(day, month, year))) : Option.none();
+	if (Option.isSome(numeric)) {
+		const year = validYear(textAt(numeric.value, 3));
+		const month = Number(textAt(numeric.value, 2));
+		const day = Number(textAt(numeric.value, 1));
+		if (year !== void 0 && month >= 1 && month <= 12) {
+			const value = isoDate(year, month, day);
+			if (isIsoDate(value) && value !== "9999-12-31") return Option.some(fixedDatePeriod(value, dateLabel(day, month, year)));
+		}
+	}
+	const current = String$1.match(/^(?:le )?(1er|[0-3]?\d)(?: de)? ([a-zàâçéèêëîïôûùüÿœ]+\.?)$/u)(input);
+	if (Option.isSome(current)) return namedCurrentYearDatePeriod(textAt(current.value, 2), textAt(current.value, 1).replace(/er$/u, ""), monthNumber, currentDateLabel);
+	const relative = String$1.match(/^(?:le )?(1er|[0-3]?\d) (de .+|du .+)$/u)(input);
+	if (Option.isNone(relative)) return Option.none();
+	const periodText = afterDe(textAt(relative.value, 2));
+	const alias = periodAliases.find((entry) => entry[0] === periodText && entry[1] === "month");
+	if (alias === void 0) return Option.none();
+	const day = Number(textAt(relative.value, 1).replace(/er$/u, ""));
+	const month = relativePeriod(alias[1], alias[2], alias[3]);
+	return periodDay(month, day, `${day === 1 ? "1er" : day} ${withDe(alias[3])}`);
 };
 const quarterNumber = (value) => {
 	if ((value.startsWith("q") || value.startsWith("t")) && value.length === 2) return Number(value.slice(1));
@@ -399,12 +544,13 @@ const parseQuarter = (input) => {
 	const quarter = quarterNumber(textAt(standalone.value, 1));
 	return quarter === void 0 ? Option.none() : Option.some(quarterOfRelativeYear(quarter, 0, `T${quarter}`));
 };
-const parseBasePeriod = (input) => {
-	if (isIsoDate(input) && input !== "9999-12-31") return Option.some(fixedDatePeriod(input, input));
-	const namedDate = parseNamedDate(input);
-	if (Option.isSome(namedDate)) return namedDate;
-	const quarter = parseQuarter(input);
-	if (Option.isSome(quarter)) return quarter;
+const parseDatedPeriod = (input) => {
+	const knownPeriod = Option.firstSomeOf([
+		absoluteDatePeriod(input, "fr"),
+		parseNamedDate(input),
+		parseQuarter(input)
+	]);
+	if (Option.isSome(knownPeriod)) return knownPeriod;
 	const yearMatch = String$1.match(/^(?:(?:l')?année |annee )?(\d{4})$/u)(input);
 	if (Option.isSome(yearMatch)) {
 		const year = validYear(textAt(yearMatch.value, 1));
@@ -414,17 +560,31 @@ const parseBasePeriod = (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}`));
+		if (month !== void 0 && year !== void 0) return Option.some(fixedMonthPeriod(year, month, `${textAt(months, month - 1)} ${year}`));
+	}
+	return Option.none();
+};
+const parseBasePeriod = (input) => {
+	const datedPeriod = parseDatedPeriod(input);
+	if (Option.isSome(datedPeriod)) return datedPeriod;
+	const suffixedRelativeMonth = String$1.match(/^([a-zàâçéèêëîïôûùüÿœ]+\.?) (dernier|prochain)$/u)(input);
+	if (Option.isSome(suffixedRelativeMonth)) {
+		const month = monthNumber(textAt(suffixedRelativeMonth.value, 1));
+		if (month !== void 0) {
+			const modifier = textAt(suffixedRelativeMonth.value, 2);
+			const direction = modifier === "dernier" ? -1 : 1;
+			return Option.some(monthOfRelativeYear(month, direction, `${textAt(months, month - 1)} ${modifier}`));
+		}
 	}
 	const relativeMonth = String$1.match(/^([a-zàâçéèêëîïôûùüÿœ]+\.?) de (l'année dernière|l'annee derniere|l'année prochaine|l'annee prochaine|cette année|cette annee)$/u)(input);
 	if (Option.isSome(relativeMonth)) {
 		const month = monthNumber(textAt(relativeMonth.value, 1));
 		const yearText = textAt(relativeMonth.value, 2);
 		const direction = relativeYearDirection(yearText);
-		if (month !== void 0) return Option.some(monthOfRelativeYear(month, direction, `${title(textAt(months, month - 1))} de ${relativeYearName(direction)}`));
+		if (month !== void 0) return Option.some(monthOfRelativeYear(month, direction, `${textAt(months, month - 1)} de ${relativeYearName(direction)}`));
 	}
 	const standaloneMonth = monthNumber(input);
-	if (standaloneMonth !== void 0) return Option.some(monthOfRelativeYear(standaloneMonth, 0, title(textAt(months, standaloneMonth - 1))));
+	if (standaloneMonth !== void 0) return Option.some(monthOfRelativeYear(standaloneMonth, 0, textAt(months, standaloneMonth - 1)));
 	const alias = periodAliases.find((entry) => entry[0] === input);
 	if (alias !== void 0) return Option.some(relativePeriod(alias[1], alias[2], alias[3]));
 	if ([
@@ -446,16 +606,35 @@ const parseBasePeriod = (input) => {
 	].includes(input)) return Option.some(relativeWeekend(1, "le week-end prochain"));
 	if (input === "l'avant-dernier week-end") return Option.some(relativeWeekend(-2, input));
 	if (input === "le week-end après le prochain") return Option.some(relativeWeekend(2, input));
-	return Option.none();
+	const weekday = nextWeekdayPhrases.indexOf(input);
+	return weekday === -1 ? Option.none() : Option.some(relativeWeekday(weekday, 1, nextWeekdayPhrases[weekday] ?? input));
 };
 const parsePeriod = (input) => {
+	const shifted = String$1.match(/^(.+) (il y a|dans) ([1-9]\d*) (jour|jours|semaine|semaines|mois|trimestre|trimestres|an|ans|année|annee|années|annees)$/u)(input);
+	if (Option.isSome(shifted)) {
+		const amount = parseTrailingCount(textAt(shifted.value, 3));
+		const alias = unitAliases.find((unit) => unit[0] === textAt(shifted.value, 4));
+		const entry = alias === void 0 ? void 0 : units.find((unit) => unit.unit === alias[1]);
+		const period = parsePeriod(textAt(shifted.value, 1));
+		if (Option.isSome(amount) && entry !== void 0 && Option.isSome(period)) {
+			const past = textAt(shifted.value, 2) === "il y a";
+			const direction = past ? -amount.value : amount.value;
+			const noun = amount.value === 1 ? entry.singular : entry.plural;
+			const canonical = `${period.value.canonical} ${past ? "il y a" : "dans"} ${amount.value} ${noun}`;
+			return Option.some(shiftPeriod(period.value, direction, entry.unit, canonical));
+		}
+	}
 	const edge = String$1.match(/^(?:le |la |l')?(début|debut|commencement|fin)(?: du | de la | de l'| de )(.+)$/u)(input);
 	if (Option.isSome(edge)) {
 		const edgeName = textAt(edge.value, 1);
-		const period = parseBasePeriod(textAt(edge.value, 2));
+		const periodText = textAt(edge.value, 2);
+		const basePeriod = parseBasePeriod(periodText);
+		const implicitUnit = unitAliases.find((entry) => entry[0] === periodText)?.[1];
+		const implicit = units.find((entry) => entry.unit === implicitUnit);
+		const period = Option.isSome(basePeriod) || implicit === void 0 ? basePeriod : Option.some(relativePeriod(implicit.unit, 0, implicit.current));
 		if (Option.isSome(period)) {
 			const isEnd = edgeName === "fin";
-			const canonical = `${isEnd ? "fin" : "début"} de ${period.value.canonical}`;
+			const canonical = `${isEnd ? "fin" : "début"} ${withDe(period.value.canonical)}`;
 			return Option.some(isEnd ? periodEndDay(period.value, canonical) : periodStartDay(period.value, canonical));
 		}
 	}
@@ -466,9 +645,30 @@ const parsePeriod = (input) => {
 		"tout le ",
 		"toute la "
 	].find((prefix) => input.startsWith(prefix));
-	return parseBasePeriod(wrapper === void 0 ? input : input.slice(wrapper.length));
+	const base = parseBasePeriod(wrapper === void 0 ? input : input.slice(wrapper.length));
+	return Option.isSome(base) ? base : parseCalendarOffset(input);
+};
+const countedUnit = (value, amount) => {
+	const plural = value === "mois" || value.endsWith("s");
+	if (value !== "mois" && plural === (amount === 1)) return void 0;
+	const unit = unitAliases.find((entry) => entry[0] === value)?.[1];
+	return unit === void 0 ? void 0 : units.find((entry) => entry.unit === unit);
+};
+const modifierAgreesWithNoun = (input, noun) => {
+	const match = String$1.match(/(?:^| )(derniers|dernières|dernieres|passés|passées|passes|précédents|précédentes|precedents|precedentes|prochains|prochaines|suivants|suivantes)(?: |$)/u)(input);
+	if (Option.isNone(match)) return true;
+	const modifier = textAt(match.value, 1);
+	return (noun.startsWith("semaine") || noun.startsWith("année") || noun.startsWith("annee")) === [
+		"dernières",
+		"dernieres",
+		"passées",
+		"passes",
+		"précédentes",
+		"precedentes",
+		"prochaines",
+		"suivantes"
+	].includes(modifier);
 };
-const countedUnit = (value) => unitAliases.find((entry) => entry[0] === value)?.[1];
 const countedUnitPattern = "jour|jours|semaine|semaines|mois|trimestre|trimestres|an|ans|année|annee|années|annees";
 const compileCountedPattern = (source) => new RegExp(source.replace("UNIT", countedUnitPattern), "u");
 const calendarPastPattern = compileCountedPattern("^il y a ([1-9]\\d*) (UNIT)$");
@@ -477,38 +677,89 @@ const rollingSincePattern = compileCountedPattern("^depuis ([1-9]\\d*) (UNIT)$")
 const rollingBarePattern = compileCountedPattern("^([1-9]\\d*) (UNIT)$");
 const rollingPastPatterns = [
 	compileCountedPattern("^(?:(?:les|la) )?(?:derniers|dernières|dernieres|passés|passées|passes|précédents|précédentes|precedents|precedentes) ([1-9]\\d*) (UNIT)$"),
-	compileCountedPattern("^(?:(?:les|la) )?([1-9]\\d*) (?:derniers|dernières|dernieres|passés|passées|passes|précédents|précédentes|precedents|precedentes) (UNIT)$"),
+	compileCountedPattern("^(?:(?:les|la|au cours des|pendant les) )?([1-9]\\d*) (?:derniers|dernières|dernieres|passés|passées|passes|précédents|précédentes|precedents|precedentes) (UNIT)$"),
 	compileCountedPattern("^([1-9]\\d*) (UNIT) (?:derniers|dernières|dernieres|passés|passées|passes|précédents|précédentes|precedents|precedentes)$")
 ];
 const rollingFuturePatterns = [
 	compileCountedPattern("^(?:(?:les|la) )?(?:prochains|prochaines|suivants|suivantes) ([1-9]\\d*) (UNIT)$"),
-	compileCountedPattern("^(?:(?:les|la) )?([1-9]\\d*) (?:prochains|prochaines|suivants|suivantes) (UNIT)$"),
+	compileCountedPattern("^(?:(?:les|la|au cours des|pendant les) )?([1-9]\\d*) (?:prochains|prochaines|suivants|suivantes) (UNIT)$"),
 	compileCountedPattern("^([1-9]\\d*) (UNIT) (?:prochains|prochaines|suivants|suivantes|à venir)$")
 ];
 const firstPatternMatch = (input, patterns) => Option.firstSomeOf(patterns.map((pattern) => String$1.match(pattern)(input)));
-const isFeminineUnit = (unit) => unit === "week";
 const relativeCountPhrase = (amount, entry, future) => {
-	const noun = amount === 1 ? entry.singular : entry.plural;
-	let modifier = future ? "prochains" : "derniers";
-	if (isFeminineUnit(entry.unit)) modifier = future ? "prochaines" : "dernières";
-	return `les ${amount} ${modifier} ${noun}`;
+	if (amount === 1) return singularRollingCanonical(entry, future);
+	return `les ${amount} ${rollingModifier(entry, future, true)} ${entry.rollingPlural}`;
 };
+const singularRollingCanonical = (entry, future) => {
+	const article = indefiniteArticle(entry);
+	return future ? `à partir de maintenant pendant ${article} ${entry.singular}` : `depuis ${article} ${entry.singular}`;
+};
+const singularRollingPhrases = units.flatMap((entry) => {
+	const period = `${rollingArticle(entry)} ${rollingModifier(entry, false, false)} ${entry.rollingSingular}`;
+	const futurePeriod = `${rollingArticle(entry)} ${rollingModifier(entry, true, false)} ${entry.rollingSingular}`;
+	const article = indefiniteArticle(entry);
+	return [
+		{
+			phrase: period,
+			entry,
+			future: false
+		},
+		{
+			phrase: `au cours ${withDe(period)}`,
+			entry,
+			future: false
+		},
+		{
+			phrase: `depuis ${article} ${entry.singular}`,
+			entry,
+			future: false
+		},
+		{
+			phrase: `pendant ${futurePeriod}`,
+			entry,
+			future: true
+		},
+		{
+			phrase: `à partir de maintenant pendant ${article} ${entry.singular}`,
+			entry,
+			future: true
+		}
+	];
+});
+const singularCalendarOffsets = units.flatMap((entry) => {
+	const quantity = `${indefiniteArticle(entry)} ${entry.singular}`;
+	return [{
+		phrase: `il y a ${quantity}`,
+		entry,
+		direction: -1
+	}, {
+		phrase: `dans ${quantity}`,
+		entry,
+		direction: 1
+	}];
+});
 const parseCalendarOffset = (input) => {
+	const singular = singularCalendarOffsets.find((entry) => entry.phrase === input);
+	if (singular !== void 0) return Option.some(relativePeriod(singular.entry.unit, singular.direction, singular.phrase));
 	const past = String$1.match(calendarPastPattern)(input);
 	const future = String$1.match(calendarFuturePattern)(input);
 	const match = Option.firstSomeOf([past, future]);
 	if (Option.isNone(match)) return Option.none();
 	const amount = parseTrailingCount(textAt(match.value, 1));
-	const unit = countedUnit(textAt(match.value, 2));
-	if (Option.isNone(amount) || unit === void 0) return Option.none();
-	const entry = units.find((item) => item.unit === unit);
+	if (Option.isNone(amount)) return Option.none();
+	const entry = countedUnit(textAt(match.value, 2), amount.value);
 	if (entry === void 0) return Option.none();
 	const direction = Option.isSome(past) ? -amount.value : amount.value;
 	const noun = amount.value === 1 ? entry.singular : entry.plural;
 	const canonical = direction < 0 ? `il y a ${amount.value} ${noun}` : `dans ${amount.value} ${noun}`;
-	return Option.some(candidate(periodRange(relativePeriod(unit, direction, canonical)), canonical));
+	return Option.some(relativePeriod(entry.unit, direction, canonical));
 };
 const parseRollingPeriod = (input) => {
+	const singular = singularRollingPhrases.find((entry) => entry.phrase === input);
+	if (singular !== void 0) {
+		const range = singular.future ? futureRange(1, singular.entry.unit) : trailingRange(1, singular.entry.unit);
+		return Option.some(candidate(range, singularRollingCanonical(singular.entry, singular.future)));
+	}
 	const since = String$1.match(rollingSincePattern)(input);
 	const past = firstPatternMatch(input, rollingPastPatterns);
 	const bare = String$1.match(rollingBarePattern)(input);
@@ -521,19 +772,31 @@ const parseRollingPeriod = (input) => {
 	]);
 	if (Option.isNone(match)) return Option.none();
 	const amount = parseTrailingCount(textAt(match.value, 1));
-	const unit = countedUnit(textAt(match.value, 2));
-	if (Option.isNone(amount) || unit === void 0) return Option.none();
-	const entry = units.find((item) => item.unit === unit);
-	if (entry === void 0) return Option.none();
+	if (Option.isNone(amount)) return Option.none();
+	const noun = textAt(match.value, 2);
+	const entry = countedUnit(noun, amount.value);
+	if (entry === void 0 || !modifierAgreesWithNoun(input, noun)) return Option.none();
 	const isFuture = Option.isSome(future);
-	const range = isFuture ? futureRange(amount.value, unit) : trailingRange(amount.value, unit);
+	const range = isFuture ? futureRange(amount.value, entry.unit) : trailingRange(amount.value, entry.unit);
 	return Option.some(candidate(range, relativeCountPhrase(amount.value, entry, isFuture)));
 };
+const parseElidedDateRange = (input) => {
+	const joined = String$1.match(/^(?:du (1er|[0-3]?\d) au|entre le (1er|[0-3]?\d) et le) (1er|[0-3]?\d) (.+)$/u)(input);
+	const dashed = String$1.match(/^(1er|[0-3]?\d)[–—-](1er|[0-3]?\d) (.+)$/u)(input);
+	const match = Option.firstSomeOf([joined, dashed]);
+	if (Option.isNone(match)) return Option.none();
+	const isJoined = Option.isSome(joined);
+	const lowerDay = textAt(match.value, 1) || textAt(match.value, 2);
+	const upperDay = textAt(match.value, isJoined ? 3 : 2);
+	const period = afterDe(textAt(match.value, isJoined ? 4 : 3));
+	const datePeriod = periodAliases.some((entry) => entry[0] === period && entry[1] === "month") ? withDe(period) : period;
+	return joinedPeriodCandidate(`du ${lowerDay} ${datePeriod} au ${upperDay} ${datePeriod}`, [["du ", " au "]], parsePeriod, rangeLabel);
+};
 const boundaryCandidate = (input) => {
 	const included = String$1.match(/^jusqu'à (.+) (?:inclus|incluse|inclusivement)$/u)(input);
 	if (Option.isSome(included)) {
 		const period = parsePeriod(textAt(included.value, 1));
-		if (Option.isSome(period)) return Option.some(periodBoundaryCandidate(period.value, "through", `jusqu'à ${period.value.canonical}`));
+		if (Option.isSome(period)) return Option.some(periodBoundaryCandidate(period.value, "through", untilLabel(period.value.canonical)));
 	}
 	return openBoundaryCandidate(input, [
 		["jusqu'avant ", "before"],
@@ -562,12 +825,12 @@ const parseFrench = (input) => {
 		"à partir de maintenant",
 		"désormais"
 	].includes(input)) return Option.some(candidate(fromNowRange(), "depuis maintenant"));
-	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.unit), toDate.entry.toDate));
+	const elided = parseElidedDateRange(input);
+	if (Option.isSome(elided)) return elided;
 	const nowBounded = joinedNowCandidate(input, [
 		["depuis ", " jusqu'à maintenant"],
 		["depuis ", " jusqu'à aujourd'hui"],
@@ -575,7 +838,8 @@ const parseFrench = (input) => {
 	], [
 		"d'aujourd'hui à ",
 		"de maintenant à ",
-		"entre aujourd'hui et "
+		"entre aujourd'hui et ",
+		"maintenant à "
 	], parsePeriod, (period) => `depuis ${period} jusqu'à maintenant`, (period) => `de maintenant à ${period}`);
 	if (Option.isSome(nowBounded)) return nowBounded;
 	const bounded = joinedPeriodCandidate(input, [
@@ -588,20 +852,32 @@ const parseFrench = (input) => {
 		["", " — "],
 		["", " jusqu'à "],
 		["", " au "]
-	], parsePeriod, (lower, upper) => `du ${lower} au ${upper}`);
+	], parsePeriod, rangeLabel);
 	if (Option.isSome(bounded)) return bounded;
 	const boundary = boundaryCandidate(input);
 	if (Option.isSome(boundary)) return boundary;
-	return Option.map(parsePeriod(input), (period) => candidate(periodRange(period), period.canonical));
+	return parsePeriod(input).pipe(Option.map((period) => candidate(periodRange(period), period.canonical)));
 };
-const staticPeriodPhrases = [
-	...periodAliases.map((entry) => entry[0]),
+const weekendPhrases = [
 	"ce week-end",
 	"le week-end dernier",
 	"le week-end prochain",
 	"l'avant-dernier week-end",
-	"le week-end après le prochain",
-	...periodAliases.flatMap((entry) => [`début de ${entry[0]}`, `fin de ${entry[0]}`]),
+	"le week-end après le prochain"
+];
+const edgePeriodPhrases = [
+	...units.filter((entry) => entry.unit !== "day").flatMap((entry) => [
+		entry.current,
+		entry.previous,
+		entry.next
+	]),
+	...weekendPhrases,
+	...months
+].flatMap((period) => [`début ${withDe(period)}`, `fin ${withDe(period)}`]);
+const staticPeriodPhrases = [
+	...periodAliases.map((entry) => entry[0]),
+	...weekendPhrases,
+	...edgePeriodPhrases,
 	...[
 		1,
 		2,
@@ -615,9 +891,12 @@ const staticPeriodPhrases = [
 	]),
 	...months.flatMap((month) => [
 		month,
+		`${month} dernier`,
+		`${month} prochain`,
 		`${month} de l'année dernière`,
 		`${month} de l'année prochaine`
-	])
+	]),
+	...nextWeekdayPhrases
 ];
 const staticPeriods = periodsFromPhrases(staticPeriodPhrases, parsePeriod);
 const boundaryPrefixes = [
@@ -631,15 +910,16 @@ const countedSuggestions = (input) => {
 	if (amount === void 0) return [];
 	return units.flatMap((entry) => {
 		const noun = amount === 1 ? entry.singular : entry.plural;
-		const past = isFeminineUnit(entry.unit) ? "dernières" : "derniers";
-		const future = isFeminineUnit(entry.unit) ? "prochaines" : "prochains";
+		const rollingNoun = amount === 1 ? entry.rollingSingular : entry.rollingPlural;
+		const past = rollingModifier(entry, false, amount !== 1);
+		const future = rollingModifier(entry, true, amount !== 1);
 		return [
 			relativeCountPhrase(amount, entry, false),
-			`${amount} ${past} ${noun}`,
+			`${amount} ${past} ${rollingNoun}`,
 			`${amount} ${noun}`,
 			relativeCountPhrase(amount, entry, true),
-			`${amount} ${future} ${noun}`,
-			`${amount} ${noun} à venir`,
+			`${amount} ${future} ${rollingNoun}`,
+			`${amount} ${rollingNoun} à venir`,
 			`il y a ${amount} ${noun}`,
 			`dans ${amount} ${noun}`
 		];
@@ -648,6 +928,8 @@ const countedSuggestions = (input) => {
 const frenchSuggestionPhrases = [
 	...units.map((entry) => entry.toDate),
 	...units.map((entry) => entry.remaining),
+	...singularRollingPhrases.map((entry) => entry.phrase),
+	...singularCalendarOffsets.map((entry) => entry.phrase),
 	...staticPeriodPhrases,
 	...prefixNaturalPhrases(staticPeriodPhrases, boundaryPrefixes),
 	"jusqu'à maintenant",
@@ -663,6 +945,17 @@ const suggestFrench = (input, limit) => {
 	], limit);
 };
 const renderFrench = (range) => {
+	const shifted = decomposeShiftedPeriodRange(range);
+	if (Option.isSome(shifted)) {
+		const base = renderFrench(shifted.value.baseRange);
+		const entry = units.find((unit) => unit.unit === shifted.value.unit);
+		if (Option.isSome(base) && entry !== void 0) {
+			const amount = Math.abs(shifted.value.amount);
+			const noun = amount === 1 ? entry.singular : entry.plural;
+			const direction = shifted.value.amount < 0 ? "il y a" : "dans";
+			return Option.some(`${base.value} ${direction} ${amount} ${noun}`);
+		}
+	}
 	const offset = calendarPeriodOffset(range);
 	if (Option.isSome(offset) && Math.abs(offset.value.amount) > 1) {
 		const entry = units.find((unit) => unit.unit === offset.value.unit);
@@ -675,24 +968,26 @@ const renderFrench = (range) => {
 	const future = futurePeriod(range);
 	if (Option.isSome(future)) {
 		const entry = units.find((unit) => unit.unit === future.value.unit);
-		if (entry !== void 0) {
-			const noun = future.value.amount === 1 ? entry.singular : entry.plural;
-			return Option.some(`${future.value.amount} ${noun} à venir`);
-		}
+		if (entry !== void 0) return Option.some(future.value.amount === 1 ? singularRollingCanonical(entry, true) : relativeCountPhrase(future.value.amount, entry, true));
 	}
 	const trailing = trailingPeriod(range);
 	if (Option.isSome(trailing)) {
 		const entry = units.find((unit) => unit.unit === trailing.value.unit);
-		if (entry !== void 0) return Option.some(relativeCountPhrase(trailing.value.amount, entry, false));
+		if (entry !== void 0) return Option.some(trailing.value.amount === 1 ? singularRollingCanonical(entry, false) : relativeCountPhrase(trailing.value.amount, entry, false));
 	}
-	const periods = [...staticPeriods, ...periodsFromPhrases([...datedPeriods(range, months), ...datedQuarterPeriods(range)], parsePeriod)];
-	return renderPeriodRange(range, [...units.map((entry) => candidate(periodToDateRange(entry.unit), entry.toDate)), ...units.map((entry) => candidate(remainingPeriodRange(entry.unit), entry.remaining))], periods, (period) => `depuis ${period}`, (period) => `avant ${period}`, (period) => `jusqu'à ${period}`, (period) => `après ${period}`, (lower, upper) => `du ${lower} au ${upper}`, (period) => `depuis ${period} jusqu'à maintenant`, (period) => `de maintenant à ${period}`, () => "jusqu'à maintenant", () => "depuis maintenant");
+	const periods = [
+		...staticPeriods,
+		...currentYearDatePeriods(range, currentDateLabel),
+		...periodsFromPhrases([...datedPeriods(range, months), ...datedQuarterPeriods(range)], parsePeriod)
+	];
+	return renderPeriodRange(range, [...units.map((entry) => candidate(periodToDateRange(entry.unit), entry.toDate)), ...units.map((entry) => candidate(remainingPeriodRange(entry.unit), entry.remaining))], periods, (period) => `depuis ${period}`, (period) => `avant ${period}`, untilLabel, (period) => `après ${period}`, rangeLabel, (period) => `depuis ${period} jusqu'à maintenant`, (period) => `de maintenant à ${period}`, () => "jusqu'à maintenant", () => "depuis maintenant");
 };
-const normalizeFrench = (input, locale) => normalizeNaturalText(input, locale).replaceAll("’", "'");
+const normalizeFrench = (input, locale) => normalizeFrenchCounts(normalizeNaturalText(input, locale).replaceAll("’", "'"));
 const FrenchContribution = new BaseLanguageContribution({
 	locale: "fr",
 	vocabulary: [
 		...months,
+		...weekdays,
 		...monthAbbreviations.flatMap((aliases) => aliases),
 		...units.flatMap((entry) => [
 			entry.singular,
@@ -723,7 +1018,7 @@ const FrenchContribution = new BaseLanguageContribution({
 		"jusqu'à"
 	],
 	normalize: normalizeFrench,
-	correct: correctWhitespaceSeparatedText,
+	correct: correctFrench,
 	parseExact: parseFrench,
 	suggest: suggestFrench,
 	render: renderFrench