chronolizer 0.1.0 → 0.2.0

package/dist/locales/de.mjs

@@ -0,0 +1,828 @@
+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 { 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 { Effect, Option, String as String$1 } from "effect";
+//#region src/locales/de.ts
+const months = [
+	"januar",
+	"februar",
+	"märz",
+	"april",
+	"mai",
+	"juni",
+	"juli",
+	"august",
+	"september",
+	"oktober",
+	"november",
+	"dezember"
+];
+const monthAbbreviations = [
+	["jan"],
+	["feb"],
+	["mär", "mrz"],
+	["apr"],
+	["mai"],
+	["jun"],
+	["jul"],
+	["aug"],
+	["sep", "sept"],
+	["okt"],
+	["nov"],
+	["dez"]
+];
+const unitPhrases = [
+	{
+		unit: "day",
+		noun: "tag",
+		plural: "tage",
+		current: "heute",
+		previous: "gestern",
+		next: "morgen",
+		compound: "tages",
+		currentGenitive: "dieses tages",
+		dative: "tagen",
+		genitive: "des tages"
+	},
+	{
+		unit: "week",
+		noun: "woche",
+		plural: "wochen",
+		current: "diese woche",
+		previous: "letzte woche",
+		next: "nächste woche",
+		compound: "wochen",
+		currentGenitive: "dieser woche",
+		dative: "wochen",
+		genitive: "der woche"
+	},
+	{
+		unit: "month",
+		noun: "monat",
+		plural: "monate",
+		current: "dieser monat",
+		previous: "letzter monat",
+		next: "nächster monat",
+		compound: "monats",
+		currentGenitive: "dieses monats",
+		dative: "monaten",
+		genitive: "des monats"
+	},
+	{
+		unit: "quarter",
+		noun: "quartal",
+		plural: "quartale",
+		current: "dieses quartal",
+		previous: "letztes quartal",
+		next: "nächstes quartal",
+		compound: "quartals",
+		currentGenitive: "dieses quartals",
+		dative: "quartalen",
+		genitive: "des quartals"
+	},
+	{
+		unit: "year",
+		noun: "jahr",
+		plural: "jahre",
+		current: "dieses jahr",
+		previous: "letztes jahr",
+		next: "nächstes jahr",
+		compound: "jahres",
+		currentGenitive: "dieses jahres",
+		dative: "jahren",
+		genitive: "des jahres"
+	}
+];
+const title = (value) => `${value.slice(0, 1).toLocaleUpperCase("de")}${value.slice(1)}`;
+const canonicalToDate = (entry) => `seit ${title(entry.compound)}beginn`;
+const canonicalRelative = (value) => {
+	const separator = value.lastIndexOf(" ");
+	if (separator === -1) return value;
+	return `${value.slice(0, separator + 1)}${title(value.slice(separator + 1))}`;
+};
+const remainingPeriodPhrases = unitPhrases.flatMap((entry) => [`rest ${entry.genitive}`, `rest ${entry.currentGenitive}`].map((phrase) => ({
+	entry,
+	phrase
+})));
+const toDatePhrases = unitPhrases.flatMap((entry) => [
+	`seit ${entry.compound}beginn`,
+	`seit ${entry.compound}anfang`,
+	`seit beginn ${entry.genitive}`,
+	`seit anfang ${entry.genitive}`,
+	`seit beginn ${entry.currentGenitive}`,
+	`seit anfang ${entry.currentGenitive}`,
+	`vom ${entry.compound}beginn bis heute`,
+	`vom ${entry.compound}anfang bis heute`,
+	`vom beginn ${entry.genitive} bis heute`,
+	`vom anfang ${entry.genitive} bis heute`,
+	`vom beginn ${entry.currentGenitive} bis heute`,
+	`vom anfang ${entry.currentGenitive} bis heute`,
+	`${entry.noun} bis heute`,
+	`${entry.current} bisher`,
+	`bisher ${entry.current}`
+].map((phrase) => ({
+	entry,
+	phrase
+})));
+const currentBoundaryPhrases = unitPhrases.flatMap((entry) => [
+	[`vor ${entry.compound}beginn`, "before"],
+	[`vor ${entry.compound}anfang`, "before"],
+	[`bis ${entry.compound}beginn`, "before"],
+	[`bis ${entry.compound}anfang`, "before"],
+	[`bis ${entry.compound}ende`, "through"],
+	[`nach ${entry.compound}ende`, "after"],
+	[`ab ${entry.compound}ende`, "after"]
+].map(([phrase, boundary]) => ({
+	boundary,
+	entry,
+	phrase
+})));
+const relativeAliases = [
+	[
+		"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 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 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}`));
+		}
+	}
+	return Option.none();
+};
+const quarterNames = [
+	"erstes",
+	"zweites",
+	"drittes",
+	"viertes"
+];
+const quarterNumber = (value) => {
+	if (value.startsWith("q")) return Number(value.slice(1));
+	if (value.endsWith(".")) return Number(value.slice(0, -1));
+	const index = quarterNames.findIndex((name) => name === value);
+	return index === -1 ? void 0 : index + 1;
+};
+const relativeDirection = (value) => {
+	if (value === "letzten") return -1;
+	if (value === "nächsten") return 1;
+	return 0;
+};
+const parseQuarter = (input) => {
+	const fixed = String$1.match(/^(q[1-4]|[1-4]\.|erstes|zweites|drittes|viertes)(?: quartal)? (\d{4})$/u)(input);
+	const reversed = String$1.match(/^(\d{4}) (q[1-4])$/u)(input);
+	const relative = String$1.match(/^(q[1-4]|[1-4]\.|erstes|zweites|drittes|viertes)(?: quartal)? (letzten|dieses|nächsten) jahres$/u)(input);
+	const standalone = String$1.match(/^(q[1-4]|[1-4]\.|erstes|zweites|drittes|viertes)(?: quartal)?$/u)(input);
+	const fixedMatch = Option.firstSomeOf([fixed, reversed]);
+	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}`));
+	}
+	if (Option.isSome(relative)) {
+		const directionText = textAt(relative.value, 2);
+		const quarter = quarterNumber(textAt(relative.value, 1));
+		if (quarter !== void 0) {
+			const direction = relativeDirection(directionText);
+			return Option.some(quarterOfRelativeYear(quarter, direction, `Q${quarter} ${directionText} Jahres`));
+		}
+	}
+	if (Option.isNone(standalone)) return Option.none();
+	const quarter = quarterNumber(textAt(standalone.value, 1));
+	return quarter === void 0 ? Option.none() : Option.some(quarterOfRelativeYear(quarter, 0, `Q${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 yearMatch = String$1.match(/^(?:(?:das )?(?:kalender)?jahr )?(\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äöüß]+\.?) (letzten|dieses|nächsten) jahres$/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))} ${directionText} Jahres`));
+	}
+	const standaloneMonth = monthNumber(input);
+	if (standaloneMonth !== void 0) return Option.some(monthOfRelativeYear(standaloneMonth, 0, title(textAt(months, standaloneMonth - 1))));
+	if (input === "wochenende" || input === "dieses wochenende" || input === "am wochenende") return Option.some(relativeWeekend(0, "dieses Wochenende"));
+	if (input === "letztes wochenende" || input === "vergangenes wochenende") return Option.some(relativeWeekend(-1, "letztes Wochenende"));
+	if (input === "nächstes wochenende" || input === "kommendes wochenende") return Option.some(relativeWeekend(1, "nächstes Wochenende"));
+	if (input === "vorletztes wochenende") return Option.some(relativeWeekend(-2, "vorletztes Wochenende"));
+	if (input === "übernächstes wochenende") return Option.some(relativeWeekend(2, "übernächstes Wochenende"));
+	const relative = unitPhrases.find((entry) => entry.current === input || entry.previous === input || entry.next === input);
+	if (relative !== void 0) {
+		let direction = 0;
+		if (input === relative.previous) direction = -1;
+		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();
+};
+const parsePeriod = (input) => {
+	const edge = String$1.match(/^(anfang|beginn|ende) (.+)$/u)(input);
+	if (Option.isSome(edge)) {
+		const edgeName = textAt(edge.value, 1);
+		const period = parseBasePeriod(textAt(edge.value, 2));
+		if (Option.isSome(period)) {
+			const canonical = `${edgeName === "ende" ? "Ende" : "Anfang"} ${period.value.canonical}`;
+			return Option.some(edgeName === "ende" ? periodEndDay(period.value, canonical) : periodStartDay(period.value, canonical));
+		}
+	}
+	const wrapper = [
+		"im ",
+		"für ",
+		"während "
+	].find((prefix) => input.startsWith(prefix));
+	return parseBasePeriod(wrapper === void 0 ? input : input.slice(wrapper.length));
+};
+const currentBoundaryCandidate = (input) => {
+	const match = currentBoundaryPhrases.find((entry) => entry.phrase === input);
+	if (match === void 0) return Option.none();
+	const period = relativePeriod(match.entry.unit, 0, match.entry.current);
+	return Option.some(periodBoundaryCandidate(period, match.boundary, match.phrase));
+};
+const boundaryCandidate = (input) => openBoundaryCandidate(input, [
+	["seit dem beginn von ", "since"],
+	["seit dem anfang von ", "since"],
+	["seit dem jahr ", "since"],
+	["ab dem jahr ", "since"],
+	["bis zum beginn von ", "before"],
+	["bis zum anfang von ", "before"],
+	["bis zum jahr ", "before"],
+	["bis zum ende von ", "through"],
+	["nach dem ende von ", "after"],
+	["bis einschließlich ", "through"],
+	["seit beginn ", "since"],
+	["seit anfang ", "since"],
+	["ab beginn ", "since"],
+	["ab anfang ", "since"],
+	["vor beginn ", "before"],
+	["vor anfang ", "before"],
+	["bis beginn ", "before"],
+	["bis anfang ", "before"],
+	["bis ende ", "through"],
+	["nach ende ", "after"],
+	["ab ende ", "after"],
+	["seit ", "since"],
+	["vor ", "before"],
+	["nach ", "after"],
+	["bis ", "before"],
+	["ab ", "since"]
+], parsePeriod);
+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 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(candidate(periodRange(relativePeriod(entry.unit, direction, canonical)), 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) ([1-9]\d*) (tag|tagen|woche|wochen|monat|monaten|quartal|quartalen|jahr|jahren)$/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 futureGenitive = String$1.match(/^innerhalb der nächsten ([1-9]\d*) (tag|tage|woche|wochen|monat|monate|quartal|quartale|jahr|jahre)$/u)(input);
+	const match = Option.firstSomeOf([
+		past,
+		pastDative,
+		pastGenitive,
+		future,
+		futureDative,
+		futureGenitive
+	]);
+	if (Option.isNone(match)) return Option.none();
+	const amount = parseTrailingCount(textAt(match.value, 1));
+	if (Option.isNone(amount)) return Option.none();
+	const usesDative = Option.isSome(pastDative) || Option.isSome(futureDative);
+	const entry = countedUnit(textAt(match.value, 2), amount.value, usesDative);
+	if (entry === void 0) return Option.none();
+	const isFuture = Option.isSome(future) || Option.isSome(futureDative) || Option.isSome(futureGenitive);
+	const range = isFuture ? futureRange(amount.value, entry.unit) : trailingRange(amount.value, entry.unit);
+	const direction = isFuture ? "nächste" : "letzte";
+	const noun = amount.value === 1 ? entry.noun : entry.plural;
+	return Option.some(candidate(range, `${direction} ${amount.value} ${title(noun)}`));
+};
+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)}`));
+	if (["bis heute", "bis jetzt"].includes(input)) return Option.some(candidate(untilNowRange(), "bis heute"));
+	if (["ab jetzt", "von jetzt an"].includes(input)) return Option.some(candidate(fromNowRange(), "ab jetzt"));
+	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), canonicalToDate(toDate.entry)));
+	const currentBoundary = currentBoundaryCandidate(input);
+	if (Option.isSome(currentBoundary)) return currentBoundary;
+	const nowBounded = joinedNowCandidate(input, [
+		["von ", " bis heute"],
+		["vom ", " bis heute"],
+		["zwischen ", " und heute"]
+	], ["von heute bis ", "zwischen heute und "], 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}`);
+	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));
+};
+const staticPeriodPhrases = [
+	"dieses wochenende",
+	"letztes wochenende",
+	"nächstes wochenende",
+	"vorletztes wochenende",
+	"übernächstes wochenende",
+	...unitPhrases.flatMap((entry) => [
+		entry.current,
+		entry.previous,
+		entry.next,
+		`anfang ${entry.current}`,
+		`ende ${entry.current}`,
+		`anfang ${entry.previous}`,
+		`ende ${entry.previous}`,
+		`anfang ${entry.next}`,
+		`ende ${entry.next}`
+	]),
+	...[
+		1,
+		2,
+		3,
+		4
+	].flatMap((quarter) => [
+		`q${quarter}`,
+		`q${quarter} letzten jahres`,
+		`q${quarter} nächsten jahres`
+	]),
+	...months.flatMap((month) => [
+		month,
+		`${month} letzten jahres`,
+		`${month} nächsten jahres`
+	])
+];
+const staticPeriods = periodsFromPhrases(staticPeriodPhrases, parsePeriod);
+const boundaryPrefixes = [
+	"seit ",
+	"vor ",
+	"bis einschließlich ",
+	"nach "
+];
+const countedSuggestions = (input) => {
+	const amount = naturalCount(input);
+	if (amount === void 0) return [];
+	return unitPhrases.flatMap((entry) => {
+		const noun = amount === 1 ? entry.noun : entry.plural;
+		const dative = amount === 1 ? entry.noun : entry.dative;
+		return [
+			...amount === 1 ? [`${amount} ${noun}`] : [
+				`letzte ${amount} ${noun}`,
+				`${amount} ${noun}`,
+				`nächste ${amount} ${noun}`
+			],
+			`vor ${amount} ${dative}`,
+			`in ${amount} ${dative}`
+		];
+	});
+};
+const germanSuggestionPhrases = [
+	...unitPhrases.map(canonicalToDate),
+	...unitPhrases.map((entry) => `rest ${entry.genitive}`),
+	...staticPeriodPhrases,
+	...prefixNaturalPhrases(staticPeriodPhrases, boundaryPrefixes),
+	"bis heute",
+	"ab jetzt"
+].map((phrase) => normalizeNaturalText(phrase, "de"));
+const suggestGerman = (input, limit) => {
+	const fixed = fixedCalendarPeriodPhrases(input, months);
+	return completeNaturalPhrases(input, [
+		...germanSuggestionPhrases,
+		...fixed,
+		...prefixNaturalPhrases(fixed, boundaryPrefixes),
+		...countedSuggestions(input)
+	], limit);
+};
+const renderGerman = (range) => {
+	const offset = calendarPeriodOffset(range);
+	if (Option.isSome(offset) && Math.abs(offset.value.amount) > 1) {
+		const entry = unitPhrases.find((unit) => unit.unit === offset.value.unit);
+		if (entry !== void 0) return Option.some(`${offset.value.amount < 0 ? "vor" : "in"} ${Math.abs(offset.value.amount)} ${title(Math.abs(offset.value.amount) === 1 ? entry.noun : entry.dative)}`);
+	}
+	const future = futurePeriod(range);
+	if (Option.isSome(future)) {
+		const entry = unitPhrases.find((unit) => unit.unit === future.value.unit);
+		if (entry !== void 0) return Option.some(`nächste ${future.value.amount} ${title(future.value.amount === 1 ? entry.noun : entry.plural)}`);
+	}
+	const trailing = trailingPeriod(range);
+	if (Option.isSome(trailing)) {
+		const entry = unitPhrases.find((unit) => unit.unit === trailing.value.unit);
+		if (entry !== void 0) return Option.some(trailing.value.amount === 1 ? `1 ${title(entry.noun)}` : `letzte ${trailing.value.amount} ${title(entry.plural)}`);
+	}
+	const periods = [...staticPeriods, ...periodsFromPhrases([...datedPeriods(range, months), ...datedQuarterPeriods(range)], 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 ${period}`, (period) => `vor ${period}`, (period) => `bis einschließlich ${period}`, (period) => `nach ${period}`, (lower, upper) => `von ${lower} bis ${upper}`, (period) => `von ${period} bis heute`, (period) => `von heute bis ${period}`, () => "bis heute", () => "ab jetzt");
+};
+const GermanContribution = new BaseLanguageContribution({
+	locale: "de",
+	vocabulary: [
+		...months,
+		...quarterNames,
+		"q1",
+		"q2",
+		"q3",
+		"q4",
+		...monthAbbreviations.flatMap((aliases) => aliases),
+		...toDatePhrases.flatMap((entry) => entry.phrase.split(" ")),
+		...remainingPeriodPhrases.flatMap((entry) => entry.phrase.split(" ")),
+		...currentBoundaryPhrases.flatMap((entry) => entry.phrase.split(" ")),
+		...relativeAliases.flatMap((entry) => entry[0].split(" ")),
+		...unitPhrases.flatMap((entry) => [
+			entry.noun,
+			entry.plural,
+			entry.dative,
+			...entry.currentGenitive.split(" "),
+			...entry.current.split(" "),
+			...entry.previous.split(" "),
+			...entry.next.split(" ")
+		]),
+		"ab",
+		"an",
+		"anfang",
+		"beginn",
+		"bisher",
+		"bis",
+		"dem",
+		"den",
+		"die",
+		"dieses",
+		"einschließlich",
+		"ende",
+		"für",
+		"im",
+		"innerhalb",
+		"jetzt",
+		"kalenderjahr",
+		"jahres",
+		"kommende",
+		"kommenden",
+		"letzte",
+		"letzten",
+		"nach",
+		"nächste",
+		"nächsten",
+		"seit",
+		"vor",
+		"vorherige",
+		"vorherigen",
+		"vergangene",
+		"vergangenen",
+		"vom",
+		"von",
+		"während",
+		"wochenende",
+		"zwischen",
+		"zuvor"
+	],
+	normalize: normalizeNaturalText,
+	correct: correctWhitespaceSeparatedText,
+	parseExact: parseGerman,
+	suggest: suggestGerman,
+	render: renderGerman
+});
+const GermanLanguage = defineLanguagePlugin({
+	id: "chronolizer/language-de",
+	effect: (context) => Effect.asVoid(context.register("chronolizer/language-de", GermanContribution))
+});
+const GermanLanguageLayer = languagePluginsLayer([GermanLanguage]);
+//#endregion
+export { GermanContribution, GermanLanguage, GermanLanguageLayer };