chronolizer 0.1.0

package/dist/index.mjs

@@ -0,0 +1,2305 @@
+import { Array as Array$1, Context, Data, DateTime, Effect, Layer, Match, Option, Order, Ref, Result, Schema, SchemaIssue, SchemaTransformation, String as String$1 } from "effect";
+//#region src/ast/schemas.ts
+const Unit = Schema.Literals([
+	"day",
+	"week",
+	"month",
+	"quarter",
+	"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 isIsoDate = (value) => {
+	if (Option.isNone(String$1.match(/^\d{4}-\d{2}-\d{2}$/)(value))) return false;
+	const year = Number(value.slice(0, 4));
+	const month = Number(value.slice(5, 7));
+	const day = Number(value.slice(8, 10));
+	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 });
+const ShiftAmount = Schema.Int.check(Schema.isBetween({
+	minimum: Number.MIN_SAFE_INTEGER,
+	maximum: Number.MAX_SAFE_INTEGER
+}));
+const Shift = Schema.TaggedStruct("Shift", {
+	base: Schema.suspend(() => InstantExpr),
+	amount: ShiftAmount,
+	unit: Unit
+});
+const StartOf = Schema.TaggedStruct("StartOf", {
+	base: Schema.suspend(() => InstantExpr),
+	unit: Unit
+});
+const InstantExpr = Schema.suspend(() => Schema.Union([
+	Now,
+	DateLiteral,
+	Shift,
+	StartOf
+])).annotate({ identifier: "InstantExpr" });
+const GreaterThan = Schema.TaggedStruct("GreaterThan", { value: InstantExpr });
+const GreaterThanOrEqual = Schema.TaggedStruct("GreaterThanOrEqual", { value: InstantExpr });
+const LessThan = Schema.TaggedStruct("LessThan", { value: InstantExpr });
+const LessThanOrEqual = Schema.TaggedStruct("LessThanOrEqual", { value: InstantExpr });
+const LowerBound = Schema.Union([GreaterThan, GreaterThanOrEqual]);
+const UpperBound = Schema.Union([LessThan, LessThanOrEqual]);
+const BoundedDateRange = Schema.TaggedStruct("DateRange", {
+	lower: LowerBound,
+	upper: UpperBound
+});
+const LowerOpenDateRange = Schema.TaggedStruct("DateRange", {
+	lower: LowerBound,
+	upper: Schema.optionalKey(Schema.Never)
+});
+const UpperOpenDateRange = Schema.TaggedStruct("DateRange", {
+	lower: Schema.optionalKey(Schema.Never),
+	upper: UpperBound
+});
+const DateRangeExpr = Schema.Union([
+	BoundedDateRange,
+	LowerOpenDateRange,
+	UpperOpenDateRange
+]).annotate({ identifier: "DateRangeExpr" });
+//#endregion
+//#region src/ast/constructors.ts
+const now = () => Now.make({});
+const dateLiteral = (value) => DateLiteral.make({ value });
+const shift = (base, amount, unit) => Shift.make({
+	base,
+	amount,
+	unit
+});
+const startOf = (base, unit) => StartOf.make({
+	base,
+	unit
+});
+const greaterThan = (value) => GreaterThan.make({ value });
+const greaterThanOrEqual = (value) => GreaterThanOrEqual.make({ value });
+const lessThan = (value) => LessThan.make({ value });
+const lessThanOrEqual = (value) => LessThanOrEqual.make({ value });
+const boundedRange = (lower, upper) => DateRangeExpr.make({
+	lower,
+	upper
+});
+const lowerOpenRange = (lower) => DateRangeExpr.make({ lower });
+const upperOpenRange = (upper) => DateRangeExpr.make({ upper });
+//#endregion
+//#region src/ast/fold.ts
+const foldInstant = (expression, algebra) => {
+	switch (expression._tag) {
+		case "Now": return algebra.now();
+		case "DateLiteral": return algebra.dateLiteral(expression.value);
+		case "Shift": return algebra.shift(foldInstant(expression.base, algebra), expression.amount, expression.unit);
+		case "StartOf": return algebra.startOf(foldInstant(expression.base, algebra), expression.unit);
+	}
+};
+const shiftOffset = (base, amount, unit) => {
+	switch (unit) {
+		case "year": return {
+			...base,
+			months: base.months + amount * 12
+		};
+		case "quarter": return {
+			...base,
+			months: base.months + amount * 3
+		};
+		case "month": return {
+			...base,
+			months: base.months + amount
+		};
+		case "week": return {
+			...base,
+			days: base.days + amount * 7
+		};
+		case "day": return {
+			...base,
+			days: base.days + amount
+		};
+	}
+};
+const containsPositiveShiftInstant = (expression) => {
+	const offset = foldInstant(expression, {
+		now: () => ({
+			months: 0,
+			days: 0
+		}),
+		dateLiteral: () => ({
+			months: 0,
+			days: 0
+		}),
+		shift: shiftOffset,
+		startOf: (base) => base
+	});
+	return offset.months > 0 || offset.days > 0;
+};
+const containsPositiveShift = (range) => range.lower !== void 0 && containsPositiveShiftInstant(range.lower.value) || range.upper !== void 0 && containsPositiveShiftInstant(range.upper.value);
+//#endregion
+//#region src/ast/normalize.ts
+const normalizeInstant = (expression) => Match.valueTags(expression, {
+	Now: () => now(),
+	DateLiteral: (literal) => dateLiteral(literal.value),
+	StartOf: (operation) => startOf(normalizeInstant(operation.base), operation.unit),
+	Shift: (operation) => {
+		const base = normalizeInstant(operation.base);
+		if (operation.amount === 0) return base;
+		if (base._tag === "Shift" && base.unit === operation.unit) {
+			const amount = base.amount + operation.amount;
+			if (Number.isSafeInteger(amount)) return normalizeInstant(shift(base.base, amount, operation.unit));
+		}
+		return shift(base, operation.amount, operation.unit);
+	}
+});
+const normalizeLower = (bound) => Match.valueTags(bound, {
+	GreaterThan: (value) => greaterThan(normalizeInstant(value.value)),
+	GreaterThanOrEqual: (value) => greaterThanOrEqual(normalizeInstant(value.value))
+});
+const normalizeUpper = (bound) => Match.valueTags(bound, {
+	LessThan: (value) => lessThan(normalizeInstant(value.value)),
+	LessThanOrEqual: (value) => lessThanOrEqual(normalizeInstant(value.value))
+});
+const normalizeRange = (range) => {
+	if (range.lower !== void 0 && range.upper !== void 0) return boundedRange(normalizeLower(range.lower), normalizeUpper(range.upper));
+	if (range.lower !== void 0) return lowerOpenRange(normalizeLower(range.lower));
+	return upperOpenRange(normalizeUpper(range.upper));
+};
+//#endregion
+//#region src/filter/errors.ts
+var FilterExpressionParseError = class extends Schema.TaggedError()("FilterExpressionParseError", {
+	input: Schema.String,
+	offset: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
+	expected: Schema.String
+}) {};
+var InvalidDateFilterError = class extends Schema.TaggedError()("InvalidDateFilterError", { message: Schema.String }) {};
+//#endregion
+//#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 failAt = (input, offset, expected) => Effect.fail(new FilterExpressionParseError({
+	input,
+	offset,
+	expected
+}));
+const isDigit = (value) => value >= "0" && value <= "9";
+const isFirstPositiveDigit = (value) => value >= "1" && value <= "9";
+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 \"/\"");
+	}
+	while (cursor < input.length) {
+		const operator = input[cursor];
+		if (operator === "/") {
+			const unit = unitFromSymbol(input[cursor + 1] ?? "");
+			if (unit === void 0) return yield* failAt(input, cursor + 1, "a date unit: d, w, M, q, or y");
+			expression = startOf(expression, unit);
+			cursor += 2;
+			continue;
+		}
+		if (operator !== "+" && operator !== "-") return yield* failAt(input, cursor, "an operation beginning with \"+\", \"-\", or \"/\"");
+		const amountStart = cursor + 1;
+		if (!isFirstPositiveDigit(input[amountStart] ?? "")) return yield* failAt(input, amountStart, "a positive integer without a leading zero");
+		cursor = amountStart + 1;
+		while (cursor < input.length && isDigit(input[cursor] ?? "")) cursor += 1;
+		const amount = Number(input.slice(amountStart, cursor));
+		if (!Number.isSafeInteger(amount)) return yield* failAt(input, amountStart, "a safe positive integer");
+		const unit = unitFromSymbol(input[cursor] ?? "");
+		if (unit === void 0) return yield* failAt(input, cursor, "a date unit: d, w, M, q, or y");
+		expression = shift(expression, operator === "+" ? amount : -amount, unit);
+		cursor += 1;
+	}
+	return expression;
+});
+const appendOperation = (base, operation) => ({
+	text: `${base.text}${base.fixedAnchor ? "||" : ""}${operation}`,
+	fixedAnchor: false
+});
+const formatInstantExpression = (expression) => foldInstant(normalizeInstant(expression), {
+	now: () => ({
+		text: "now",
+		fixedAnchor: false
+	}),
+	dateLiteral: (value) => ({
+		text: value,
+		fixedAnchor: true
+	}),
+	shift: (base, amount, unit) => appendOperation(base, `${amount < 0 ? "-" : "+"}${Math.abs(amount)}${symbolFromUnit(unit)}`),
+	startOf: (base, unit) => appendOperation(base, `/${symbolFromUnit(unit)}`)
+}).text;
+//#endregion
+//#region src/filter/schema.ts
+const DateExpressionString = Schema.String.check(Schema.isMinLength(1)).annotate({ identifier: "DateExpressionString" });
+const DateFilter = Schema.Struct({
+	gt: Schema.optionalKey(DateExpressionString),
+	gte: Schema.optionalKey(DateExpressionString),
+	lt: Schema.optionalKey(DateExpressionString),
+	lte: Schema.optionalKey(DateExpressionString)
+}).check(Schema.makeFilter((filter) => !(filter.gt !== void 0 && filter.gte !== void 0), { expected: "at most one lower date bound" }), Schema.makeFilter((filter) => !(filter.lt !== void 0 && filter.lte !== void 0), { expected: "at most one upper date bound" }), Schema.makeFilter((filter) => filter.gt !== void 0 || filter.gte !== void 0 || filter.lt !== void 0 || filter.lte !== void 0, { expected: "at least one date bound" })).annotate({ identifier: "DateFilter" });
+//#endregion
+//#region src/filter/codec.ts
+const parseLower = (filter) => {
+	if (filter.gt !== void 0) return Effect.map(parseInstantExpression(filter.gt), greaterThan);
+	if (filter.gte !== void 0) return Effect.map(parseInstantExpression(filter.gte), greaterThanOrEqual);
+	return Effect.void;
+};
+const parseUpper = (filter) => {
+	if (filter.lt !== void 0) return Effect.map(parseInstantExpression(filter.lt), lessThan);
+	if (filter.lte !== void 0) return Effect.map(parseInstantExpression(filter.lte), lessThanOrEqual);
+	return Effect.void;
+};
+const parseFilter = Effect.fn("chronolizer.parseFilter")(function* (filter) {
+	const lower = yield* parseLower(filter);
+	const upper = yield* parseUpper(filter);
+	if (lower !== void 0 && upper !== void 0) return normalizeRange(boundedRange(lower, upper));
+	if (lower !== void 0) return normalizeRange(lowerOpenRange(lower));
+	if (upper !== void 0) return normalizeRange(upperOpenRange(upper));
+	return yield* new InvalidDateFilterError({ message: "A date filter must contain at least one bound" });
+});
+const formatLower = Match.typeTags()({
+	GreaterThan: (bound) => DateFilter.make({ gt: formatInstantExpression(bound.value) }),
+	GreaterThanOrEqual: (bound) => DateFilter.make({ gte: formatInstantExpression(bound.value) })
+});
+const formatUpper = Match.typeTags()({
+	LessThan: (bound) => DateFilter.make({ lt: formatInstantExpression(bound.value) }),
+	LessThanOrEqual: (bound) => DateFilter.make({ lte: formatInstantExpression(bound.value) })
+});
+const formatFilter = (range) => {
+	const normalized = normalizeRange(range);
+	if (normalized.lower !== void 0 && normalized.upper !== void 0) return DateFilter.make({
+		...formatLower(normalized.lower),
+		...formatUpper(normalized.upper)
+	});
+	if (normalized.lower !== void 0) return formatLower(normalized.lower);
+	return formatUpper(normalized.upper);
+};
+const rangeKey = (range) => {
+	const filter = formatFilter(range);
+	return `${filter.gt ?? ""}|${filter.gte ?? ""}|${filter.lt ?? ""}|${filter.lte ?? ""}`;
+};
+const completePeriod = (start, end) => boundedRange(greaterThanOrEqual(start), lessThan(end));
+//#endregion
+//#region src/filter/transformation.ts
+const expressionIssue = (input, offset, expected) => new SchemaIssue.Forbidden({ message: `Invalid date expression at offset ${offset}: expected ${expected}; input: ${input}` });
+const InstantExpressionFromString = Schema.String.pipe(Schema.decodeTo(InstantExpr, SchemaTransformation.transformOrFail({
+	decode: (input) => Effect.mapError(parseInstantExpression(input), (error) => expressionIssue(error.input, error.offset, error.expected)),
+	encode: (expression) => Effect.succeed(formatInstantExpression(expression))
+})));
+const DateRangeFromFilter = DateFilter.pipe(Schema.decodeTo(DateRangeExpr, SchemaTransformation.transformOrFail({
+	decode: (filter) => Effect.mapError(parseFilter(filter), (error) => new SchemaIssue.Forbidden({ message: error._tag === "FilterExpressionParseError" ? `Invalid filter expression at offset ${error.offset}: expected ${error.expected}` : error.message })),
+	encode: (range) => Effect.succeed(formatFilter(range))
+})));
+//#endregion
+//#region src/language/errors.ts
+var UnsupportedLocaleError = class extends Schema.TaggedError()("UnsupportedLocaleError", { locale: Schema.String }) {};
+var LanguageConflictError = class extends Schema.TaggedError()("LanguageConflictError", {
+	locale: Schema.String,
+	firstPluginId: Schema.String,
+	secondPluginId: Schema.String,
+	message: Schema.String
+}) {};
+var LanguageRegistrationError = class extends Schema.TaggedError()("LanguageRegistrationError", {
+	pluginId: Schema.String,
+	locale: Schema.String,
+	message: Schema.String
+}) {};
+var NaturalLanguageParseError = class extends Schema.TaggedError()("NaturalLanguageParseError", {
+	input: Schema.String,
+	locale: Schema.String,
+	message: Schema.String
+}) {};
+var AmbiguousNaturalLanguageError = class extends Schema.TaggedError()("AmbiguousNaturalLanguageError", {
+	input: Schema.String,
+	locale: Schema.String,
+	alternatives: Schema.Array(Schema.String)
+}) {};
+var NaturalLanguageRenderError = class extends Schema.TaggedError()("NaturalLanguageRenderError", {
+	locale: Schema.String,
+	message: Schema.String
+}) {};
+//#endregion
+//#region src/language/model.ts
+const ParseQuality = Schema.Literals([
+	"exact",
+	"corrected",
+	"ambiguous"
+]);
+const Correction = Schema.Struct({
+	original: Schema.String,
+	replacement: Schema.String,
+	distance: Schema.Int.check(Schema.isGreaterThanOrEqualTo(1)),
+	offset: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0))
+});
+const NaturalCorrectionCandidate = Schema.Struct({
+	text: Schema.String,
+	corrections: Schema.Array(Correction),
+	cost: Schema.Int.check(Schema.isGreaterThanOrEqualTo(1))
+});
+const NaturalAlternative = Schema.Struct({
+	canonical: Schema.String,
+	range: DateRangeExpr
+});
+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
+});
+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 BaseLanguageMetadata = Schema.TaggedStruct("BaseLanguage", {
+	locale: Locale,
+	vocabulary: Schema.Array(Schema.String)
+});
+const LanguageExtensionMetadata = Schema.TaggedStruct("LanguageExtension", {
+	locale: Locale,
+	priority: Schema.Int,
+	vocabulary: Schema.Array(Schema.String)
+});
+const LanguageContributionMetadata = Schema.Union([BaseLanguageMetadata, LanguageExtensionMetadata]);
+//#endregion
+//#region src/natural/text.ts
+const normalizeNaturalText = (input, locale) => input.normalize("NFKC").toLocaleLowerCase(locale).trim().replace(/\s+/gu, " ");
+const naturalWords = (input) => input.length === 0 ? [] : input.split(" ");
+//#endregion
+//#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;
+	while (parent.includes("-")) {
+		parent = parent.slice(0, parent.lastIndexOf("-"));
+		candidates.push(parent);
+	}
+	return candidates;
+};
+const compileLanguage = (locale, registered) => {
+	const locales = localeCandidates(locale);
+	const base = Array$1.sort(Array$1.filterMap(registered, (entry) => {
+		const contribution = entry.contribution;
+		return contribution._tag === "BaseLanguage" && locales.includes(contribution.locale) ? Result.succeed({
+			pluginId: entry.pluginId,
+			contribution
+		}) : Result.failVoid;
+	}), Order.mapInput(Order.Number, (entry) => locales.indexOf(entry.contribution.locale)))[0];
+	if (base === void 0) return Option.none();
+	const extensions = Array$1.sort(Array$1.filterMap(registered, (entry) => {
+		const contribution = entry.contribution;
+		return contribution._tag === "LanguageExtension" && locales.includes(contribution.locale) ? Result.succeed({
+			pluginId: entry.pluginId,
+			contribution
+		}) : Result.failVoid;
+	}), Order.combine(Order.mapInput(Order.flip(Order.Number), (entry) => entry.contribution.priority), Order.mapInput(Order.String, (entry) => entry.pluginId)));
+	const vocabulary = Object.freeze(Array$1.dedupe([...base.contribution.vocabulary, ...Array$1.flatMap(extensions, (entry) => entry.contribution.vocabulary)]));
+	const parsers = Object.freeze([...extensions.map((entry) => entry.contribution.parseExact), base.contribution.parseExact]);
+	const parseExact = (input) => {
+		const candidates = [];
+		for (const parser of parsers) {
+			const candidate = parser(input);
+			if (Option.isSome(candidate)) candidates.push(candidate.value);
+		}
+		return candidates;
+	};
+	return Option.some(Object.freeze({
+		locale: base.contribution.locale,
+		vocabulary,
+		normalize: base.contribution.normalize ?? normalizeNaturalText,
+		correct: base.contribution.correct,
+		parseExact,
+		render: base.contribution.render
+	}));
+};
+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({
+			pluginId,
+			locale: contribution.locale,
+			message: "Invalid plugin identifier or contribution metadata"
+		});
+		const token = Symbol(pluginId);
+		yield* Effect.acquireRelease(Ref.modify(entries, (current) => {
+			const conflictingBase = Array$1.findFirst(current, (entry) => contribution._tag === "BaseLanguage" && entry.contribution._tag === "BaseLanguage" && entry.contribution.locale === contribution.locale);
+			return Option.match(conflictingBase, {
+				onNone: () => [Result.succeed(token), Array$1.append(current, {
+					token,
+					pluginId,
+					contribution
+				})],
+				onSome: (conflict) => [Result.fail(new LanguageConflictError({
+					locale: contribution.locale,
+					firstPluginId: conflict.pluginId,
+					secondPluginId: pluginId,
+					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$1.filter(items, (entry) => entry.token !== registeredToken)));
+	});
+	const resolve = Effect.fn(function* (locale) {
+		const canonical = canonicalBaseLocale(locale);
+		if (Option.isSome(canonical)) {
+			const compiled = compileLanguage(canonical.value, yield* Ref.get(entries));
+			if (Option.isSome(compiled)) return compiled.value;
+		}
+		return yield* new UnsupportedLocaleError({ locale });
+	});
+	return LanguageRegistry.of({
+		register,
+		resolve
+	});
+});
+const LanguageRegistryLayer = Layer.effect(LanguageRegistry, createRegistry());
+const duplicatePluginId = (plugins) => {
+	const ids = /* @__PURE__ */ new Set();
+	for (const plugin of plugins) {
+		if (ids.has(plugin.id)) return plugin.id;
+		ids.add(plugin.id);
+	}
+};
+const createPluginRegistry = Effect.fn(function* (plugins) {
+	const duplicate = duplicatePluginId(plugins);
+	if (duplicate !== void 0) return yield* new LanguageRegistrationError({
+		pluginId: duplicate,
+		locale: "*",
+		message: "Plugin identifiers must be unique"
+	});
+	const registry = yield* createRegistry();
+	const context = { register: registry.register };
+	const ordered = Array$1.sortWith(plugins, (plugin) => plugin.id, Order.String);
+	for (const plugin of ordered) yield* plugin.effect(context);
+	return registry;
+});
+const languagePluginsLayer = (plugins) => Layer.effect(LanguageRegistry, createPluginRegistry(plugins));
+const defineLanguagePlugin = (plugin) => plugin;
+//#endregion
+//#region src/natural/correction.ts
+const isProtectedToken = (word) => Option.isSome(String$1.match(/^\d+$/u)(word)) || Option.isSome(String$1.match(/^\d{4}-\d{2}-\d{2}$/u)(word)) || word.length <= 3;
+const damerauLevenshtein = (left, right) => {
+	const rows = left.length + 1;
+	const columns = right.length + 1;
+	const matrix = Array.from({ length: rows }, () => Array(columns).fill(0));
+	for (let row = 0; row < rows; row += 1) matrix[row][0] = row;
+	for (let column = 0; column < columns; column += 1) matrix[0][column] = column;
+	for (let row = 1; row < rows; row += 1) for (let column = 1; column < columns; column += 1) {
+		const substitution = left[row - 1] === right[column - 1] ? 0 : 1;
+		matrix[row][column] = Math.min(matrix[row - 1][column] + 1, matrix[row][column - 1] + 1, matrix[row - 1][column - 1] + substitution);
+		if (row > 1 && column > 1 && left[row - 1] === right[column - 2] && left[row - 2] === right[column - 1]) matrix[row][column] = Math.min(matrix[row][column], matrix[row - 2][column - 2] + 1);
+	}
+	return matrix[left.length][right.length];
+};
+const replacementsFor = (word, vocabulary) => {
+	if (vocabulary.includes(word)) return [{
+		word,
+		distance: 0
+	}];
+	if (isProtectedToken(word)) return [];
+	const maximum = word.length >= 6 ? 2 : 1;
+	const matches = vocabulary.filter((candidate) => Math.abs(candidate.length - word.length) <= maximum).map((candidate) => ({
+		word: candidate,
+		distance: damerauLevenshtein(word, candidate)
+	})).filter((candidate) => candidate.distance <= maximum);
+	if (matches.length === 0) return [];
+	const minimum = Math.min(...matches.map((candidate) => candidate.distance));
+	return matches.filter((candidate) => candidate.distance === minimum).slice(0, 4);
+};
+const correctWhitespaceSeparatedText = (input, vocabulary) => {
+	const words = naturalWords(input);
+	let partials = [{
+		words: [],
+		corrections: [],
+		cost: 0,
+		offset: 0
+	}];
+	for (const word of words) {
+		const replacements = replacementsFor(word, vocabulary);
+		if (replacements.length === 0) return [];
+		const next = [];
+		for (const partial of partials) for (const replacement of replacements) {
+			const correction = replacement.distance === 0 ? partial.corrections : [...partial.corrections, Correction.make({
+				original: word,
+				replacement: replacement.word,
+				distance: replacement.distance,
+				offset: partial.offset
+			})];
+			next.push({
+				words: [...partial.words, replacement.word],
+				corrections: correction,
+				cost: partial.cost + replacement.distance,
+				offset: partial.offset + word.length + 1
+			});
+		}
+		partials = next.slice(0, 32);
+	}
+	return partials.filter((partial) => partial.corrections.length > 0).map((partial) => NaturalCorrectionCandidate.make({
+		text: partial.words.join(" "),
+		corrections: partial.corrections,
+		cost: partial.cost
+	}));
+};
+//#endregion
+//#region src/locales/shared.ts
+const Period = Schema.Struct({
+	start: InstantExpr,
+	end: InstantExpr,
+	canonical: Schema.String
+});
+const periodRange = (period) => boundedRange(greaterThanOrEqual(period.start), lessThan(period.end));
+const periodToDateRange = (unit) => boundedRange(greaterThanOrEqual(startOf(now(), unit)), lessThanOrEqual(now()));
+const fromNowRange = () => lowerOpenRange(greaterThanOrEqual(now()));
+const untilNowRange = () => upperOpenRange(lessThanOrEqual(now()));
+const remainingPeriodRange = (unit) => {
+	const start = startOf(now(), unit);
+	return boundedRange(greaterThanOrEqual(now()), lessThan(shift(start, 1, unit)));
+};
+const periodStartDay = (period, canonical) => Period.make({
+	start: period.start,
+	end: shift(period.start, 1, "day"),
+	canonical
+});
+const periodEndDay = (period, canonical) => Period.make({
+	start: shift(period.end, -1, "day"),
+	end: period.end,
+	canonical
+});
+const relativeWeekend = (direction, canonical) => {
+	const weekBase = direction === 0 ? now() : shift(now(), direction, "week");
+	const weekStart = startOf(weekBase, "week");
+	const start = shift(weekStart, 5, "day");
+	return Period.make({
+		start,
+		end: shift(start, 2, "day"),
+		canonical
+	});
+};
+const TrailingCount = Schema.Int.check(Schema.isBetween({
+	minimum: 1,
+	maximum: Number.MAX_SAFE_INTEGER
+}));
+const TrailingPeriod = Schema.Struct({
+	amount: TrailingCount,
+	unit: Unit
+});
+const FuturePeriod = Schema.Struct({
+	amount: TrailingCount,
+	unit: Unit
+});
+const CalendarPeriodOffset = Schema.Struct({
+	amount: Schema.Int,
+	unit: Unit
+});
+const validYear = (value) => {
+	const year = Number(value);
+	return Number.isInteger(year) && year >= 1 && year <= 9998 ? year : void 0;
+};
+const parseTrailingCount = (value) => {
+	const amount = Number(value);
+	return Schema.is(TrailingCount)(amount) ? Option.some(amount) : Option.none();
+};
+const trailingRange = (amount, unit) => boundedRange(greaterThanOrEqual(shift(now(), -amount, unit)), lessThanOrEqual(now()));
+const futureRange = (amount, unit) => boundedRange(greaterThanOrEqual(now()), lessThanOrEqual(shift(now(), amount, unit)));
+const trailingPeriod = (range) => {
+	if (range.lower?._tag !== "GreaterThanOrEqual" || range.upper?._tag !== "LessThanOrEqual" || range.lower.value._tag !== "Shift" || range.lower.value.amount >= 0 || range.lower.value.base._tag !== "Now" || range.upper.value._tag !== "Now") return Option.none();
+	return Option.some(TrailingPeriod.make({
+		amount: -range.lower.value.amount,
+		unit: range.lower.value.unit
+	}));
+};
+const futurePeriod = (range) => {
+	if (range.lower?._tag !== "GreaterThanOrEqual" || range.upper?._tag !== "LessThanOrEqual" || range.lower.value._tag !== "Now" || range.upper.value._tag !== "Shift" || range.upper.value.amount <= 0 || range.upper.value.base._tag !== "Now") return Option.none();
+	return Option.some(FuturePeriod.make({
+		amount: range.upper.value.amount,
+		unit: range.upper.value.unit
+	}));
+};
+const relativePeriod = (unit, direction, canonical) => {
+	const base = direction === 0 ? now() : shift(now(), direction, unit);
+	const start = startOf(base, unit);
+	return Period.make({
+		start,
+		end: shift(start, 1, unit),
+		canonical
+	});
+};
+const pad = (value) => String(value).padStart(2, "0");
+const isoDate = (year, month, day) => `${String(year).padStart(4, "0")}-${pad(month)}-${pad(day)}`;
+const nextDay = (year, month, day) => {
+	if (day < daysInMonth(year, month)) return isoDate(year, month, day + 1);
+	if (month < 12) return isoDate(year, month + 1, 1);
+	return isoDate(year + 1, 1, 1);
+};
+const previousDay = (year, month, day) => {
+	if (day > 1) return isoDate(year, month, day - 1);
+	if (month > 1) return isoDate(year, month - 1, daysInMonth(year, month - 1));
+	return isoDate(year - 1, 12, 31);
+};
+const fixedDatePeriod = (value, canonical) => {
+	const year = Number(value.slice(0, 4));
+	const month = Number(value.slice(5, 7));
+	const day = Number(value.slice(8, 10));
+	return Period.make({
+		start: dateLiteral(value),
+		end: dateLiteral(nextDay(year, month, day)),
+		canonical
+	});
+};
+const namedDatePeriod = (yearText, monthText, dayText, monthNumber, canonical) => {
+	const year = validYear(yearText);
+	const month = monthNumber(monthText);
+	const day = Number(dayText);
+	if (year === void 0 || month === void 0) return Option.none();
+	const value = isoDate(year, month, day);
+	if (!isIsoDate(value) || value === "9999-12-31") return Option.none();
+	return Option.some(fixedDatePeriod(value, canonical(day, month, year)));
+};
+const fixedMonthPeriod = (year, month, canonical) => {
+	const nextYear = month === 12 ? year + 1 : year;
+	const nextMonth = month === 12 ? 1 : month + 1;
+	return Period.make({
+		start: dateLiteral(isoDate(year, month, 1)),
+		end: dateLiteral(isoDate(nextYear, nextMonth, 1)),
+		canonical
+	});
+};
+const fixedYearPeriod = (year, canonical) => Period.make({
+	start: dateLiteral(isoDate(year, 1, 1)),
+	end: dateLiteral(isoDate(year + 1, 1, 1)),
+	canonical
+});
+const fixedQuarterPeriod = (year, quarter, canonical) => {
+	const month = (quarter - 1) * 3 + 1;
+	const nextYear = quarter === 4 ? year + 1 : year;
+	const nextMonth = quarter === 4 ? 1 : month + 3;
+	return Period.make({
+		start: dateLiteral(isoDate(year, month, 1)),
+		end: dateLiteral(isoDate(nextYear, nextMonth, 1)),
+		canonical
+	});
+};
+const quarterOfRelativeYear = (quarter, direction, canonical) => {
+	const yearBase = direction === 0 ? now() : shift(now(), direction, "year");
+	const yearStart = startOf(yearBase, "year");
+	const start = quarter === 1 ? yearStart : shift(yearStart, (quarter - 1) * 3, "month");
+	return Period.make({
+		start,
+		end: shift(start, 1, "quarter"),
+		canonical
+	});
+};
+const monthOfRelativeYear = (month, direction, canonical) => {
+	const yearBase = direction === 0 ? now() : shift(now(), direction, "year");
+	const yearStart = startOf(yearBase, "year");
+	const start = month === 1 ? yearStart : shift(yearStart, month - 1, "month");
+	return Period.make({
+		start,
+		end: shift(start, 1, "month"),
+		canonical
+	});
+};
+const calendarPeriodOffset = (range) => {
+	if (range.lower?._tag !== "GreaterThanOrEqual" || range.upper?._tag !== "LessThan" || range.lower.value._tag !== "StartOf" || range.lower.value.base._tag !== "Shift" || range.lower.value.base.amount === 0 || range.lower.value.base.base._tag !== "Now" || range.lower.value.unit !== range.lower.value.base.unit || range.upper.value._tag !== "Shift" || range.upper.value.amount !== 1 || range.upper.value.unit !== range.lower.value.unit || formatInstantExpression(range.upper.value.base) !== formatInstantExpression(range.lower.value)) return Option.none();
+	return Option.some(CalendarPeriodOffset.make({
+		amount: range.lower.value.base.amount,
+		unit: range.lower.value.unit
+	}));
+};
+const candidate = (range, canonical) => NaturalCandidate.make({
+	range,
+	canonical
+});
+const joinedNowCandidate = (input, periodToNow, nowToPeriod, parsePeriod, canonicalToNow, canonicalFromNow) => {
+	for (const [prefix, suffix] of periodToNow) {
+		if (!input.startsWith(prefix) || !input.endsWith(suffix)) continue;
+		const period = parsePeriod(input.slice(prefix.length, -suffix.length));
+		if (Option.isNone(period)) continue;
+		return Option.some(candidate(boundedRange(greaterThanOrEqual(period.value.start), lessThanOrEqual(now())), canonicalToNow(period.value.canonical)));
+	}
+	for (const prefix of nowToPeriod) {
+		if (!input.startsWith(prefix)) continue;
+		const period = parsePeriod(input.slice(prefix.length));
+		if (Option.isNone(period)) continue;
+		return Option.some(candidate(boundedRange(greaterThanOrEqual(now()), lessThan(period.value.end)), canonicalFromNow(period.value.canonical)));
+	}
+	return Option.none();
+};
+const joinedPeriodCandidate = (input, joins, parsePeriod, canonical) => {
+	for (const [prefix, separator] of joins) {
+		if (!input.startsWith(prefix)) continue;
+		const separatorIndex = input.indexOf(separator, prefix.length);
+		if (separatorIndex === -1) continue;
+		const lower = parsePeriod(input.slice(prefix.length, separatorIndex));
+		const upper = parsePeriod(input.slice(separatorIndex + separator.length));
+		if (Option.isNone(lower) || Option.isNone(upper)) continue;
+		return Option.some(candidate(boundedRange(greaterThanOrEqual(lower.value.start), lessThan(upper.value.end)), canonical(lower.value.canonical, upper.value.canonical)));
+	}
+	return Option.none();
+};
+const periodBoundaryCandidate = (period, boundary, canonical) => {
+	switch (boundary) {
+		case "since": return candidate(lowerOpenRange(greaterThanOrEqual(period.start)), canonical);
+		case "before": return candidate(upperOpenRange(lessThan(period.start)), canonical);
+		case "through": return candidate(upperOpenRange(lessThan(period.end)), canonical);
+		case "after": return candidate(lowerOpenRange(greaterThanOrEqual(period.end)), canonical);
+	}
+};
+const openBoundaryCandidate = (input, boundaries, parsePeriod) => {
+	for (const boundary of boundaries) {
+		if (!input.startsWith(boundary[0])) continue;
+		const period = parsePeriod(input.slice(boundary[0].length));
+		if (Option.isNone(period)) continue;
+		const canonical = `${boundary[0]}${period.value.canonical}`;
+		return Option.some(periodBoundaryCandidate(period.value, boundary[1], canonical));
+	}
+	return Option.none();
+};
+const expressionDates = (range) => {
+	const filter = formatFilter(range);
+	const expressions = [
+		filter.gt,
+		filter.gte,
+		filter.lt,
+		filter.lte
+	];
+	const dates = /* @__PURE__ */ new Set();
+	for (const expression of expressions) {
+		if (expression === void 0) continue;
+		const match = String$1.match(/^(\d{4})-(\d{2})-(\d{2})/u)(expression);
+		if (Option.isSome(match)) dates.add(match.value[0]);
+	}
+	return [...dates];
+};
+const datedQuarterPeriods = (range) => {
+	return [...new Set(expressionDates(range).map((date) => date.slice(0, 4)))].flatMap((year) => [
+		1,
+		2,
+		3,
+		4
+	].map((quarter) => `q${quarter} ${year}`));
+};
+const datedPeriods = (range, months) => {
+	const dates = expressionDates(range);
+	return [...[...new Set(dates.map((date) => date.slice(0, 4)))].flatMap((year) => [...months.map((month) => `${month} ${year}`), year]), ...dates.flatMap((date) => date === "0000-01-01" ? [date] : [date, previousDay(Number(date.slice(0, 4)), Number(date.slice(5, 7)), Number(date.slice(8, 10)))])];
+};
+const periodsFromPhrases = (phrases, parsePeriod) => phrases.flatMap((phrase) => Option.match(parsePeriod(phrase), {
+	onNone: () => [],
+	onSome: (period) => [period]
+}));
+const renderPeriodRange = (range, toDate, periods, since, before, through, after, between, toNow, fromNow, untilNow, afterNow) => {
+	const expected = rangeKey(range);
+	for (const entry of toDate) if (rangeKey(entry.range) === expected) return Option.some(entry.canonical);
+	const filter = formatFilter(range);
+	if (filter.lte === "now" && filter.gt === void 0 && filter.gte === void 0) return Option.some(untilNow());
+	if (filter.gte === "now" && filter.lt === void 0 && filter.lte === void 0) return Option.some(afterNow());
+	if (filter.gte !== void 0 && filter.lte === "now") {
+		const period = periods.find((candidate) => formatInstantExpression(candidate.start) === filter.gte);
+		if (period !== void 0) return Option.some(toNow(period.canonical));
+	}
+	if (filter.gte === "now" && filter.lt !== void 0) {
+		const period = periods.find((candidate) => formatInstantExpression(candidate.end) === filter.lt);
+		if (period !== void 0) return Option.some(fromNow(period.canonical));
+	}
+	if (filter.gte !== void 0 && filter.lt !== void 0) {
+		const exact = periods.find((period) => formatInstantExpression(period.start) === filter.gte && formatInstantExpression(period.end) === filter.lt);
+		if (exact !== void 0) return Option.some(exact.canonical);
+		const lower = periods.find((period) => formatInstantExpression(period.start) === filter.gte)?.canonical;
+		const upper = periods.find((period) => formatInstantExpression(period.end) === filter.lt)?.canonical;
+		return lower === void 0 || upper === void 0 ? Option.none() : Option.some(between(lower, upper));
+	}
+	if (filter.gte !== void 0 && filter.lt === void 0 && filter.lte === void 0) for (const period of periods) {
+		if (formatInstantExpression(period.start) === filter.gte) return Option.some(since(period.canonical));
+		if (formatInstantExpression(period.end) === filter.gte) return Option.some(after(period.canonical));
+	}
+	if (filter.lt !== void 0 && filter.gt === void 0 && filter.gte === void 0) for (const period of periods) {
+		if (formatInstantExpression(period.start) === filter.lt) return Option.some(before(period.canonical));
+		if (formatInstantExpression(period.end) === filter.lt) return Option.some(through(period.canonical));
+	}
+	return Option.none();
+};
+//#endregion
+//#region src/locales/de.ts
+const months$1 = [
+	"januar",
+	"februar",
+	"märz",
+	"april",
+	"mai",
+	"juni",
+	"juli",
+	"august",
+	"september",
+	"oktober",
+	"november",
+	"dezember"
+];
+const monthAbbreviations$1 = [
+	["jan"],
+	["feb"],
+	["mär", "mrz"],
+	["apr"],
+	["mai"],
+	["jun"],
+	["jul"],
+	["aug"],
+	["sep", "sept"],
+	["okt"],
+	["nov"],
+	["dez"]
+];
+const unitPhrases = [
+	{
+		unit: "day",
+		noun: "tag",
+		plural: "tage",
+		current: "heute",
+		previous: "gestern",
+		next: "morgen",
+		compound: "tages",
+		currentGenitive: "dieses tages",
+		dative: "tagen",
+		genitive: "des tages"
+	},
+	{
+		unit: "week",
+		noun: "woche",
+		plural: "wochen",
+		current: "diese woche",
+		previous: "letzte woche",
+		next: "nächste woche",
+		compound: "wochen",
+		currentGenitive: "dieser woche",
+		dative: "wochen",
+		genitive: "der woche"
+	},
+	{
+		unit: "month",
+		noun: "monat",
+		plural: "monate",
+		current: "dieser monat",
+		previous: "letzter monat",
+		next: "nächster monat",
+		compound: "monats",
+		currentGenitive: "dieses monats",
+		dative: "monaten",
+		genitive: "des monats"
+	},
+	{
+		unit: "quarter",
+		noun: "quartal",
+		plural: "quartale",
+		current: "dieses quartal",
+		previous: "letztes quartal",
+		next: "nächstes quartal",
+		compound: "quartals",
+		currentGenitive: "dieses quartals",
+		dative: "quartalen",
+		genitive: "des quartals"
+	},
+	{
+		unit: "year",
+		noun: "jahr",
+		plural: "jahre",
+		current: "dieses jahr",
+		previous: "letztes jahr",
+		next: "nächstes jahr",
+		compound: "jahres",
+		currentGenitive: "dieses jahres",
+		dative: "jahren",
+		genitive: "des jahres"
+	}
+];
+const title$1 = (value) => `${value.slice(0, 1).toLocaleUpperCase("de")}${value.slice(1)}`;
+const canonicalToDate = (entry) => `seit ${title$1(entry.compound)}beginn`;
+const canonicalRelative = (value) => {
+	const separator = value.lastIndexOf(" ");
+	if (separator === -1) return value;
+	return `${value.slice(0, separator + 1)}${title$1(value.slice(separator + 1))}`;
+};
+const remainingPeriodPhrases$1 = unitPhrases.flatMap((entry) => [`rest ${entry.genitive}`, `rest ${entry.currentGenitive}`].map((phrase) => ({
+	entry,
+	phrase
+})));
+const toDatePhrases$1 = unitPhrases.flatMap((entry) => [
+	`seit ${entry.compound}beginn`,
+	`seit ${entry.compound}anfang`,
+	`seit beginn ${entry.genitive}`,
+	`seit anfang ${entry.genitive}`,
+	`seit beginn ${entry.currentGenitive}`,
+	`seit anfang ${entry.currentGenitive}`,
+	`vom ${entry.compound}beginn bis heute`,
+	`vom ${entry.compound}anfang bis heute`,
+	`vom beginn ${entry.genitive} bis heute`,
+	`vom anfang ${entry.genitive} bis heute`,
+	`vom beginn ${entry.currentGenitive} bis heute`,
+	`vom anfang ${entry.currentGenitive} bis heute`,
+	`${entry.noun} bis heute`,
+	`${entry.current} bisher`,
+	`bisher ${entry.current}`
+].map((phrase) => ({
+	entry,
+	phrase
+})));
+const currentBoundaryPhrases = unitPhrases.flatMap((entry) => [
+	[`vor ${entry.compound}beginn`, "before"],
+	[`vor ${entry.compound}anfang`, "before"],
+	[`bis ${entry.compound}beginn`, "before"],
+	[`bis ${entry.compound}anfang`, "before"],
+	[`bis ${entry.compound}ende`, "through"],
+	[`nach ${entry.compound}ende`, "after"],
+	[`ab ${entry.compound}ende`, "after"]
+].map(([phrase, boundary]) => ({
+	boundary,
+	entry,
+	phrase
+})));
+const relativeAliases = [
+	[
+		"vorletzten tag",
+		"day",
+		-2,
+		"vorletzter tag"
+	],
+	[
+		"übernächsten tag",
+		"day",
+		2,
+		"übernächster tag"
+	],
+	[
+		"vorletzte woche",
+		"week",
+		-2,
+		"vorletzte woche"
+	],
+	[
+		"übernächste woche",
+		"week",
+		2,
+		"übernächste woche"
+	],
+	[
+		"vorletzten monat",
+		"month",
+		-2,
+		"vorletzter monat"
+	],
+	[
+		"übernächsten monat",
+		"month",
+		2,
+		"übernächster monat"
+	],
+	[
+		"vorletztes quartal",
+		"quarter",
+		-2,
+		"vorletztes quartal"
+	],
+	[
+		"übernächstes quartal",
+		"quarter",
+		2,
+		"übernächstes quartal"
+	],
+	[
+		"vorletztes jahr",
+		"year",
+		-2,
+		"vorletztes jahr"
+	],
+	[
+		"übernächstes jahr",
+		"year",
+		2,
+		"übernächstes jahr"
+	],
+	[
+		"letzten tag",
+		"day",
+		-1,
+		"gestern"
+	],
+	[
+		"vergangenen tag",
+		"day",
+		-1,
+		"gestern"
+	],
+	[
+		"vorherigen tag",
+		"day",
+		-1,
+		"gestern"
+	],
+	[
+		"diesen tag",
+		"day",
+		0,
+		"heute"
+	],
+	[
+		"heutigen tag",
+		"day",
+		0,
+		"heute"
+	],
+	[
+		"nächsten tag",
+		"day",
+		1,
+		"morgen"
+	],
+	[
+		"kommenden tag",
+		"day",
+		1,
+		"morgen"
+	],
+	[
+		"vergangene woche",
+		"week",
+		-1,
+		"letzte woche"
+	],
+	[
+		"vorherige woche",
+		"week",
+		-1,
+		"letzte woche"
+	],
+	[
+		"aktuelle woche",
+		"week",
+		0,
+		"diese woche"
+	],
+	[
+		"laufende woche",
+		"week",
+		0,
+		"diese woche"
+	],
+	[
+		"kommende woche",
+		"week",
+		1,
+		"nächste woche"
+	],
+	[
+		"folgende woche",
+		"week",
+		1,
+		"nächste woche"
+	],
+	[
+		"letzten monat",
+		"month",
+		-1,
+		"letzter monat"
+	],
+	[
+		"vergangenen monat",
+		"month",
+		-1,
+		"letzter monat"
+	],
+	[
+		"vorherigen monat",
+		"month",
+		-1,
+		"letzter monat"
+	],
+	[
+		"diesen monat",
+		"month",
+		0,
+		"dieser monat"
+	],
+	[
+		"aktuellen monat",
+		"month",
+		0,
+		"dieser monat"
+	],
+	[
+		"laufenden monat",
+		"month",
+		0,
+		"dieser monat"
+	],
+	[
+		"nächsten monat",
+		"month",
+		1,
+		"nächster monat"
+	],
+	[
+		"kommenden monat",
+		"month",
+		1,
+		"nächster monat"
+	],
+	[
+		"folgenden monat",
+		"month",
+		1,
+		"nächster monat"
+	],
+	[
+		"vergangenes quartal",
+		"quarter",
+		-1,
+		"letztes quartal"
+	],
+	[
+		"vorheriges quartal",
+		"quarter",
+		-1,
+		"letztes quartal"
+	],
+	[
+		"aktuelles quartal",
+		"quarter",
+		0,
+		"dieses quartal"
+	],
+	[
+		"laufendes quartal",
+		"quarter",
+		0,
+		"dieses quartal"
+	],
+	[
+		"kommendes quartal",
+		"quarter",
+		1,
+		"nächstes quartal"
+	],
+	[
+		"folgendes quartal",
+		"quarter",
+		1,
+		"nächstes quartal"
+	],
+	[
+		"vergangenes jahr",
+		"year",
+		-1,
+		"letztes jahr"
+	],
+	[
+		"vorheriges jahr",
+		"year",
+		-1,
+		"letztes jahr"
+	],
+	[
+		"aktuelles jahr",
+		"year",
+		0,
+		"dieses jahr"
+	],
+	[
+		"laufendes jahr",
+		"year",
+		0,
+		"dieses jahr"
+	],
+	[
+		"kommendes jahr",
+		"year",
+		1,
+		"nächstes jahr"
+	],
+	[
+		"folgendes jahr",
+		"year",
+		1,
+		"nächstes jahr"
+	]
+];
+const monthNumber$1 = (value) => {
+	const normalized = value.endsWith(".") ? value.slice(0, -1) : value;
+	const fullIndex = months$1.findIndex((month) => month === normalized);
+	if (fullIndex !== -1) return fullIndex + 1;
+	const shortIndex = monthAbbreviations$1.findIndex((aliases) => aliases.some((alias) => alias === normalized));
+	return shortIndex === -1 ? void 0 : shortIndex + 1;
+};
+const parseNamedDate$1 = (input) => {
+	const named = String$1.match(/^([0-3]?\d)\.? ([a-zäöüß]+\.?) (\d{4})$/u)(input);
+	if (Option.isSome(named)) return namedDatePeriod(named.value[3], named.value[2], named.value[1], monthNumber$1, (day, month, year) => `${day}. ${title$1(months$1[month - 1])} ${year}`);
+	const numeric = String$1.match(/^([0-3]?\d)\.([01]?\d)\.(\d{4})$/u)(input);
+	if (Option.isSome(numeric)) {
+		const year = validYear(numeric.value[3]);
+		const day = Number(numeric.value[1]);
+		const month = Number(numeric.value[2]);
+		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, `${day}. ${title$1(months$1[month - 1])} ${year}`));
+		}
+	}
+	return Option.none();
+};
+const quarterNames$1 = [
+	"erstes",
+	"zweites",
+	"drittes",
+	"viertes"
+];
+const quarterNumber$1 = (value) => {
+	if (value.startsWith("q")) return Number(value.slice(1));
+	if (value.endsWith(".")) return Number(value.slice(0, -1));
+	const index = quarterNames$1.findIndex((name) => name === value);
+	return index === -1 ? void 0 : index + 1;
+};
+const relativeDirection$1 = (value) => {
+	if (value === "letzten") return -1;
+	if (value === "nächsten") return 1;
+	return 0;
+};
+const parseQuarter$1 = (input) => {
+	const fixed = String$1.match(/^(q[1-4]|[1-4]\.|erstes|zweites|drittes|viertes)(?: quartal)? (\d{4})$/u)(input);
+	const reversed = String$1.match(/^(\d{4}) (q[1-4])$/u)(input);
+	const relative = String$1.match(/^(q[1-4]|[1-4]\.|erstes|zweites|drittes|viertes)(?: quartal)? (letzten|dieses|nächsten) jahres$/u)(input);
+	const standalone = String$1.match(/^(q[1-4]|[1-4]\.|erstes|zweites|drittes|viertes)(?: quartal)?$/u)(input);
+	if (Option.isSome(fixed) || Option.isSome(reversed)) {
+		const match = [fixed, reversed].find(Option.isSome)?.value;
+		if (match === void 0) return Option.none();
+		const quarterText = Option.isSome(reversed) ? match[2] : match[1];
+		const yearText = Option.isSome(reversed) ? match[1] : match[2];
+		const quarter = quarterNumber$1(quarterText);
+		const year = validYear(yearText);
+		if (quarter !== void 0 && year !== void 0) return Option.some(fixedQuarterPeriod(year, quarter, `Q${quarter} ${year}`));
+	}
+	if (Option.isSome(relative)) {
+		const quarter = quarterNumber$1(relative.value[1]);
+		if (quarter !== void 0) {
+			const direction = relativeDirection$1(relative.value[2]);
+			return Option.some(quarterOfRelativeYear(quarter, direction, `Q${quarter} ${relative.value[2]} Jahres`));
+		}
+	}
+	if (Option.isNone(standalone)) return Option.none();
+	const quarter = quarterNumber$1(standalone.value[1]);
+	return quarter === void 0 ? Option.none() : Option.some(quarterOfRelativeYear(quarter, 0, `Q${quarter}`));
+};
+const parseBasePeriod$1 = (input) => {
+	if (isIsoDate(input) && input !== "9999-12-31") return Option.some(fixedDatePeriod(input, input));
+	const namedDate = parseNamedDate$1(input);
+	if (Option.isSome(namedDate)) return namedDate;
+	const quarter = parseQuarter$1(input);
+	if (Option.isSome(quarter)) return quarter;
+	const yearMatch = String$1.match(/^(?:(?:das )?(?:kalender)?jahr )?(\d{4})$/u)(input);
+	if (Option.isSome(yearMatch)) {
+		const year = validYear(yearMatch.value[1]);
+		if (year !== void 0) return Option.some(fixedYearPeriod(year, String(year)));
+	}
+	const monthYear = String$1.match(/^([a-zäöüß]+\.?) (\d{4})$/u)(input);
+	if (Option.isSome(monthYear)) {
+		const month = monthNumber$1(monthYear.value[1]);
+		const year = validYear(monthYear.value[2]);
+		if (month !== void 0 && year !== void 0) return Option.some(fixedMonthPeriod(year, month, `${title$1(months$1[month - 1])} ${year}`));
+	}
+	const relativeMonth = String$1.match(/^([a-zäöüß]+\.?) (letzten|dieses|nächsten) jahres$/u)(input);
+	if (Option.isSome(relativeMonth)) {
+		const month = monthNumber$1(relativeMonth.value[1]);
+		const direction = relativeDirection$1(relativeMonth.value[2]);
+		if (month !== void 0) return Option.some(monthOfRelativeYear(month, direction, `${title$1(months$1[month - 1])} ${relativeMonth.value[2]} Jahres`));
+	}
+	const standaloneMonth = monthNumber$1(input);
+	if (standaloneMonth !== void 0) return Option.some(monthOfRelativeYear(standaloneMonth, 0, title$1(months$1[standaloneMonth - 1])));
+	if (input === "wochenende" || input === "dieses wochenende" || input === "am wochenende") return Option.some(relativeWeekend(0, "dieses Wochenende"));
+	if (input === "letztes wochenende" || input === "vergangenes wochenende") return Option.some(relativeWeekend(-1, "letztes Wochenende"));
+	if (input === "nächstes wochenende" || input === "kommendes wochenende") return Option.some(relativeWeekend(1, "nächstes Wochenende"));
+	if (input === "vorletztes wochenende") return Option.some(relativeWeekend(-2, "vorletztes Wochenende"));
+	if (input === "übernächstes wochenende") return Option.some(relativeWeekend(2, "übernächstes Wochenende"));
+	const relative = unitPhrases.find((entry) => entry.current === input || entry.previous === input || entry.next === input);
+	if (relative !== void 0) {
+		let direction = 0;
+		if (input === relative.previous) direction = -1;
+		if (input === relative.next) direction = 1;
+		return Option.some(relativePeriod(relative.unit, direction, canonicalRelative(input)));
+	}
+	const alias = relativeAliases.find((entry) => entry[0] === input);
+	if (alias !== void 0) return Option.some(relativePeriod(alias[1], alias[2], canonicalRelative(alias[3])));
+	return Option.none();
+};
+const parsePeriod$1 = (input) => {
+	const edge = String$1.match(/^(anfang|beginn|ende) (.+)$/u)(input);
+	if (Option.isSome(edge)) {
+		const period = parseBasePeriod$1(edge.value[2]);
+		if (Option.isSome(period)) {
+			const canonical = `${edge.value[1] === "ende" ? "Ende" : "Anfang"} ${period.value.canonical}`;
+			return Option.some(edge.value[1] === "ende" ? periodEndDay(period.value, canonical) : periodStartDay(period.value, canonical));
+		}
+	}
+	const wrapper = [
+		"im ",
+		"für ",
+		"während "
+	].find((prefix) => input.startsWith(prefix));
+	return parseBasePeriod$1(wrapper === void 0 ? input : input.slice(wrapper.length));
+};
+const currentBoundaryCandidate = (input) => {
+	const match = currentBoundaryPhrases.find((entry) => entry.phrase === input);
+	if (match === void 0) return Option.none();
+	const period = relativePeriod(match.entry.unit, 0, match.entry.current);
+	return Option.some(periodBoundaryCandidate(period, match.boundary, match.phrase));
+};
+const boundaryCandidate$1 = (input) => openBoundaryCandidate(input, [
+	["seit dem beginn von ", "since"],
+	["seit dem anfang von ", "since"],
+	["seit dem jahr ", "since"],
+	["ab dem jahr ", "since"],
+	["bis zum beginn von ", "before"],
+	["bis zum anfang von ", "before"],
+	["bis zum jahr ", "before"],
+	["bis zum ende von ", "through"],
+	["nach dem ende von ", "after"],
+	["bis einschließlich ", "through"],
+	["seit beginn ", "since"],
+	["seit anfang ", "since"],
+	["ab beginn ", "since"],
+	["ab anfang ", "since"],
+	["vor beginn ", "before"],
+	["vor anfang ", "before"],
+	["bis beginn ", "before"],
+	["bis anfang ", "before"],
+	["bis ende ", "through"],
+	["nach ende ", "after"],
+	["ab ende ", "after"],
+	["seit ", "since"],
+	["vor ", "before"],
+	["nach ", "after"],
+	["bis ", "before"],
+	["ab ", "since"]
+], parsePeriod$1);
+const countedUnit$1 = (value, amount, dative = false) => unitPhrases.find((entry) => {
+	if (amount === 1) return value === entry.noun;
+	return value === (dative ? entry.dative : entry.plural);
+});
+const parseCalendarOffset$1 = (input) => {
+	const prefixed = String$1.match(/^(vor|in) ([1-9]\d*) (tag|tagen|woche|wochen|monat|monaten|quartal|quartalen|jahr|jahren)$/u)(input);
+	const prior = String$1.match(/^([1-9]\d*) (tag|tage|woche|wochen|monat|monate|quartal|quartale|jahr|jahre) zuvor$/u)(input);
+	const match = [prefixed, prior].find(Option.isSome)?.value;
+	if (match === void 0) return Option.none();
+	const amountText = Option.isSome(prefixed) ? match[2] : match[1];
+	const unitText = Option.isSome(prefixed) ? match[3] : match[2];
+	const amount = parseTrailingCount(amountText);
+	if (Option.isNone(amount)) return Option.none();
+	const entry = countedUnit$1(unitText, amount.value, Option.isSome(prefixed));
+	if (entry === void 0) return Option.none();
+	const isPast = Option.isSome(prior) || Option.isSome(prefixed) && match[1] === "vor";
+	const direction = isPast ? -amount.value : amount.value;
+	const directionName = isPast ? "vor" : "in";
+	const noun = amount.value === 1 ? entry.noun : entry.dative;
+	const canonical = `${directionName} ${amount.value} ${title$1(noun)}`;
+	return Option.some(candidate(periodRange(relativePeriod(entry.unit, direction, canonical)), canonical));
+};
+const parseRollingPeriod$1 = (input) => {
+	const past = String$1.match(/^(?:(?:die letzten|letzten|letzte|vergangene|vorherige) )?([1-9]\d*) (tag|tage|woche|wochen|monat|monate|quartal|quartale|jahr|jahre)$/u)(input);
+	const pastDative = String$1.match(/^(?:in den letzten|in den vergangenen|in den vorherigen) ([1-9]\d*) (tag|tagen|woche|wochen|monat|monaten|quartal|quartalen|jahr|jahren)$/u)(input);
+	const pastGenitive = String$1.match(/^während der letzten ([1-9]\d*) (tag|tage|woche|wochen|monat|monate|quartal|quartale|jahr|jahre)$/u)(input);
+	const future = String$1.match(/^(?:die nächsten|nächsten|nächste|kommende) ([1-9]\d*) (tag|tage|woche|wochen|monat|monate|quartal|quartale|jahr|jahre)$/u)(input);
+	const futureDative = String$1.match(/^(?:in den nächsten|in den kommenden|innerhalb von) ([1-9]\d*) (tag|tagen|woche|wochen|monat|monaten|quartal|quartalen|jahr|jahren)$/u)(input);
+	const futureGenitive = String$1.match(/^innerhalb der nächsten ([1-9]\d*) (tag|tage|woche|wochen|monat|monate|quartal|quartale|jahr|jahre)$/u)(input);
+	const match = [
+		past,
+		pastDative,
+		pastGenitive,
+		future,
+		futureDative,
+		futureGenitive
+	].find(Option.isSome)?.value;
+	if (match === void 0) return Option.none();
+	const amount = parseTrailingCount(match[1]);
+	if (Option.isNone(amount)) return Option.none();
+	const usesDative = Option.isSome(pastDative) || Option.isSome(futureDative);
+	const entry = countedUnit$1(match[2], amount.value, usesDative);
+	if (entry === void 0) return Option.none();
+	const isFuture = Option.isSome(future) || Option.isSome(futureDative) || Option.isSome(futureGenitive);
+	const range = isFuture ? futureRange(amount.value, entry.unit) : trailingRange(amount.value, entry.unit);
+	const direction = isFuture ? "nächste" : "letzte";
+	const noun = amount.value === 1 ? entry.noun : entry.plural;
+	return Option.some(candidate(range, `${direction} ${amount.value} ${title$1(noun)}`));
+};
+const parseGerman = (input) => {
+	const remaining = remainingPeriodPhrases$1.find((entry) => entry.phrase === input);
+	if (remaining !== void 0) return Option.some(candidate(remainingPeriodRange(remaining.entry.unit), `Rest ${canonicalRelative(remaining.entry.genitive)}`));
+	if (["bis heute", "bis jetzt"].includes(input)) return Option.some(candidate(untilNowRange(), "bis heute"));
+	if (["ab jetzt", "von jetzt an"].includes(input)) return Option.some(candidate(fromNowRange(), "ab jetzt"));
+	const offset = parseCalendarOffset$1(input);
+	if (Option.isSome(offset)) return offset;
+	const rolling = parseRollingPeriod$1(input);
+	if (Option.isSome(rolling)) return rolling;
+	const toDate = toDatePhrases$1.find((entry) => entry.phrase === input);
+	if (toDate !== void 0) return Option.some(candidate(periodToDateRange(toDate.entry.unit), canonicalToDate(toDate.entry)));
+	const currentBoundary = currentBoundaryCandidate(input);
+	if (Option.isSome(currentBoundary)) return currentBoundary;
+	const nowBounded = joinedNowCandidate(input, [
+		["von ", " bis heute"],
+		["vom ", " bis heute"],
+		["zwischen ", " und heute"]
+	], ["von heute bis ", "zwischen heute und "], parsePeriod$1, (period) => `von ${period} bis heute`, (period) => `von heute bis ${period}`);
+	if (Option.isSome(nowBounded)) return nowBounded;
+	const bounded = joinedPeriodCandidate(input, [
+		["von ", " bis einschließlich "],
+		["vom ", " bis einschließlich "],
+		["von ", " bis zum "],
+		["vom ", " bis zum "],
+		["von ", " bis "],
+		["vom ", " bis "],
+		["zwischen ", " und "],
+		["", " bis einschließlich "],
+		["", " bis "],
+		["", " - "],
+		["", " – "],
+		["", " — "],
+		["zwischen ", "-"],
+		["", "-"],
+		["zwischen ", "–"],
+		["", "–"],
+		["zwischen ", "—"],
+		["", "—"],
+		["zwischen ", "~"],
+		["", "~"]
+	], parsePeriod$1, (lower, upper) => `von ${lower} bis ${upper}`);
+	if (Option.isSome(bounded)) return bounded;
+	const boundary = boundaryCandidate$1(input);
+	if (Option.isSome(boundary)) return boundary;
+	return Option.map(parsePeriod$1(input), (period) => candidate(periodRange(period), period.canonical));
+};
+const staticPeriods$1 = periodsFromPhrases([
+	"dieses wochenende",
+	"letztes wochenende",
+	"nächstes wochenende",
+	"vorletztes wochenende",
+	"übernächstes wochenende",
+	...unitPhrases.flatMap((entry) => [
+		entry.current,
+		entry.previous,
+		entry.next,
+		`anfang ${entry.current}`,
+		`ende ${entry.current}`,
+		`anfang ${entry.previous}`,
+		`ende ${entry.previous}`,
+		`anfang ${entry.next}`,
+		`ende ${entry.next}`
+	]),
+	...[
+		1,
+		2,
+		3,
+		4
+	].flatMap((quarter) => [
+		`q${quarter}`,
+		`q${quarter} letzten jahres`,
+		`q${quarter} nächsten jahres`
+	]),
+	...months$1.flatMap((month) => [
+		month,
+		`${month} letzten jahres`,
+		`${month} nächsten jahres`
+	])
+], parsePeriod$1);
+const renderGerman = (range) => {
+	const offset = calendarPeriodOffset(range);
+	if (Option.isSome(offset) && Math.abs(offset.value.amount) > 1) {
+		const entry = unitPhrases.find((unit) => unit.unit === offset.value.unit);
+		if (entry !== void 0) return Option.some(`${offset.value.amount < 0 ? "vor" : "in"} ${Math.abs(offset.value.amount)} ${title$1(Math.abs(offset.value.amount) === 1 ? entry.noun : entry.dative)}`);
+	}
+	const future = futurePeriod(range);
+	if (Option.isSome(future)) {
+		const entry = unitPhrases.find((unit) => unit.unit === future.value.unit);
+		if (entry !== void 0) return Option.some(`nächste ${future.value.amount} ${title$1(future.value.amount === 1 ? entry.noun : entry.plural)}`);
+	}
+	const trailing = trailingPeriod(range);
+	if (Option.isSome(trailing)) {
+		const entry = unitPhrases.find((unit) => unit.unit === trailing.value.unit);
+		if (entry !== void 0) return Option.some(trailing.value.amount === 1 ? `1 ${title$1(entry.noun)}` : `letzte ${trailing.value.amount} ${title$1(entry.plural)}`);
+	}
+	const periods = [...staticPeriods$1, ...periodsFromPhrases([...datedPeriods(range, months$1), ...datedQuarterPeriods(range)], parsePeriod$1)];
+	return renderPeriodRange(range, [...unitPhrases.map((entry) => candidate(periodToDateRange(entry.unit), canonicalToDate(entry))), ...unitPhrases.map((entry) => candidate(remainingPeriodRange(entry.unit), `Rest ${canonicalRelative(entry.genitive)}`))], periods, (period) => `seit ${period}`, (period) => `vor ${period}`, (period) => `bis einschließlich ${period}`, (period) => `nach ${period}`, (lower, upper) => `von ${lower} bis ${upper}`, (period) => `von ${period} bis heute`, (period) => `von heute bis ${period}`, () => "bis heute", () => "ab jetzt");
+};
+const GermanContribution = new BaseLanguageContribution({
+	locale: "de",
+	vocabulary: [
+		...months$1,
+		...quarterNames$1,
+		"q1",
+		"q2",
+		"q3",
+		"q4",
+		...monthAbbreviations$1.flatMap((aliases) => aliases),
+		...toDatePhrases$1.flatMap((entry) => entry.phrase.split(" ")),
+		...remainingPeriodPhrases$1.flatMap((entry) => entry.phrase.split(" ")),
+		...currentBoundaryPhrases.flatMap((entry) => entry.phrase.split(" ")),
+		...relativeAliases.flatMap((entry) => entry[0].split(" ")),
+		...unitPhrases.flatMap((entry) => [
+			entry.noun,
+			entry.plural,
+			entry.dative,
+			...entry.currentGenitive.split(" "),
+			...entry.current.split(" "),
+			...entry.previous.split(" "),
+			...entry.next.split(" ")
+		]),
+		"ab",
+		"an",
+		"anfang",
+		"beginn",
+		"bisher",
+		"bis",
+		"dem",
+		"den",
+		"die",
+		"dieses",
+		"einschließlich",
+		"ende",
+		"für",
+		"im",
+		"innerhalb",
+		"jetzt",
+		"kalenderjahr",
+		"jahres",
+		"kommende",
+		"kommenden",
+		"letzte",
+		"letzten",
+		"nach",
+		"nächste",
+		"nächsten",
+		"seit",
+		"vor",
+		"vorherige",
+		"vorherigen",
+		"vergangene",
+		"vergangenen",
+		"vom",
+		"von",
+		"während",
+		"wochenende",
+		"zwischen",
+		"zuvor"
+	],
+	normalize: normalizeNaturalText,
+	correct: correctWhitespaceSeparatedText,
+	parseExact: parseGerman,
+	render: renderGerman
+});
+const GermanLanguage = defineLanguagePlugin({
+	id: "chronolizer/language-de",
+	effect: (context) => Effect.asVoid(context.register("chronolizer/language-de", GermanContribution))
+});
+const GermanLanguageLayer = languagePluginsLayer([GermanLanguage]);
+//#endregion
+//#region src/locales/en.ts
+const months = [
+	"january",
+	"february",
+	"march",
+	"april",
+	"may",
+	"june",
+	"july",
+	"august",
+	"september",
+	"october",
+	"november",
+	"december"
+];
+const monthAbbreviations = [
+	["jan"],
+	["feb"],
+	["mar"],
+	["apr"],
+	["may"],
+	["jun"],
+	["jul"],
+	["aug"],
+	["sep", "sept"],
+	["oct"],
+	["nov"],
+	["dec"]
+];
+const quarterNames = [
+	"first",
+	"second",
+	"third",
+	"fourth"
+];
+const units = [
+	[
+		"day",
+		"day",
+		"days"
+	],
+	[
+		"week",
+		"week",
+		"weeks"
+	],
+	[
+		"month",
+		"month",
+		"months"
+	],
+	[
+		"quarter",
+		"quarter",
+		"quarters"
+	],
+	[
+		"year",
+		"year",
+		"years"
+	]
+];
+const title = (value) => `${value.slice(0, 1).toLocaleUpperCase("en")}${value.slice(1)}`;
+const currentPeriod = (unit) => unit === "day" ? "today" : `this ${unit}`;
+const remainingPeriodPhrases = units.flatMap((entry) => [
+	`rest of the ${entry[0]}`,
+	`rest of ${entry[0]}`,
+	`rest of ${currentPeriod(entry[0])}`,
+	`remainder of the ${entry[0]}`,
+	`remaining ${entry[0]}`
+].map((phrase) => ({
+	entry,
+	phrase
+})));
+const toDateAbbreviations = [
+	"dtd",
+	"wtd",
+	"mtd",
+	"qtd",
+	"ytd"
+];
+const toDatePhrases = units.flatMap((entry, index) => [
+	`${entry[0]} to date`,
+	`${entry[0]}-to-date`,
+	toDateAbbreviations[index],
+	`since the start of the ${entry[0]}`,
+	`since the beginning of the ${entry[0]}`,
+	`from the start of the ${entry[0]} to now`,
+	`from the beginning of the ${entry[0]} to now`,
+	`${currentPeriod(entry[0])} so far`,
+	`so far ${currentPeriod(entry[0])}`,
+	`${currentPeriod(entry[0])} until now`,
+	`${currentPeriod(entry[0])} up to now`
+].map((phrase) => ({
+	entry,
+	phrase
+})));
+const monthNumber = (value) => {
+	const normalized = value.endsWith(".") ? value.slice(0, -1) : value;
+	const fullIndex = months.findIndex((month) => month === normalized);
+	if (fullIndex !== -1) return fullIndex + 1;
+	const shortIndex = monthAbbreviations.findIndex((aliases) => aliases.some((alias) => alias === normalized));
+	return shortIndex === -1 ? void 0 : shortIndex + 1;
+};
+const relativeDirection = (value) => {
+	if (value === "last" || value === "previous") return -1;
+	if (value === "next" || value === "coming" || value === "upcoming") return 1;
+	return 0;
+};
+const relativeDirectionName = (direction) => {
+	if (direction < 0) return "last";
+	if (direction > 0) return "next";
+	return "this";
+};
+const quarterNumber = (value) => {
+	if (value.startsWith("q")) return Number(value.slice(1));
+	const index = quarterNames.findIndex((name) => name === value);
+	return index === -1 ? void 0 : index + 1;
+};
+const parseQuarter = (input) => {
+	const fixed = String$1.match(/^(q[1-4])(?: of)? (\d{4})$/u)(input);
+	const reversed = String$1.match(/^(\d{4}) (q[1-4])$/u)(input);
+	const namedFixed = String$1.match(/^(first|second|third|fourth) quarter(?: of)? (\d{4})$/u)(input);
+	const relative = String$1.match(/^(q[1-4])(?: of)? (last|this|next) year$/u)(input);
+	const namedRelative = String$1.match(/^(first|second|third|fourth) quarter(?: of)? (last|this|next) year$/u)(input);
+	const standalone = String$1.match(/^(q[1-4])$/u)(input);
+	const namedStandalone = String$1.match(/^(first|second|third|fourth) quarter$/u)(input);
+	if (Option.isSome(fixed) || Option.isSome(reversed) || Option.isSome(namedFixed)) {
+		const match = [
+			fixed,
+			reversed,
+			namedFixed
+		].find(Option.isSome)?.value;
+		if (match === void 0) return Option.none();
+		const quarterText = Option.isSome(reversed) ? match[2] : match[1];
+		const yearText = Option.isSome(reversed) ? match[1] : match[2];
+		const quarter = quarterNumber(quarterText);
+		const year = validYear(yearText);
+		if (quarter !== void 0 && year !== void 0) return Option.some(fixedQuarterPeriod(year, quarter, `Q${quarter} ${year}`));
+	}
+	if (Option.isSome(relative) || Option.isSome(namedRelative)) {
+		const match = [relative, namedRelative].find(Option.isSome)?.value;
+		if (match === void 0) return Option.none();
+		const quarter = quarterNumber(match[1]);
+		if (quarter !== void 0) {
+			const direction = relativeDirection(match[2]);
+			return Option.some(quarterOfRelativeYear(quarter, direction, `Q${quarter} of ${match[2]} year`));
+		}
+	}
+	const match = [standalone, namedStandalone].find(Option.isSome)?.value;
+	if (match === void 0) return Option.none();
+	const quarter = quarterNumber(match[1]);
+	return quarter === void 0 ? Option.none() : Option.some(quarterOfRelativeYear(quarter, 0, `Q${quarter}`));
+};
+const parseNamedDate = (input) => {
+	const dayFirst = String$1.match(/^([0-3]?\d)(?:st|nd|rd|th)? ([a-z]+\.?) (\d{4})$/u)(input);
+	if (Option.isSome(dayFirst)) return namedDatePeriod(dayFirst.value[3], dayFirst.value[2], dayFirst.value[1], monthNumber, (day, month, year) => `${day} ${title(months[month - 1])} ${year}`);
+	const monthFirst = String$1.match(/^([a-z]+\.?) ([0-3]?\d)(?:st|nd|rd|th)?,? (\d{4})$/u)(input);
+	if (Option.isSome(monthFirst)) return namedDatePeriod(monthFirst.value[3], monthFirst.value[1], monthFirst.value[2], monthNumber, (day, month, year) => `${day} ${title(months[month - 1])} ${year}`);
+	return Option.none();
+};
+const parseBasePeriod = (input) => {
+	if (isIsoDate(input) && input !== "9999-12-31") return Option.some(fixedDatePeriod(input, input));
+	const namedDate = parseNamedDate(input);
+	if (Option.isSome(namedDate)) return namedDate;
+	const quarter = parseQuarter(input);
+	if (Option.isSome(quarter)) return quarter;
+	const yearMatch = String$1.match(/^(?:(?:the )?(?:calendar )?year )?(\d{4})$/u)(input);
+	if (Option.isSome(yearMatch)) {
+		const year = validYear(yearMatch.value[1]);
+		if (year !== void 0) return Option.some(fixedYearPeriod(year, String(year)));
+	}
+	const monthYear = String$1.match(/^([a-z]+\.?) (\d{4})$/u)(input);
+	if (Option.isSome(monthYear)) {
+		const month = monthNumber(monthYear.value[1]);
+		const year = validYear(monthYear.value[2]);
+		if (month !== void 0 && year !== void 0) return Option.some(fixedMonthPeriod(year, month, `${title(months[month - 1])} ${year}`));
+	}
+	const relativeMonth = String$1.match(/^([a-z]+\.?) (?:of )?(last|this|next) year$/u)(input);
+	if (Option.isSome(relativeMonth)) {
+		const month = monthNumber(relativeMonth.value[1]);
+		const direction = relativeDirection(relativeMonth.value[2]);
+		if (month !== void 0) return Option.some(monthOfRelativeYear(month, direction, `${title(months[month - 1])} of ${relativeMonth.value[2]} year`));
+	}
+	const standaloneMonth = monthNumber(input);
+	if (standaloneMonth !== void 0) return Option.some(monthOfRelativeYear(standaloneMonth, 0, title(months[standaloneMonth - 1])));
+	if (input === "today") return Option.some(relativePeriod("day", 0, "today"));
+	if (input === "yesterday") return Option.some(relativePeriod("day", -1, "yesterday"));
+	if (input === "tomorrow") return Option.some(relativePeriod("day", 1, "tomorrow"));
+	if (input === "weekend" || input === "the weekend" || input === "this weekend") return Option.some(relativeWeekend(0, "this weekend"));
+	if (input === "last weekend" || input === "previous weekend") return Option.some(relativeWeekend(-1, "last weekend"));
+	if (input === "next weekend" || input === "coming weekend") return Option.some(relativeWeekend(1, "next weekend"));
+	if (input === "the weekend before last") return Option.some(relativeWeekend(-2, "the weekend before last"));
+	if (input === "the weekend after next") return Option.some(relativeWeekend(2, "the weekend after next"));
+	const articlePeriod = String$1.match(/^the (day|week|month|quarter|year)$/u)(input);
+	if (Option.isSome(articlePeriod)) {
+		const entry = units.find((unit) => unit[0] === articlePeriod.value[1]);
+		if (entry !== void 0) return Option.some(relativePeriod(entry[1], 0, currentPeriod(entry[0])));
+	}
+	const outerRelative = String$1.match(/^(?:the )?(day|week|month|quarter|year) (before last|after next)$/u)(input);
+	if (Option.isSome(outerRelative)) {
+		const entry = units.find((unit) => unit[0] === outerRelative.value[1]);
+		if (entry !== void 0) {
+			const direction = outerRelative.value[2] === "before last" ? -2 : 2;
+			return Option.some(relativePeriod(entry[1], direction, input));
+		}
+	}
+	const relative = String$1.match(/^(?:the )?(last|previous|this|current|next|coming|upcoming) ([a-z]+)$/u)(input);
+	if (Option.isSome(relative)) {
+		const unit = units.find((entry) => entry[0] === relative.value[2])?.[1];
+		if (unit !== void 0) {
+			const direction = relativeDirection(relative.value[1]);
+			const canonicalDirection = relativeDirectionName(direction);
+			return Option.some(relativePeriod(unit, direction, `${canonicalDirection} ${relative.value[2]}`));
+		}
+	}
+	return Option.none();
+};
+const parsePeriod = (input) => {
+	const edge = String$1.match(/^(?:the )?(start|beginning|end) of (.+)$/u)(input);
+	if (Option.isSome(edge)) {
+		const period = parseBasePeriod(edge.value[2]);
+		if (Option.isSome(period)) {
+			const name = edge.value[1] === "beginning" ? "start" : edge.value[1];
+			const canonical = `${name} of ${period.value.canonical}`;
+			return Option.some(name === "end" ? periodEndDay(period.value, canonical) : periodStartDay(period.value, canonical));
+		}
+	}
+	const wrapper = [
+		"during ",
+		"in ",
+		"for ",
+		"all of ",
+		"the whole of "
+	].find((prefix) => input.startsWith(prefix));
+	return parseBasePeriod(wrapper === void 0 ? input : input.slice(wrapper.length));
+};
+const boundaryCandidate = (input) => openBoundaryCandidate(input, [
+	["up to and including ", "through"],
+	["up to including ", "through"],
+	["since the beginning of ", "since"],
+	["since the start of ", "since"],
+	["from the beginning of ", "since"],
+	["from the start of ", "since"],
+	["starting from ", "since"],
+	["through the end of ", "through"],
+	["until the end of ", "through"],
+	["after the end of ", "after"],
+	["until the start of ", "before"],
+	["before the beginning of ", "before"],
+	["before the start of ", "before"],
+	["before beginning of ", "before"],
+	["before start of ", "before"],
+	["starting ", "since"],
+	["through ", "through"],
+	["before ", "before"],
+	["since ", "since"],
+	["after ", "after"],
+	["until ", "before"],
+	["till ", "before"],
+	["up to ", "before"],
+	["from ", "since"]
+], parsePeriod);
+const countedUnit = (value, amount) => units.find((entry) => value === (amount === 1 ? entry[0] : entry[2]));
+const parseCalendarOffset = (input) => {
+	const singular = String$1.match(/^(?:(?:a|one) (day|week|month|quarter|year) (ago|prior|from now)|in (?:a|one) (day|week|month|quarter|year))$/u)(input);
+	if (Option.isSome(singular)) {
+		const unitText = singular.value[1] ?? singular.value[3];
+		const entry = units.find((unit) => unit[0] === unitText);
+		if (entry !== void 0) {
+			const isPast = singular.value[2] === "ago" || singular.value[2] === "prior";
+			const direction = isPast ? -1 : 1;
+			const canonical = isPast ? `1 ${entry[0]} ago` : `in 1 ${entry[0]}`;
+			return Option.some(candidate(periodRange(relativePeriod(entry[1], direction, canonical)), canonical));
+		}
+	}
+	const past = String$1.match(/^([1-9]\d*) (day|days|week|weeks|month|months|quarter|quarters|year|years) (?:ago|prior)$/u)(input);
+	const match = [
+		past,
+		String$1.match(/^in ([1-9]\d*) (day|days|week|weeks|month|months|quarter|quarters|year|years)$/u)(input),
+		String$1.match(/^([1-9]\d*) (day|days|week|weeks|month|months|quarter|quarters|year|years) from now$/u)(input)
+	].find(Option.isSome)?.value;
+	if (match === void 0) return Option.none();
+	const amount = parseTrailingCount(match[1]);
+	if (Option.isNone(amount)) return Option.none();
+	const entry = countedUnit(match[2], amount.value);
+	if (entry === void 0) return Option.none();
+	const unitText = match[2];
+	const direction = Option.isSome(past) ? -amount.value : amount.value;
+	const canonical = direction < 0 ? `${amount.value} ${unitText} ago` : `in ${amount.value} ${unitText}`;
+	return Option.some(candidate(periodRange(relativePeriod(entry[1], direction, canonical)), canonical));
+};
+const parseRollingPeriod = (input) => {
+	const past = String$1.match(/^(?:(?:last|previous|past) |(?:in|over) the (?:last|previous|past) )?([1-9]\d*) (day|days|week|weeks|month|months|quarter|quarters|year|years)$/u)(input);
+	const future = String$1.match(/^(?:(?:next|coming|within) |(?:in|over|within) the (?:next|coming) )([1-9]\d*) (day|days|week|weeks|month|months|quarter|quarters|year|years)$/u)(input);
+	const match = [past, future].find(Option.isSome)?.value;
+	if (match === void 0) return Option.none();
+	const amount = parseTrailingCount(match[1]);
+	if (Option.isNone(amount)) return Option.none();
+	const entry = countedUnit(match[2], amount.value);
+	if (entry === void 0) return Option.none();
+	const isFuture = Option.isSome(future);
+	const range = isFuture ? futureRange(amount.value, entry[1]) : trailingRange(amount.value, entry[1]);
+	const direction = isFuture ? "next" : "last";
+	const noun = amount.value === 1 ? entry[0] : entry[2];
+	return Option.some(candidate(range, `${direction} ${amount.value} ${noun}`));
+};
+const parseEnglish = (input) => {
+	const remaining = remainingPeriodPhrases.find((entry) => entry.phrase === input);
+	if (remaining !== void 0) return Option.some(candidate(remainingPeriodRange(remaining.entry[1]), `rest of ${remaining.entry[0]}`));
+	if ([
+		"until now",
+		"till now",
+		"up to now",
+		"through now"
+	].includes(input)) return Option.some(candidate(untilNowRange(), "until now"));
+	if ([
+		"from now",
+		"from now on",
+		"starting now"
+	].includes(input)) return Option.some(candidate(fromNowRange(), "from now"));
+	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[1]), `${toDate.entry[0]} to date`));
+	const nowBounded = joinedNowCandidate(input, [
+		["from ", " to now"],
+		["from ", " until now"],
+		["from ", " through now"],
+		["between ", " and now"]
+	], [
+		"from now to ",
+		"from now until ",
+		"from now through ",
+		"between now and "
+	], parsePeriod, (period) => `from ${period} to now`, (period) => `from now to ${period}`);
+	if (Option.isSome(nowBounded)) return nowBounded;
+	const bounded = joinedPeriodCandidate(input, [
+		["from ", " to and including "],
+		["from ", " through and including "],
+		["from ", " to "],
+		["from ", " until "],
+		["from ", " through "],
+		["from ", " till "],
+		["between ", " and "],
+		["between ", " through "],
+		["", " to and including "],
+		["", " through and including "],
+		["", " to "],
+		["", " until "],
+		["", " through "],
+		["", " till "],
+		["", " - "],
+		["", " – "],
+		["", " — "],
+		["between ", "-"],
+		["", "-"],
+		["between ", "–"],
+		["", "–"],
+		["between ", "—"],
+		["", "—"],
+		["between ", "~"],
+		["", "~"]
+	], parsePeriod, (lower, upper) => `from ${lower} to ${upper}`);
+	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));
+};
+const staticPeriods = periodsFromPhrases([
+	"today",
+	"yesterday",
+	"tomorrow",
+	"this weekend",
+	"last weekend",
+	"next weekend",
+	"the weekend before last",
+	"the weekend after next",
+	...units.flatMap((entry) => [
+		`this ${entry[0]}`,
+		`last ${entry[0]}`,
+		`next ${entry[0]}`,
+		`start of this ${entry[0]}`,
+		`end of this ${entry[0]}`,
+		`start of last ${entry[0]}`,
+		`end of last ${entry[0]}`,
+		`start of next ${entry[0]}`,
+		`end of next ${entry[0]}`
+	]),
+	...[
+		1,
+		2,
+		3,
+		4
+	].flatMap((quarter) => [
+		`q${quarter}`,
+		`q${quarter} of last year`,
+		`q${quarter} of next year`
+	]),
+	...months.flatMap((month) => [
+		month,
+		`${month} of last year`,
+		`${month} of next year`
+	])
+], parsePeriod);
+const renderEnglish = (range) => {
+	const offset = calendarPeriodOffset(range);
+	if (Option.isSome(offset) && Math.abs(offset.value.amount) > 1) {
+		const entry = units.find((unit) => unit[1] === offset.value.unit);
+		if (entry !== void 0) {
+			const noun = offset.value.amount === -1 || offset.value.amount === 1 ? entry[0] : entry[2];
+			return Option.some(offset.value.amount < 0 ? `${-offset.value.amount} ${noun} ago` : `in ${offset.value.amount} ${noun}`);
+		}
+	}
+	const future = futurePeriod(range);
+	if (Option.isSome(future)) {
+		const entry = units.find((unit) => unit[1] === future.value.unit);
+		if (entry !== void 0) return Option.some(`next ${future.value.amount} ${future.value.amount === 1 ? entry[0] : entry[2]}`);
+	}
+	const trailing = trailingPeriod(range);
+	if (Option.isSome(trailing)) {
+		const entry = units.find((unit) => unit[1] === trailing.value.unit);
+		if (entry !== void 0) return Option.some(trailing.value.amount === 1 ? `1 ${entry[0]}` : `last ${trailing.value.amount} ${entry[2]}`);
+	}
+	const periods = [...staticPeriods, ...periodsFromPhrases([...datedPeriods(range, months), ...datedQuarterPeriods(range)], parsePeriod)];
+	return renderPeriodRange(range, [...units.map((entry) => candidate(periodToDateRange(entry[1]), `${entry[0]} to date`)), ...units.map((entry) => candidate(remainingPeriodRange(entry[1]), `rest of ${entry[0]}`))], periods, (period) => `since ${period}`, (period) => `before ${period}`, (period) => `through ${period}`, (period) => `after ${period}`, (lower, upper) => `from ${lower} to ${upper}`, (period) => `from ${period} to now`, (period) => `from now to ${period}`, () => "until now", () => "from now");
+};
+const EnglishContribution = new BaseLanguageContribution({
+	locale: "en",
+	vocabulary: [
+		...months,
+		...quarterNames,
+		"q1",
+		"q2",
+		"q3",
+		"q4",
+		...monthAbbreviations.flatMap((aliases) => aliases),
+		...toDatePhrases.flatMap((entry) => entry.phrase.split(" ")),
+		...remainingPeriodPhrases.flatMap((entry) => entry.phrase.split(" ")),
+		...units.flatMap((entry) => [entry[0], entry[2]]),
+		"after",
+		"ago",
+		"all",
+		"one",
+		"and",
+		"beginning",
+		"before",
+		"calendar",
+		"coming",
+		"current",
+		"date",
+		"during",
+		"end",
+		"far",
+		"for",
+		"from",
+		"in",
+		"including",
+		"last",
+		"next",
+		"now",
+		"on",
+		"over",
+		"of",
+		"past",
+		"previous",
+		"prior",
+		"since",
+		"so",
+		"start",
+		"starting",
+		"this",
+		"through",
+		"till",
+		"whole",
+		"to",
+		"until",
+		"upcoming",
+		"within",
+		"today",
+		"tomorrow",
+		"weekend",
+		"yesterday"
+	],
+	normalize: normalizeNaturalText,
+	correct: correctWhitespaceSeparatedText,
+	parseExact: parseEnglish,
+	render: renderEnglish
+});
+const EnglishLanguage = defineLanguagePlugin({
+	id: "chronolizer/language-en",
+	effect: (context) => Effect.asVoid(context.register("chronolizer/language-en", EnglishContribution))
+});
+const EnglishLanguageLayer = languagePluginsLayer([EnglishLanguage]);
+//#endregion
+//#region src/locales/default.ts
+const DefaultLanguageLayer = languagePluginsLayer([EnglishLanguage, GermanLanguage]);
+//#endregion
+//#region src/natural/api.ts
+const distinctCandidates = (candidates) => Array$1.dedupeWith(candidates, (left, right) => rangeKey(left.range) === rangeKey(right.range));
+const applyFuturePolicy = (candidates, allowFuture) => allowFuture === false ? Array$1.filter(candidates, (candidate) => !containsPositiveShift(candidate.range)) : candidates;
+const parseQuality = (hasAlternatives, hasCorrections) => {
+	if (hasAlternatives) return "ambiguous";
+	if (hasCorrections) return "corrected";
+	return "exact";
+};
+const resultFromCandidates = (candidates, corrections) => {
+	const distinct = Array$1.sortWith(distinctCandidates(candidates), (candidate) => candidate.canonical, Order.String);
+	const selected = Array$1.headNonEmpty(distinct);
+	const alternatives = Array$1.tailNonEmpty(distinct).map((candidate) => NaturalAlternative.make({
+		canonical: candidate.canonical,
+		range: candidate.range
+	}));
+	return NaturalParseResult.make({
+		range: selected.range,
+		quality: parseQuality(alternatives.length > 0, corrections.length > 0),
+		corrections,
+		alternatives
+	});
+};
+const parseNatural = Effect.fn("chronolizer.parseNatural")(function* (input, options) {
+	const language = yield* (yield* LanguageRegistry).resolve(options.locale);
+	const normalized = language.normalize(input, language.locale);
+	if (normalized.length === 0) return yield* new NaturalLanguageParseError({
+		input,
+		locale: options.locale,
+		message: "The complete input must contain a date-range expression"
+	});
+	const exact = language.parseExact(normalized);
+	const allowedExact = applyFuturePolicy(exact, options.allowFuture);
+	if (Array$1.isReadonlyArrayNonEmpty(allowedExact)) return resultFromCandidates(allowedExact, []);
+	if (options.typoMode !== "tolerant") {
+		const message = exact.length > 0 && options.allowFuture === false ? "The expression contains a positive relative shift, but future ranges are disabled" : "The complete input is not a supported date-range expression";
+		return yield* new NaturalLanguageParseError({
+			input,
+			locale: options.locale,
+			message
+		});
+	}
+	const corrected = language.correct?.(normalized, language.vocabulary) ?? [];
+	const parsedCorrections = Array$1.filterMap(corrected, (correction) => {
+		const candidates = applyFuturePolicy(language.parseExact(correction.text), options.allowFuture);
+		return Array$1.isReadonlyArrayNonEmpty(candidates) ? Result.succeed({
+			correction,
+			candidates
+		}) : Result.failVoid;
+	});
+	const successful = Array$1.sortWith(parsedCorrections, (entry) => entry.correction.cost, Order.Number);
+	if (!Array$1.isReadonlyArrayNonEmpty(successful)) return yield* new NaturalLanguageParseError({
+		input,
+		locale: options.locale,
+		message: "No conservative typo correction produced a complete expression"
+	});
+	const first = Array$1.headNonEmpty(successful);
+	const best = Array$1.prepend(Array$1.filter(Array$1.tailNonEmpty(successful), (entry) => entry.correction.cost === first.correction.cost), first);
+	return resultFromCandidates(Array$1.flatMap(best, (entry) => entry.candidates), first.correction.corrections);
+});
+const formatNatural = Effect.fn("chronolizer.formatNatural")(function* (range, options) {
+	const rendered = (yield* (yield* LanguageRegistry).resolve(options.locale)).render(range);
+	if (Option.isSome(rendered)) return rendered.value;
+	return yield* new NaturalLanguageRenderError({
+		locale: options.locale,
+		message: "The range has no canonical natural-language form in this locale"
+	});
+});
+//#endregion
+//#region src/resolve/schema.ts
+const ResolvedGreaterThan = Schema.TaggedStruct("GreaterThan", { value: Schema.DateTimeZoned });
+const ResolvedGreaterThanOrEqual = Schema.TaggedStruct("GreaterThanOrEqual", { value: Schema.DateTimeZoned });
+const ResolvedLessThan = Schema.TaggedStruct("LessThan", { value: Schema.DateTimeZoned });
+const ResolvedLessThanOrEqual = Schema.TaggedStruct("LessThanOrEqual", { value: Schema.DateTimeZoned });
+const ResolvedLowerBound = Schema.Union([ResolvedGreaterThan, ResolvedGreaterThanOrEqual]);
+const ResolvedUpperBound = Schema.Union([ResolvedLessThan, ResolvedLessThanOrEqual]);
+const ResolvedBoundedDateRange = Schema.TaggedStruct("ResolvedDateRange", {
+	lower: ResolvedLowerBound,
+	upper: ResolvedUpperBound
+});
+const ResolvedLowerOpenDateRange = Schema.TaggedStruct("ResolvedDateRange", {
+	lower: ResolvedLowerBound,
+	upper: Schema.optionalKey(Schema.Never)
+});
+const ResolvedUpperOpenDateRange = Schema.TaggedStruct("ResolvedDateRange", {
+	lower: Schema.optionalKey(Schema.Never),
+	upper: ResolvedUpperBound
+});
+const ResolvedDateRange = Schema.Union([
+	ResolvedBoundedDateRange,
+	ResolvedLowerOpenDateRange,
+	ResolvedUpperOpenDateRange
+]).annotate({ identifier: "ResolvedDateRange" });
+var ResolutionError = class extends Schema.TaggedError()("ResolutionError", { message: Schema.String }) {};
+//#endregion
+//#region src/resolve/resolve.ts
+const shiftDateTime = (value, amount, unit) => {
+	switch (unit) {
+		case "day": return DateTime.add(value, { days: amount });
+		case "week": return DateTime.add(value, { weeks: amount });
+		case "month": return DateTime.add(value, { months: amount });
+		case "quarter": return DateTime.add(value, { months: amount * 3 });
+		case "year": return DateTime.add(value, { years: amount });
+	}
+};
+const startOfDateTime = (value, unit) => {
+	if (unit === "quarter") {
+		const month = DateTime.getPart(value, "month");
+		const quarterMonth = Math.floor((month - 1) / 3) * 3 + 1;
+		return DateTime.startOf(DateTime.setParts(value, { month: quarterMonth }), "month");
+	}
+	return DateTime.startOf(value, unit, { weekStartsOn: 1 });
+};
+const literalInZone = (value, zone) => {
+	const zoned = DateTime.makeZoned({
+		year: Number(value.slice(0, 4)),
+		month: Number(value.slice(5, 7)),
+		day: Number(value.slice(8, 10))
+	}, {
+		timeZone: zone,
+		adjustForTimeZone: true
+	});
+	return Option.match(zoned, {
+		onNone: () => Effect.fail(new ResolutionError({ message: `Cannot resolve the date ${value}` })),
+		onSome: Effect.succeed
+	});
+};
+const evaluateInstant = (expression, reference, zone) => foldInstant(expression, {
+	now: () => Effect.succeed(reference),
+	dateLiteral: (value) => literalInZone(value, zone),
+	shift: (base, amount, unit) => Effect.map(base, (value) => shiftDateTime(value, amount, unit)),
+	startOf: (base, unit) => Effect.map(base, (value) => startOfDateTime(value, unit))
+});
+const resolveLower = (bound, reference, zone) => Match.valueTags(bound, {
+	GreaterThan: (value) => Effect.map(evaluateInstant(value.value, reference, zone), (resolved) => ResolvedGreaterThan.make({ value: resolved })),
+	GreaterThanOrEqual: (value) => Effect.map(evaluateInstant(value.value, reference, zone), (resolved) => ResolvedGreaterThanOrEqual.make({ value: resolved }))
+});
+const resolveUpper = (bound, reference, zone) => Match.valueTags(bound, {
+	LessThan: (value) => Effect.map(evaluateInstant(value.value, reference, zone), (resolved) => ResolvedLessThan.make({ value: resolved })),
+	LessThanOrEqual: (value) => Effect.map(evaluateInstant(value.value, reference, zone), (resolved) => ResolvedLessThanOrEqual.make({ value: resolved }))
+});
+const resolve = Effect.fn("chronolizer.resolve")(function* (range) {
+	const zone = yield* DateTime.CurrentTimeZone;
+	const reference = yield* DateTime.nowInCurrentZone;
+	if (range.lower !== void 0 && range.upper !== void 0) {
+		const lower = yield* resolveLower(range.lower, reference, zone);
+		const upper = yield* resolveUpper(range.upper, reference, zone);
+		if (DateTime.toEpochMillis(lower.value) >= DateTime.toEpochMillis(upper.value)) return yield* new ResolutionError({ message: "The lower range endpoint must be before the upper endpoint" });
+		return ResolvedDateRange.make({
+			lower,
+			upper
+		});
+	}
+	if (range.lower !== void 0) return ResolvedDateRange.make({ lower: yield* resolveLower(range.lower, reference, zone) });
+	return ResolvedDateRange.make({ upper: yield* resolveUpper(range.upper, reference, zone) });
+});
+//#endregion
+export { AmbiguousNaturalLanguageError, BaseLanguageContribution, BaseLanguageMetadata, Correction, DateExpressionString, DateFilter, DateLiteral, DateRangeExpr, DateRangeFromFilter, DefaultLanguageLayer, EnglishContribution, EnglishLanguage, EnglishLanguageLayer, FilterExpressionParseError, GermanContribution, GermanLanguage, GermanLanguageLayer, GreaterThan, GreaterThanOrEqual, InstantExpr, InstantExpressionFromString, InvalidDateFilterError, IsoDate, LanguageConflictError, LanguageContributionMetadata, LanguageExtensionContribution, LanguageExtensionMetadata, LanguageRegistrationError, LanguageRegistry, LanguageRegistryLayer, LessThan, LessThanOrEqual, Locale, LowerBound, NaturalAlternative, NaturalCandidate, NaturalCorrectionCandidate, NaturalLanguageParseError, NaturalLanguageRenderError, NaturalParseResult, Now, ParseQuality, ResolutionError, ResolvedDateRange, ResolvedGreaterThan, ResolvedGreaterThanOrEqual, ResolvedLessThan, ResolvedLessThanOrEqual, ResolvedLowerBound, ResolvedUpperBound, Shift, StartOf, Unit, UnsupportedLocaleError, UpperBound, boundedRange, canonicalBaseLocale, 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, upperOpenRange };