chronolizer 0.3.0 → 0.4.0

package/README.md

@@ -1,6 +1,6 @@
 # Chronolizer
 
-Chronolizer is an Effect 4 library that converts natural-language date ranges to compact date-math filters and back. It supports open ranges, autocomplete, typo correction, and eight languages.
+Chronolizer is an Effect 4 library that converts natural-language date ranges to compact date filters and back. It supports ranges without a start or end, autocomplete, spelling correction, and eight languages.
 
 ```text
 year to date          → { gte: "now/y", lte: "now" }
@@ -9,11 +9,11 @@ since January 2025    → { gte: "2025-01-01" }
 ```
 
 > [!NOTE]
-> Chronolizer currently uses `effect@4.0.0-rc.112`. The API can change while Effect v4 has release-candidate status.
+> Chronolizer currently uses `effect@4.0.0-rc.112`. Effect 4 is not stable yet, so its API can change.
 
 ## Install Chronolizer
 
-Chronolizer requires Effect 4 and ESM. Install both packages as direct dependencies.
+Chronolizer requires Effect 4 and uses ES modules. Install both packages:
 
 ```sh
 pnpm add chronolizer effect@4.0.0-rc.112
@@ -21,7 +21,7 @@ pnpm add chronolizer effect@4.0.0-rc.112
 
 ## Parse your first date range
 
-English is available from the main package entry.
+English is available from the main package.
 
 ```ts
 import { EnglishLanguageLayer, formatFilter, parseNatural } from "chronolizer";
@@ -43,7 +43,7 @@ Effect.runPromise(program);
 
 ### Parse other languages
 
-Import each non-English language from its own package entry. This keeps unused languages out of your bundle.
+Import each non-English language separately. This keeps unused language code out of your build.
 
 ```ts
 import { formatFilter, parseNatural } from "chronolizer";
@@ -60,7 +60,7 @@ Effect.runPromise(program);
 // { gte: "now/y", lte: "now" }
 ```
 
-Use `languagePluginsLayer` when one application needs more than one language:
+Use `languagePluginsLayer` to combine languages:
 
 ```ts
 import { EnglishLanguage, languagePluginsLayer, parseNatural } from "chronolizer";
@@ -77,7 +77,7 @@ Effect.runPromise(program);
 
 ### Format a range as natural language
 
-`formatNatural` returns the canonical phrase for a range. It preserves the meaning, but it does not reproduce the original wording. Absolute days use the locale's numeric `Intl.DateTimeFormat` form.
+`formatNatural` returns one standard phrase for a range. It preserves the meaning, but it does not reproduce the original wording. Absolute days use the language's numeric `Intl.DateTimeFormat` form.
 
 ```ts
 import { formatNatural, parseFilter } from "chronolizer";
@@ -96,7 +96,7 @@ Effect.runPromise(program);
 
 ### Add autocomplete
 
