chronolizer 0.2.0 → 0.4.0

package/dist/locales/pl.mjs

@@ -3,8 +3,8 @@ 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, periodEndDay, periodRange, periodStartDay, periodToDateRange, periodsFromPhrases, quarterOfRelativeYear, relativePeriod, relativeWeekend, remainingPeriodRange, renderPeriodRange, textAt, trailingPeriod, trailingRange, untilNowRange, validYear } from "./shared.mjs";
+import { completeNaturalPhrases, fixedCalendarPeriodPhrases, naturalCount } 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, 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/pl.ts
 const months = [
@@ -21,6 +21,95 @@ const months = [
 	"listopad",
 	"grudzień"
 ];
+const weekdays = [
+	"poniedziałek",
+	"wtorek",
+	"środa",
+	"czwartek",
+	"piątek",
+	"sobota",
+	"niedziela"
+];
+const weekdayGenitives = [
+	"poniedziałku",
+	"wtorku",
+	"środy",
+	"czwartku",
+	"piątku",
+	"soboty",
+	"niedzieli"
+];
+const nextWeekdays = weekdays.flatMap((weekday, day) => {
+	const feminine = day === 2 || day >= 5;
+	const canonical = `${feminine ? "następna" : "następny"} ${weekday}`;
+	return [{
+		phrase: canonical,
+		day,
+		canonical
+	}, {
+		phrase: `${feminine ? "następnej" : "następnego"} ${textAt(weekdayGenitives, day)}`,
+		day,
+		canonical
+	}];
+});
+const polishCountWords = [
+	[
+		"dwa",
+		"dwie",
+		"dwóch"
+	],
+	["trzy"],
+	["cztery"],
+	["pięć"],
+	["sześć"],
+	["siedem"],
+	["osiem"],
+	["dziewięć"],
+	["dziesięć"],
+	["jedenaście"],
+	["dwanaście"],
+	["trzynaście"],
+	["czternaście"],
+	["piętnaście"],
+	["szesnaście"],
+	["siedemnaście"],
+	["osiemnaście"],
+	["dziewiętnaście"],
+	["dwadzieścia"]
+];
+const polishCountOnes = [
+	[1, "jeden"],
+	[2, "dwa"],
+	[3, "trzy"],
+	[4, "cztery"],
+	[5, "pięć"],
+	[6, "sześć"],
+	[7, "siedem"],
+	[8, "osiem"],
+	[9, "dziewięć"]
+];
+const polishCountAliases = [
+	...sequentialCountAliases([[
+		"jeden",
+		"jedna",
+		"jedno"
+	]], 1),
+	...sequentialCountAliases(polishCountWords, 2),
+	...compoundCountAliases(decimalTens([
+		"dwadzieścia",
+		"trzydzieści",
+		"czterdzieści",
+		"pięćdziesiąt",
+		"sześćdziesiąt",
+		"siedemdziesiąt",
+		"osiemdziesiąt",
+		"dziewięćdziesiąt"
+	]), polishCountOnes, (ten, one) => [`${ten} ${one}`])
+];
+const normalizePolishCounts = compileCountAliasNormalizer(polishCountAliases);
+const polishCountVocabulary = new Set(countAliasVocabulary(polishCountAliases));
+const correctPolish = (input, vocabulary) => correctWhitespaceSeparatedText(input, vocabulary, polishCountVocabulary);
+const normalizePolish = (input, locale) => normalizePolishCounts(normalizeNaturalText(input, locale));
 const monthGenitives = [
 	"stycznia",
 	"lutego",
@@ -86,8 +175,8 @@ const units = [
 		current: "dzisiaj",
 		previous: "wczoraj",
 		next: "jutro",
-		toDate: "dzisiaj do tej pory",
-		remaining: "reszta dnia"
+		toDate: "od początku dnia",
+		remaining: "do końca tego dnia"
 	},
 	{
 		unit: "week",
@@ -97,8 +186,8 @@ const units = [
 		current: "ten tydzień",
 		previous: "poprzedni tydzień",
 		next: "następny tydzień",
-		toDate: "tydzień do dziś",
-		remaining: "reszta tygodnia"
+		toDate: "od początku tygodnia",
+		remaining: "do końca tego tygodnia"
 	},
 	{
 		unit: "month",
@@ -108,8 +197,8 @@ const units = [
 		current: "ten miesiąc",
 		previous: "poprzedni miesiąc",
 		next: "następny miesiąc",
-		toDate: "miesiąc do dziś",
-		remaining: "reszta miesiąca"
+		toDate: "od początku miesiąca",
+		remaining: "do końca tego miesiąca"
 	},
 	{
 		unit: "quarter",
@@ -119,8 +208,8 @@ const units = [
 		current: "ten kwartał",
 		previous: "poprzedni kwartał",
 		next: "następny kwartał",
-		toDate: "kwartał do dziś",
-		remaining: "reszta kwartału"
+		toDate: "od początku kwartału",
+		remaining: "do końca tego kwartału"
 	},
 	{
 		unit: "year",
@@ -130,8 +219,8 @@ const units = [
 		current: "ten rok",
 		previous: "poprzedni rok",
 		next: "następny rok",
-		toDate: "rok do dziś",
-		remaining: "reszta roku"
+		toDate: "od początku roku",
+		remaining: "do końca tego roku"
 	}
 ];
 const title = (value) => `${value.slice(0, 1).toLocaleUpperCase("pl")}${value.slice(1)}`;
@@ -151,6 +240,64 @@ const unitAliases = [
 	["lata", "year"],
 	["lat", "year"]
 ];
+const declinedUnits = [
+	[
+		"week",
+		"tydzień",
+		"tygodnia",
+		"tygodniem",
+		"tygodniu"
+	],
+	[
+		"month",
+		"miesiąc",
+		"miesiąca",
+		"miesiącem",
+		"miesiącu"
+	],
+	[
+		"quarter",
+		"kwartał",
+		"kwartału",
+		"kwartałem",
+		"kwartale"
+	],
+	[
+		"year",
+		"rok",
+		"roku",
+		"rokiem",
+		"roku"
+	]
+];
+const relativeAdjectives = [
+	[
+		0,
+		"ten",
+		"tego",
+		"tym"
+	],
+	[
+		-1,
+		"poprzedni",
+		"poprzedniego",
+		"poprzednim"
+	],
+	[
+		1,
+		"następny",
+		"następnego",
+		"następnym"
+	]
+];
+const declinedPeriods = declinedUnits.flatMap(([unit, nominativeNoun, genitiveNoun, instrumentalNoun, locativeNoun]) => relativeAdjectives.map(([direction, nominative, genitive, oblique]) => [
+	`${nominative} ${nominativeNoun}`,
+	unit,
+	direction,
+	`${genitive} ${genitiveNoun}`,
+	`${oblique} ${instrumentalNoun}`,
+	`${oblique} ${locativeNoun}`
+]));
 const periodAliases = [
 	...units.flatMap((entry) => [
 		[
@@ -220,77 +367,55 @@ const periodAliases = [
 		1,
 		"następny rok"
 	],
+	...declinedPeriods.flatMap(([canonical, unit, direction, genitive, instrumental, locative]) => [
+		[
+			genitive,
+			unit,
+			direction,
+			canonical
+		],
+		[
+			instrumental,
+			unit,
+			direction,
+			canonical
+		],
+		[
+			locative,
+			unit,
+			direction,
+			canonical
+		]
+	]),
 	[
-		"tego tygodnia",
-		"week",
-		0,
-		"ten tydzień"
-	],
-	[
-		"poprzedniego tygodnia",
+		"zeszłym tygodniu",
 		"week",
 		-1,
 		"poprzedni tydzień"
 	],
 	[
-		"następnego tygodnia",
-		"week",
-		1,
-		"następny tydzień"
-	],
-	[
-		"tego miesiąca",
-		"month",
-		0,
-		"ten miesiąc"
-	],
-	[
-		"poprzedniego miesiąca",
+		"zeszłym miesiącu",
 		"month",
 		-1,
 		"poprzedni miesiąc"
 	],
 	[
-		"następnego miesiąca",
-		"month",
-		1,
-		"następny miesiąc"
-	],
-	[
-		"tego kwartału",
-		"quarter",
-		0,
-		"ten kwartał"
-	],
-	[
-		"poprzedniego kwartału",
+		"zeszłym kwartale",
 		"quarter",
 		-1,
 		"poprzedni kwartał"
 	],
 	[
-		"następnego kwartału",
-		"quarter",
-		1,
-		"następny kwartał"
-	],
-	[
-		"tego roku",
-		"year",
-		0,
-		"ten rok"
-	],
-	[
-		"poprzedniego roku",
+		"zeszłym roku",
 		"year",
 		-1,
 		"poprzedni rok"
 	],
 	[
-		"następnego roku",
-		"year",
-		1,
-		"następny rok"
+		"dziś",
+		"day",
+		0,
+		"dzisiaj"
 	],
 	[
 		"przedwczoraj",
@@ -341,21 +466,33 @@ const periodAliases = [
 		"rok po następnym"
 	]
 ];
-const toDatePhrases = units.flatMap((entry) => {
-	const yearAliases = entry.unit === "year" ? [
-		"od początku roku",
-		"od początku roku do dziś",
-		"w tym roku do dziś"
-	] : [];
-	return [entry.toDate, ...yearAliases].map((phrase) => ({
+const legacyToDatePhrases = [
+	"dzisiaj do tej pory",
+	"tydzień do dziś",
+	"miesiąc do dziś",
+	"kwartał do dziś",
+	"rok do dziś"
+];
+const toDatePhrases = units.flatMap((entry, index) => {
+	const aliases = [entry.toDate, textAt(legacyToDatePhrases, index)];
+	if (entry.unit === "year") aliases.push("od początku roku do dziś", "w tym roku do dziś");
+	return aliases.map((phrase) => ({
+		entry,
+		phrase
+	}));
+});
+const remainingPhrases = units.flatMap((entry) => {
+	const implicit = entry.remaining.replace("tego ", "");
+	const legacy = entry.remaining.replace("do końca tego", "reszta");
+	return [
+		entry.remaining,
+		implicit,
+		legacy
+	].map((phrase) => ({
 		entry,
 		phrase
 	}));
 });
-const remainingPhrases = units.map((entry) => ({
-	entry,
-	phrase: entry.remaining
-}));
 const relativeYearDirection = (value) => {
 	if (value.includes("poprzed")) return -1;
 	if (value.includes("następn")) return 1;
@@ -374,23 +511,42 @@ const monthNumber = (value) => {
 	return short === -1 ? void 0 : short + 1;
 };
 const dateLabel = (day, month, year) => `${day}. ${textAt(monthGenitives, month - 1)} ${year}`;
+const currentDateLabel = (day, month) => `${day}. ${textAt(monthGenitives, month - 1)}`;
 const withMonthCase = (value, forms) => {
 	const month = months.findIndex((name) => value.startsWith(title(name)) || value.startsWith(name));
 	if (month === -1) return value;
 	const name = textAt(months, month);
 	return `${textAt(forms, month)}${value.slice(name.length)}`;
 };
+const periodCaseIndexes = {
+	genitive: 3,
+	instrumental: 4,
+	locative: 5
+};
+const monthCases = {
+	genitive: monthGenitives,
+	instrumental: monthInstrumentals,
+	locative: monthLocatives
+};
+const withPeriodCase = (value, grammaticalCase) => {
+	const period = declinedPeriods.find((entry) => entry[0] === value);
+	return period === void 0 ? withMonthCase(value, monthCases[grammaticalCase]) : period[periodCaseIndexes[grammaticalCase]];
+};
 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, 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(/^([0-3]?\d)\.? ([a-ząćęłńóśźż]+\.?)$/u)(input);
+	return Option.isSome(current) ? namedCurrentYearDatePeriod(textAt(current.value, 2), textAt(current.value, 1), monthNumber, currentDateLabel) : Option.none();
 };
 const quarterNumber = (value) => {
 	if (value.startsWith("q") && value.length === 2) return Number(value.slice(1));
@@ -417,12 +573,13 @@ const parseQuarter = (input) => {
 	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 parseDatedPeriod = (input) => {
+	const knownPeriod = Option.firstSomeOf([
+		absoluteDatePeriod(input, "pl"),
+		parseNamedDate(input),
+		parseQuarter(input)
+	]);
+	if (Option.isSome(knownPeriod)) return knownPeriod;
 	const yearMatch = String$1.match(/^(?:rok |roku )?(\d{4})$/u)(input);
 	if (Option.isSome(yearMatch)) {
 		const year = validYear(textAt(yearMatch.value, 1));
@@ -434,6 +591,20 @@ const parseBasePeriod = (input) => {
 		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}`));
 	}
+	return Option.none();
+};
+const parseBasePeriod = (input) => {
+	const datedPeriod = parseDatedPeriod(input);
+	if (Option.isSome(datedPeriod)) return datedPeriod;
+	const prefixedRelativeMonth = String$1.match(/^(poprzedni|ten|następny) ([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 = relativeYearDirection(modifier);
+			return Option.some(monthOfRelativeYear(month, direction, `${modifier} ${textAt(months, month - 1)}`));
+		}
+	}
 	const relativeMonth = String$1.match(/^([a-ząćęłńóśźż]+\.?) (poprzedniego roku|następnego roku|tego roku)$/u)(input);
 	const relativeMonthYearFirst = String$1.match(/^(poprzedniego roku|następnego roku|tego roku) ([a-ząćęłńóśźż]+\.?)$/u)(input);
 	const relativeMatch = Option.firstSomeOf([relativeMonth, relativeMonthYearFirst]);
@@ -454,33 +625,54 @@ const parseBasePeriod = (input) => {
 	if (["następny weekend", "przyszły weekend"].includes(input)) return Option.some(relativeWeekend(1, "następny weekend"));
 	if (input === "weekend przed poprzednim") return Option.some(relativeWeekend(-2, input));
 	if (input === "weekend po następnym") return Option.some(relativeWeekend(2, input));
-	return Option.none();
+	const weekday = nextWeekdays.find((entry) => entry.phrase === input);
+	return weekday === void 0 ? Option.none() : Option.some(relativeWeekday(weekday.day, 1, weekday.canonical));
 };
 const parsePeriod = (input) => {
+	const shifted = String$1.match(/^(.+) (?:([1-9]\d*) (dzień|dni|tydzień|tygodnie|tygodni|miesiąc|miesiące|miesięcy|kwartał|kwartały|kwartałów|rok|lata|lat) (temu)|za ([1-9]\d*) (dzień|dni|tydzień|tygodnie|tygodni|miesiąc|miesiące|miesięcy|kwartał|kwartały|kwartałów|rok|lata|lat))$/u)(input);
+	if (Option.isSome(shifted)) {
+		const past = textAt(shifted.value, 4) === "temu";
+		const amount = parseTrailingCount(textAt(shifted.value, past ? 2 : 5));
+		const alias = unitAliases.find((unit) => unit[0] === textAt(shifted.value, past ? 3 : 6));
+		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 direction = past ? -amount.value : amount.value;
+			const noun = countNoun(amount.value, entry);
+			const canonical = past ? `${period.value.canonical} ${amount.value} ${noun} temu` : `${period.value.canonical} za ${amount.value} ${noun}`;
+			return Option.some(shiftPeriod(period.value, direction, entry.unit, canonical));
+		}
+	}
 	const edge = String$1.match(/^(początek|koniec) (.+)$/u)(input);
 	if (Option.isSome(edge)) {
-		const period = parseBasePeriod(textAt(edge.value, 2));
+		const periodText = textAt(edge.value, 2);
+		const basePeriod = parseBasePeriod(periodText);
+		const implicitUnit = declinedUnits.find((entry) => entry[2] === periodText)?.[0];
+		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 = textAt(edge.value, 1) === "koniec";
-			const canonical = `${isEnd ? "koniec" : "początek"} ${period.value.canonical}`;
+			const canonical = `${isEnd ? "koniec" : "początek"} ${withPeriodCase(period.value.canonical, "genitive")}`;
 			return Option.some(isEnd ? periodEndDay(period.value, canonical) : periodStartDay(period.value, canonical));
 		}
 	}
 	const wrapper = [
 		"w ",
+		"we ",
 		"przez ",
 		"cały ",
 		"całe "
 	].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) => unitAliases.find((entry) => entry[0] === value)?.[1];
 const countedUnitPattern = "dzień|dni|tydzień|tygodnie|tygodni|miesiąc|miesiące|miesięcy|kwartał|kwartały|kwartałów|rok|lata|lat";
 const countedPattern = (source) => new RegExp(source.replace("UNIT", countedUnitPattern), "u");
-const calendarPastPattern = countedPattern("^([1-9]\\d*) (UNIT) temu$");
-const calendarFuturePattern = countedPattern("^za ([1-9]\\d*) (UNIT)$");
-const rollingPastPatterns = [countedPattern("^(?:ostatni|ostatnie|ostatnich|miniony|minione|minionych) ([1-9]\\d*) (UNIT)$")];
-const rollingFuturePatterns = [countedPattern("^(?:następny|następne|następnych|kolejny|kolejne|kolejnych) ([1-9]\\d*) (UNIT)$")];
+const calendarPastPattern = countedPattern("^(?:dokładnie )?(?:([1-9]\\d*) )?(UNIT) temu$");
+const calendarFuturePattern = countedPattern("^za (?:([1-9]\\d*) )?(UNIT)$");
+const rollingPastPatterns = [countedPattern("^(?:ostatni|ostatnie|ostatnich|miniony|minione|minionych) ([1-9]\\d*) (UNIT)$"), countedPattern("^w ciągu (?:ostatniego|ostatnich|minionego|minionych) ([1-9]\\d*) (UNIT)$")];
+const rollingFuturePatterns = [countedPattern("^(?:następny|następne|następnych|kolejny|kolejne|kolejnych) ([1-9]\\d*) (UNIT)$"), countedPattern("^w ciągu (?:najbliższego|najbliższych) ([1-9]\\d*) (UNIT)$")];
 const rollingBarePattern = countedPattern("^([1-9]\\d*) (UNIT)$");
 const firstPatternMatch = (input, patterns) => Option.firstSomeOf(patterns.map((pattern) => String$1.match(pattern)(input)));
 const countNoun = (amount, entry) => {
@@ -494,15 +686,17 @@ const parseCalendarOffset = (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));
+	const amountText = textAt(match.value, 1);
+	const unitText = textAt(match.value, 2);
+	const amount = parseTrailingCount(amountText || "1");
+	const unit = countedUnit(unitText);
 	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 (entry === void 0 || amountText.length === 0 && unitText !== entry.singular) return Option.none();
 	const direction = Option.isSome(past) ? -amount.value : amount.value;
 	const noun = countNoun(amount.value, entry);
 	const canonical = direction < 0 ? `${amount.value} ${noun} temu` : `za ${amount.value} ${noun}`;
-	return Option.some(candidate(periodRange(relativePeriod(unit, direction, canonical)), canonical));
+	return Option.some(relativePeriod(unit, direction, canonical));
 };
 const rollingModifier = (amount, future) => {
 	if (amount === 1) return future ? "następny" : "ostatni";
@@ -531,17 +725,48 @@ const parseRollingPeriod = (input) => {
 	const modifier = rollingModifier(amount.value, isFuture);
 	return Option.some(candidate(range, `${modifier} ${amount.value} ${countNoun(amount.value, entry)}`));
 };
+const boundaries = [
+	[
+		"do początku ",
+		"before",
+		(period) => `przed ${withPeriodCase(period, "instrumental")}`
+	],
+	[
+		"począwszy od ",
+		"since",
+		(period) => `od ${withPeriodCase(period, "genitive")}`
+	],
+	[
+		"od ",
+		"since",
+		(period) => `od ${withPeriodCase(period, "genitive")}`
+	],
+	[
+		"przed ",
+		"before",
+		(period) => `przed ${withPeriodCase(period, "instrumental")}`
+	],
+	[
+		"do ",
+		"through",
+		(period) => `do ${withPeriodCase(period, "genitive")} włącznie`
+	],
+	[
+		"po ",
+		"after",
+		(period) => `po ${withPeriodCase(period, "locative")}`
+	]
+];
 const boundaryCandidate = (input) => {
+	if (input.startsWith("do koniec ")) return Option.none();
 	const included = String$1.match(/^do (.+) włącznie$/u)(input);
-	if (Option.isSome(included)) return openBoundaryCandidate(`do ${textAt(included.value, 1)}`, [["do ", "through"]], parsePeriod);
-	return openBoundaryCandidate(input, [
-		["do początku ", "before"],
-		["począwszy od ", "since"],
-		["od ", "since"],
-		["przed ", "before"],
-		["do ", "through"],
-		["po ", "after"]
-	], parsePeriod);
+	if (Option.isSome(included)) return parsePeriod(textAt(included.value, 1)).pipe(Option.map((value) => periodBoundaryCandidate(value, "through", `do ${withPeriodCase(value.canonical, "genitive")} włącznie`)));
+	for (const [prefix, boundary, canonical] of boundaries) {
+		if (!input.startsWith(prefix)) continue;
+		const period = parsePeriod(input.slice(prefix.length));
+		if (Option.isSome(period)) return Option.some(periodBoundaryCandidate(period.value, boundary, canonical(period.value.canonical)));
+	}
+	return Option.none();
 };
 const parsePolish = (input) => {
 	const remaining = remainingPhrases.find((entry) => entry.phrase === input);
@@ -552,17 +777,36 @@ const parsePolish = (input) => {
 		"do teraz"
 	].includes(input)) return Option.some(candidate(untilNowRange(), "do dziś"));
 	if (["od teraz", "od dziś"].includes(input)) return Option.some(candidate(fromNowRange(), "od teraz"));
-	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 nowBounded = joinedNowCandidate(input, [["od ", " do dziś"], ["między ", " a dziś"]], ["od dziś do ", "między dziś a "], parsePeriod, (period) => `od ${period} do dziś`, (period) => `od dziś do ${period}`);
+	const elidedDayRange = String$1.match(/^(?:(?:między|pomiędzy) ([0-3]?\d)\.? a |([0-3]?\d)\.?[–—])([0-3]?\d)\.? ([a-ząćęłńóśźż]+\.?)(?: (\d{4}))?$/u)(input);
+	if (Option.isSome(elidedDayRange)) {
+		const lowerDay = textAt(elidedDayRange.value, 1) || textAt(elidedDayRange.value, 2);
+		const upperDay = textAt(elidedDayRange.value, 3);
+		const month = textAt(elidedDayRange.value, 4);
+		const year = textAt(elidedDayRange.value, 5);
+		const suffix = year.length === 0 ? "" : ` ${year}`;
+		const expanded = `między ${lowerDay} ${month}${suffix} a ${upperDay} ${month}${suffix}`;
+		const joined = joinedPeriodCandidate(expanded, [["między ", " a "], ["pomiędzy ", " a "]], parsePeriod, (lower, upper) => `od ${lower} do ${upper} włącznie`);
+		if (Option.isSome(joined)) return joined;
+	}
+	const nowBounded = joinedNowCandidate(input, [
+		["od ", " do dziś"],
+		["między ", " a dziś"],
+		["pomiędzy ", " a dziś"]
+	], [
+		"od dziś do ",
+		"między dziś a ",
+		"pomiędzy dziś a ",
+		"teraz do "
+	], parsePeriod, (period) => `od ${period} do dziś`, (period) => `od dziś do ${period}`);
 	if (Option.isSome(nowBounded)) return nowBounded;
 	const bounded = joinedPeriodCandidate(input, [
 		["od ", " do "],
 		["między ", " a "],
+		["pomiędzy ", " a "],
 		["", " - "],
 		["", " – "],
 		["", " — "]
@@ -570,16 +814,33 @@ const parsePolish = (input) => {
 	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 edgePhrases = [...declinedPeriods.map((entry) => entry[3]), ...monthGenitives].flatMap((phrase) => [`początek ${phrase}`, `koniec ${phrase}`]);
+const canonicalPeriodPhrases = [
+	...units.flatMap((entry) => [
+		entry.current,
+		entry.previous,
+		entry.next
+	]),
+	"przedwczoraj",
+	"pojutrze",
+	"przedostatni tydzień",
+	"tydzień po następnym",
+	"przedostatni miesiąc",
+	"miesiąc po następnym",
+	"przedostatni rok",
+	"rok po następnym",
 	"ten weekend",
 	"poprzedni weekend",
 	"następny weekend",
 	"weekend przed poprzednim",
-	"weekend po następnym",
-	...periodAliases.flatMap((entry) => [`początek ${entry[0]}`, `koniec ${entry[0]}`]),
+	"weekend po następnym"
+];
+const staticPeriodPhrases = [
+	...periodAliases.map((entry) => entry[0]),
+	...canonicalPeriodPhrases,
+	...edgePhrases,
 	...[
 		1,
 		2,
@@ -593,18 +854,32 @@ const staticPeriodPhrases = [
 	]),
 	...months.flatMap((month) => [
 		month,
+		`poprzedni ${month}`,
+		`następny ${month}`,
 		`${month} poprzedniego roku`,
 		`${month} następnego roku`
-	])
+	]),
+	...nextWeekdays.map((entry) => entry.phrase)
 ];
 const staticPeriods = periodsFromPhrases(staticPeriodPhrases, parsePeriod);
-const boundaryPrefixes = [
-	"od ",
-	"począwszy od ",
-	"przed ",
-	"do ",
-	"po "
-];
+const monthBoundaryPhrases = months.flatMap((_, index) => {
+	const genitive = textAt(monthGenitives, index);
+	const instrumental = textAt(monthInstrumentals, index);
+	const locative = textAt(monthLocatives, index);
+	return [
+		`od ${genitive}`,
+		`począwszy od ${genitive}`,
+		`przed ${instrumental}`,
+		`do ${genitive} włącznie`,
+		`po ${locative}`
+	];
+});
+const fixedBoundaryPhrases = (phrases) => phrases.flatMap((phrase) => [
+	`od ${withMonthCase(phrase, monthGenitives)}`,
+	`przed ${withMonthCase(phrase, monthInstrumentals)}`,
+	`do ${withMonthCase(phrase, monthGenitives)} włącznie`,
+	`po ${withMonthCase(phrase, monthLocatives)}`
+]);
 const countedSuggestions = (input) => {
 	const amount = naturalCount(input);
 	if (amount === void 0) return [];
@@ -620,23 +895,47 @@ const countedSuggestions = (input) => {
 	});
 };
 const polishSuggestionPhrases = [
-	...units.map((entry) => entry.toDate),
-	...units.map((entry) => entry.remaining),
-	...staticPeriodPhrases,
-	...prefixNaturalPhrases(staticPeriodPhrases, boundaryPrefixes),
+	...toDatePhrases.map((entry) => entry.phrase),
+	...remainingPhrases.map((entry) => entry.phrase),
+	...canonicalPeriodPhrases,
+	...edgePhrases,
+	...[
+		1,
+		2,
+		3,
+		4
+	].flatMap((quarter) => [
+		`q${quarter}`,
+		`q${quarter} tego roku`,
+		`q${quarter} poprzedniego roku`,
+		`q${quarter} następnego roku`
+	]),
+	...months,
+	...monthBoundaryPhrases,
 	"do dziś",
 	"od teraz"
 ];
 const suggestPolish = (input, limit) => {
-	const fixed = fixedCalendarPeriodPhrases(input, months);
-	return completeNaturalPhrases(input, [
+	const correctedInput = input.startsWith("do koniec") ? `do końca${input.slice(9)}` : input;
+	const fixed = fixedCalendarPeriodPhrases(correctedInput, months);
+	return completeNaturalPhrases(correctedInput, [
 		...polishSuggestionPhrases,
 		...fixed,
-		...prefixNaturalPhrases(fixed, boundaryPrefixes),
-		...countedSuggestions(input)
+		...fixedBoundaryPhrases(fixed),
+		...countedSuggestions(correctedInput)
 	], limit);
 };
 const renderPolish = (range) => {
+	const shifted = decomposeShiftedPeriodRange(range);
+	if (Option.isSome(shifted)) {
+		const base = renderPolish(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 = countNoun(amount, entry);
+			return Option.some(shifted.value.amount < 0 ? `${base.value} ${amount} ${noun} temu` : `${base.value} za ${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);
@@ -656,13 +955,19 @@ const renderPolish = (range) => {
 		const entry = units.find((unit) => unit.unit === trailing.value.unit);
 		if (entry !== void 0) return Option.some(`${rollingModifier(trailing.value.amount, false)} ${trailing.value.amount} ${countNoun(trailing.value.amount, entry)}`);
 	}
-	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) => `od ${withMonthCase(period, monthGenitives)}`, (period) => `przed ${withMonthCase(period, monthInstrumentals)}`, (period) => `do ${withMonthCase(period, monthGenitives)} włącznie`, (period) => `po ${withMonthCase(period, monthLocatives)}`, (lower, upper) => `od ${withMonthCase(lower, monthGenitives)} do ${withMonthCase(upper, monthGenitives)} włącznie`, (period) => `od ${withMonthCase(period, monthGenitives)} do dziś`, (period) => `od dziś do ${withMonthCase(period, monthGenitives)}`, () => "do dziś", () => "od teraz");
+	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) => `od ${withPeriodCase(period, "genitive")}`, (period) => `przed ${withPeriodCase(period, "instrumental")}`, (period) => `do ${withPeriodCase(period, "genitive")} włącznie`, (period) => `po ${withPeriodCase(period, "locative")}`, (lower, upper) => `od ${withPeriodCase(lower, "genitive")} do ${withPeriodCase(upper, "genitive")} włącznie`, (period) => `od ${withPeriodCase(period, "genitive")} do dziś`, (period) => `od dziś do ${withPeriodCase(period, "genitive")}`, () => "do dziś", () => "od teraz");
 };
 const PolishContribution = new BaseLanguageContribution({
 	locale: "pl",
 	vocabulary: [
 		...months,
+		...weekdays,
+		...weekdayGenitives,
 		...monthGenitives,
 		...monthInstrumentals,
 		...monthLocatives,
@@ -677,27 +982,34 @@ const PolishContribution = new BaseLanguageContribution({
 		]),
 		...toDatePhrases.flatMap((entry) => entry.phrase.split(" ")),
 		...remainingPhrases.flatMap((entry) => entry.phrase.split(" ")),
+		...periodAliases.flatMap((entry) => entry[0].split(" ")),
+		"ciągu",
+		"dokładnie",
 		"dziś",
 		"dotychczas",
 		"koniec",
+		"końca",
 		"kolejne",
 		"między",
 		"minione",
+		"najbliższych",
 		"następne",
 		"od",
 		"ostatnie",
 		"po",
 		"początek",
 		"począwszy",
+		"pomiędzy",
 		"poprzedni",
 		"przed",
 		"teraz",
 		"temu",
 		"włącznie",
+		"we",
 		"za"
 	],
-	normalize: normalizeNaturalText,
-	correct: correctWhitespaceSeparatedText,
+	normalize: normalizePolish,
+	correct: correctPolish,
 	parseExact: parsePolish,
 	suggest: suggestPolish,
 	render: renderPolish