chronolizer 0.2.0 → 0.3.0

package/dist/ast/schemas.mjs

@@ -1,4 +1,4 @@
-import { Option, Schema, String } from "effect";
+import { Match, Option, Schema, String } from "effect";
 //#region src/ast/schemas.ts
 const Unit = Schema.Literals([
 	"day",
@@ -8,16 +8,7 @@ const Unit = Schema.Literals([
 	"year"
 ]);
 const isLeapYear = (year) => year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
-const daysInMonth = (year, month) => {
-	switch (month) {
-		case 2: return isLeapYear(year) ? 29 : 28;
-		case 4:
-		case 6:
-		case 9:
-		case 11: return 30;
-		default: return 31;
-	}
-};
+const daysInMonth = (year, month) => Match.value(month).pipe(Match.when(2, () => isLeapYear(year) ? 29 : 28), Match.when(Match.is(4, 6, 9, 11), () => 30), Match.orElse(() => 31));
 const isIsoDate = (value) => {
 	if (Option.isNone(String.match(/^\d{4}-\d{2}-\d{2}$/)(value))) return false;
 	const year = Number(value.slice(0, 4));
@@ -26,21 +17,21 @@ const isIsoDate = (value) => {
 	return month >= 1 && month <= 12 && day >= 1 && day <= daysInMonth(year, month);
 };
 const IsoDate = Schema.String.check(Schema.makeFilter(isIsoDate, { expected: "an ISO calendar date (YYYY-MM-DD)" })).annotate({ identifier: "IsoDate" });
-const Now = Schema.TaggedStruct("Now", {});
-const DateLiteral = Schema.TaggedStruct("DateLiteral", { value: IsoDate });
+var Now = class extends Schema.TaggedClass()("Now", {}) {};
+var DateLiteral = class extends Schema.TaggedClass()("DateLiteral", { value: IsoDate }) {};
 const ShiftAmount = Schema.Int.check(Schema.isBetween({
 	minimum: Number.MIN_SAFE_INTEGER,
 	maximum: Number.MAX_SAFE_INTEGER
 }));
-const Shift = Schema.TaggedStruct("Shift", {
+var Shift = class extends Schema.TaggedClass()("Shift", {
 	base: Schema.suspend(() => InstantExpr),
 	amount: ShiftAmount,
 	unit: Unit
-});
-const StartOf = Schema.TaggedStruct("StartOf", {
+}) {};
+var StartOf = class extends Schema.TaggedClass()("StartOf", {
 	base: Schema.suspend(() => InstantExpr),
 	unit: Unit
-});
+}) {};
 const InstantExpr = Schema.suspend(() => Schema.Union([
 	Now,
 	DateLiteral,

package/dist/filter/expression.mjs

@@ -3,27 +3,10 @@ import { dateLiteral, now, shift, startOf } from "../ast/constructors.mjs";
 import { foldInstant } from "../ast/fold.mjs";
 import { normalizeInstant } from "../ast/normalize.mjs";
 import { FilterExpressionParseError } from "./errors.mjs";
-import { Effect } from "effect";
+import { Effect, Match } from "effect";
 //#region src/filter/expression.ts
-const unitFromSymbol = (symbol) => {
-	switch (symbol) {
-		case "d": return "day";
-		case "w": return "week";
-		case "M": return "month";
-		case "q": return "quarter";
-		case "y": return "year";
-		default: return;
-	}
-};
-const symbolFromUnit = (unit) => {
-	switch (unit) {
-		case "day": return "d";
-		case "week": return "w";
-		case "month": return "M";
-		case "quarter": return "q";
-		case "year": return "y";
-	}
-};
+const unitFromSymbol = (symbol) => Match.value(symbol).pipe(Match.when("d", () => "day"), Match.when("w", () => "week"), Match.when("M", () => "month"), Match.when("q", () => "quarter"), Match.when("y", () => "year"), Match.orElse(() => void 0));
+const symbolFromUnit = (unit) => Match.value(unit).pipe(Match.when("day", () => "d"), Match.when("week", () => "w"), Match.when("month", () => "M"), Match.when("quarter", () => "q"), Match.when("year", () => "y"), Match.exhaustive);
 const failAt = (input, offset, expected) => Effect.fail(new FilterExpressionParseError({
 	input,
 	offset,

package/dist/index.d.mts

@@ -1,6 +1,6 @@
 import { DateLiteral, DateRangeExpr, GreaterThan, GreaterThanOrEqual, InstantExpr, IsoDate, LessThan, LessThanOrEqual, LowerBound, Now, Shift, StartOf, Unit, UpperBound, daysInMonth, isIsoDate } from "./ast/schemas.mjs";
 import { boundedRange, dateLiteral, greaterThan, greaterThanOrEqual, lessThan, lessThanOrEqual, lowerOpenRange, now, shift, startOf, upperOpenRange } from "./ast/constructors.mjs";
-import { InstantAlgebra, containsPositiveShift, foldInstant } from "./ast/fold.mjs";
+import { InstantAlgebra, containsPositiveShift, foldInstant, isCurrentPeriod } from "./ast/fold.mjs";
 import { normalizeInstant, normalizeRange } from "./ast/normalize.mjs";
 import { FilterExpressionParseError, InvalidDateFilterError } from "./filter/errors.mjs";
 import { completePeriod, formatFilter, parseFilter, rangeKey } from "./filter/codec.mjs";
@@ -19,4 +19,4 @@ import { SuggestNaturalOptions, suggestNatural } from "./natural/suggest.mjs";
 import { naturalWords, normalizeNaturalText } from "./natural/text.mjs";
 import { ResolutionError, ResolvedDateRange, ResolvedGreaterThan, ResolvedGreaterThanOrEqual, ResolvedLessThan, ResolvedLessThanOrEqual, ResolvedLowerBound, ResolvedUpperBound } from "./resolve/schema.mjs";
 import { resolve } from "./resolve/resolve.mjs";
-export { AmbiguousNaturalLanguageError, BaseLanguageContribution, BaseLanguageMetadata, CompiledLanguage, Correction, DateExpressionString, DateFilter, DateLiteral, DateRangeExpr, DateRangeFromFilter, EnglishContribution, EnglishLanguage, EnglishLanguageLayer, FilterExpressionParseError, type FormatNaturalOptions, GreaterThan, GreaterThanOrEqual, InstantAlgebra, InstantExpr, InstantExpressionFromString, InvalidDateFilterError, IsoDate, LanguageConflictError, LanguageContribution, LanguageContributionMetadata, LanguageExtensionContribution, LanguageExtensionMetadata, LanguagePlugin, LanguagePluginContext, LanguageRegistrationError, LanguageRegistry, LanguageRegistryLayer, LessThan, LessThanOrEqual, Locale, LowerBound, NaturalAlternative, NaturalCandidate, NaturalCorrectionCandidate, NaturalLanguageParseError, NaturalLanguageRenderError, NaturalParseResult, NaturalSuggestion, Now, type ParseNaturalOptions, ParseQuality, ResolutionError, ResolvedDateRange, ResolvedGreaterThan, ResolvedGreaterThanOrEqual, ResolvedLessThan, ResolvedLessThanOrEqual, ResolvedLowerBound, ResolvedUpperBound, Shift, StartOf, type SuggestNaturalOptions, Unit, UnsupportedLocaleError, UpperBound, boundedRange, canonicalBaseLocale, completeNaturalPhrases, completePeriod, containsPositiveShift, correctWhitespaceSeparatedText, dateLiteral, daysInMonth, defineLanguagePlugin, foldInstant, formatFilter, formatInstantExpression, formatNatural, greaterThan, greaterThanOrEqual, isIsoDate, languagePluginsLayer, lessThan, lessThanOrEqual, lowerOpenRange, naturalWords, normalizeInstant, normalizeNaturalText, normalizeRange, now, parseFilter, parseInstantExpression, parseNatural, rangeKey, resolve, shift, startOf, suggestNatural, upperOpenRange };
+export { AmbiguousNaturalLanguageError, BaseLanguageContribution, BaseLanguageMetadata, CompiledLanguage, Correction, DateExpressionString, DateFilter, DateLiteral, DateRangeExpr, DateRangeFromFilter, EnglishContribution, EnglishLanguage, EnglishLanguageLayer, FilterExpressionParseError, type FormatNaturalOptions, GreaterThan, GreaterThanOrEqual, InstantAlgebra, InstantExpr, InstantExpressionFromString, InvalidDateFilterError, IsoDate, LanguageConflictError, LanguageContribution, LanguageContributionMetadata, LanguageExtensionContribution, LanguageExtensionMetadata, LanguagePlugin, LanguagePluginContext, LanguageRegistrationError, LanguageRegistry, LanguageRegistryLayer, LessThan, LessThanOrEqual, Locale, LowerBound, NaturalAlternative, NaturalCandidate, NaturalCorrectionCandidate, NaturalLanguageParseError, NaturalLanguageRenderError, NaturalParseResult, NaturalSuggestion, Now, type ParseNaturalOptions, ParseQuality, ResolutionError, ResolvedDateRange, ResolvedGreaterThan, ResolvedGreaterThanOrEqual, ResolvedLessThan, ResolvedLessThanOrEqual, ResolvedLowerBound, ResolvedUpperBound, Shift, StartOf, type SuggestNaturalOptions, Unit, UnsupportedLocaleError, UpperBound, boundedRange, canonicalBaseLocale, completeNaturalPhrases, completePeriod, containsPositiveShift, correctWhitespaceSeparatedText, dateLiteral, daysInMonth, defineLanguagePlugin, foldInstant, formatFilter, formatInstantExpression, formatNatural, greaterThan, greaterThanOrEqual, isCurrentPeriod, isIsoDate, languagePluginsLayer, lessThan, lessThanOrEqual, lowerOpenRange, naturalWords, normalizeInstant, normalizeNaturalText, normalizeRange, now, parseFilter, parseInstantExpression, parseNatural, rangeKey, resolve, shift, startOf, suggestNatural, upperOpenRange };

package/dist/index.mjs

@@ -1,6 +1,6 @@
 import { DateLiteral, DateRangeExpr, GreaterThan, GreaterThanOrEqual, InstantExpr, IsoDate, LessThan, LessThanOrEqual, LowerBound, Now, Shift, StartOf, Unit, UpperBound, daysInMonth, isIsoDate } from "./ast/schemas.mjs";
 import { boundedRange, dateLiteral, greaterThan, greaterThanOrEqual, lessThan, lessThanOrEqual, lowerOpenRange, now, shift, startOf, upperOpenRange } from "./ast/constructors.mjs";
-import { containsPositiveShift, foldInstant } from "./ast/fold.mjs";
+import { containsPositiveShift, foldInstant, isCurrentPeriod } from "./ast/fold.mjs";
 import { normalizeInstant, normalizeRange } from "./ast/normalize.mjs";
 import { FilterExpressionParseError, InvalidDateFilterError } from "./filter/errors.mjs";
 import { formatInstantExpression, parseInstantExpression } from "./filter/expression.mjs";
@@ -19,4 +19,4 @@ import { parseNatural } from "./natural/parse.mjs";
 import { suggestNatural } from "./natural/suggest.mjs";
 import { ResolutionError, ResolvedDateRange, ResolvedGreaterThan, ResolvedGreaterThanOrEqual, ResolvedLessThan, ResolvedLessThanOrEqual, ResolvedLowerBound, ResolvedUpperBound } from "./resolve/schema.mjs";
 import { resolve } from "./resolve/resolve.mjs";
-export { AmbiguousNaturalLanguageError, BaseLanguageContribution, BaseLanguageMetadata, Correction, DateExpressionString, DateFilter, DateLiteral, DateRangeExpr, DateRangeFromFilter, EnglishContribution, EnglishLanguage, EnglishLanguageLayer, FilterExpressionParseError, GreaterThan, GreaterThanOrEqual, InstantExpr, InstantExpressionFromString, InvalidDateFilterError, IsoDate, LanguageConflictError, LanguageContributionMetadata, LanguageExtensionContribution, LanguageExtensionMetadata, LanguageRegistrationError, LanguageRegistry, LanguageRegistryLayer, LessThan, LessThanOrEqual, Locale, LowerBound, NaturalAlternative, NaturalCandidate, NaturalCorrectionCandidate, NaturalLanguageParseError, NaturalLanguageRenderError, NaturalParseResult, NaturalSuggestion, Now, ParseQuality, ResolutionError, ResolvedDateRange, ResolvedGreaterThan, ResolvedGreaterThanOrEqual, ResolvedLessThan, ResolvedLessThanOrEqual, ResolvedLowerBound, ResolvedUpperBound, Shift, StartOf, Unit, UnsupportedLocaleError, UpperBound, boundedRange, canonicalBaseLocale, completeNaturalPhrases, completePeriod, containsPositiveShift, correctWhitespaceSeparatedText, dateLiteral, daysInMonth, defineLanguagePlugin, foldInstant, formatFilter, formatInstantExpression, formatNatural, greaterThan, greaterThanOrEqual, isIsoDate, languagePluginsLayer, lessThan, lessThanOrEqual, lowerOpenRange, naturalWords, normalizeInstant, normalizeNaturalText, normalizeRange, now, parseFilter, parseInstantExpression, parseNatural, rangeKey, resolve, shift, startOf, suggestNatural, upperOpenRange };
+export { AmbiguousNaturalLanguageError, BaseLanguageContribution, BaseLanguageMetadata, Correction, DateExpressionString, DateFilter, DateLiteral, DateRangeExpr, DateRangeFromFilter, EnglishContribution, EnglishLanguage, EnglishLanguageLayer, FilterExpressionParseError, GreaterThan, GreaterThanOrEqual, InstantExpr, InstantExpressionFromString, InvalidDateFilterError, IsoDate, LanguageConflictError, LanguageContributionMetadata, LanguageExtensionContribution, LanguageExtensionMetadata, LanguageRegistrationError, LanguageRegistry, LanguageRegistryLayer, LessThan, LessThanOrEqual, Locale, LowerBound, NaturalAlternative, NaturalCandidate, NaturalCorrectionCandidate, NaturalLanguageParseError, NaturalLanguageRenderError, NaturalParseResult, NaturalSuggestion, Now, ParseQuality, ResolutionError, ResolvedDateRange, ResolvedGreaterThan, ResolvedGreaterThanOrEqual, ResolvedLessThan, ResolvedLessThanOrEqual, ResolvedLowerBound, ResolvedUpperBound, Shift, StartOf, Unit, UnsupportedLocaleError, UpperBound, boundedRange, canonicalBaseLocale, completeNaturalPhrases, completePeriod, containsPositiveShift, correctWhitespaceSeparatedText, dateLiteral, daysInMonth, defineLanguagePlugin, foldInstant, formatFilter, formatInstantExpression, formatNatural, greaterThan, greaterThanOrEqual, isCurrentPeriod, isIsoDate, languagePluginsLayer, lessThan, lessThanOrEqual, lowerOpenRange, naturalWords, normalizeInstant, normalizeNaturalText, normalizeRange, now, parseFilter, parseInstantExpression, parseNatural, rangeKey, resolve, shift, startOf, suggestNatural, upperOpenRange };

package/dist/language/model.d.mts

@@ -22,8 +22,37 @@ declare const NaturalCorrectionCandidate: Schema.Struct<{
   readonly cost: Schema.Int;
 }>;
 type NaturalCorrectionCandidate = typeof NaturalCorrectionCandidate.Type;
-declare const NaturalAlternative: Schema.Struct<{
+declare const NaturalCandidate: Schema.Struct<{
+  readonly range: Schema.Union<readonly [Schema.TaggedStruct<"DateRange", {
+    readonly lower: Schema.Union<readonly [Schema.TaggedStruct<"GreaterThan", {
+      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+    }>, Schema.TaggedStruct<"GreaterThanOrEqual", {
+      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+    }>]>;
+    readonly upper: Schema.Union<readonly [Schema.TaggedStruct<"LessThan", {
+      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+    }>, Schema.TaggedStruct<"LessThanOrEqual", {
+      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+    }>]>;
+  }>, Schema.TaggedStruct<"DateRange", {
+    readonly lower: Schema.Union<readonly [Schema.TaggedStruct<"GreaterThan", {
+      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+    }>, Schema.TaggedStruct<"GreaterThanOrEqual", {
+      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+    }>]>;
+    readonly upper: Schema.optionalKey<Schema.Never>;
+  }>, Schema.TaggedStruct<"DateRange", {
+    readonly lower: Schema.optionalKey<Schema.Never>;
+    readonly upper: Schema.Union<readonly [Schema.TaggedStruct<"LessThan", {
+      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+    }>, Schema.TaggedStruct<"LessThanOrEqual", {
+      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+    }>]>;
+  }>]>;
   readonly canonical: Schema.String;
+}>;
+type NaturalCandidate = typeof NaturalCandidate.Type;
+declare const NaturalAlternative: Schema.Struct<{
   readonly range: Schema.Union<readonly [Schema.TaggedStruct<"DateRange", {
     readonly lower: Schema.Union<readonly [Schema.TaggedStruct<"GreaterThan", {
       readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
@@ -50,8 +79,9 @@ declare const NaturalAlternative: Schema.Struct<{
       readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
     }>]>;
   }>]>;
+  readonly canonical: Schema.String;
 }>;
-type NaturalAlternative = typeof NaturalAlternative.Type;
+type NaturalAlternative = NaturalCandidate;
 declare const NaturalParseResult: Schema.Struct<{
   readonly range: Schema.Union<readonly [Schema.TaggedStruct<"DateRange", {
     readonly lower: Schema.Union<readonly [Schema.TaggedStruct<"GreaterThan", {
@@ -87,7 +117,6 @@ declare const NaturalParseResult: Schema.Struct<{
     readonly offset: Schema.Int;
   }>>;
   readonly alternatives: Schema.$Array<Schema.Struct<{
-    readonly canonical: Schema.String;
     readonly range: Schema.Union<readonly [Schema.TaggedStruct<"DateRange", {
       readonly lower: Schema.Union<readonly [Schema.TaggedStruct<"GreaterThan", {
         readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
@@ -114,39 +143,10 @@ declare const NaturalParseResult: Schema.Struct<{
         readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
       }>]>;
     }>]>;
+    readonly canonical: Schema.String;
   }>>;
 }>;
 type NaturalParseResult = typeof NaturalParseResult.Type;
-declare const NaturalCandidate: Schema.Struct<{
-  readonly range: Schema.Union<readonly [Schema.TaggedStruct<"DateRange", {
-    readonly lower: Schema.Union<readonly [Schema.TaggedStruct<"GreaterThan", {
-      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
-    }>, Schema.TaggedStruct<"GreaterThanOrEqual", {
-      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
-    }>]>;
-    readonly upper: Schema.Union<readonly [Schema.TaggedStruct<"LessThan", {
-      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
-    }>, Schema.TaggedStruct<"LessThanOrEqual", {
-      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
-    }>]>;
-  }>, Schema.TaggedStruct<"DateRange", {
-    readonly lower: Schema.Union<readonly [Schema.TaggedStruct<"GreaterThan", {
-      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
-    }>, Schema.TaggedStruct<"GreaterThanOrEqual", {
-      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
-    }>]>;
-    readonly upper: Schema.optionalKey<Schema.Never>;
-  }>, Schema.TaggedStruct<"DateRange", {
-    readonly lower: Schema.optionalKey<Schema.Never>;
-    readonly upper: Schema.Union<readonly [Schema.TaggedStruct<"LessThan", {
-      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
-    }>, Schema.TaggedStruct<"LessThanOrEqual", {
-      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
-    }>]>;
-  }>]>;
-  readonly canonical: Schema.String;
-}>;
-type NaturalCandidate = typeof NaturalCandidate.Type;
 declare const NaturalSuggestion: Schema.Struct<{
   readonly text: Schema.String;
   readonly range: Schema.Union<readonly [Schema.TaggedStruct<"DateRange", {

package/dist/language/model.mjs

@@ -17,20 +17,17 @@ const NaturalCorrectionCandidate = Schema.Struct({
 	corrections: Schema.Array(Correction),
 	cost: Schema.Int.check(Schema.isGreaterThanOrEqualTo(1))
 });
-const NaturalAlternative = Schema.Struct({
-	canonical: Schema.String,
-	range: DateRangeExpr
+const NaturalCandidate = Schema.Struct({
+	range: DateRangeExpr,
+	canonical: Schema.String
 });
+const NaturalAlternative = NaturalCandidate;
 const NaturalParseResult = Schema.Struct({
 	range: DateRangeExpr,
 	quality: ParseQuality,
 	corrections: Schema.Array(Correction),
 	alternatives: Schema.Array(NaturalAlternative)
 });
-const NaturalCandidate = Schema.Struct({
-	range: DateRangeExpr,
-	canonical: Schema.String
-});
 const NaturalSuggestion = Schema.Struct({
 	text: Schema.String,
 	range: DateRangeExpr

package/dist/language/registry.mjs

@@ -1,20 +1,9 @@
 import { LanguageConflictError, LanguageRegistrationError, UnsupportedLocaleError } from "./errors.mjs";
-import { BaseLanguageMetadata, LanguageContributionMetadata, LanguageExtensionMetadata, canonicalBaseLocale } from "./model.mjs";
+import { LanguageContributionMetadata, canonicalBaseLocale } from "./model.mjs";
 import { normalizeNaturalText } from "../natural/text.mjs";
 import { Array, Context, Effect, Layer, Match, Option, Order, Ref, Result, Schema } from "effect";
 //#region src/language/registry.ts
 var LanguageRegistry = class extends Context.Service()("chronolizer/LanguageRegistry") {};
-const metadataOf = (contribution) => Match.valueTags(contribution, {
-	BaseLanguage: (base) => BaseLanguageMetadata.make({
-		locale: base.locale,
-		vocabulary: base.vocabulary
-	}),
-	LanguageExtension: (extension) => LanguageExtensionMetadata.make({
-		locale: extension.locale,
-		priority: extension.priority,
-		vocabulary: extension.vocabulary
-	})
-});
 const localeCandidates = (locale) => {
 	const candidates = [locale];
 	let parent = locale;
@@ -44,14 +33,7 @@ const compileLanguage = (locale, registered) => {
 	const vocabulary = Object.freeze(Array.dedupe([...base.contribution.vocabulary, ...Array.flatMap(extensions, (entry) => entry.contribution.vocabulary)]));
 	const parsers = Object.freeze([...extensions.map((entry) => entry.contribution.parseExact), base.contribution.parseExact]);
 	const suggesters = Object.freeze([...extensions.map((entry) => entry.contribution.suggest), base.contribution.suggest].filter((suggest) => suggest !== void 0));
-	const parseExact = (input) => {
-		const candidates = [];
-		for (const parser of parsers) {
-			const candidate = parser(input);
-			if (Option.isSome(candidate)) candidates.push(candidate.value);
-		}
-		return candidates;
-	};
+	const parseExact = (input) => Array.flatMap(parsers, (parser) => Option.toArray(parser(input)));
 	return Option.some(Object.freeze({
 		locale: base.contribution.locale,
 		vocabulary,
@@ -65,7 +47,7 @@ const compileLanguage = (locale, registered) => {
 const createRegistry = Effect.fn(function* () {
 	const entries = yield* Ref.make([]);
 	const register = Effect.fn(function* (pluginId, contribution) {
-		if (pluginId.length === 0 || !Schema.is(LanguageContributionMetadata)(metadataOf(contribution))) return yield* new LanguageRegistrationError({
+		if (pluginId.length === 0 || !Schema.is(LanguageContributionMetadata)(contribution)) return yield* new LanguageRegistrationError({
 			pluginId,
 			locale: contribution.locale,
 			message: "Invalid plugin identifier or contribution metadata"

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 { calendarPeriodOffset, candidate, datedPeriods, datedQuarterPeriods, fixedDatePeriod, fixedMonthPeriod, fixedQuarterPeriod, fixedYearPeriod, fromNowRange, futurePeriod, futureRange, isoDate, joinedNowCandidate, joinedPeriodCandidate, monthOfRelativeYear, namedDatePeriod, openBoundaryCandidate, parseTrailingCount, periodEndDay, periodRange, periodStartDay, periodToDateRange, periodsFromPhrases, quarterOfRelativeYear, relativePeriod, relativeWeekend, remainingPeriodRange, renderPeriodRange, textAt, trailingPeriod, trailingRange, untilNowRange, validYear } from "./shared.mjs";
+import { 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 { Effect, Option, String as String$1 } from "effect";
 //#region src/locales/cs.ts
 const months = [
@@ -85,6 +85,7 @@ const units = [
 		many: "dnů",
 		pastSingular: "dnem",
 		pastPlural: "dny",
+		durationGenitive: "dne",
 		current: "dnes",
 		previous: "včera",
 		next: "zítra",
@@ -98,6 +99,7 @@ const units = [
 		many: "týdnů",
 		pastSingular: "týdnem",
 		pastPlural: "týdny",
+		durationGenitive: "týdne",
 		current: "tento týden",
 		previous: "minulý týden",
 		next: "příští týden",
@@ -111,6 +113,7 @@ const units = [
 		many: "měsíců",
 		pastSingular: "měsícem",
 		pastPlural: "měsíci",
+		durationGenitive: "měsíce",
 		current: "tento měsíc",
 		previous: "minulý měsíc",
 		next: "příští měsíc",
@@ -124,6 +127,7 @@ const units = [
 		many: "čtvrtletí",
 		pastSingular: "čtvrtletím",
 		pastPlural: "čtvrtletími",
+		durationGenitive: "čtvrtletí",
 		current: "toto čtvrtletí",
 		previous: "minulé čtvrtletí",
 		next: "příští čtvrtletí",
@@ -137,6 +141,7 @@ const units = [
 		many: "let",
 		pastSingular: "rokem",
 		pastPlural: "lety",
+		durationGenitive: "roku",
 		current: "tento rok",
 		previous: "minulý rok",
 		next: "příští rok",
@@ -144,7 +149,6 @@ const units = [
 		remaining: "zbytek roku"
 	}
 ];
-const title = (value) => `${value.slice(0, 1).toLocaleUpperCase("cs")}${value.slice(1)}`;
 const unitAliases = [
 	["den", "day"],
 	["dny", "day"],
@@ -360,17 +364,22 @@ const monthNumber = (value) => {
 	return short === -1 ? void 0 : short + 1;
 };
 const dateLabel = (day, month, year) => `${day}. ${textAt(monthGenitives, month - 1)} ${year}`;
+const currentDateLabel = (day, month) => `${day}. ${textAt(monthGenitives, month - 1)}`;
 const parseNamedDate = (input) => {
 	const named = String$1.match(/^([0-3]?\d)\.?(?: )([a-záčďéěíňóřšťúůýž]+\.?) (\d{4})$/u)(input);
 	if (Option.isSome(named)) return namedDatePeriod(textAt(named.value, 3), textAt(named.value, 2), textAt(named.value, 1), monthNumber, dateLabel);
 	const numeric = String$1.match(/^([0-3]?\d)(?:\. ?|[/-])([01]?\d)(?:\. ?|[/-])(\d{4})$/u)(input);
-	if (Option.isNone(numeric)) return Option.none();
-	const year = validYear(textAt(numeric.value, 3));
-	const month = Number(textAt(numeric.value, 2));
-	const day = Number(textAt(numeric.value, 1));
-	if (year === void 0 || month < 1 || month > 12) return Option.none();
-	const value = isoDate(year, month, day);
-	return isIsoDate(value) && value !== "9999-12-31" ? Option.some(fixedDatePeriod(value, dateLabel(day, month, year))) : Option.none();
+	if (Option.isSome(numeric)) {
+		const year = validYear(textAt(numeric.value, 3));
+		const month = Number(textAt(numeric.value, 2));
+		const day = Number(textAt(numeric.value, 1));
+		if (year !== void 0 && month >= 1 && month <= 12) {
+			const value = isoDate(year, month, day);
+			if (isIsoDate(value) && value !== "9999-12-31") return Option.some(fixedDatePeriod(value, dateLabel(day, month, year)));
+		}
+	}
+	const current = String$1.match(/^([0-3]?\d)\.? ([a-záčďéěíňóřšťúůýž]+\.?)$/u)(input);
+	return Option.isSome(current) ? namedCurrentYearDatePeriod(textAt(current.value, 2), textAt(current.value, 1), monthNumber, currentDateLabel) : Option.none();
 };
 const quarterNumber = (value) => {
 	if (value.startsWith("q") && value.length === 2) return Number(value.slice(1));
@@ -398,7 +407,8 @@ const parseQuarter = (input) => {
 	return quarter === void 0 ? Option.none() : Option.some(quarterOfRelativeYear(quarter, 0, `Q${quarter}`));
 };
 const parseBasePeriod = (input) => {
-	if (isIsoDate(input) && input !== "9999-12-31") return Option.some(fixedDatePeriod(input, input));
+	const absoluteDate = absoluteDatePeriod(input, "cs");
+	if (Option.isSome(absoluteDate)) return absoluteDate;
 	const namedDate = parseNamedDate(input);
 	if (Option.isSome(namedDate)) return namedDate;
 	const quarter = parseQuarter(input);
@@ -412,7 +422,7 @@ const parseBasePeriod = (input) => {
 	if (Option.isSome(monthYear)) {
 		const month = monthNumber(textAt(monthYear.value, 1));
 		const year = validYear(textAt(monthYear.value, 2));
-		if (month !== void 0 && year !== void 0) return Option.some(fixedMonthPeriod(year, month, `${title(textAt(months, month - 1))} ${year}`));
+		if (month !== void 0 && year !== void 0) return Option.some(fixedMonthPeriod(year, month, `${textAt(months, month - 1)} ${year}`));
 	}
 	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);
@@ -423,10 +433,10 @@ const parseBasePeriod = (input) => {
 		const yearText = textAt(relativeMatch.value, yearFirst ? 1 : 2);
 		const month = monthNumber(monthText);
 		const direction = relativeYearDirection(yearText);
-		if (month !== void 0) return Option.some(monthOfRelativeYear(month, direction, `${title(textAt(months, month - 1))} ${relativeYearName(direction)}`));
+		if (month !== void 0) return Option.some(monthOfRelativeYear(month, direction, `${textAt(months, month - 1)} ${relativeYearName(direction)}`));
 	}
 	const standaloneMonth = monthNumber(input);
-	if (standaloneMonth !== void 0) return Option.some(monthOfRelativeYear(standaloneMonth, 0, title(textAt(months, standaloneMonth - 1))));
+	if (standaloneMonth !== void 0) return Option.some(monthOfRelativeYear(standaloneMonth, 0, textAt(months, standaloneMonth - 1)));
 	const alias = periodAliases.find((entry) => entry[0] === input);
 	if (alias !== void 0) return Option.some(relativePeriod(alias[1], alias[2], alias[3]));
 	if (["víkend", "tento víkend"].includes(input)) return Option.some(relativeWeekend(0, "tento víkend"));
@@ -464,6 +474,24 @@ const rollingFuturePatterns = [countedPattern("^(?:příští|následující) ([
 const rollingSincePattern = countedPattern("^za poslední ([1-9]\\d*) (UNIT)$");
 const rollingBarePattern = countedPattern("^([1-9]\\d*) (UNIT)$");
 const firstPatternMatch = (input, patterns) => Option.firstSomeOf(patterns.map((pattern) => String$1.match(pattern)(input)));
+const singularRollingPhrases = units.flatMap((entry) => [
+	{
+		phrase: `poslední ${entry.singular}`,
+		entry,
+		future: false
+	},
+	{
+		phrase: `během posledního ${entry.durationGenitive}`,
+		entry,
+		future: false
+	},
+	{
+		phrase: `během následujícího ${entry.durationGenitive}`,
+		entry,
+		future: true
+	}
+]);
+const singularRollingCanonical = (entry, future) => `během ${future ? "následujícího" : "posledního"} ${entry.durationGenitive}`;
 const countNoun = (amount, entry) => {
 	if (amount === 1) return entry.singular;
 	const lastTwo = amount % 100;
@@ -487,6 +515,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);
@@ -505,9 +538,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 ? "příští" : "poslední";
 	return Option.some(candidate(range, `${modifier} ${amount.value} ${countNoun(amount.value, entry)}`));
 };
+const parseElidedDateRange = (input) => {
+	const joined = String$1.match(/^od ([0-3]?\d)\.?(?: do) ([0-3]?\d)\.? ([a-záčďéěíňóřšťúůýž]+\.?)(?: (\d{4}))?$/u)(input);
+	const dashed = String$1.match(/^([0-3]?\d)\.?[–—-]([0-3]?\d)\.? ([a-záčďéěíňóřšťúůýž]+\.?)(?: (\d{4}))?$/u)(input);
+	const match = Option.firstSomeOf([joined, dashed]);
+	if (Option.isNone(match)) return Option.none();
+	const lowerDay = textAt(match.value, 1);
+	const upperDay = textAt(match.value, 2);
+	const month = textAt(match.value, 3);
+	const year = textAt(match.value, 4);
+	const suffix = year.length === 0 ? "" : ` ${year}`;
+	return joinedPeriodCandidate(`od ${lowerDay}. ${month}${suffix} do ${upperDay}. ${month}${suffix}`, [["od ", " do "]], parsePeriod, (lower, upper) => `od ${lower} do ${upper} včetně`);
+};
 const boundaryCandidate = (input) => {
 	const included = String$1.match(/^do (.+) včetně$/u)(input);
 	if (Option.isSome(included)) return openBoundaryCandidate(`do ${textAt(included.value, 1)}`, [["do ", "through"]], parsePeriod);
@@ -539,6 +585,8 @@ const parseCzech = (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}`);
 	if (Option.isSome(nowBounded)) return nowBounded;
 	const bounded = joinedPeriodCandidate(input, [
@@ -551,7 +599,7 @@ const parseCzech = (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]),
@@ -606,6 +654,7 @@ const countedSuggestions = (input) => {
 const czechSuggestionPhrases = [
 	...units.map((entry) => entry.toDate),
 	...units.map((entry) => entry.remaining),
+	...singularRollingPhrases.map((entry) => entry.phrase),
 	...staticPeriodPhrases,
 	...prefixNaturalPhrases(staticPeriodPhrases, boundaryPrefixes),
 	"dosud",
@@ -634,14 +683,18 @@ const renderCzech = (range) => {
 	const future = futurePeriod(range);
 	if (Option.isSome(future)) {
 		const entry = units.find((unit) => unit.unit === future.value.unit);
-		if (entry !== void 0) return Option.some(`příští ${future.value.amount} ${countNoun(future.value.amount, entry)}`);
+		if (entry !== void 0) return Option.some(future.value.amount === 1 ? singularRollingCanonical(entry, true) : `příští ${future.value.amount} ${countNoun(future.value.amount, entry)}`);
 	}
 	const trailing = trailingPeriod(range);
 	if (Option.isSome(trailing)) {
 		const entry = units.find((unit) => unit.unit === trailing.value.unit);
-		if (entry !== void 0) return Option.some(`poslední ${trailing.value.amount} ${countNoun(trailing.value.amount, entry)}`);
+		if (entry !== void 0) return Option.some(trailing.value.amount === 1 ? singularRollingCanonical(entry, false) : `poslední ${trailing.value.amount} ${countNoun(trailing.value.amount, entry)}`);
 	}
-	const periods = [...staticPeriods, ...periodsFromPhrases([...datedPeriods(range, months), ...datedQuarterPeriods(range)], parsePeriod)];
+	const periods = [
+		...staticPeriods,
+		...currentYearDatePeriods(range, currentDateLabel),
+		...periodsFromPhrases([...datedPeriods(range, months), ...datedQuarterPeriods(range)], parsePeriod)
+	];
 	return renderPeriodRange(range, [...units.map((entry) => candidate(periodToDateRange(entry.unit), entry.toDate)), ...units.map((entry) => candidate(remainingPeriodRange(entry.unit), entry.remaining))], periods, (period) => `od ${period}`, (period) => `před ${period}`, (period) => `do ${period} včetně`, (period) => `po ${period}`, (lower, upper) => `od ${lower} do ${upper} včetně`, (period) => `od ${period} do dneška`, (period) => `od dneška do ${period}`, () => "dosud", () => "od nynějška");
 };
 const CzechContribution = new BaseLanguageContribution({