chronolizer 0.1.0 → 0.3.0

package/dist/natural/correction.d.mts

@@ -0,0 +1,13 @@
+//#region src/natural/correction.d.ts
+declare const correctWhitespaceSeparatedText: (input: string, vocabulary: ReadonlyArray<string>) => {
+  readonly text: string;
+  readonly corrections: readonly {
+    readonly original: string;
+    readonly replacement: string;
+    readonly distance: number;
+    readonly offset: number;
+  }[];
+  readonly cost: number;
+}[];
+//#endregion
+export { correctWhitespaceSeparatedText };

package/dist/natural/correction.mjs

@@ -0,0 +1,73 @@
+import { Correction, NaturalCorrectionCandidate } from "../language/model.mjs";
+import { naturalWords } from "./text.mjs";
+import { Option, String } from "effect";
+//#region src/natural/correction.ts
+const isProtectedValue = (word) => Option.isSome(String.match(/^\d+$/u)(word)) || Option.isSome(String.match(/^\d{4}-\d{2}-\d{2}$/u)(word));
+const damerauLevenshteinDistance = (left, right) => {
+	const fallback = left.length + right.length;
+	let previousPrevious;
+	let previous = Array.from({ length: right.length + 1 }, (_, index) => index);
+	for (let row = 1; row <= left.length; row += 1) {
+		const current = [row];
+		for (let column = 1; column <= right.length; column += 1) {
+			const substitution = left.charAt(row - 1) === right.charAt(column - 1) ? 0 : 1;
+			const distance = Math.min((previous[column] ?? fallback) + 1, (current[column - 1] ?? fallback) + 1, (previous[column - 1] ?? fallback) + substitution);
+			const transposed = previousPrevious !== void 0 && row > 1 && column > 1 && left.charAt(row - 1) === right.charAt(column - 2) && left.charAt(row - 2) === right.charAt(column - 1) ? (previousPrevious[column - 2] ?? fallback) + 1 : fallback;
+			current.push(Math.min(distance, transposed));
+		}
+		previousPrevious = previous;
+		previous = current;
+	}
+	return previous[right.length] ?? fallback;
+};
+const replacementsFor = (word, vocabulary) => {
+	if (vocabulary.includes(word) || isProtectedValue(word)) return [{
+		word,
+		distance: 0
+	}];
+	if (word.length <= 3) 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: damerauLevenshteinDistance(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
+export { correctWhitespaceSeparatedText, damerauLevenshteinDistance };

package/dist/natural/format.d.mts

@@ -0,0 +1,47 @@
+import { InstantExpr } from "../ast/schemas.mjs";
+import { NaturalLanguageRenderError, UnsupportedLocaleError } from "../language/errors.mjs";
+import { LanguageRegistry } from "../language/registry.mjs";
+import { Effect } from "effect";
+//#region src/natural/format.d.ts
+interface FormatNaturalOptions {
+  readonly locale: string;
+}
+declare const formatNatural: (range: {
+  readonly _tag: "DateRange";
+  readonly lower: {
+    readonly _tag: "GreaterThan";
+    readonly value: InstantExpr;
+  } | {
+    readonly _tag: "GreaterThanOrEqual";
+    readonly value: InstantExpr;
+  };
+  readonly upper: {
+    readonly _tag: "LessThan";
+    readonly value: InstantExpr;
+  } | {
+    readonly _tag: "LessThanOrEqual";
+    readonly value: InstantExpr;
+  };
+} | {
+  readonly _tag: "DateRange";
+  readonly lower: {
+    readonly _tag: "GreaterThan";
+    readonly value: InstantExpr;
+  } | {
+    readonly _tag: "GreaterThanOrEqual";
+    readonly value: InstantExpr;
+  };
+  readonly upper?: never;
+} | {
+  readonly _tag: "DateRange";
+  readonly lower?: never;
+  readonly upper: {
+    readonly _tag: "LessThan";
+    readonly value: InstantExpr;
+  } | {
+    readonly _tag: "LessThanOrEqual";
+    readonly value: InstantExpr;
+  };
+}, options: FormatNaturalOptions) => Effect.Effect<string, NaturalLanguageRenderError | UnsupportedLocaleError, LanguageRegistry>;
+//#endregion
+export { FormatNaturalOptions, formatNatural };

package/dist/natural/format.mjs

@@ -0,0 +1,14 @@
+import { NaturalLanguageRenderError } from "../language/errors.mjs";
+import { LanguageRegistry } from "../language/registry.mjs";
+import { Effect, Option } from "effect";
+//#region src/natural/format.ts
+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
+export { formatNatural };

package/dist/natural/parse.d.mts

@@ -0,0 +1,99 @@
+import { InstantExpr } from "../ast/schemas.mjs";
+import { NaturalLanguageParseError, UnsupportedLocaleError } from "../language/errors.mjs";
+import { LanguageRegistry } from "../language/registry.mjs";
+import "../index.mjs";
+import { Effect } from "effect";
+//#region src/natural/parse.d.ts
+interface ParseNaturalOptions {
+  readonly locale: string;
+  readonly typoMode?: "strict" | "tolerant";
+  readonly allowFuture?: boolean;
+}
+declare const parseNatural: (input: string, options: ParseNaturalOptions) => Effect.Effect<{
+  readonly range: {
+    readonly _tag: "DateRange";
+    readonly lower: {
+      readonly _tag: "GreaterThan";
+      readonly value: InstantExpr;
+    } | {
+      readonly _tag: "GreaterThanOrEqual";
+      readonly value: InstantExpr;
+    };
+    readonly upper: {
+      readonly _tag: "LessThan";
+      readonly value: InstantExpr;
+    } | {
+      readonly _tag: "LessThanOrEqual";
+      readonly value: InstantExpr;
+    };
+  } | {
+    readonly _tag: "DateRange";
+    readonly lower: {
+      readonly _tag: "GreaterThan";
+      readonly value: InstantExpr;
+    } | {
+      readonly _tag: "GreaterThanOrEqual";
+      readonly value: InstantExpr;
+    };
+    readonly upper?: never;
+  } | {
+    readonly _tag: "DateRange";
+    readonly lower?: never;
+    readonly upper: {
+      readonly _tag: "LessThan";
+      readonly value: InstantExpr;
+    } | {
+      readonly _tag: "LessThanOrEqual";
+      readonly value: InstantExpr;
+    };
+  };
+  readonly quality: "ambiguous" | "corrected" | "exact";
+  readonly corrections: readonly {
+    readonly original: string;
+    readonly replacement: string;
+    readonly distance: number;
+    readonly offset: number;
+  }[];
+  readonly alternatives: readonly {
+    readonly range: {
+      readonly _tag: "DateRange";
+      readonly lower: {
+        readonly _tag: "GreaterThan";
+        readonly value: InstantExpr;
+      } | {
+        readonly _tag: "GreaterThanOrEqual";
+        readonly value: InstantExpr;
+      };
+      readonly upper: {
+        readonly _tag: "LessThan";
+        readonly value: InstantExpr;
+      } | {
+        readonly _tag: "LessThanOrEqual";
+        readonly value: InstantExpr;
+      };
+    } | {
+      readonly _tag: "DateRange";
+      readonly lower: {
+        readonly _tag: "GreaterThan";
+        readonly value: InstantExpr;
+      } | {
+        readonly _tag: "GreaterThanOrEqual";
+        readonly value: InstantExpr;
+      };
+      readonly upper?: never;
+    } | {
+      readonly _tag: "DateRange";
+      readonly lower?: never;
+      readonly upper: {
+        readonly _tag: "LessThan";
+        readonly value: InstantExpr;
+      } | {
+        readonly _tag: "LessThanOrEqual";
+        readonly value: InstantExpr;
+      };
+    };
+    readonly canonical: string;
+  }[];
+}, NaturalLanguageParseError | UnsupportedLocaleError, LanguageRegistry>;
+//#endregion
+export { ParseNaturalOptions, parseNatural };

package/dist/natural/parse.mjs

@@ -0,0 +1,66 @@
+import { rangeKey } from "../filter/codec.mjs";
+import { NaturalLanguageParseError } from "../language/errors.mjs";
+import { NaturalAlternative, NaturalParseResult } from "../language/model.mjs";
+import { LanguageRegistry } from "../language/registry.mjs";
+import { applyFuturePolicy } from "./policy.mjs";
+import { Array, Effect, Order, Result } from "effect";
+//#region src/natural/parse.ts
+const distinctCandidates = (candidates) => Array.dedupeWith(candidates, (left, right) => rangeKey(left.range) === rangeKey(right.range));
+const parseQuality = (hasAlternatives, hasCorrections) => {
+	if (hasAlternatives) return "ambiguous";
+	if (hasCorrections) return "corrected";
+	return "exact";
+};
+const resultFromCandidates = (candidates, corrections) => {
+	const distinct = distinctCandidates(candidates);
+	const selected = Array.headNonEmpty(distinct);
+	const alternatives = Array.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.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.filterMap(corrected, (correction) => {
+		const candidates = applyFuturePolicy(language.parseExact(correction.text), options.allowFuture);
+		return Array.isReadonlyArrayNonEmpty(candidates) ? Result.succeed({
+			correction,
+			candidates
+		}) : Result.failVoid;
+	});
+	const successful = Array.sortWith(parsedCorrections, (entry) => entry.correction.cost, Order.Number);
+	if (!Array.isReadonlyArrayNonEmpty(successful)) return yield* new NaturalLanguageParseError({
+		input,
+		locale: options.locale,
+		message: "No conservative typo correction produced a complete expression"
+	});
+	const first = Array.headNonEmpty(successful);
+	const best = Array.prepend(Array.takeWhile(Array.tailNonEmpty(successful), (entry) => entry.correction.cost === first.correction.cost), first);
+	return resultFromCandidates(Array.flatMap(best, (entry) => entry.candidates), first.correction.corrections);
+});
+//#endregion
+export { parseNatural };

package/dist/natural/policy.mjs

@@ -0,0 +1,6 @@
+import { containsPositiveShift, isCurrentPeriod } from "../ast/fold.mjs";
+import { Array } from "effect";
+//#region src/natural/policy.ts
+const applyFuturePolicy = (candidates, allowFuture) => allowFuture === false ? Array.filter(candidates, (candidate) => isCurrentPeriod(candidate.range) || !containsPositiveShift(candidate.range)) : candidates;
+//#endregion
+export { applyFuturePolicy };

package/dist/natural/suggest.d.mts

@@ -0,0 +1,53 @@
+import { InstantExpr } from "../ast/schemas.mjs";
+import { UnsupportedLocaleError } from "../language/errors.mjs";
+import { LanguageRegistry } from "../language/registry.mjs";
+import "../index.mjs";
+import { Effect } from "effect";
+//#region src/natural/suggest.d.ts
+interface SuggestNaturalOptions {
+  readonly locale: string;
+  readonly limit?: number;
+  readonly allowFuture?: boolean;
+}
+declare const suggestNatural: (input: string, options: SuggestNaturalOptions) => Effect.Effect<{
+  readonly text: string;
+  readonly range: {
+    readonly _tag: "DateRange";
+    readonly lower: {
+      readonly _tag: "GreaterThan";
+      readonly value: InstantExpr;
+    } | {
+      readonly _tag: "GreaterThanOrEqual";
+      readonly value: InstantExpr;
+    };
+    readonly upper: {
+      readonly _tag: "LessThan";
+      readonly value: InstantExpr;
+    } | {
+      readonly _tag: "LessThanOrEqual";
+      readonly value: InstantExpr;
+    };
+  } | {
+    readonly _tag: "DateRange";
+    readonly lower: {
+      readonly _tag: "GreaterThan";
+      readonly value: InstantExpr;
+    } | {
+      readonly _tag: "GreaterThanOrEqual";
+      readonly value: InstantExpr;
+    };
+    readonly upper?: never;
+  } | {
+    readonly _tag: "DateRange";
+    readonly lower?: never;
+    readonly upper: {
+      readonly _tag: "LessThan";
+      readonly value: InstantExpr;
+    } | {
+      readonly _tag: "LessThanOrEqual";
+      readonly value: InstantExpr;
+    };
+  };
+}[], UnsupportedLocaleError, LanguageRegistry>;
+//#endregion
+export { SuggestNaturalOptions, suggestNatural };

package/dist/natural/suggest.mjs

@@ -0,0 +1,24 @@
+import { rangeKey } from "../filter/codec.mjs";
+import { NaturalSuggestion } from "../language/model.mjs";
+import { LanguageRegistry } from "../language/registry.mjs";
+import { applyFuturePolicy } from "./policy.mjs";
+import { Array, Effect } from "effect";
+//#region src/natural/suggest.ts
+const suggestionLimit = (limit) => {
+	if (limit === void 0) return 10;
+	if (!Number.isSafeInteger(limit) || limit <= 0) return 0;
+	return Math.min(limit, 100);
+};
+const suggestNatural = Effect.fn("chronolizer.suggestNatural")(function* (input, options) {
+	const language = yield* (yield* LanguageRegistry).resolve(options.locale);
+	const normalized = language.normalize(input, language.locale);
+	const limit = suggestionLimit(options.limit);
+	if (limit === 0) return [];
+	const suggestions = Array.flatMap(Array.dedupe(language.suggest(normalized, limit * 2)), (text) => applyFuturePolicy(language.parseExact(language.normalize(text, language.locale)), options.allowFuture).map((candidate) => NaturalSuggestion.make({
+		text: candidate.canonical,
+		range: candidate.range
+	})));
+	return Array.take(Array.dedupeWith(suggestions, (left, right) => rangeKey(left.range) === rangeKey(right.range)), limit);
+});
+//#endregion
+export { suggestNatural };

package/dist/natural/suggestion.d.mts

@@ -0,0 +1,4 @@
+//#region src/natural/suggestion.d.ts
+declare const completeNaturalPhrases: (input: string, phrases: ReadonlyArray<string>, limit: number) => string[];
+//#endregion
+export { completeNaturalPhrases };

package/dist/natural/suggestion.mjs

@@ -0,0 +1,79 @@
+import { damerauLevenshteinDistance } from "./correction.mjs";
+import { Array as Array$1, Option, String } from "effect";
+//#region src/natural/suggestion.ts
+const fuzzyPrefixDistance = (input, target) => {
+	const lengths = Array$1.dedupe([
+		Math.max(1, input.length - 1),
+		input.length,
+		Math.min(target.length, input.length + 1)
+	]);
+	return Math.min(...lengths.map((length) => damerauLevenshteinDistance(input, target.slice(0, length))));
+};
+const completionCost = (input, target) => {
+	if (input === target || target.startsWith(input)) return 0;
+	if (input.length < 3 || input[0] !== target[0]) return void 0;
+	const maximum = input.length >= 5 ? 2 : 1;
+	const distance = fuzzyPrefixDistance(input, target);
+	return distance <= maximum ? distance : void 0;
+};
+const phraseScore = (input, phrase) => {
+	if (input === phrase) return 0;
+	if (phrase.startsWith(input)) return 1;
+	const inputWords = input.split(" ");
+	const phraseWords = phrase.split(" ");
+	if (inputWords.length > phraseWords.length) return void 0;
+	let cost = 0;
+	for (const [index, inputWord] of inputWords.entries()) {
+		const targetWord = phraseWords[index];
+		if (targetWord === void 0) return void 0;
+		const wordCost = completionCost(inputWord, targetWord);
+		if (wordCost === void 0) return void 0;
+		cost += wordCost;
+	}
+	return cost === 0 ? 2 : 2 + cost;
+};
+const completeYearPrefix = (input) => {
+	const match = String.match(/(?:^| )(\d{3,4})$/u)(input);
+	if (Option.isNone(match)) return [];
+	const prefix = match.value[1] ?? "";
+	if (prefix.length === 4) {
+		const year = Number(prefix);
+		return year >= 1 && year <= 9998 ? [prefix] : [];
+	}
+	return Array.from({ length: 10 }, (_, digit) => `${prefix}${digit}`).filter((year) => {
+		const value = Number(year);
+		return value >= 1 && value <= 9998;
+	});
+};
+const fixedCalendarPeriodPhrases = (input, months) => completeYearPrefix(input).flatMap((year) => [
+	year,
+	...months.map((month) => `${month} ${year}`),
+	...[
+		1,
+		2,
+		3,
+		4
+	].map((quarter) => `q${quarter} ${year}`)
+]);
+const prefixNaturalPhrases = (phrases, prefixes) => phrases.flatMap((phrase) => prefixes.map((prefix) => `${prefix}${phrase}`));
+const naturalCount = (input) => {
+	const match = String.match(/(?:^| )([1-9]\d*)(?: |$)/u)(input);
+	if (Option.isNone(match)) return void 0;
+	const value = Number(match.value[1]);
+	return Number.isSafeInteger(value) ? value : void 0;
+};
+const completeNaturalPhrases = (input, phrases, limit) => {
+	const ranked = [];
+	for (const [index, phrase] of Array$1.dedupe(phrases).entries()) {
+		const score = phraseScore(input, phrase);
+		if (score !== void 0) ranked.push({
+			phrase,
+			score,
+			index
+		});
+	}
+	const sorted = ranked.sort((left, right) => left.score - right.score || left.index - right.index);
+	return (sorted.some((entry) => entry.score <= 1) ? sorted.filter((entry) => entry.score <= 1) : sorted).slice(0, limit).map((entry) => entry.phrase);
+};
+//#endregion
+export { completeNaturalPhrases, fixedCalendarPeriodPhrases, naturalCount, prefixNaturalPhrases };

package/dist/natural/text.d.mts

@@ -0,0 +1,5 @@
+//#region src/natural/text.d.ts
+declare const normalizeNaturalText: (input: string, locale: string) => string;
+declare const naturalWords: (input: string) => string[];
+//#endregion
+export { naturalWords, normalizeNaturalText };

package/dist/natural/text.mjs

@@ -0,0 +1,5 @@
+//#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
+export { naturalWords, normalizeNaturalText };

package/dist/resolve/resolve.d.mts

@@ -0,0 +1,79 @@
+import { InstantExpr } from "../ast/schemas.mjs";
+import { ResolutionError } from "./schema.mjs";
+import { DateTime, Effect } from "effect";
+//#region src/resolve/resolve.d.ts
+declare const resolve: (range: {
+  readonly _tag: "DateRange";
+  readonly lower: {
+    readonly _tag: "GreaterThan";
+    readonly value: InstantExpr;
+  } | {
+    readonly _tag: "GreaterThanOrEqual";
+    readonly value: InstantExpr;
+  };
+  readonly upper: {
+    readonly _tag: "LessThan";
+    readonly value: InstantExpr;
+  } | {
+    readonly _tag: "LessThanOrEqual";
+    readonly value: InstantExpr;
+  };
+} | {
+  readonly _tag: "DateRange";
+  readonly lower: {
+    readonly _tag: "GreaterThan";
+    readonly value: InstantExpr;
+  } | {
+    readonly _tag: "GreaterThanOrEqual";
+    readonly value: InstantExpr;
+  };
+  readonly upper?: never;
+} | {
+  readonly _tag: "DateRange";
+  readonly lower?: never;
+  readonly upper: {
+    readonly _tag: "LessThan";
+    readonly value: InstantExpr;
+  } | {
+    readonly _tag: "LessThanOrEqual";
+    readonly value: InstantExpr;
+  };
+}) => Effect.Effect<{
+  readonly _tag: "ResolvedDateRange";
+  readonly lower: {
+    readonly _tag: "GreaterThan";
+    readonly value: DateTime.Zoned;
+  } | {
+    readonly _tag: "GreaterThanOrEqual";
+    readonly value: DateTime.Zoned;
+  };
+  readonly upper: {
+    readonly _tag: "LessThan";
+    readonly value: DateTime.Zoned;
+  } | {
+    readonly _tag: "LessThanOrEqual";
+    readonly value: DateTime.Zoned;
+  };
+} | {
+  readonly _tag: "ResolvedDateRange";
+  readonly lower: {
+    readonly _tag: "GreaterThan";
+    readonly value: DateTime.Zoned;
+  } | {
+    readonly _tag: "GreaterThanOrEqual";
+    readonly value: DateTime.Zoned;
+  };
+  readonly upper?: never;
+} | {
+  readonly _tag: "ResolvedDateRange";
+  readonly lower?: never;
+  readonly upper: {
+    readonly _tag: "LessThan";
+    readonly value: DateTime.Zoned;
+  } | {
+    readonly _tag: "LessThanOrEqual";
+    readonly value: DateTime.Zoned;
+  };
+}, ResolutionError, DateTime.CurrentTimeZone>;
+//#endregion
+export { resolve };

package/dist/resolve/resolve.mjs

@@ -0,0 +1,58 @@
+import { foldInstant } from "../ast/fold.mjs";
+import { ResolutionError, ResolvedDateRange, ResolvedGreaterThan, ResolvedGreaterThanOrEqual, ResolvedLessThan, ResolvedLessThanOrEqual } from "./schema.mjs";
+import { DateTime, Effect, Match, Option } from "effect";
+//#region src/resolve/resolve.ts
+const shiftDateTime = (value, amount, unit) => Match.value(unit).pipe(Match.when("day", () => DateTime.add(value, { days: amount })), Match.when("week", () => DateTime.add(value, { weeks: amount })), Match.when("month", () => DateTime.add(value, { months: amount })), Match.when("quarter", () => DateTime.add(value, { months: amount * 3 })), Match.when("year", () => DateTime.add(value, { years: amount })), Match.exhaustive);
+const startOfDateTime = (value, unit) => {
+	if (unit === "quarter") {
+		const month = DateTime.getPart(value, "month");
+		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 { resolve };