chronolizer 0.4.0 → 0.4.1

package/dist/natural/correction.mjs

@@ -1,24 +1,41 @@
 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);
+const isProtectedValue = (word) => /^(?:\d+|\d{4}-\d{2}-\d{2})$/u.test(word);
+const damerauLevenshteinDistance = (left, right, maximum = Math.max(left.length, right.length), workspace = [
+	[],
+	[],
+	[]
+]) => {
+	const outside = maximum + 1;
+	if (Math.abs(left.length - right.length) > maximum) return outside;
+	const width = right.length + 1;
+	let [previousPrevious, previous, current] = workspace;
+	for (const row of workspace) {
+		row.length = width;
+		row.fill(outside);
+	}
+	for (let column = 0; column <= Math.min(right.length, maximum); column += 1) previous[column] = column;
 	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));
+		current.fill(outside);
+		if (row <= maximum) current[0] = row;
+		const firstColumn = Math.max(1, row - maximum);
+		const lastColumn = Math.min(right.length, row + maximum);
+		let rowMinimum = row <= maximum ? row : outside;
+		for (let column = firstColumn; column <= lastColumn; column += 1) {
+			const substitution = left.charCodeAt(row - 1) === right.charCodeAt(column - 1) ? 0 : 1;
+			let distance = Math.min((previous[column] ?? outside) + 1, (current[column - 1] ?? outside) + 1, (previous[column - 1] ?? outside) + substitution);
+			if (row > 1 && column > 1 && left.charCodeAt(row - 1) === right.charCodeAt(column - 2) && left.charCodeAt(row - 2) === right.charCodeAt(column - 1)) distance = Math.min(distance, (previousPrevious[column - 2] ?? outside) + 1);
+			current[column] = distance;
+			rowMinimum = Math.min(rowMinimum, distance);
 		}
+		if (rowMinimum > maximum) return outside;
+		const reusable = previousPrevious;
 		previousPrevious = previous;
 		previous = current;
+		current = reusable;
 	}
-	return previous[right.length] ?? fallback;
+	return previous[right.length] ?? outside;
 };
 const segmentedReplacements = (word, vocabulary) => {
 	const segmentations = Array.from({ length: word.length + 1 }, () => []);
@@ -43,34 +60,60 @@ const segmentedReplacements = (word, vocabulary) => {
 		distance: parts.length - 1
 	}));
 };