-`suggestNatural` returns valid canonical phrases and their semantic ranges.
+`suggestNatural` returns valid standard phrases and their date ranges.
 
 ```ts
 import { EnglishLanguageLayer, suggestNatural } from "chronolizer";
@@ -115,7 +115,7 @@ The default limit is 10. The maximum limit is 100. A nonpositive or invalid limi
 
 ### Accept spelling errors
 
-Set `typoMode` to `"tolerant"` for conservative correction:
+Set `typoMode` to `"tolerant"` to correct close spelling errors:
 
 ```ts
 const program = parseNatural("januray of last yaer", {
@@ -124,11 +124,11 @@ const program = parseNatural("januray of last yaer", {
 });
 ```
 
-The successful value contains its `quality`, applied `corrections`, and any semantic `alternatives`. Strict mode is the default and does not correct the input.
+The result contains its `quality`, applied `corrections`, and any `alternatives` with a different meaning. Strict mode is the default and does not correct the input.
 
-### Exclude future relative ranges
+### Exclude future ranges
 
-Set `allowFuture` to `false` to reject explicit relative future ranges:
+Set `allowFuture` to `false` to reject periods after the current period:
 
 ```ts
 const program = parseNatural("next 3 months", {
@@ -137,7 +137,7 @@ const program = parseNatural("next 3 months", {
 });
 ```
 
-This option rejects forms such as `next month`, `next 3 weeks`, and `in 3 years`. It keeps complete current calendar periods such as `today`, `this week`, and `this month`. It does not change them to period-to-date ranges.
+This option rejects forms such as `next month`, `next 3 weeks`, and `in 3 years`. It keeps complete current calendar periods such as `today`, `this week`, and `this month`. It does not change them to ranges that end at the current time.
 
 The option does not compare fixed dates, such as `January 2099`, with the current date. Parsing does not read the clock.
 
@@ -145,7 +145,7 @@ The same option is available in `suggestNatural`.
 
 ### Resolve a range to dates
 
-Provide an Effect time zone when you resolve relative expressions:
+Provide an Effect time zone when you calculate ranges based on the current date:
 
 ```ts
 import { parseFilter, resolve } from "chronolizer";
@@ -159,7 +159,7 @@ const program = parseFilter({ gte: "now/y", lte: "now" }).pipe(
 Effect.runPromise(program);
 ```
 
-`resolve` uses the Effect clock and `DateTime.CurrentTimeZone`. It does not use the host time zone without your decision.
+`resolve` uses the Effect clock and `DateTime.CurrentTimeZone`. It uses only the time zone that you provide.
 
 ### Validate an external filter
 
@@ -176,18 +176,19 @@ const program = Schema.decodeUnknownEffect(DateFilter)(externalInput).pipe(
 Effect.runPromise(program);
 ```
 
-## Supported expressions
+## Supported input
 
-Supported input families include:
+You can parse:
 
-- calendar days, weeks, months, quarters, and years;
-- rolling ranges, such as `last 3 months`;
-- calendar offsets, such as `30 months ago`;
-- period-to-date ranges, such as `year to date`;
-- fixed months, quarters, years, and explicit date intervals;
+- days, weeks, months, quarters, and years;
+- ranges with a length, such as `last 3 months`;
+- single periods in the past or future, such as `30 months ago`;
+- ranges from a period start to now, such as `year to date`;
+- fixed months, quarters, years, and date ranges;
 - named days with or without a year, such as `January 12` and `12th of January`;
-- open ranges, such as `since January 2025` and `from January 12`;
-- compositional boundaries, such as `the day before January 12`;
+- ranges without one end, such as `since January 2025` and `from January 12`;
+- written counts from one through ninety-nine, such as `two weeks ago` and `twenty-one weeks ago`;
+- combined phrases, such as `the day before January 12` and `yesterday two weeks ago`;
 - period starts, period ends, and weekends;
 - abbreviated month names and common equivalent phrases.
 
@@ -206,16 +207,16 @@ Examples:
 
 ## Supported languages
 
-| Language | Locale | Import                                    |
-| -------- | ------ | ----------------------------------------- |
-| English  | `en`   | `chronolizer` or `chronolizer/locales/en` |
-| German   | `de`   | `chronolizer/locales/de`                  |
-| Spanish  | `es`   | `chronolizer/locales/es`                  |
-| French   | `fr`   | `chronolizer/locales/fr`                  |
-| Dutch    | `nl`   | `chronolizer/locales/nl`                  |
-| Turkish  | `tr`   | `chronolizer/locales/tr`                  |
-| Czech    | `cs`   | `chronolizer/locales/cs`                  |
-| Polish   | `pl`   | `chronolizer/locales/pl`                  |
+| Language | Code | Import                                    |
+| -------- | ---- | ----------------------------------------- |
+| English  | `en` | `chronolizer` or `chronolizer/locales/en` |
+| German   | `de` | `chronolizer/locales/de`                  |
+| Spanish  | `es` | `chronolizer/locales/es`                  |
+| French   | `fr` | `chronolizer/locales/fr`                  |
+| Dutch    | `nl` | `chronolizer/locales/nl`                  |
+| Turkish  | `tr` | `chronolizer/locales/tr`                  |
+| Czech    | `cs` | `chronolizer/locales/cs`                  |
+| Polish   | `pl` | `chronolizer/locales/pl`                  |
 
 ## Date filter reference
 
@@ -239,22 +240,22 @@ unit       := "d" | "w" | "M" | "q" | "y"
 
 `/unit` moves a value to the start of its calendar unit. Add `||` before operations on a fixed date, for example `2025-01-01||+1M`.
 
-Complete calendar periods use a half-open interval: the lower bound is inclusive and the next period start is exclusive. Weeks start on Monday.
+A complete calendar period includes its start but excludes the start of the next period. Weeks start on Monday.
 
 A named day without a year uses the current calendar year. Write the year for February 29 because parsing does not read the clock.
 
 ## Main API
 
-| Export                | Purpose                                                             |
-| --------------------- | ------------------------------------------------------------------- |
-| `parseNatural`        | Parse complete natural-language input to a semantic range           |
-| `formatNatural`       | Render a supported range as a canonical phrase                      |
-| `suggestNatural`      | Return autocomplete suggestions and semantic ranges                 |
-| `parseFilter`         | Parse a date filter to a semantic range                             |
-| `formatFilter`        | Format a semantic range as a date filter                            |
-| `resolve`             | Resolve a semantic range with an Effect clock and time zone         |
-| `DateFilter`          | Validate external date-filter data with Effect Schema               |
-| `DateRangeFromFilter` | Decode and encode a filter through one Effect Schema transformation |
+| Export                | Purpose                                                    |
+| --------------------- | ---------------------------------------------------------- |
+| `parseNatural`        | Parse complete natural-language input to a date range      |
+| `formatNatural`       | Write a supported range as one standard phrase             |
+| `suggestNatural`      | Return autocomplete suggestions and date ranges            |
+| `parseFilter`         | Parse a date filter to a date range                        |
+| `formatFilter`        | Format a date range as a date filter                       |
+| `resolve`             | Calculate dates with an Effect clock and time zone         |
+| `DateFilter`          | Validate external date-filter data with Effect Schema      |
+| `DateRangeFromFilter` | Convert a filter in both directions with one Effect Schema |
 
 ## License
 

package/dist/filter/expression.mjs

@@ -14,25 +14,31 @@ const failAt = (input, offset, expected) => Effect.fail(new FilterExpressionPars
 }));
 const isDigit = (value) => value >= "0" && value <= "9";
 const isFirstPositiveDigit = (value) => value >= "1" && value <= "9";
+const parseAnchor = Effect.fn(function* (input) {
+	if (input.startsWith("now")) return {
+		expression: now(),
+		cursor: 3,
+		fixed: false
+	};
+	const candidate = input.slice(0, 10);
+	if (!isIsoDate(candidate)) return yield* failAt(input, 0, "\"now\" or an ISO date (YYYY-MM-DD)");
+	return {
+		expression: dateLiteral(candidate),
+		cursor: 10,
+		fixed: true
+	};
+});
+const operationStart = Effect.fn(function* (input, anchor) {
+	if (!anchor.fixed || anchor.cursor === input.length) return anchor.cursor;
+	if (input.slice(anchor.cursor, anchor.cursor + 2) !== "||") return yield* failAt(input, anchor.cursor, "\"||\" before date operations");
+	const cursor = anchor.cursor + 2;
+	if (cursor === input.length) return yield* failAt(input, cursor, "an operation beginning with \"+\", \"-\", or \"/\"");
+	return cursor;
+});
 const parseInstantExpression = Effect.fn(function* (input) {
-	let cursor = 0;
-	let expression;
-	let fixedAnchor = false;
-	if (input.startsWith("now")) {
-		expression = now();
-		cursor = 3;
-	} else {
-		const candidate = input.slice(0, 10);
-		if (!isIsoDate(candidate)) return yield* failAt(input, 0, "\"now\" or an ISO date (YYYY-MM-DD)");
-		expression = dateLiteral(candidate);
-		cursor = 10;
-		fixedAnchor = true;
-	}
-	if (fixedAnchor && cursor < input.length) {
-		if (input.slice(cursor, cursor + 2) !== "||") return yield* failAt(input, cursor, "\"||\" before date operations");
-		cursor += 2;
-		if (cursor === input.length) return yield* failAt(input, cursor, "an operation beginning with \"+\", \"-\", or \"/\"");
-	}
+	const anchor = yield* parseAnchor(input);
+	let expression = anchor.expression;
+	let cursor = yield* operationStart(input, anchor);
 	while (cursor < input.length) {
 		const operator = input[cursor];
 		if (operator === "/") {

package/dist/language/model.mjs

@@ -35,7 +35,7 @@ const NaturalSuggestion = Schema.Struct({
 var BaseLanguageContribution = class extends Data.TaggedClass("BaseLanguage") {};
 var LanguageExtensionContribution = class extends Data.TaggedClass("LanguageExtension") {};
 const canonicalBaseLocale = (input) => Result.getSuccess(Result.try(() => new Intl.Locale(input).baseName));
-const Locale = Schema.String.check(Schema.makeFilter((value) => Option.contains(canonicalBaseLocale(value), value), { expected: "a canonical BCP 47 base locale identifier" })).annotate({ identifier: "Locale" });
+const Locale = Schema.String.check(Schema.makeFilter((value) => Option.contains(canonicalBaseLocale(value), value), { expected: "a standard BCP 47 language code" })).annotate({ identifier: "Locale" });
 const BaseLanguageMetadata = Schema.TaggedStruct("BaseLanguage", {
 	locale: Locale,
 	vocabulary: Schema.Array(Schema.String)

package/dist/language/registry.mjs

@@ -45,28 +45,34 @@ const compileLanguage = (locale, registered) => {
 	}));
 };
 const createRegistry = Effect.fn(function* () {
-	const entries = yield* Ref.make([]);
+	const state = yield* Ref.make({
+		entries: [],
+		compiledLanguages: /* @__PURE__ */ new Map()
+	});
 	const register = Effect.fn(function* (pluginId, contribution) {
 		if (pluginId.length === 0 || !Schema.is(LanguageContributionMetadata)(contribution)) return yield* new LanguageRegistrationError({
 			pluginId,
 			locale: contribution.locale,
-			message: "Invalid plugin identifier or contribution metadata"
+			message: "The plugin name or language settings are invalid"
 		});
 		const token = Symbol(pluginId);
-		yield* Effect.acquireRelease(Ref.modify(entries, (current) => {
+		yield* Effect.acquireRelease(Ref.modify(state, (current) => {
 			const conflictingBase = Match.valueTags(contribution, {
-				BaseLanguage: (base) => Array.findFirst(current, (entry) => Match.valueTags(entry.contribution, {
+				BaseLanguage: (base) => Array.findFirst(current.entries, (entry) => Match.valueTags(entry.contribution, {
 					BaseLanguage: (registeredBase) => registeredBase.locale === base.locale,
 					LanguageExtension: () => false
 				})),
 				LanguageExtension: () => Option.none()
 			});
 			return Option.match(conflictingBase, {
-				onNone: () => [Result.succeed(token), Array.append(current, {
-					token,
-					pluginId,
-					contribution
-				})],
+				onNone: () => [Result.succeed(token), {
+					entries: Array.append(current.entries, {
+						token,
+						pluginId,
+						contribution
+					}),
+					compiledLanguages: /* @__PURE__ */ new Map()
+				}],
 				onSome: (conflict) => [Result.fail(new LanguageConflictError({
 					locale: contribution.locale,
 					firstPluginId: conflict.pluginId,
@@ -74,12 +80,26 @@ const createRegistry = Effect.fn(function* () {
 					message: "Only one base language can be registered for a locale"
 				})), current]
 			});
-		}).pipe(Effect.flatMap((result) => Effect.fromResult(result))), (registeredToken) => Ref.update(entries, (items) => Array.filter(items, (entry) => entry.token !== registeredToken)));
+		}).pipe(Effect.flatMap((result) => Effect.fromResult(result))), (registeredToken) => Ref.update(state, (current) => ({
+			entries: Array.filter(current.entries, (entry) => entry.token !== registeredToken),
+			compiledLanguages: /* @__PURE__ */ new Map()
+		})));
 	});
 	const resolve = Effect.fn(function* (locale) {
 		const canonical = canonicalBaseLocale(locale);
 		if (Option.isSome(canonical)) {
-			const compiled = compileLanguage(canonical.value, yield* Ref.get(entries));
+			const compiled = yield* Ref.modify(state, (current) => {
+				const cached = current.compiledLanguages.get(canonical.value);
+				if (cached !== void 0) return [Option.some(cached), current];
+				const language = compileLanguage(canonical.value, current.entries);
+				if (Option.isNone(language)) return [language, current];
+				const cache = new Map(current.compiledLanguages);
+				cache.set(canonical.value, language.value);
+				return [language, {
+					entries: current.entries,
+					compiledLanguages: cache
+				}];
+			});
 			if (Option.isSome(compiled)) return compiled.value;
 		}
 		return yield* new UnsupportedLocaleError({ locale });
@@ -102,7 +122,7 @@ const createPluginRegistry = Effect.fn(function* (plugins) {
 	if (duplicate !== void 0) return yield* new LanguageRegistrationError({
 		pluginId: duplicate,
 		locale: "*",
-		message: "Plugin identifiers must be unique"
+		message: "Plugin names must be unique"
 	});
 	const registry = yield* createRegistry();
 	const context = { register: registry.register };

package/dist/locales/cs.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 { absoluteDatePeriod, calendarPeriodOffset, candidate, currentYearDatePeriods, datedPeriods, datedQuarterPeriods, fixedDatePeriod, fixedMonthPeriod, fixedQuarterPeriod, fixedYearPeriod, fromNowRange, futurePeriod, futureRange, isoDate, joinedNowCandidate, joinedPeriodCandidate, monthOfRelativeYear, namedCurrentYearDatePeriod, namedDatePeriod, openBoundaryCandidate, parseTrailingCount, 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, 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/cs.ts
 const months = [
@@ -21,6 +21,123 @@ const months = [
 	"listopad",
 	"prosinec"
 ];
+const weekdays = [
+	"pondělí",
+	"úterý",
+	"středa",
+	"čtvrtek",
+	"pátek",
+	"sobota",
+	"neděle"
+];
+const weekdayGenitives = [
+	"pondělí",
+	"úterý",
+	"středy",
+	"čtvrtka",
+	"pátku",
+	"soboty",
+	"neděle"
+];
+const nextWeekdays = weekdays.flatMap((weekday, day) => [{
+	phrase: `příští ${weekday}`,
+	day,
+	canonical: `příští ${weekday}`
+}, {
+	phrase: `příštího ${textAt(weekdayGenitives, day)}`,
+	day,
+	canonical: `příští ${weekday}`
+}]);
+const czechCountWords = [
+	[
+		"dva",
+		"dvě",
+		"dvou",
+		"dvěma"
+	],
+	[
+		"tři",
+		"tří",
+		"třemi"
+	],
+	[
+		"čtyři",
+		"čtyř",
+		"čtyřmi"
+	],
+	["pět", "pěti"],
+	["šest", "šesti"],
+	["sedm", "sedmi"],
+	["osm", "osmi"],
+	["devět", "devíti"],
+	["deset", "deseti"],
+	["jedenáct", "jedenácti"],
+	["dvanáct", "dvanácti"],
+	["třináct", "třinácti"],
+	["čtrnáct", "čtrnácti"],
+	["patnáct", "patnácti"],
+	["šestnáct", "šestnácti"],
+	["sedmnáct", "sedmnácti"],
+	["osmnáct", "osmnácti"],
+	["devatenáct", "devatenácti"],
+	["dvacet", "dvaceti"]
+];
+const czechCountOnes = [
+	[1, "jedna"],
+	[2, "dva"],
+	[3, "tři"],
+	[4, "čtyři"],
+	[5, "pět"],
+	[6, "šest"],
+	[7, "sedm"],
+	[8, "osm"],
+	[9, "devět"]
+];
+const czechObliqueCountOnes = [
+	[1, "jedním"],
+	[2, "dvěma"],
+	[3, "třemi"],
+	[4, "čtyřmi"],
+	[5, "pěti"],
+	[6, "šesti"],
+	[7, "sedmi"],
+	[8, "osmi"],
+	[9, "devíti"]
+];
+const czechCountAliases = [
+	...sequentialCountAliases([[
+		"jeden",
+		"jedna",
+		"jedno",
+		"jedním",
+		"jednou"
+	]], 1),
+	...sequentialCountAliases(czechCountWords, 2),
+	...compoundCountAliases(decimalTens([
+		"dvacet",
+		"třicet",
+		"čtyřicet",
+		"padesát",
+		"šedesát",
+		"sedmdesát",
+		"osmdesát",
+		"devadesát"
+	]), czechCountOnes, (ten, one) => [`${ten} ${one}`]),
+	...compoundCountAliases(decimalTens([
+		"dvaceti",
+		"třiceti",
+		"čtyřiceti",
+		"padesáti",
+		"šedesáti",
+		"sedmdesáti",
+		"osmdesáti",
+		"devadesáti"
+	]), czechObliqueCountOnes, (ten, one) => [`${ten} ${one}`])
+];
+const normalizeCzechCounts = compileCountAliasNormalizer(czechCountAliases);
+const czechCountVocabulary = new Set(countAliasVocabulary(czechCountAliases));
+const correctCzech = (input, vocabulary) => correctWhitespaceSeparatedText(input, vocabulary, czechCountVocabulary);
+const normalizeCzech = (input, locale) => normalizeCzechCounts(normalizeNaturalText(input, locale));
 const monthGenitives = [
 	"ledna",
 	"února",
@@ -406,13 +523,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) => {
-	const absoluteDate = absoluteDatePeriod(input, "cs");
-	if (Option.isSome(absoluteDate)) return absoluteDate;
-	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, "cs"),
+		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));
@@ -424,6 +541,20 @@ const parseBasePeriod = (input) => {
 		const year = validYear(textAt(monthYear.value, 2));
 		if (month !== void 0 && year !== void 0) return Option.some(fixedMonthPeriod(year, month, `${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(/^(minulý|tento|příští) ([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áčďéěíňóřšťúůýž]+\.?) (minulého roku|příštího roku|tohoto roku)$/u)(input);
 	const relativeMonthYearFirst = String$1.match(/^(minulého roku|příštího roku|tohoto roku) ([a-záčďéěíňóřšťúůýž]+\.?)$/u)(input);
 	const relativeMatch = Option.firstSomeOf([relativeMonth, relativeMonthYearFirst]);
@@ -444,12 +575,31 @@ const parseBasePeriod = (input) => {
 	if (["příští víkend", "následující víkend"].includes(input)) return Option.some(relativeWeekend(1, "příští víkend"));
 	if (input === "předminulý víkend") return Option.some(relativeWeekend(-2, input));
 	if (input === "přespříští víkend") 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(/^(.+) (před|za) ([1-9]\d*) (den|dny|dnů|dnem|týden|týdny|týdnů|týdnem|měsíc|měsíce|měsíců|měsícem|měsíci|čtvrtletí|čtvrtletím|čtvrtletími|rok|roky|let|rokem|lety)$/u)(input);
+	if (Option.isSome(shifted)) {
+		const amount = parseTrailingCount(textAt(shifted.value, 3));
+		const alias = unitAliases.find((unit) => unit[0] === textAt(shifted.value, 4));
+		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 past = textAt(shifted.value, 2) === "před";
+			const direction = past ? -amount.value : amount.value;
+			const pastNoun = amount.value === 1 ? entry.pastSingular : entry.pastPlural;
+			const noun = past ? pastNoun : countNoun(amount.value, entry);
+			const canonical = `${period.value.canonical} ${past ? "před" : "za"} ${amount.value} ${noun}`;
+			return Option.some(shiftPeriod(period.value, direction, entry.unit, canonical));
+		}
+	}
 	const edge = String$1.match(/^(začátek|počátek|konec) (.+)$/u)(input);
 	if (Option.isSome(edge)) {
-		const period = parseBasePeriod(textAt(edge.value, 2));
+		const periodText = textAt(edge.value, 2);
+		const basePeriod = parseBasePeriod(periodText);
+		const implicit = units.find((entry) => entry.durationGenitive === periodText);
+		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) === "konec";
 			const canonical = `${isEnd ? "konec" : "začátek"} ${period.value.canonical}`;
@@ -462,7 +612,8 @@ const parsePeriod = (input) => {
 		"celý ",
 		"celé "
 	].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 = "den|dny|dnů|dnem|týden|týdny|týdnů|týdnem|měsíc|měsíce|měsíců|měsícem|měsíci|čtvrtletí|čtvrtletím|čtvrtletími|rok|roky|let|rokem|lety";
@@ -512,7 +663,7 @@ const parseCalendarOffset = (input) => {
 	const futureNoun = countNoun(amount.value, entry);
 	const pastNoun = amount.value === 1 ? entry.pastSingular : entry.pastPlural;
 	const canonical = direction < 0 ? `před ${amount.value} ${pastNoun}` : `za ${amount.value} ${futureNoun}`;
-	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);
@@ -579,15 +730,17 @@ const parseCzech = (input) => {
 		"ode dneška",
 		"od teď"
 	].includes(input)) return Option.some(candidate(fromNowRange(), "od nynějška"));
-	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 nowBounded = joinedNowCandidate(input, [["od ", " do dneška"], ["mezi ", " a dneškem"]], ["od dneška do ", "mezi dneškem a "], parsePeriod, (period) => `od ${period} do dneška`, (period) => `od dneška do ${period}`);
+	const nowBounded = joinedNowCandidate(input, [["od ", " do dneška"], ["mezi ", " a dneškem"]], [
+		"od dneška do ",
+		"mezi dneškem a ",
+		"dnešek až "
+	], parsePeriod, (period) => `od ${period} do dneška`, (period) => `od dneška do ${period}`);
 	if (Option.isSome(nowBounded)) return nowBounded;
 	const bounded = joinedPeriodCandidate(input, [
 		["od ", " do "],
@@ -609,6 +762,8 @@ const staticPeriodPhrases = [
 	"předminulý víkend",
 	"přespříští víkend",
 	...periodAliases.flatMap((entry) => [`začátek ${entry[0]}`, `konec ${entry[0]}`]),
+	...nextWeekdays.map((entry) => entry.phrase),
+	...months.flatMap((month) => [`minulý ${month}`, `příští ${month}`]),
 	...[
 		1,
 		2,
@@ -670,6 +825,18 @@ const suggestCzech = (input, limit) => {
 	], limit);
 };
 const renderCzech = (range) => {
+	const shifted = decomposeShiftedPeriodRange(range);
+	if (Option.isSome(shifted)) {
+		const base = renderCzech(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 pastNoun = amount === 1 ? entry.pastSingular : entry.pastPlural;
+			const noun = shifted.value.amount < 0 ? pastNoun : countNoun(amount, entry);
+			const direction = shifted.value.amount < 0 ? "před" : "za";
+			return Option.some(`${base.value} ${direction} ${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);
@@ -701,6 +868,8 @@ const CzechContribution = new BaseLanguageContribution({
 	locale: "cs",
 	vocabulary: [
 		...months,
+		...weekdays,
+		...weekdayGenitives,
 		...monthAbbreviations.flatMap((aliases) => aliases),
 		...units.flatMap((entry) => [
 			entry.singular,
@@ -731,8 +900,8 @@ const CzechContribution = new BaseLanguageContribution({
 		"začátek",
 		"zbytek"
 	],
-	normalize: normalizeNaturalText,
-	correct: correctWhitespaceSeparatedText,
+	normalize: normalizeCzech,
+	correct: correctCzech,
 	parseExact: parseCzech,
 	suggest: suggestCzech,
 	render: renderCzech