chronolizer 0.2.0 → 0.4.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,
@@ -31,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/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
@@ -38,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

@@ -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,
@@ -63,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)(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"
+			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,
@@ -92,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 });
@@ -120,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 };