-const replacementsFor = (word, vocabulary, segmentationVocabulary) => {
-	if (vocabulary.includes(word) || isProtectedValue(word)) return [{
+const vocabularySets = /* @__PURE__ */ new WeakMap();
+const vocabularySet = (vocabulary) => {
+	const cached = vocabularySets.get(vocabulary);
+	if (cached !== void 0) return cached;
+	const words = new Set(vocabulary);
+	vocabularySets.set(vocabulary, words);
+	return words;
+};
+const replacementsFor = (word, vocabulary, segmentationVocabulary, workspace) => {
+	if (vocabulary.has(word) || isProtectedValue(word)) return [{
 		word,
 		distance: 0
 	}];
 	const segmented = segmentedReplacements(word, segmentationVocabulary);
 	if (word.length <= 3) return segmented;
 	const maximum = word.length >= 6 ? 2 : 1;
-	const fuzzy = vocabulary.filter((candidate) => Math.abs(candidate.length - word.length) <= maximum).map((candidate) => ({
-		word: candidate,
-		distance: damerauLevenshteinDistance(word, candidate)
-	})).filter((candidate) => candidate.distance <= maximum);
-	const matches = [...segmented, ...fuzzy];
-	if (matches.length === 0) return [];
-	const minimum = Math.min(...matches.map((candidate) => candidate.distance));
-	return matches.filter((candidate) => candidate.distance === minimum).slice(0, 4);
+	let minimum = Number.POSITIVE_INFINITY;
+	const matches = [];
+	const addMatch = (replacement, distance) => {
+		if (distance > minimum) return;
+		if (distance < minimum) {
+			minimum = distance;
+			matches.length = 0;
+		}
+		if (matches.length < 4) matches.push({
+			word: replacement,
+			distance
+		});
+	};
+	for (const replacement of segmented) addMatch(replacement.word, replacement.distance);
+	for (const candidate of vocabulary) {
+		if (Math.abs(candidate.length - word.length) > maximum) continue;
+		const distance = damerauLevenshteinDistance(word, candidate, maximum, workspace);
+		if (distance <= maximum) addMatch(candidate, distance);
+	}
+	return matches;
 };
 const emptySegmentationVocabulary = /* @__PURE__ */ new Set();
 const correctWhitespaceSeparatedText = (input, vocabulary, segmentationVocabulary = emptySegmentationVocabulary) => {
 	const words = naturalWords(input);
+	const wordsInVocabulary = vocabularySet(vocabulary);
+	const workspace = [
+		[],
+		[],
+		[]
+	];
 	let partials = [{
-		words: [],
+		text: "",
 		corrections: [],
 		cost: 0,
 		offset: 0
 	}];
 	for (const word of words) {
-		const replacements = replacementsFor(word, vocabulary, segmentationVocabulary);
+		const replacements = replacementsFor(word, wordsInVocabulary, segmentationVocabulary, workspace);
 		if (replacements.length === 0) return [];
 		const next = [];
 		for (const partial of partials) for (const replacement of replacements) {
@@ -81,7 +124,7 @@ const correctWhitespaceSeparatedText = (input, vocabulary, segmentationVocabular
 				offset: partial.offset
 			})];
 			next.push({
-				words: [...partial.words, replacement.word],
+				text: partial.text.length === 0 ? replacement.word : `${partial.text} ${replacement.word}`,
 				corrections: correction,
 				cost: partial.cost + replacement.distance,
 				offset: partial.offset + word.length + 1
@@ -90,7 +133,7 @@ const correctWhitespaceSeparatedText = (input, vocabulary, segmentationVocabular
 		partials = next.slice(0, 32);
 	}
 	return partials.filter((partial) => partial.corrections.length > 0).map((partial) => NaturalCorrectionCandidate.make({
-		text: partial.words.join(" "),
+		text: partial.text,
 		corrections: partial.corrections,
 		cost: partial.cost
 	}));

package/dist/natural/parse.mjs

@@ -5,7 +5,7 @@ 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 distinctCandidates = (candidates) => candidates.length === 1 ? candidates : Array.dedupeWith(candidates, (left, right) => rangeKey(left.range) === rangeKey(right.range));
 const parseQuality = (hasAlternatives, hasCorrections) => {
 	if (hasAlternatives) return "ambiguous";
 	if (hasCorrections) return "corrected";

package/dist/natural/suggest.mjs

@@ -30,7 +30,15 @@ const suggestNatural = Effect.fn("chronolizer.suggestNatural")(function* (input,
 		text: candidate.canonical,
 		range: candidate.range
 	})));
-	const distinct = (suggestions) => Array$1.dedupeWith(suggestions, (left, right) => rangeKey(left.range) === rangeKey(right.range));
+	const distinct = (suggestions) => {
+		const keys = /* @__PURE__ */ new Set();
+		return suggestions.filter((suggestion) => {
+			const key = rangeKey(suggestion.range);
+			if (keys.has(key)) return false;
+			keys.add(key);
+			return true;
+		});
+	};
 	const suggested = distinct(suggestionsFrom([...language.suggest(normalized, limit * 2), normalized]));
 	if (suggested.length > 0) return Array$1.take(suggested, limit);
 	const completionVocabulary = Array$1.dedupe([...Array$1.flatMap(language.suggest("", 100), naturalWords), ...language.vocabulary]);

package/dist/natural/suggestion.mjs

@@ -1,40 +1,44 @@
 import { damerauLevenshteinDistance } from "./correction.mjs";
-import { Array as Array$1, Option, String } from "effect";
+import { Option, String } from "effect";
 //#region src/natural/suggestion.ts
-const fuzzyPrefixDistance = (input, target) => {
-	const lengths = Array$1.dedupe([
+const completionCost = (input, target, targetStart, targetEnd, workspace) => {
+	const targetLength = targetEnd - targetStart;
+	if (input.length <= targetLength && target.startsWith(input, targetStart)) return 0;
+	if (input.length < 3 || input.charCodeAt(0) !== target.charCodeAt(targetStart)) return void 0;
+	const maximum = input.length >= 5 ? 2 : 1;
+	let minimum = maximum + 1;
+	let previousLength = -1;
+	for (const length of [
 		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;
+		Math.min(targetLength, input.length + 1)
+	]) {
+		if (length === previousLength) continue;
+		previousLength = length;
+		minimum = Math.min(minimum, damerauLevenshteinDistance(input, target.slice(targetStart, targetStart + length), maximum, workspace));
+	}
+	return minimum <= maximum ? minimum : void 0;
 };
-const phraseScore = (input, phrase) => {
+const phraseScore = (input, inputWords, phrase, workspace) => {
 	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;
 	let addedWords = 0;
-	let phraseIndex = 0;
+	let phraseStart = 0;
 	for (const inputWord of inputWords) {
-		let wordCost = completionCost(inputWord, phraseWords[phraseIndex] ?? "");
+		let phraseEnd = phrase.indexOf(" ", phraseStart);
+		if (phraseEnd === -1) phraseEnd = phrase.length;
+		let wordCost = completionCost(inputWord, phrase, phraseStart, phraseEnd, workspace);
 		while (wordCost === void 0 && addedWords < 3) {
-			phraseIndex += 1;
+			phraseStart = phraseEnd + 1;
+			phraseEnd = phrase.indexOf(" ", phraseStart);
+			if (phraseEnd === -1) phraseEnd = phrase.length;
 			addedWords += 1;
-			wordCost = completionCost(inputWord, phraseWords[phraseIndex] ?? "");
+			wordCost = completionCost(inputWord, phrase, phraseStart, phraseEnd, workspace);
 		}
 		if (wordCost === void 0) return void 0;
 		cost += wordCost;
-		phraseIndex += 1;
+		phraseStart = phraseEnd + 1;
 	}
 	return 2 + cost + addedWords;
 };
@@ -70,16 +74,30 @@ const naturalCount = (input) => {
 };
 const completeNaturalPhrases = (input, phrases, limit) => {
 	const ranked = [];
-	for (const [index, phrase] of Array$1.dedupe(phrases).entries()) {
-		const score = phraseScore(input, phrase);
+	const inputWords = input.split(" ");
+	const workspace = [
+		[],
+		[],
+		[]
+	];
+	let index = 0;
+	for (const phrase of new Set(phrases)) {
+		const score = phraseScore(input, inputWords, phrase, workspace);
 		if (score !== void 0) ranked.push({
 			phrase,
 			score,
 			index
 		});
+		index += 1;
+	}
+	ranked.sort((left, right) => left.score - right.score || left.index - right.index);
+	const maximumScore = (ranked[0]?.score ?? 2) <= 1 ? 1 : Number.POSITIVE_INFINITY;
+	const matches = [];
+	for (const entry of ranked) {
+		if (entry.score > maximumScore || matches.length >= limit) break;
+		matches.push(entry.phrase);
 	}
-	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);
+	return matches;
 };
 //#endregion
 export { completeNaturalPhrases, fixedCalendarPeriodPhrases, naturalCount, prefixNaturalPhrases };

package/dist/resolve/resolve.mjs

@@ -6,8 +6,7 @@ const shiftDateTime = (value, amount, unit) => Match.value(unit).pipe(Match.when
 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(DateTime.subtract(value, { months: (month - 1) % 3 }), "month");
 	}
 	return DateTime.startOf(value, unit, { weekStartsOn: 1 });
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chronolizer",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "Bidirectional natural-language date ranges for Effect.",
   "homepage": "https://github.com/tobimori/chronolizer#readme",
   "bugs": "https://github.com/tobimori/chronolizer/issues",
@@ -54,6 +54,7 @@
     }
   },
   "scripts": {
+    "benchmark": "pnpm build && node tools/benchmark.mjs",
     "build": "vp pack",
     "check:bundle-size": "node tools/check-bundle-size.mjs",
     "check:tree-shaking": "node tools/check-tree-shaking.mjs",