chronolizer 0.2.0 → 0.4.0

package/dist/locales/tr.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, 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 { Effect, Option, String as String$1 } from "effect";
 //#region src/locales/tr.ts
 const months = [
@@ -21,6 +21,61 @@ const months = [
 	"kasım",
 	"aralık"
 ];
+const weekdays = [
+	"pazartesi",
+	"salı",
+	"çarşamba",
+	"perşembe",
+	"cuma",
+	"cumartesi",
+	"pazar"
+];
+const nextWeekdayPhrases = weekdays.map((weekday) => `gelecek ${weekday}`);
+const turkishCountWords = [
+	["iki"],
+	["üç", "uc"],
+	["dört", "dort"],
+	["beş", "bes"],
+	["altı", "alti"],
+	["yedi"],
+	["sekiz"],
+	["dokuz"],
+	["on"],
+	["on bir"],
+	["on iki"],
+	["on üç"],
+	["on dört"],
+	["on beş"],
+	["on altı"],
+	["on yedi"],
+	["on sekiz"],
+	["on dokuz"],
+	["yirmi"]
+];
+const turkishCountOnes = [
+	[1, "bir"],
+	[2, "iki"],
+	[3, "üç"],
+	[4, "dört"],
+	[5, "beş"],
+	[6, "altı"],
+	[7, "yedi"],
+	[8, "sekiz"],
+	[9, "dokuz"]
+];
+const turkishCountAliases = [...sequentialCountAliases(turkishCountWords, 2), ...compoundCountAliases(decimalTens([
+	"yirmi",
+	"otuz",
+	"kırk",
+	"elli",
+	"altmış",
+	"yetmiş",
+	"seksen",
+	"doksan"
+]), turkishCountOnes, (ten, one) => [`${ten} ${one}`])];
+const normalizeTurkishCounts = compileCountAliasNormalizer(turkishCountAliases);
+const turkishCountVocabulary = new Set(countAliasVocabulary(turkishCountAliases));
+const correctTurkish = (input, vocabulary) => correctWhitespaceSeparatedText(input, vocabulary, turkishCountVocabulary);
 const monthAbbreviations = [
 	["oca"],
 	["şub", "sub"],
@@ -298,17 +353,22 @@ const monthNumber = (value) => {
 	return short === -1 ? void 0 : short + 1;
 };
 const dateLabel = (day, month, year) => `${day} ${textAt(months, month - 1)} ${year}`;
+const currentDateLabel = (day, month) => `${day} ${textAt(months, month - 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, 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.startsWith("ç")) && value.length === 2) return Number(value.slice(1));
@@ -335,12 +395,13 @@ const parseQuarter = (input) => {
 	const quarter = quarterNumber(textAt(standalone.value, 1));
 	return quarter === void 0 ? Option.none() : Option.some(quarterOfRelativeYear(quarter, 0, `Ç${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, "tr"),
+		parseNamedDate(input),
+		parseQuarter(input)
+	]);
+	if (Option.isSome(knownPeriod)) return knownPeriod;
 	const yearMatch = String$1.match(/^(?:yıl |yılı )?(\d{4})$/u)(input);
 	if (Option.isSome(yearMatch)) {
 		const year = validYear(textAt(yearMatch.value, 1));
@@ -352,6 +413,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(/^(geçen|bu|gelecek) ([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} ${title(textAt(months, month - 1))}`));
+		}
+	}
 	const relativeMonth = String$1.match(/^([a-zçğıöşü]+\.?) (geçen yıl|gelecek yıl|bu yıl)$/u)(input);
 	const relativeMonthYearFirst = String$1.match(/^(geçen yıl|gelecek yıl|bu yıl) ([a-zçğıöşü]+\.?)$/u)(input);
 	const relativeMatch = Option.firstSomeOf([relativeMonth, relativeMonthYearFirst]);
@@ -372,16 +447,38 @@ const parseBasePeriod = (input) => {
 	if (["gelecek hafta sonu", "önümüzdeki hafta sonu"].includes(input)) return Option.some(relativeWeekend(1, "gelecek hafta sonu"));
 	if (input === "geçen hafta sonundan önceki hafta sonu") return Option.some(relativeWeekend(-2, input));
 	if (input === "gelecek hafta sonundan sonraki hafta sonu") 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 parsePeriodEdge = (input) => {
 	const edge = String$1.match(/^(.+?)(?:ın|in|un|ün) (başı|başlangıcı|sonu)$/u)(input);
-	if (Option.isSome(edge)) {
-		const period = parseBasePeriod(textAt(edge.value, 1));
-		if (Option.isSome(period)) {
-			const isEnd = textAt(edge.value, 2) === "sonu";
-			const canonical = `${period.value.canonical} ${isEnd ? "sonu" : "başı"}`;
-			return Option.some(isEnd ? periodEndDay(period.value, canonical) : periodStartDay(period.value, canonical));
+	if (Option.isNone(edge)) return Option.none();
+	const periodText = textAt(edge.value, 1);
+	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.isNone(period)) return Option.none();
+	const isEnd = textAt(edge.value, 2) === "sonu";
+	const canonical = `${period.value.canonical} ${isEnd ? "sonu" : "başı"}`;
+	return Option.some(isEnd ? periodEndDay(period.value, canonical) : periodStartDay(period.value, canonical));
+};
+const parsePeriod = (input) => {
+	const prefix = String$1.match(/^([1-9]\d*) (gün|gun|hafta|ay|çeyrek|ceyrek|yıl|yil|sene) (önce|sonra) (.+)$/u)(input);
+	const suffix = String$1.match(/^(.+) ([1-9]\d*) (gün|gun|hafta|ay|çeyrek|ceyrek|yıl|yil|sene) (önce|sonra)$/u)(input);
+	const shifted = Option.firstSomeOf([prefix, suffix]);
+	if (Option.isSome(shifted)) {
+		const prefixOrder = Option.isSome(prefix);
+		const amount = parseTrailingCount(textAt(shifted.value, prefixOrder ? 1 : 2));
+		const alias = unitAliases.find((unit) => unit[0] === textAt(shifted.value, prefixOrder ? 2 : 3));
+		const entry = alias === void 0 ? void 0 : units.find((unit) => unit.unit === alias[1]);
+		const period = parsePeriod(textAt(shifted.value, prefixOrder ? 4 : 1));
+		if (Option.isSome(amount) && entry !== void 0 && Option.isSome(period)) {
+			const past = textAt(shifted.value, prefixOrder ? 3 : 4) === "önce";
+			const direction = past ? -amount.value : amount.value;
+			const noun = amount.value === 1 ? entry.singular : entry.plural;
+			const canonical = `${amount.value} ${noun} ${past ? "önce" : "sonra"} ${period.value.canonical}`;
+			return Option.some(shiftPeriod(period.value, direction, entry.unit, canonical));
 		}
 	}
 	const wrapper = [
@@ -389,7 +486,11 @@ const parsePeriod = (input) => {
 		"içinde ",
 		"tüm "
 	].find((prefix) => input.startsWith(prefix));
-	return parseBasePeriod(wrapper === void 0 ? input : input.slice(wrapper.length));
+	return Option.firstSomeOf([
+		parsePeriodEdge(input),
+		parseBasePeriod(wrapper === void 0 ? input : input.slice(wrapper.length)),
+		parseCalendarOffset(input)
+	]);
 };
 const countedUnit = (value) => unitAliases.find((entry) => entry[0] === value)?.[1];
 const countedUnitPattern = "gün|gun|hafta|ay|çeyrek|ceyrek|yıl|yil|sene";
@@ -401,7 +502,46 @@ const rollingFuturePatterns = [countedPattern("^(?:gelecek|önümüzdeki|sonraki
 const rollingSincePattern = countedPattern("^([1-9]\\d*) (UNIT) boyunca$");
 const rollingBarePattern = countedPattern("^([1-9]\\d*) (UNIT)$");
 const firstPatternMatch = (input, patterns) => Option.firstSomeOf(patterns.map((pattern) => String$1.match(pattern)(input)));
+const singularRollingCanonical = (entry, future) => future ? `önümüzdeki bir ${entry.singular}` : `son bir ${entry.singular}`;
+const singularRollingPhrases = units.flatMap((entry) => [
+	{
+		phrase: `son bir ${entry.singular}`,
+		entry,
+		future: false
+	},
+	{
+		phrase: `bir ${entry.singular} boyunca`,
+		entry,
+		future: false
+	},
+	{
+		phrase: `geçtiğimiz bir ${entry.singular}`,
+		entry,
+		future: false
+	},
+	{
+		phrase: `önümüzdeki bir ${entry.singular}`,
+		entry,
+		future: true
+	},
+	{
+		phrase: `bugünden itibaren bir ${entry.singular} boyunca`,
+		entry,
+		future: true
+	}
+]);
+const singularCalendarOffsets = units.flatMap((entry) => [{
+	phrase: `bir ${entry.singular} önce`,
+	entry,
+	direction: -1
+}, {
+	phrase: `bir ${entry.singular} sonra`,
+	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 = firstPatternMatch(input, calendarFuturePatterns);
 	const match = Option.firstSomeOf([past, future]);
@@ -414,9 +554,14 @@ const parseCalendarOffset = (input) => {
 	const direction = Option.isSome(past) ? -amount.value : amount.value;
 	const noun = amount.value === 1 ? entry.singular : entry.plural;
 	const canonical = direction < 0 ? `${amount.value} ${noun} önce` : `${amount.value} ${noun} sonra`;
-	return Option.some(candidate(periodRange(relativePeriod(unit, direction, canonical)), canonical));
+	return Option.some(relativePeriod(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);
@@ -435,9 +580,22 @@ const parseRollingPeriod = (input) => {
 	if (entry === void 0) return Option.none();
 	const isFuture = Option.isSome(future);
 	const range = isFuture ? futureRange(amount.value, unit) : trailingRange(amount.value, unit);
+	if (amount.value === 1) return Option.some(candidate(range, singularRollingCanonical(entry, isFuture)));
 	const modifier = isFuture ? "gelecek" : "son";
-	const noun = amount.value === 1 ? entry.singular : entry.plural;
-	return Option.some(candidate(range, `${modifier} ${amount.value} ${noun}`));
+	return Option.some(candidate(range, `${modifier} ${amount.value} ${entry.plural}`));
+};
+const parseElidedDateRange = (input) => {
+	const full = String$1.match(/^([0-3]?\d)(?:\.)? ([a-zçğıöşü]+\.?)'?(?:den|dan|ten|tan) ([0-3]?\d)(?:\.)? ([a-zçğıöşü]+\.?)'?(?:e|a|ye|ya) kadar$/u)(input);
+	if (Option.isSome(full)) return joinedPeriodCandidate(`${textAt(full.value, 1)} ${textAt(full.value, 2)} ile ${textAt(full.value, 3)} ${textAt(full.value, 4)}`, [["", " ile "]], parsePeriod, (lower, upper) => `${lower} ile ${upper} arası`);
+	const elided = String$1.match(/^([0-3]?\d)(?:\.)? ([a-zçğıöşü]+\.?)'?(?:den|dan|ten|tan) ([0-3]?\d)'?(?:sine|sına|üne|una|ine|ına) kadar$/u)(input);
+	const dashed = String$1.match(/^([0-3]?\d)[–—-]([0-3]?\d) ([a-zçğıöşü]+\.?)$/u)(input);
+	const match = Option.firstSomeOf([elided, dashed]);
+	if (Option.isNone(match)) return Option.none();
+	const isElided = Option.isSome(elided);
+	const lowerDay = textAt(match.value, 1);
+	const upperDay = textAt(match.value, isElided ? 3 : 2);
+	const month = textAt(match.value, isElided ? 2 : 3);
+	return joinedPeriodCandidate(`${lowerDay} ${month} ile ${upperDay} ${month}`, [["", " ile "]], parsePeriod, (lower, upper) => `${lower} ile ${upper} arası`);
 };
 const suffixBoundary = (input) => {
 	const boundaries = [
@@ -480,14 +638,19 @@ const parseTurkish = (input) => {
 		"şu andan itibaren",
 		"bundan sonra"
 	].includes(input)) return Option.some(candidate(fromNowRange(), "bugünden itibaren"));
-	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 joinedInput = input.endsWith(" arası") ? input.slice(0, -6) : input;
-	const nowBounded = joinedNowCandidate(joinedInput, [["", " ile bugün"], ["", " ve bugün"]], ["bugün ile ", "bugün ve "], parsePeriod, (period) => `${period} ile bugün arası`, (period) => `bugün ile ${period} arası`);
+	const nowBounded = joinedNowCandidate(joinedInput, [["", " ile bugün"], ["", " ve bugün"]], [
+		"bugün ile ",
+		"bugün ve ",
+		"şimdi ile ",
+		"şimdi ve "
+	], parsePeriod, (period) => `${period} ile bugün arası`, (period) => `bugün ile ${period} arası`);
 	if (Option.isSome(nowBounded)) return nowBounded;
 	const bounded = joinedPeriodCandidate(joinedInput, [
 		["", " ile "],
@@ -499,7 +662,7 @@ const parseTurkish = (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]),
@@ -526,6 +689,8 @@ const staticPeriodPhrases = [
 	"geçen yılın sonu",
 	"gelecek yılın başı",
 	"gelecek yılın sonu",
+	...nextWeekdayPhrases,
+	...months.flatMap((month) => [`geçen ${month}`, `gelecek ${month}`]),
 	...[
 		1,
 		2,
@@ -569,6 +734,8 @@ const countedSuggestions = (input) => {
 const turkishSuggestionPhrases = [
 	...units.map((entry) => entry.toDate),
 	...units.map((entry) => entry.remaining),
+	...singularRollingPhrases.map((entry) => entry.phrase),
+	...singularCalendarOffsets.map((entry) => entry.phrase),
 	...staticPeriodPhrases,
 	...prefixNaturalPhrases(staticPeriodPhrases, boundaryPrefixes),
 	"şimdiye kadar",
@@ -584,6 +751,17 @@ const suggestTurkish = (input, limit) => {
 	], limit);
 };
 const renderTurkish = (range) => {
+	const shifted = decomposeShiftedPeriodRange(range);
+	if (Option.isSome(shifted)) {
+		const base = renderTurkish(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 ? "önce" : "sonra";
+			return Option.some(`${amount} ${noun} ${direction} ${base.value}`);
+		}
+	}
 	const offset = calendarPeriodOffset(range);
 	if (Option.isSome(offset) && Math.abs(offset.value.amount) > 1) {
 		const entry = units.find((unit) => unit.unit === offset.value.unit);
@@ -596,27 +774,26 @@ const renderTurkish = (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(`gelecek ${future.value.amount} ${noun}`);
-		}
+		if (entry !== void 0) return Option.some(future.value.amount === 1 ? singularRollingCanonical(entry, true) : `gelecek ${future.value.amount} ${entry.plural}`);
 	}
 	const trailing = trailingPeriod(range);
 	if (Option.isSome(trailing)) {
 		const entry = units.find((unit) => unit.unit === trailing.value.unit);
-		if (entry !== void 0) {
-			const noun = trailing.value.amount === 1 ? entry.singular : entry.plural;
-			return Option.some(`son ${trailing.value.amount} ${noun}`);
-		}
+		if (entry !== void 0) return Option.some(trailing.value.amount === 1 ? singularRollingCanonical(entry, false) : `son ${trailing.value.amount} ${entry.plural}`);
 	}
-	const periods = [...staticPeriods, ...periodsFromPhrases([...datedPeriods(range, months), ...datedQuarterPeriods(range).map((phrase) => phrase.startsWith("Q") ? `Ç${phrase.slice(1)}` : phrase)], parsePeriod)];
+	const periods = [
+		...staticPeriods,
+		...currentYearDatePeriods(range, currentDateLabel),
+		...periodsFromPhrases([...datedPeriods(range, months), ...datedQuarterPeriods(range).map((phrase) => phrase.startsWith("Q") ? `Ç${phrase.slice(1)}` : phrase)], parsePeriod)
+	];
 	return renderPeriodRange(range, [...units.map((entry) => candidate(periodToDateRange(entry.unit), entry.toDate)), ...units.map((entry) => candidate(remainingPeriodRange(entry.unit), entry.remaining))], periods, (period) => `${period} itibarıyla`, (period) => `${period} öncesi`, (period) => `${period} sonuna kadar`, (period) => `${period} sonrası`, (lower, upper) => `${lower} ile ${upper} arası`, (period) => `${period} ile bugün arası`, (period) => `bugün ile ${period} arası`, () => "şimdiye kadar", () => "bugünden itibaren");
 };
-const normalizeTurkish = (input, locale) => normalizeNaturalText(input, locale).replaceAll("’", "'");
+const normalizeTurkish = (input, locale) => normalizeTurkishCounts(normalizeNaturalText(input, locale).replaceAll("’", "'"));
 const TurkishContribution = new BaseLanguageContribution({
 	locale: "tr",
 	vocabulary: [
 		...months,
+		...weekdays,
 		...monthAbbreviations.flatMap((aliases) => aliases),
 		...units.flatMap((entry) => [
 			entry.singular,
@@ -633,6 +810,7 @@ const TurkishContribution = new BaseLanguageContribution({
 		"gelecek",
 		"geçen",
 		"geri",
+		"ile",
 		"itibaren",
 		"itibarıyla",
 		"kadar",
@@ -643,10 +821,11 @@ const TurkishContribution = new BaseLanguageContribution({
 		"son",
 		"sonra",
 		"sonrası",
+		"şimdi",
 		"şimdiye"
 	],
 	normalize: normalizeTurkish,
-	correct: correctWhitespaceSeparatedText,
+	correct: correctTurkish,
 	parseExact: parseTurkish,
 	suggest: suggestTurkish,
 	render: renderTurkish

package/dist/natural/correction.d.mts

@@ -1,5 +1,5 @@
 //#region src/natural/correction.d.ts
-declare const correctWhitespaceSeparatedText: (input: string, vocabulary: ReadonlyArray<string>) => {
+declare const correctWhitespaceSeparatedText: (input: string, vocabulary: ReadonlyArray<string>, segmentationVocabulary?: ReadonlySet<string>) => {
   readonly text: string;
   readonly corrections: readonly {
     readonly original: string;

package/dist/natural/correction.mjs

@@ -20,22 +20,48 @@ const damerauLevenshteinDistance = (left, right) => {
 	}
 	return previous[right.length] ?? fallback;
 };
-const replacementsFor = (word, vocabulary) => {
+const segmentedReplacements = (word, vocabulary) => {
+	const segmentations = Array.from({ length: word.length + 1 }, () => []);
+	const initial = segmentations[0];
+	if (initial !== void 0) initial.push([]);
+	for (let start = 0; start < word.length; start += 1) {
+		const prefixes = segmentations[start] ?? [];
+		if (prefixes.length === 0) continue;
+		for (let end = start + 1; end <= word.length; end += 1) {
+			const part = word.slice(start, end);
+			if (!vocabulary.has(part)) continue;
+			const target = segmentations[end];
+			if (target === void 0) continue;
+			for (const prefix of prefixes) {
+				if (target.length >= 4) break;
+				target.push([...prefix, part]);
+			}
+		}
+	}
+	return (segmentations[word.length] ?? []).filter((parts) => parts.length > 1).map((parts) => ({
+		word: parts.join(" "),
+		distance: parts.length - 1
+	}));
+};
+const replacementsFor = (word, vocabulary, segmentationVocabulary) => {
 	if (vocabulary.includes(word) || isProtectedValue(word)) return [{
 		word,
 		distance: 0
 	}];
-	if (word.length <= 3) return [];
+	const segmented = segmentedReplacements(word, segmentationVocabulary);
+	if (word.length <= 3) return segmented;
 	const maximum = word.length >= 6 ? 2 : 1;
-	const matches = vocabulary.filter((candidate) => Math.abs(candidate.length - word.length) <= maximum).map((candidate) => ({
+	const fuzzy = vocabulary.filter((candidate) => Math.abs(candidate.length - word.length) <= maximum).map((candidate) => ({
 		word: candidate,
 		distance: damerauLevenshteinDistance(word, candidate)
 	})).filter((candidate) => candidate.distance <= maximum);
+	const matches = [...segmented, ...fuzzy];
 	if (matches.length === 0) return [];
 	const minimum = Math.min(...matches.map((candidate) => candidate.distance));
 	return matches.filter((candidate) => candidate.distance === minimum).slice(0, 4);
 };
-const correctWhitespaceSeparatedText = (input, vocabulary) => {
+const emptySegmentationVocabulary = /* @__PURE__ */ new Set();
+const correctWhitespaceSeparatedText = (input, vocabulary, segmentationVocabulary = emptySegmentationVocabulary) => {
 	const words = naturalWords(input);
 	let partials = [{
 		words: [],
@@ -44,7 +70,7 @@ const correctWhitespaceSeparatedText = (input, vocabulary) => {
 		offset: 0
 	}];
 	for (const word of words) {
-		const replacements = replacementsFor(word, vocabulary);
+		const replacements = replacementsFor(word, vocabulary, segmentationVocabulary);
 		if (replacements.length === 0) return [];
 		const next = [];
 		for (const partial of partials) for (const replacement of replacements) {

package/dist/natural/format.mjs

@@ -7,7 +7,7 @@ const formatNatural = Effect.fn("chronolizer.formatNatural")(function* (range, o
 	if (Option.isSome(rendered)) return rendered.value;
 	return yield* new NaturalLanguageRenderError({
 		locale: options.locale,
-		message: "The range has no canonical natural-language form in this locale"
+		message: "The range has no standard natural-language form for this language"
 	});
 });
 //#endregion

package/dist/natural/parse.d.mts

@@ -55,7 +55,6 @@ declare const parseNatural: (input: string, options: ParseNaturalOptions) => Eff
     readonly offset: number;
   }[];
   readonly alternatives: readonly {
-    readonly canonical: string;
     readonly range: {
       readonly _tag: "DateRange";
       readonly lower: {
@@ -93,6 +92,7 @@ declare const parseNatural: (input: string, options: ParseNaturalOptions) => Eff
         readonly value: InstantExpr;
       };
     };
+    readonly canonical: string;
   }[];
 }, NaturalLanguageParseError | UnsupportedLocaleError, LanguageRegistry>;
 //#endregion

package/dist/natural/parse.mjs

@@ -31,13 +31,13 @@ const parseNatural = Effect.fn("chronolizer.parseNatural")(function* (input, opt
 	if (normalized.length === 0) return yield* new NaturalLanguageParseError({
 		input,
 		locale: options.locale,
-		message: "The complete input must contain a date-range expression"
+		message: "The complete input must contain a date range"
 	});
 	const exact = language.parseExact(normalized);
 	const allowedExact = applyFuturePolicy(exact, options.allowFuture);
 	if (Array.isReadonlyArrayNonEmpty(allowedExact)) return resultFromCandidates(allowedExact, []);
 	if (options.typoMode !== "tolerant") {
-		const message = exact.length > 0 && options.allowFuture === false ? "The expression contains a positive relative shift, but future ranges are disabled" : "The complete input is not a supported date-range expression";
+		const message = exact.length > 0 && options.allowFuture === false ? "This date range is in the future, but future ranges are disabled" : "The complete input is not a supported date range";
 		return yield* new NaturalLanguageParseError({
 			input,
 			locale: options.locale,
@@ -46,7 +46,8 @@ const parseNatural = Effect.fn("chronolizer.parseNatural")(function* (input, opt
 	}
 	const corrected = language.correct?.(normalized, language.vocabulary) ?? [];
 	const parsedCorrections = Array.filterMap(corrected, (correction) => {
-		const candidates = applyFuturePolicy(language.parseExact(correction.text), options.allowFuture);
+		const correctedText = language.normalize(correction.text, language.locale);
+		const candidates = applyFuturePolicy(language.parseExact(correctedText), options.allowFuture);
 		return Array.isReadonlyArrayNonEmpty(candidates) ? Result.succeed({
 			correction,
 			candidates
@@ -56,7 +57,7 @@ const parseNatural = Effect.fn("chronolizer.parseNatural")(function* (input, opt
 	if (!Array.isReadonlyArrayNonEmpty(successful)) return yield* new NaturalLanguageParseError({
 		input,
 		locale: options.locale,
-		message: "No conservative typo correction produced a complete expression"
+		message: "No supported date range was found after spelling correction"
 	});
 	const first = Array.headNonEmpty(successful);
 	const best = Array.prepend(Array.takeWhile(Array.tailNonEmpty(successful), (entry) => entry.correction.cost === first.correction.cost), first);

package/dist/natural/policy.mjs

@@ -1,6 +1,6 @@
-import { containsPositiveShift } from "../ast/fold.mjs";
+import { containsPositiveShift, isCurrentPeriod } from "../ast/fold.mjs";
 import { Array } from "effect";
 //#region src/natural/policy.ts
-const applyFuturePolicy = (candidates, allowFuture) => allowFuture === false ? Array.filter(candidates, (candidate) => !containsPositiveShift(candidate.range)) : candidates;
+const applyFuturePolicy = (candidates, allowFuture) => allowFuture === false ? Array.filter(candidates, (candidate) => isCurrentPeriod(candidate.range) || !containsPositiveShift(candidate.range)) : candidates;
 //#endregion
 export { applyFuturePolicy };

package/dist/natural/suggest.mjs

@@ -1,24 +1,40 @@
 import { rangeKey } from "../filter/codec.mjs";
 import { NaturalSuggestion } from "../language/model.mjs";
+import { naturalWords } from "./text.mjs";
 import { LanguageRegistry } from "../language/registry.mjs";
 import { applyFuturePolicy } from "./policy.mjs";
-import { Array, Effect } from "effect";
+import { Array as Array$1, Effect } from "effect";
 //#region src/natural/suggest.ts
 const suggestionLimit = (limit) => {
 	if (limit === void 0) return 10;
 	if (!Number.isSafeInteger(limit) || limit <= 0) return 0;
 	return Math.min(limit, 100);
 };
+const singleWordCompletions = (input, vocabulary) => {
+	const words = naturalWords(input);
+	if (words.length === 0 || words.length > 12) return [];
+	const positions = Array.from({ length: words.length + 1 }, (_, index) => index);
+	const insertions = Array$1.flatMap(positions, (index) => Array$1.flatMap(vocabulary, (word) => word.length === 0 || word.includes(" ") ? [] : [[
+		...words.slice(0, index),
+		word,
+		...words.slice(index)
+	].join(" ")]));
+	return Array$1.dedupe(insertions);
+};
 const suggestNatural = Effect.fn("chronolizer.suggestNatural")(function* (input, options) {
 	const language = yield* (yield* LanguageRegistry).resolve(options.locale);
 	const normalized = language.normalize(input, language.locale);
 	const limit = suggestionLimit(options.limit);
 	if (limit === 0) return [];
-	const suggestions = Array.flatMap(Array.dedupe(language.suggest(normalized, limit * 2)), (text) => applyFuturePolicy(language.parseExact(language.normalize(text, language.locale)), options.allowFuture).map((candidate) => NaturalSuggestion.make({
+	const suggestionsFrom = (texts) => Array$1.flatMap(Array$1.dedupe(texts), (text) => applyFuturePolicy(language.parseExact(language.normalize(text, language.locale)), options.allowFuture).map((candidate) => NaturalSuggestion.make({
 		text: candidate.canonical,
 		range: candidate.range
 	})));
-	return Array.take(Array.dedupeWith(suggestions, (left, right) => rangeKey(left.range) === rangeKey(right.range)), limit);
+	const distinct = (suggestions) => Array$1.dedupeWith(suggestions, (left, right) => rangeKey(left.range) === rangeKey(right.range));
+	const suggested = distinct(suggestionsFrom([...language.suggest(normalized, limit * 2), normalized]));
+	if (suggested.length > 0) return Array$1.take(suggested, limit);
+	const completionVocabulary = Array$1.dedupe([...Array$1.flatMap(language.suggest("", 100), naturalWords), ...language.vocabulary]);
+	return Array$1.take(distinct(suggestionsFrom(singleWordCompletions(normalized, completionVocabulary))), limit);
 });
 //#endregion
 export { suggestNatural };

package/dist/natural/suggestion.mjs

@@ -23,14 +23,20 @@ const phraseScore = (input, phrase) => {
 	const phraseWords = phrase.split(" ");
 	if (inputWords.length > phraseWords.length) return void 0;
 	let cost = 0;
-	for (const [index, inputWord] of inputWords.entries()) {
-		const targetWord = phraseWords[index];
-		if (targetWord === void 0) return void 0;
-		const wordCost = completionCost(inputWord, targetWord);
+	let addedWords = 0;
+	let phraseIndex = 0;
+	for (const inputWord of inputWords) {
+		let wordCost = completionCost(inputWord, phraseWords[phraseIndex] ?? "");
+		while (wordCost === void 0 && addedWords < 3) {
+			phraseIndex += 1;
+			addedWords += 1;
+			wordCost = completionCost(inputWord, phraseWords[phraseIndex] ?? "");
+		}
 		if (wordCost === void 0) return void 0;
 		cost += wordCost;
+		phraseIndex += 1;
 	}
-	return cost === 0 ? 2 : 2 + cost;
+	return 2 + cost + addedWords;
 };
 const completeYearPrefix = (input) => {
 	const match = String.match(/(?:^| )(\d{3,4})$/u)(input);

package/dist/resolve/resolve.mjs

@@ -2,15 +2,7 @@ import { foldInstant } from "../ast/fold.mjs";
 import { ResolutionError, ResolvedDateRange, ResolvedGreaterThan, ResolvedGreaterThanOrEqual, ResolvedLessThan, ResolvedLessThanOrEqual } from "./schema.mjs";
 import { DateTime, Effect, Match, Option } from "effect";
 //#region src/resolve/resolve.ts
-const shiftDateTime = (value, amount, unit) => {
-	switch (unit) {
-		case "day": return DateTime.add(value, { days: amount });
-		case "week": return DateTime.add(value, { weeks: amount });
-		case "month": return DateTime.add(value, { months: amount });
-		case "quarter": return DateTime.add(value, { months: amount * 3 });
-		case "year": return DateTime.add(value, { years: amount });
-	}
-};
+const shiftDateTime = (value, amount, unit) => Match.value(unit).pipe(Match.when("day", () => DateTime.add(value, { days: amount })), Match.when("week", () => DateTime.add(value, { weeks: amount })), Match.when("month", () => DateTime.add(value, { months: amount })), Match.when("quarter", () => DateTime.add(value, { months: amount * 3 })), Match.when("year", () => DateTime.add(value, { years: amount })), Match.exhaustive);
 const startOfDateTime = (value, unit) => {
 	if (unit === "quarter") {
 		const month = DateTime.getPart(value, "month");
@@ -53,7 +45,7 @@ const resolve = Effect.fn("chronolizer.resolve")(function* (range) {
 	if (range.lower !== void 0 && range.upper !== void 0) {
 		const lower = yield* resolveLower(range.lower, reference, zone);
 		const upper = yield* resolveUpper(range.upper, reference, zone);
-		if (DateTime.toEpochMillis(lower.value) >= DateTime.toEpochMillis(upper.value)) return yield* new ResolutionError({ message: "The lower range endpoint must be before the upper endpoint" });
+		if (DateTime.toEpochMillis(lower.value) >= DateTime.toEpochMillis(upper.value)) return yield* new ResolutionError({ message: "The range start must be before the range end" });
 		return ResolvedDateRange.make({
 			lower,
 			upper