chronolizer 0.2.0 → 0.3.0

package/dist/locales/shared.mjs

@@ -1,9 +1,9 @@
-import { InstantExpr, Unit, daysInMonth, isIsoDate } from "../ast/schemas.mjs";
+import { GreaterThanOrEqual, InstantExpr, LessThan, LessThanOrEqual, Now, Shift, StartOf, Unit, daysInMonth, isIsoDate } from "../ast/schemas.mjs";
 import { boundedRange, dateLiteral, greaterThanOrEqual, lessThan, lessThanOrEqual, lowerOpenRange, now, shift, startOf, upperOpenRange } from "../ast/constructors.mjs";
 import { formatInstantExpression } from "../filter/expression.mjs";
 import { formatFilter, rangeKey } from "../filter/codec.mjs";
 import { NaturalCandidate } from "../language/model.mjs";
-import { Option, Schema, String as String$1 } from "effect";
+import { Match, Option, RegExp as RegExp$1, Schema, String as String$1 } from "effect";
 //#region src/locales/shared.ts
 const textAt = (values, index) => values[index] ?? "";
 const Period = Schema.Struct({
@@ -11,6 +11,12 @@ const Period = Schema.Struct({
 	end: InstantExpr,
 	canonical: Schema.String
 });
+const isGreaterThanOrEqual = Schema.is(GreaterThanOrEqual);
+const isLessThan = Schema.is(LessThan);
+const isLessThanOrEqual = Schema.is(LessThanOrEqual);
+const isNow = Schema.is(Now);
+const isShift = Schema.is(Shift);
+const isStartOf = Schema.is(StartOf);
 const periodRange = (period) => boundedRange(greaterThanOrEqual(period.start), lessThan(period.end));
 const periodToDateRange = (unit) => boundedRange(greaterThanOrEqual(startOf(now(), unit)), lessThanOrEqual(now()));
 const fromNowRange = () => lowerOpenRange(greaterThanOrEqual(now()));
@@ -29,6 +35,20 @@ const periodEndDay = (period, canonical) => Period.make({
 	end: period.end,
 	canonical
 });
+const periodDay = (period, day, canonical) => {
+	if (!Number.isInteger(day) || day < 1 || day > 28) return Option.none();
+	const start = day === 1 ? period.start : shift(period.start, day - 1, "day");
+	return Option.some(Period.make({
+		start,
+		end: shift(start, 1, "day"),
+		canonical
+	}));
+};
+const periodPreviousDay = (period, canonical) => Period.make({
+	start: shift(period.start, -1, "day"),
+	end: period.start,
+	canonical
+});
 const relativeWeekend = (direction, canonical) => {
 	const weekBase = direction === 0 ? now() : shift(now(), direction, "week");
 	const weekStart = startOf(weekBase, "week");
@@ -43,11 +63,7 @@ const TrailingCount = Schema.Int.check(Schema.isBetween({
 	minimum: 1,
 	maximum: Number.MAX_SAFE_INTEGER
 }));
-const TrailingPeriod = Schema.Struct({
-	amount: TrailingCount,
-	unit: Unit
-});
-const FuturePeriod = Schema.Struct({
+const CountedPeriod = Schema.Struct({
 	amount: TrailingCount,
 	unit: Unit
 });
@@ -66,15 +82,17 @@ const parseTrailingCount = (value) => {
 const trailingRange = (amount, unit) => boundedRange(greaterThanOrEqual(shift(now(), -amount, unit)), lessThanOrEqual(now()));
 const futureRange = (amount, unit) => boundedRange(greaterThanOrEqual(now()), lessThanOrEqual(shift(now(), amount, unit)));
 const trailingPeriod = (range) => {
-	if (range.lower?._tag !== "GreaterThanOrEqual" || range.upper?._tag !== "LessThanOrEqual" || range.lower.value._tag !== "Shift" || range.lower.value.amount >= 0 || range.lower.value.base._tag !== "Now" || range.upper.value._tag !== "Now") return Option.none();
-	return Option.some(TrailingPeriod.make({
+	if (!isGreaterThanOrEqual(range.lower) || !isLessThanOrEqual(range.upper)) return Option.none();
+	if (!isShift(range.lower.value) || range.lower.value.amount >= 0 || !isNow(range.lower.value.base) || !isNow(range.upper.value)) return Option.none();
+	return Option.some(CountedPeriod.make({
 		amount: -range.lower.value.amount,
 		unit: range.lower.value.unit
 	}));
 };
 const futurePeriod = (range) => {
-	if (range.lower?._tag !== "GreaterThanOrEqual" || range.upper?._tag !== "LessThanOrEqual" || range.lower.value._tag !== "Now" || range.upper.value._tag !== "Shift" || range.upper.value.amount <= 0 || range.upper.value.base._tag !== "Now") return Option.none();
-	return Option.some(FuturePeriod.make({
+	if (!isGreaterThanOrEqual(range.lower) || !isLessThanOrEqual(range.upper)) return Option.none();
+	if (!isNow(range.lower.value) || !isShift(range.upper.value) || range.upper.value.amount <= 0 || !isNow(range.upper.value.base)) return Option.none();
+	return Option.some(CountedPeriod.make({
 		amount: range.upper.value.amount,
 		unit: range.upper.value.unit
 	}));
@@ -100,6 +118,50 @@ const previousDay = (year, month, day) => {
 	if (month > 1) return isoDate(year, month - 1, daysInMonth(year, month - 1));
 	return isoDate(year - 1, 12, 31);
 };
+const absoluteDateProfiles = /* @__PURE__ */ new Map();
+const absoluteDateProfile = (locale) => {
+	const cached = absoluteDateProfiles.get(locale);
+	if (cached !== void 0) return cached;
+	const formatter = new Intl.DateTimeFormat(locale, {
+		day: "numeric",
+		month: "numeric",
+		year: "numeric",
+		numberingSystem: "latn",
+		timeZone: "UTC"
+	});
+	const parts = [];
+	const pattern = formatter.formatToParts(/* @__PURE__ */ new Date("2006-11-22T00:00:00.000Z")).map((part) => {
+		if (part.type === "day" || part.type === "month" || part.type === "year") {
+			parts.push(part.type);
+			return part.type === "year" ? "([0-9]{4})" : "([0-9]{1,2})";
+		}
+		return RegExp$1.escape(part.value);
+	}).join("");
+	const profile = {
+		formatter,
+		pattern: new RegExp(`^${pattern}$`, "u"),
+		parts
+	};
+	absoluteDateProfiles.set(locale, profile);
+	return profile;
+};
+const formatAbsoluteDate = (value, locale) => absoluteDateProfile(locale).formatter.format(/* @__PURE__ */ new Date(`${value}T00:00:00.000Z`));
+const parseLocalizedAbsoluteDate = (input, locale) => {
+	const profile = absoluteDateProfile(locale);
+	const match = String$1.match(profile.pattern)(input);
+	if (Option.isNone(match)) return Option.none();
+	let day = "";
+	let month = "";
+	let year = "";
+	for (const [index, part] of profile.parts.entries()) {
+		const value = textAt(match.value, index + 1);
+		if (part === "day") day = value;
+		if (part === "month") month = value;
+		if (part === "year") year = value;
+	}
+	const value = isoDate(Number(year), Number(month), Number(day));
+	return isIsoDate(value) ? Option.some(value) : Option.none();
+};
 const fixedDatePeriod = (value, canonical) => {
 	const year = Number(value.slice(0, 4));
 	const month = Number(value.slice(5, 7));
@@ -110,6 +172,9 @@ const fixedDatePeriod = (value, canonical) => {
 		canonical
 	});
 };
+const absoluteDatePeriod = (input, locale) => {
+	return (isIsoDate(input) ? Option.some(input) : parseLocalizedAbsoluteDate(input, locale)).pipe(Option.filter((date) => date !== "9999-12-31"), Option.map((date) => fixedDatePeriod(date, formatAbsoluteDate(date, locale))));
+};
 const namedDatePeriod = (yearText, monthText, dayText, monthNumber, canonical) => {
 	const year = validYear(yearText);
 	const month = monthNumber(monthText);
@@ -119,6 +184,51 @@ const namedDatePeriod = (yearText, monthText, dayText, monthNumber, canonical) =
 	if (!isIsoDate(value) || value === "9999-12-31") return Option.none();
 	return Option.some(fixedDatePeriod(value, canonical(day, month, year)));
 };
+const minimumDaysInMonth = (month) => daysInMonth(1, month);
+const currentYearDatePeriod = (month, day, canonical) => {
+	const yearStart = startOf(now(), "year");
+	const monthStart = month === 1 ? yearStart : shift(yearStart, month - 1, "month");
+	const start = day === 1 ? monthStart : shift(monthStart, day - 1, "day");
+	return Period.make({
+		start,
+		end: shift(start, 1, "day"),
+		canonical
+	});
+};
+const namedCurrentYearDatePeriod = (monthText, dayText, monthNumber, canonical) => {
+	const month = monthNumber(monthText);
+	const day = Number(dayText);
+	if (month === void 0 || !Number.isInteger(day) || day < 1 || day > minimumDaysInMonth(month)) return Option.none();
+	return Option.some(currentYearDatePeriod(month, day, canonical(day, month)));
+};
+const currentYearDate = (expression) => {
+	const match = String$1.match(/^now\/y(?:\+([1-9]\d*)M)?(?:\+([1-9]\d*)d)?$/u)(expression);
+	if (Option.isNone(match)) return Option.none();
+	const month = Number(textAt(match.value, 1) || "0") + 1;
+	const offset = Number(textAt(match.value, 2) || "0");
+	return month >= 1 && month <= 12 ? Option.some([month, offset]) : Option.none();
+};
+const currentYearDatePeriods = (range, canonical) => {
+	const filter = formatFilter(range);
+	const expressions = [
+		filter.gt,
+		filter.gte,
+		filter.lt,
+		filter.lte
+	];
+	const dates = /* @__PURE__ */ new Map();
+	for (const expression of expressions) {
+		if (expression === void 0) continue;
+		const date = currentYearDate(expression);
+		if (Option.isNone(date)) continue;
+		const [month, offset] = date.value;
+		for (const day of [offset, offset + 1]) {
+			if (day < 1 || day > minimumDaysInMonth(month)) continue;
+			dates.set(`${month}-${day}`, [month, day]);
+		}
+	}
+	return [...dates.values()].map(([month, day]) => currentYearDatePeriod(month, day, canonical(day, month)));
+};
 const fixedMonthPeriod = (year, month, canonical) => {
 	const nextYear = month === 12 ? year + 1 : year;
 	const nextMonth = month === 12 ? 1 : month + 1;
@@ -164,10 +274,13 @@ const monthOfRelativeYear = (month, direction, canonical) => {
 	});
 };
 const calendarPeriodOffset = (range) => {
-	if (range.lower?._tag !== "GreaterThanOrEqual" || range.upper?._tag !== "LessThan" || range.lower.value._tag !== "StartOf" || range.lower.value.base._tag !== "Shift" || range.lower.value.base.amount === 0 || range.lower.value.base.base._tag !== "Now" || range.lower.value.unit !== range.lower.value.base.unit || range.upper.value._tag !== "Shift" || range.upper.value.amount !== 1 || range.upper.value.unit !== range.lower.value.unit || formatInstantExpression(range.upper.value.base) !== formatInstantExpression(range.lower.value)) return Option.none();
+	if (!isGreaterThanOrEqual(range.lower) || !isLessThan(range.upper)) return Option.none();
+	const start = range.lower.value;
+	const end = range.upper.value;
+	if (!isStartOf(start) || !isShift(start.base) || start.base.amount === 0 || !isNow(start.base.base) || start.unit !== start.base.unit || !isShift(end) || end.amount !== 1 || end.unit !== start.unit || formatInstantExpression(end.base) !== formatInstantExpression(start)) return Option.none();
 	return Option.some(CalendarPeriodOffset.make({
-		amount: range.lower.value.base.amount,
-		unit: range.lower.value.unit
+		amount: start.base.amount,
+		unit: start.unit
 	}));
 };
 const candidate = (range, canonical) => NaturalCandidate.make({
@@ -201,14 +314,7 @@ const joinedPeriodCandidate = (input, joins, parsePeriod, canonical) => {
 	}
 	return Option.none();
 };
-const periodBoundaryCandidate = (period, boundary, canonical) => {
-	switch (boundary) {
-		case "since": return candidate(lowerOpenRange(greaterThanOrEqual(period.start)), canonical);
-		case "before": return candidate(upperOpenRange(lessThan(period.start)), canonical);
-		case "through": return candidate(upperOpenRange(lessThan(period.end)), canonical);
-		case "after": return candidate(lowerOpenRange(greaterThanOrEqual(period.end)), canonical);
-	}
-};
+const periodBoundaryCandidate = (period, boundary, canonical) => Match.value(boundary).pipe(Match.when("since", () => candidate(lowerOpenRange(greaterThanOrEqual(period.start)), canonical)), Match.when("before", () => candidate(upperOpenRange(lessThan(period.start)), canonical)), Match.when("through", () => candidate(upperOpenRange(lessThan(period.end)), canonical)), Match.when("after", () => candidate(lowerOpenRange(greaterThanOrEqual(period.end)), canonical)), Match.exhaustive);
 const openBoundaryCandidate = (input, boundaries, parsePeriod) => {
 	for (const boundary of boundaries) {
 		if (!input.startsWith(boundary[0])) continue;
@@ -286,4 +392,4 @@ const renderPeriodRange = (range, toDate, periods, since, before, through, after
 	return Option.none();
 };
 //#endregion
-export { Period, 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 };
+export { Period, absoluteDatePeriod, calendarPeriodOffset, candidate, currentYearDatePeriods, datedPeriods, datedQuarterPeriods, fixedDatePeriod, fixedMonthPeriod, fixedQuarterPeriod, fixedYearPeriod, formatAbsoluteDate, fromNowRange, futurePeriod, futureRange, isoDate, joinedNowCandidate, joinedPeriodCandidate, monthOfRelativeYear, namedCurrentYearDatePeriod, namedDatePeriod, openBoundaryCandidate, parseTrailingCount, periodBoundaryCandidate, periodDay, periodEndDay, periodPreviousDay, periodRange, periodStartDay, periodToDateRange, periodsFromPhrases, quarterOfRelativeYear, relativePeriod, relativeWeekend, remainingPeriodRange, renderPeriodRange, textAt, trailingPeriod, trailingRange, untilNowRange, validYear };

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, currentYearDatePeriods, datedPeriods, datedQuarterPeriods, fixedDatePeriod, fixedMonthPeriod, fixedQuarterPeriod, fixedYearPeriod, fromNowRange, futurePeriod, futureRange, isoDate, joinedNowCandidate, joinedPeriodCandidate, monthOfRelativeYear, namedCurrentYearDatePeriod, 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/tr.ts
 const months = [
@@ -298,17 +298,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));
@@ -336,7 +341,8 @@ const parseQuarter = (input) => {
 	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 absoluteDate = absoluteDatePeriod(input, "tr");
+	if (Option.isSome(absoluteDate)) return absoluteDate;
 	const namedDate = parseNamedDate(input);
 	if (Option.isSome(namedDate)) return namedDate;
 	const quarter = parseQuarter(input);
@@ -401,7 +407,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(candidate(periodRange(relativePeriod(singular.entry.unit, singular.direction, singular.phrase)), singular.phrase));
 	const past = String$1.match(calendarPastPattern)(input);
 	const future = firstPatternMatch(input, calendarFuturePatterns);
 	const match = Option.firstSomeOf([past, future]);
@@ -417,6 +462,11 @@ const parseCalendarOffset = (input) => {
 	return Option.some(candidate(periodRange(relativePeriod(unit, direction, canonical)), 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 +485,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 = [
@@ -486,6 +549,8 @@ const parseTurkish = (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ı`);
 	if (Option.isSome(nowBounded)) return nowBounded;
@@ -499,7 +564,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]),
@@ -569,6 +634,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",
@@ -596,20 +663,18 @@ 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("’", "'");

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/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/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");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chronolizer",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Bidirectional natural-language date ranges for Effect.",
   "homepage": "https://github.com/tobimori/chronolizer#readme",
   "bugs": "https://github.com/tobimori/chronolizer/issues",