chronolizer 0.4.0 → 0.4.1

package/dist/locales/de.mjs

@@ -1,10 +1,9 @@
-import { isIsoDate } from "../ast/schemas.mjs";
 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, compileCountAliasNormalizer, compoundCountAliases, countAliasVocabulary, currentYearDatePeriods, datedPeriods, datedQuarterPeriods, decimalTens, decomposeShiftedPeriodRange, fixedDatePeriod, fixedMonthPeriod, fixedQuarterPeriod, fixedYearPeriod, fromNowRange, futurePeriod, futureRange, isoDate, joinedNowCandidate, joinedPeriodCandidate, monthOfRelativeYear, namedCurrentYearDatePeriod, namedDatePeriod, openBoundaryCandidate, parseTrailingCount, periodBoundaryCandidate, periodEndDay, periodRange, periodStartDay, periodToDateRange, periodsFromPhrases, quarterOfRelativeYear, relativePeriod, relativeWeekday, relativeWeekend, remainingPeriodRange, renderPeriodRange, sequentialCountAliases, shiftPeriod, textAt, trailingPeriod, trailingRange, untilNowRange, validYear } from "./shared.mjs";
+import { absoluteDatePeriod, calendarPeriodOffset, candidate, compileCountAliasNormalizer, compoundCountAliases, countAliasVocabulary, currentYearDatePeriods, datedPeriods, datedQuarterPeriods, decimalTens, decomposeShiftedPeriodRange, fixedMonthPeriod, fixedQuarterPeriod, fixedYearPeriod, fromNowRange, futurePeriod, futureRange, joinedNowCandidate, joinedPeriodCandidate, monthOfRelativeYear, namedCurrentYearDatePeriod, namedDatePeriod, openBoundaryCandidate, parseTrailingCount, periodBoundaryCandidate, 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/de.ts
 const months = [
@@ -21,6 +20,20 @@ const months = [
 	"november",
 	"dezember"
 ];
+const minimumMonthDays = [
+	31,
+	28,
+	31,
+	30,
+	31,
+	30,
+	31,
+	31,
+	30,
+	31,
+	30,
+	31
+];
 const germanCountWords = [
 	"zwei",
 	"drei",
@@ -56,11 +69,14 @@ const germanCountAliases = [...sequentialCountAliases(germanCountWords.map((word
 const normalizeGermanCounts = compileCountAliasNormalizer(germanCountAliases);
 const germanCountVocabulary = new Set(countAliasVocabulary(germanCountAliases));
 const correctGerman = (input, vocabulary) => correctWhitespaceSeparatedText(input, vocabulary, germanCountVocabulary);
-const normalizeGerman = (input, locale) => normalizeGermanCounts(normalizeNaturalText(input, locale));
 const monthAbbreviations = [
 	["jan"],
 	["feb"],
-	["mär", "mrz"],
+	[
+		"mär",
+		"mrz",
+		"maerz"
+	],
 	["apr"],
 	["mai"],
 	["jun"],
@@ -215,390 +231,45 @@ const currentBoundaryPhrases = unitPhrases.flatMap((entry) => [
 	entry,
 	phrase
 })));
-const declinedBoundaryPeriods = [
-	[
-		"diese woche",
-		"week",
-		0,
-		"dieser woche",
-		"diese woche"
-	],
-	[
-		"letzte woche",
-		"week",
-		-1,
-		"letzter woche",
-		"letzte woche"
-	],
-	[
-		"nächste woche",
-		"week",
-		1,
-		"nächster woche",
-		"nächste woche"
-	],
-	[
-		"dieser monat",
-		"month",
-		0,
-		"diesem monat",
-		"diesen monat"
-	],
-	[
-		"letzter monat",
-		"month",
-		-1,
-		"letztem monat",
-		"letzten monat"
-	],
-	[
-		"nächster monat",
-		"month",
-		1,
-		"nächstem monat",
-		"nächsten monat"
-	],
-	[
-		"dieses quartal",
-		"quarter",
-		0,
-		"diesem quartal",
-		"dieses quartal"
-	],
-	[
-		"letztes quartal",
-		"quarter",
-		-1,
-		"letztem quartal",
-		"letztes quartal"
-	],
-	[
-		"nächstes quartal",
-		"quarter",
-		1,
-		"nächstem quartal",
-		"nächstes quartal"
-	],
-	[
-		"dieses jahr",
-		"year",
-		0,
-		"diesem jahr",
-		"dieses jahr"
-	],
-	[
-		"letztes jahr",
-		"year",
-		-1,
-		"letztem jahr",
-		"letztes jahr"
-	],
-	[
-		"nächstes jahr",
-		"year",
-		1,
-		"nächstem jahr",
-		"nächstes jahr"
-	]
-];
-const relativeAliases = [
-	...unitPhrases.flatMap((entry) => [
-		[
-			entry.currentGenitive,
-			entry.unit,
-			0,
-			entry.current
-		],
-		[
-			entry.previousGenitive,
-			entry.unit,
-			-1,
-			entry.previous
-		],
-		[
-			entry.nextGenitive,
-			entry.unit,
-			1,
-			entry.next
-		]
-	]),
-	...declinedBoundaryPeriods.map(([canonical, unit, direction, dative]) => [
-		dative,
-		unit,
-		direction,
-		canonical
-	]),
-	[
-		"vorgestern",
-		"day",
-		-2,
-		"vorgestern"
-	],
-	[
-		"vorletzten tag",
-		"day",
-		-2,
-		"vorletzter tag"
-	],
-	[
-		"übernächsten tag",
-		"day",
-		2,
-		"übernächster tag"
-	],
-	[
-		"vorletzte woche",
-		"week",
-		-2,
-		"vorletzte woche"
-	],
-	[
-		"übernächste woche",
-		"week",
-		2,
-		"übernächste woche"
-	],
-	[
-		"vorletzten monat",
-		"month",
-		-2,
-		"vorletzter monat"
-	],
-	[
-		"übernächsten monat",
-		"month",
-		2,
-		"übernächster monat"
-	],
-	[
-		"vorletztes quartal",
-		"quarter",
-		-2,
-		"vorletztes quartal"
-	],
-	[
-		"übernächstes quartal",
-		"quarter",
-		2,
-		"übernächstes quartal"
-	],
-	[
-		"vorletztes jahr",
-		"year",
-		-2,
-		"vorletztes jahr"
-	],
-	[
-		"übernächstes jahr",
-		"year",
-		2,
-		"übernächstes jahr"
-	],
-	[
-		"letzten tag",
-		"day",
-		-1,
-		"gestern"
-	],
-	[
-		"vergangenen tag",
-		"day",
-		-1,
-		"gestern"
-	],
-	[
-		"vorherigen tag",
-		"day",
-		-1,
-		"gestern"
-	],
-	[
-		"diesen tag",
-		"day",
-		0,
-		"heute"
-	],
-	[
-		"heutigen tag",
-		"day",
-		0,
-		"heute"
-	],
-	[
-		"nächsten tag",
-		"day",
-		1,
-		"morgen"
-	],
-	[
-		"kommenden tag",
-		"day",
-		1,
-		"morgen"
-	],
-	[
-		"vergangene woche",
-		"week",
-		-1,
-		"letzte woche"
-	],
-	[
-		"vorherige woche",
-		"week",
-		-1,
-		"letzte woche"
-	],
-	[
-		"aktuelle woche",
-		"week",
-		0,
-		"diese woche"
-	],
-	[
-		"laufende woche",
-		"week",
-		0,
-		"diese woche"
-	],
-	[
-		"kommende woche",
-		"week",
-		1,
-		"nächste woche"
-	],
-	[
-		"folgende woche",
-		"week",
-		1,
-		"nächste woche"
-	],
-	[
-		"letzten monat",
-		"month",
-		-1,
-		"letzter monat"
-	],
-	[
-		"vergangenen monat",
-		"month",
-		-1,
-		"letzter monat"
-	],
-	[
-		"vorherigen monat",
-		"month",
-		-1,
-		"letzter monat"
-	],
-	[
-		"diesen monat",
-		"month",
-		0,
-		"dieser monat"
-	],
-	[
-		"aktuellen monat",
-		"month",
-		0,
-		"dieser monat"
-	],
-	[
-		"laufenden monat",
-		"month",
-		0,
-		"dieser monat"
-	],
-	[
-		"nächsten monat",
-		"month",
-		1,
-		"nächster monat"
-	],
-	[
-		"kommenden monat",
-		"month",
-		1,
-		"nächster monat"
-	],
-	[
-		"folgenden monat",
-		"month",
-		1,
-		"nächster monat"
-	],
-	[
-		"vergangenes quartal",
-		"quarter",
-		-1,
-		"letztes quartal"
-	],
-	[
-		"vorheriges quartal",
-		"quarter",
-		-1,
-		"letztes quartal"
-	],
-	[
-		"aktuelles quartal",
-		"quarter",
-		0,
-		"dieses quartal"
-	],
-	[
-		"laufendes quartal",
-		"quarter",
-		0,
-		"dieses quartal"
-	],
-	[
-		"kommendes quartal",
-		"quarter",
-		1,
-		"nächstes quartal"
-	],
-	[
-		"folgendes quartal",
-		"quarter",
-		1,
-		"nächstes quartal"
-	],
-	[
-		"vergangenes jahr",
-		"year",
-		-1,
-		"letztes jahr"
-	],
-	[
-		"vorheriges jahr",
-		"year",
-		-1,
-		"letztes jahr"
-	],
-	[
-		"aktuelles jahr",
-		"year",
-		0,
-		"dieses jahr"
-	],
-	[
-		"laufendes jahr",
-		"year",
-		0,
-		"dieses jahr"
-	],
-	[
-		"kommendes jahr",
-		"year",
-		1,
-		"nächstes jahr"
-	],
-	[
-		"folgendes jahr",
-		"year",
-		1,
-		"nächstes jahr"
-	]
+const relativeModifierStems = [
+	["vorletzt", -2],
+	["übernächst", 2],
+	["vergangen", -1],
+	["vorherig", -1],
+	["letzt", -1],
+	["heutig", 0],
+	["dies", 0],
+	["aktuell", 0],
+	["laufend", 0],
+	["nächst", 1],
+	["kommend", 1],
+	["folgend", 1]
 ];
+const relativeModifierVocabulary = relativeModifierStems.flatMap(([stem]) => [
+	"e",
+	"er",
+	"es",
+	"en",
+	"em"
+].map((ending) => `${stem}${ending}`));
+const relativeUnitCanonical = (entry, direction) => {
+	if (direction === -1) return entry.previous;
+	if (direction === 0) return entry.current;
+	if (direction === 1) return entry.next;
+	return `${direction < 0 ? "vor" : "in"} 2 ${title(entry.dative)}`;
+};
+const parseModifiedUnit = (input) => {
+	const match = String$1.match(/^([a-zäöüß]+) ([a-zäöüß]+)$/u)(input);
+	if (Option.isNone(match)) return Option.none();
+	const modifier = relativeModifierStems.find(([stem]) => textAt(match.value, 1).startsWith(stem));
+	const entry = unitPhrases.find((unit) => [
+		unit.noun,
+		unit.plural,
+		unit.dative,
+		unit.compound
+	].includes(textAt(match.value, 2)));
+	return modifier === void 0 || entry === void 0 ? Option.none() : Option.some(relativePeriod(entry.unit, modifier[1], canonicalRelative(relativeUnitCanonical(entry, modifier[1]))));
+};
 const monthNumber = (value) => {
 	const normalized = value.endsWith(".") ? value.slice(0, -1) : value;
 	const fullIndex = months.findIndex((month) => month === normalized);
@@ -606,11 +277,26 @@ const monthNumber = (value) => {
 	const shortIndex = monthAbbreviations.findIndex((aliases) => aliases.some((alias) => alias === normalized));
 	return shortIndex === -1 ? void 0 : shortIndex + 1;
 };
+const normalizeGerman = (input, locale) => {
+	const normalized = normalizeGermanCounts(normalizeNaturalText(input, locale));
+	if (normalized.endsWith(" auflaufend")) return `seit ${normalized.slice(0, -11)}`;
+	const fullMonth = String$1.match(/^(?:([a-zäöüß]+\.?) per )?(?:(0?1)\.-)?([0-3]?\d)\.([01]?\d)\.?$/u)(normalized);
+	if (Option.isNone(fullMonth)) return normalized;
+	const named = textAt(fullMonth.value, 1);
+	const lower = textAt(fullMonth.value, 2);
+	if (named.length === 0 && lower.length === 0) return normalized;
+	const numericMonth = Number(textAt(fullMonth.value, 4));
+	const month = named.length === 0 ? numericMonth : monthNumber(named);
+	return month !== void 0 && month === numericMonth && Number(textAt(fullMonth.value, 3)) === minimumMonthDays[month - 1] ? textAt(months, month - 1) : normalized;
+};
 const currentDateLabel = (day, month) => `${day}. ${title(textAt(months, month - 1))}`;
 const withRelativeCase = (canonical, grammaticalCase) => {
-	const period = declinedBoundaryPeriods.find((entry) => canonical === canonicalRelative(entry[0]));
-	if (period === void 0) return canonical;
-	return canonicalRelative(period[grammaticalCase === "dative" ? 3 : 4]);
+	const separator = canonical.indexOf(" ");
+	if (separator === -1) return canonical;
+	const modifier = canonical.slice(0, separator);
+	if (!relativeModifierStems.some(([stem]) => modifier.startsWith(stem))) return canonical;
+	if (grammaticalCase === "dative") return `${modifier.endsWith("e") ? `${modifier}r` : `${modifier.slice(0, -2)}em`}${canonical.slice(separator)}`;
+	return `${modifier.endsWith("er") ? `${modifier.slice(0, -2)}en` : modifier}${canonical.slice(separator)}`;
 };
 const withRelativeGenitive = (canonical) => {
 	for (const entry of unitPhrases) {
@@ -624,15 +310,7 @@ const parseNamedDate = (input) => {
 	const named = String$1.match(/^([0-3]?\d)\.? ([a-zäöüß]+\.?) (\d{4})$/u)(input);
 	if (Option.isSome(named)) return namedDatePeriod(textAt(named.value, 3), textAt(named.value, 2), textAt(named.value, 1), monthNumber, (day, month, year) => `${day}. ${title(textAt(months, month - 1))} ${year}`);
 	const numeric = String$1.match(/^([0-3]?\d)\.([01]?\d)\.(\d{4})$/u)(input);
-	if (Option.isSome(numeric)) {
-		const year = validYear(textAt(numeric.value, 3));
-		const day = Number(textAt(numeric.value, 1));
-		const month = Number(textAt(numeric.value, 2));
-		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, `${day}. ${title(textAt(months, month - 1))} ${year}`));
-		}
-	}
+	if (Option.isSome(numeric)) return namedDatePeriod(textAt(numeric.value, 3), textAt(numeric.value, 2), textAt(numeric.value, 1), Number, (day, month, year) => `${day}. ${title(textAt(months, month - 1))} ${year}`);
 	const current = String$1.match(/^([0-3]?\d)\.? ([a-zäöüß]+\.?)$/u)(input);
 	return Option.isSome(current) ? namedCurrentYearDatePeriod(textAt(current.value, 2), textAt(current.value, 1), monthNumber, currentDateLabel) : Option.none();
 };
@@ -699,12 +377,16 @@ const parseDatedPeriod = (input) => {
 	return Option.none();
 };
 const parseRelativeMonth = (input) => {
-	const prefixedRelativeMonth = String$1.match(/^(letzter|dieser|nächster) ([a-zäöüß]+\.?)$/u)(input);
+	const prefixedRelativeMonth = String$1.match(/^(letzt|dies|nächst)(?:er|en|em) ([a-zäöüß]+\.?)$/u)(input);
 	if (Option.isSome(prefixedRelativeMonth)) {
 		const month = monthNumber(textAt(prefixedRelativeMonth.value, 2));
 		if (month !== void 0) {
-			const modifier = textAt(prefixedRelativeMonth.value, 1);
-			const direction = relativeDirection(modifier);
+			const direction = relativeDirection(textAt(prefixedRelativeMonth.value, 1));
+			const modifier = textAt([
+				"letzter",
+				"dieser",
+				"nächster"
+			], direction + 1);
 			return Option.some(monthOfRelativeYear(month, direction, `${modifier} ${title(textAt(months, month - 1))}`));
 		}
 	}
@@ -736,28 +418,58 @@ const parseBasePeriod = (input) => {
 		if (input === relative.next) direction = 1;
 		return Option.some(relativePeriod(relative.unit, direction, canonicalRelative(input)));
 	}
-	const alias = relativeAliases.find((entry) => entry[0] === input);
-	if (alias !== void 0) return Option.some(relativePeriod(alias[1], alias[2], canonicalRelative(alias[3])));
-	return Option.none();
+	if (input === "vorgestern") return Option.some(relativePeriod("day", -2, "vorgestern"));
+	return parseModifiedUnit(input);
+};
+const countedUnit = (value, amount, dative = false) => unitPhrases.find((entry) => {
+	if (amount === 1) return value === entry.noun;
+	return value === (dative ? entry.dative : entry.plural);
+});
+const parseCalendarOffsetValue = (input) => {
+	const singular = String$1.match(/^(vor|in) (ein[^ ]* [^ ]+)$/u)(input);
+	if (Option.isSome(singular)) {
+		const entry = unitPhrases.find((unit) => unit.indefiniteDative === textAt(singular.value, 2));
+		if (entry !== void 0) {
+			const past = textAt(singular.value, 1) === "vor";
+			return Option.some({
+				amount: past ? -1 : 1,
+				canonical: `${past ? "vor" : "in"} ${canonicalRelative(entry.indefiniteDative)}`,
+				entry
+			});
+		}
+	}
+	const prefixed = String$1.match(/^(vor|in) ([1-9]\d*) ([^ ]+)$/u)(input);
+	const prior = String$1.match(/^([1-9]\d*) ([^ ]+) zuvor$/u)(input);
+	const match = Option.firstSomeOf([prefixed, prior]);
+	if (Option.isNone(match)) return Option.none();
+	const amountText = textAt(match.value, Option.isSome(prefixed) ? 2 : 1);
+	const unitText = textAt(match.value, Option.isSome(prefixed) ? 3 : 2);
+	const amount = parseTrailingCount(amountText);
+	if (Option.isNone(amount)) return Option.none();
+	const entry = countedUnit(unitText, amount.value, Option.isSome(prefixed));
+	if (entry === void 0) return Option.none();
+	const past = Option.isSome(prior) || Option.isSome(prefixed) && textAt(match.value, 1) === "vor";
+	const direction = past ? "vor" : "in";
+	const noun = amount.value === 1 ? entry.noun : entry.dative;
+	return Option.some({
+		amount: past ? -amount.value : amount.value,
+		canonical: `${direction} ${amount.value} ${title(noun)}`,
+		entry
+	});
 };
 const parsePeriod = (input) => {
-	const shifted = String$1.match(/^(.+) (vor|in) ([1-9]\d*) (tag|tagen|woche|wochen|monat|monaten|quartal|quartalen|jahr|jahren)$/u)(input);
-	if (Option.isSome(shifted)) {
-		const amount = parseTrailingCount(textAt(shifted.value, 3));
-		const unitText = textAt(shifted.value, 4);
-		const entry = unitPhrases.find((unit) => [
-			unit.noun,
-			unit.plural,
-			unit.dative
-		].includes(unitText));
-		const period = parsePeriod(textAt(shifted.value, 1));
-		if (Option.isSome(amount) && entry !== void 0 && Option.isSome(period)) {
-			const past = textAt(shifted.value, 2) === "vor";
-			const direction = past ? -amount.value : amount.value;
-			const noun = amount.value === 1 ? entry.noun : entry.dative;
-			const canonical = `${period.value.canonical} ${past ? "vor" : "in"} ${amount.value} ${title(noun)}`;
-			return Option.some(shiftPeriod(period.value, direction, entry.unit, canonical));
+	let separator = input.indexOf(" ");
+	while (separator !== -1) {
+		const offsetStart = separator + 1;
+		const firstOffsetCharacter = input[offsetStart] ?? "";
+		if (input.startsWith("vor ", offsetStart) || input.startsWith("in ", offsetStart) || firstOffsetCharacter >= "1" && firstOffsetCharacter <= "9" && input.endsWith(" zuvor")) {
+			const offset = parseCalendarOffsetValue(input.slice(offsetStart));
+			if (Option.isSome(offset)) {
+				const period = parsePeriod(input.slice(0, separator));
+				if (Option.isSome(period)) return Option.some(shiftPeriod(period.value, offset.value.amount, offset.value.entry.unit, `${period.value.canonical} ${offset.value.canonical}`));
+			}
 		}
+		separator = input.indexOf(" ", offsetStart);
 	}
 	const edge = String$1.match(/^(anfang|beginn|ende) (.+)$/u)(input);
 	if (Option.isSome(edge)) {
@@ -814,50 +526,19 @@ const boundaryCandidate = (input) => Option.map(openBoundaryCandidate(input, [
 	["bis ", "before"],
 	["ab ", "since"]
 ], parsePeriod), (result) => candidate(result.range, canonicalRelative(input)));
-const countedUnit = (value, amount, dative = false) => unitPhrases.find((entry) => {
-	if (amount === 1) return value === entry.noun;
-	return value === (dative ? entry.dative : entry.plural);
-});
-const parseCalendarOffset = (input) => {
-	const singular = String$1.match(/^(vor|in) (einem tag|einer woche|einem monat|einem quartal|einem jahr)$/u)(input);
-	if (Option.isSome(singular)) {
-		const entry = unitPhrases.find((unit) => unit.indefiniteDative === textAt(singular.value, 2));
-		if (entry !== void 0) {
-			const isPast = textAt(singular.value, 1) === "vor";
-			const direction = isPast ? -1 : 1;
-			const canonical = `${isPast ? "vor" : "in"} ${canonicalRelative(entry.indefiniteDative)}`;
-			return Option.some(relativePeriod(entry.unit, direction, canonical));
-		}
-	}
-	const prefixed = String$1.match(/^(vor|in) ([1-9]\d*) (tag|tagen|woche|wochen|monat|monaten|quartal|quartalen|jahr|jahren)$/u)(input);
-	const prior = String$1.match(/^([1-9]\d*) (tag|tage|woche|wochen|monat|monate|quartal|quartale|jahr|jahre) zuvor$/u)(input);
-	const match = Option.firstSomeOf([prefixed, prior]);
-	if (Option.isNone(match)) return Option.none();
-	const amountText = textAt(match.value, Option.isSome(prefixed) ? 2 : 1);
-	const unitText = textAt(match.value, Option.isSome(prefixed) ? 3 : 2);
-	const amount = parseTrailingCount(amountText);
-	if (Option.isNone(amount)) return Option.none();
-	const entry = countedUnit(unitText, amount.value, Option.isSome(prefixed));
-	if (entry === void 0) return Option.none();
-	const isPast = Option.isSome(prior) || Option.isSome(prefixed) && textAt(match.value, 1) === "vor";
-	const direction = isPast ? -amount.value : amount.value;
-	const directionName = isPast ? "vor" : "in";
-	const noun = amount.value === 1 ? entry.noun : entry.dative;
-	const canonical = `${directionName} ${amount.value} ${title(noun)}`;
-	return Option.some(relativePeriod(entry.unit, direction, canonical));
-};
+const parseCalendarOffset = (input) => parseCalendarOffsetValue(input).pipe(Option.map((offset) => relativePeriod(offset.entry.unit, offset.amount, offset.canonical)));
 const parseRollingPeriod = (input) => {
-	const past = String$1.match(/^(?:(?:die letzten|letzten|letzte|vergangene|vorherige) )?([1-9]\d*) (tag|tage|woche|wochen|monat|monate|quartal|quartale|jahr|jahre)$/u)(input);
-	const pastDative = String$1.match(/^(?:(?:in den letzten|in den vergangenen|in den vorherigen) |seit )([1-9]\d*) (tag|tagen|woche|wochen|monat|monaten|quartal|quartalen|jahr|jahren)$/u)(input);
-	const singularSince = String$1.match(/^seit (einem tag|einer woche|einem monat|einem quartal|einem jahr)$/u)(input);
-	const pastGenitive = String$1.match(/^während der letzten ([1-9]\d*) (tag|tage|woche|wochen|monat|monate|quartal|quartale|jahr|jahre)$/u)(input);
-	const future = String$1.match(/^(?:die nächsten|nächsten|nächste|kommende) ([1-9]\d*) (tag|tage|woche|wochen|monat|monate|quartal|quartale|jahr|jahre)$/u)(input);
-	const futureDative = String$1.match(/^(?:in den nächsten|in den kommenden|innerhalb von) ([1-9]\d*) (tag|tagen|woche|wochen|monat|monaten|quartal|quartalen|jahr|jahren)$/u)(input);
-	const singularFuture = String$1.match(/^innerhalb (eines tages|einer woche|eines monats|eines quartals|eines jahres)$/u)(input);
-	const futureGenitive = String$1.match(/^innerhalb der nächsten ([1-9]\d*) (tag|tage|woche|wochen|monat|monate|quartal|quartale|jahr|jahre)$/u)(input);
+	const past = String$1.match(/^(?:(?:die letzten|letzten|letzte|vergangene|vorherige) )?([1-9]\d*) ([^ ]+)$/u)(input);
+	const pastDative = String$1.match(/^(?:(?:in den letzten|in den vergangenen|in den vorherigen) |seit )([1-9]\d*) ([^ ]+)$/u)(input);
+	const singularSince = String$1.match(/^seit (ein[^ ]* [^ ]+)$/u)(input);
+	const pastGenitive = String$1.match(/^während der letzten ([1-9]\d*) ([^ ]+)$/u)(input);
+	const future = String$1.match(/^(?:die nächsten|nächsten|nächste|kommende) ([1-9]\d*) ([^ ]+)$/u)(input);
+	const futureDative = String$1.match(/^(?:in den nächsten|in den kommenden|innerhalb von) ([1-9]\d*) ([^ ]+)$/u)(input);
+	const singularFuture = String$1.match(/^innerhalb (ein[^ ]* [^ ]+)$/u)(input);
+	const futureGenitive = String$1.match(/^innerhalb der nächsten ([1-9]\d*) ([^ ]+)$/u)(input);
 	const match = Option.firstSomeOf([
-		past,
 		pastDative,
+		past,
 		singularSince,
 		pastGenitive,
 		future,
@@ -894,6 +575,37 @@ const parseElidedDateRange = (input) => {
 	const suffix = year.length === 0 ? "" : ` ${year}`;
 	return joinedPeriodCandidate(`von ${lowerDay}. ${month}${suffix} bis ${upperDay}. ${month}${suffix}`, [["von ", " bis "]], parsePeriod, (lower, upper) => `von ${lower} bis ${upper}`);
 };
+const boundedJoins = [
+	["von ", " bis einschließlich "],
+	["vom ", " bis einschließlich "],
+	["von ", " bis zum "],
+	["vom ", " bis zum "],
+	["von ", " bis "],
+	["vom ", " bis "],
+	["zwischen ", " und "],
+	["", " bis einschließlich "],
+	["", " bis "],
+	["", " - "],
+	["", " – "],
+	["", " — "],
+	["zwischen ", "-"],
+	["", "-"],
+	["zwischen ", "–"],
+	["", "–"],
+	["zwischen ", "—"],
+	["", "—"],
+	["zwischen ", "~"],
+	["", "~"]
+];
+const sharedRelativeYearRange = (input) => {
+	const match = String$1.match(/^(.+) (letzten|dieses|nächsten) jahres$/u)(input);
+	if (Option.isNone(match)) return Option.none();
+	const year = `${textAt(match.value, 2)} jahres`;
+	return joinedPeriodCandidate(textAt(match.value, 1), boundedJoins, (periodInput) => {
+		const inherited = parsePeriod(`${periodInput} ${year}`);
+		return Option.isSome(inherited) ? inherited : parsePeriod(periodInput);
+	}, (lower, upper) => `von ${lower} bis ${upper}`);
+};
 const parseGerman = (input) => {
 	const remaining = remainingPeriodPhrases.find((entry) => entry.phrase === input);
 	if (remaining !== void 0) return Option.some(candidate(remainingPeriodRange(remaining.entry.unit), `Rest ${canonicalRelative(remaining.entry.genitive)}`));
@@ -907,6 +619,8 @@ const parseGerman = (input) => {
 	if (Option.isSome(currentBoundary)) return currentBoundary;
 	const elided = parseElidedDateRange(input);
 	if (Option.isSome(elided)) return elided;
+	const inheritedYear = sharedRelativeYearRange(input);
+	if (Option.isSome(inheritedYear)) return inheritedYear;
 	const nowBounded = joinedNowCandidate(input, [
 		["von ", " bis heute"],
 		["vom ", " bis heute"],
@@ -918,28 +632,7 @@ const parseGerman = (input) => {
 		"jetzt bis "
 	], parsePeriod, (period) => `von ${period} bis heute`, (period) => `von heute bis ${period}`);
 	if (Option.isSome(nowBounded)) return nowBounded;
-	const bounded = joinedPeriodCandidate(input, [
-		["von ", " bis einschließlich "],
-		["vom ", " bis einschließlich "],
-		["von ", " bis zum "],
-		["vom ", " bis zum "],
-		["von ", " bis "],
-		["vom ", " bis "],
-		["zwischen ", " und "],
-		["", " bis einschließlich "],
-		["", " bis "],
-		["", " - "],
-		["", " – "],
-		["", " — "],
-		["zwischen ", "-"],
-		["", "-"],
-		["zwischen ", "–"],
-		["", "–"],
-		["zwischen ", "—"],
-		["", "—"],
-		["zwischen ", "~"],
-		["", "~"]
-	], parsePeriod, (lower, upper) => `von ${lower} bis ${upper}`);
+	const bounded = joinedPeriodCandidate(input, boundedJoins, parsePeriod, (lower, upper) => `von ${lower} bis ${upper}`);
 	if (Option.isSome(bounded)) return bounded;
 	const boundary = boundaryCandidate(input);
 	if (Option.isSome(boundary)) return boundary;
@@ -978,7 +671,8 @@ const staticPeriodPhrases = [
 		`letzter ${month}`,
 		`nächster ${month}`,
 		`${month} letzten jahres`,
-		`${month} nächsten jahres`
+		`${month} nächsten jahres`,
+		`${month} vor einem jahr`
 	]),
 	...nextWeekdays.map((entry) => entry.phrase)
 ];
@@ -1017,12 +711,20 @@ const germanSuggestionPhrases = [
 	]),
 	...staticPeriodPhrases,
 	...currentBoundaryPhrases.map((entry) => entry.phrase),
-	...declinedBoundaryPeriods.flatMap(([, , , dative, accusative]) => [
-		`seit ${dative}`,
-		`vor ${dative}`,
-		`bis einschließlich ${accusative}`,
-		`nach ${dative}`
-	]),
+	...unitPhrases.flatMap((entry) => [
+		entry.current,
+		entry.previous,
+		entry.next
+	].flatMap((period) => {
+		const dative = withRelativeCase(canonicalRelative(period), "dative");
+		const accusative = withRelativeCase(canonicalRelative(period), "accusative");
+		return [
+			`seit ${dative}`,
+			`vor ${dative}`,
+			`bis einschließlich ${accusative}`,
+			`nach ${dative}`
+		];
+	})),
 	...prefixNaturalPhrases(months, boundaryPrefixes),
 	"bis heute",
 	"ab jetzt"
@@ -1043,9 +745,9 @@ const renderGerman = (range) => {
 		const entry = unitPhrases.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.noun : entry.dative;
+			const offset = amount === 1 ? canonicalRelative(entry.indefiniteDative) : `${amount} ${title(entry.dative)}`;
 			const direction = shifted.value.amount < 0 ? "vor" : "in";
-			return Option.some(`${base.value} ${direction} ${amount} ${title(noun)}`);
+			return Option.some(`${base.value} ${direction} ${offset}`);
 		}
 	}
 	const offset = calendarPeriodOffset(range);
@@ -1069,7 +771,7 @@ const renderGerman = (range) => {
 		...currentYearDatePeriods(range, currentDateLabel),
 		...periodsFromPhrases([...dated, ...dated.flatMap((phrase) => [`anfang ${phrase}`, `ende ${phrase}`])], parsePeriod)
 	];
-	return renderPeriodRange(range, [...unitPhrases.map((entry) => candidate(periodToDateRange(entry.unit), canonicalToDate(entry))), ...unitPhrases.map((entry) => candidate(remainingPeriodRange(entry.unit), `Rest ${canonicalRelative(entry.genitive)}`))], periods, (period) => `seit ${withRelativeCase(period, "dative")}`, (period) => `vor ${withRelativeCase(period, "dative")}`, (period) => `bis einschließlich ${withRelativeCase(period, "accusative")}`, (period) => `nach ${withRelativeCase(period, "dative")}`, (lower, upper) => `von ${lower} bis ${upper}`, (period) => `von ${period} bis heute`, (period) => `von heute bis ${period}`, () => "bis heute", () => "ab jetzt");
+	return renderPeriodRange(range, [...unitPhrases.map((entry) => candidate(periodToDateRange(entry.unit), canonicalToDate(entry))), ...unitPhrases.map((entry) => candidate(remainingPeriodRange(entry.unit), `Rest ${canonicalRelative(entry.genitive)}`))], periods, (period) => `seit ${withRelativeCase(period, "dative")}`, (period) => `vor ${withRelativeCase(period, "dative")}`, (period) => `bis einschließlich ${withRelativeCase(period, "accusative")}`, (period) => `nach ${withRelativeCase(period, "dative")}`, (lower, upper) => `von ${withRelativeCase(lower, "dative")} bis ${withRelativeCase(upper, "accusative")}`, (period) => `von ${period} bis heute`, (period) => `von heute bis ${period}`, () => "bis heute", () => "ab jetzt");
 };
 const GermanContribution = new BaseLanguageContribution({
 	locale: "de",
@@ -1085,7 +787,7 @@ const GermanContribution = new BaseLanguageContribution({
 		...toDatePhrases.flatMap((entry) => entry.phrase.split(" ")),
 		...remainingPeriodPhrases.flatMap((entry) => entry.phrase.split(" ")),
 		...currentBoundaryPhrases.flatMap((entry) => entry.phrase.split(" ")),
-		...relativeAliases.flatMap((entry) => entry[0].split(" ")),
+		...relativeModifierVocabulary,
 		...unitPhrases.flatMap((entry) => [
 			entry.noun,
 			entry.plural,
@@ -1123,6 +825,8 @@ const GermanContribution = new BaseLanguageContribution({
 		"letzten",
 		"nach",
 		"nächste",
+		"auflaufend",
+		"per",
 		"nächsten",
 		"seit",
 		"vor",