which-dialect 0.1.0 → 0.1.1

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { type PronounRow, type Entry, type Hit, type LanguageMeta } from './types.ts';
+import { type PronounRow, type Entry, type Hit, type LanguageMeta, type PickRow } from './types.ts';
 export * from './types.ts';
 export * from './pos.ts';
 /**
@@ -65,6 +65,8 @@ export type Dictionary = {
      * for languages without a pronoun table.
      */
     pronouns(options?: PronounOptions): Promise<PronounRow[]>;
+    /** Hand-picked first choices for English meanings (see PickRow). Empty for languages without any. */
+    picks(): Promise<PickRow[]>;
 };
 /**
  * The regions a region or region-group name stands for (e.g. English "North America" -> US, Canada),

package/dist/index.js

@@ -103,6 +103,10 @@ export function createDictionary(options) {
             const kept = new Set(words.map((h) => h.word));
             return ranked.filter((h) => kept.has(h.word));
         },
+        async picks() {
+            const m = await meta();
+            return m.picks ? loadOnce('picks.json') : [];
+        },
         async pronouns({ listener, region, speaker, exclude = DEFAULT_EXCLUDED_LABELS } = {}) {
             const m = await meta();
             if (!m.pronouns)

package/dist/translate.d.ts

@@ -27,8 +27,9 @@ export type Translation = Hit & {
     score: number;
     /**
      * How this word was found: the English term that linked it, "synonym" for a same-language synonym,
-     * "table" for Wiktionary's translation table, or "pronouns" for a pronoun-table row's words (the
-     * `listener`'s or `about`'s row, or the default row).
+     * "table" for Wiktionary's translation table, "picked" for the target language's hand-picked words
+     * for this meaning (see PickRow), or "pronouns" for a pronoun-table row's words (the `listener`'s or
+     * `about`'s row, or the default row).
      */
     bridge: string;
     /** Example sentences for this word in the matched sense, when the dictionary has them. */
@@ -124,6 +125,11 @@ export type TranslateOptions = {
      * translations repeat another sense's. Default false. Useful for letting users pick a meaning.
      */
     allSenses?: boolean;
+    /**
+     * Use the target language's hand-picked words (default true). false returns the ranking alone, e.g. to
+     * see what picks change.
+     */
+    picks?: boolean;
 };
 export type Translator = {
     /** The senses of a word, following forms and variant spellings to the words they belong to. */

package/dist/translate.js

@@ -5,7 +5,7 @@
 // for those terms with a compatible part of speech, in the target region. Each source sense is translated
 // on its own, so a word's meanings don't get mixed up ("cool" the temperature vs. "cool" the compliment).
 import { compatiblePos } from "./pos.js";
-import { displayGloss, glossTerms, normalizeEnglish, PRONOUN_PERSONS, } from "./types.js";
+import { displayGloss, glossTerms, normalizeEnglish, PRONOUN_PERSONS, TRAILING_PARTICLE, } from "./types.js";
 import { createDictionary, DEFAULT_EXCLUDED_LABELS, resolveRegion, } from "./index.js";
 /**
  * Possible base words for a regularly inflected English word, most likely first: "walked" -> walk,
@@ -118,9 +118,61 @@ const MIN_SCORE = 1;
 // A variant that's only another spelling of a different word ("yeah": pronunciation spelling of "year")
 // ranks below the word's own meanings.
 const SPELLING_VIA = /pronunciation spelling|misspelling|eye dialect|nonstandard spelling|dated spelling|informal spelling/i;
+// Among a form's own meanings, one that needs a following construction ("Must; have/has (to).", "used
+// with have", "followed by …") is narrower than a standalone one ("got": "Have/has." comes first). Only
+// there: function words' main meanings are constructions ("would": "Past tense of will; usually
+// followed by a bare infinitive"), and demoting them everywhere put "would" → "hoàn cảnh" first.
+const CONSTRUCTION = /\((?:to|with [^)]*|followed by [^)]*)\)|\bused with\b|\bfollowed by\b/i;
 // Senses whose labels are all in this set rank after mainstream senses.
 const MARGINAL_LABELS = new Set(['informal', 'slang', 'colloquial', 'dialectal', 'rare', 'nonstandard', 'Internet', 'humorous']);
+// How a form reached its base word, when it's an inflection ("simple past of get", "form of run").
+const INFLECTION_VIA = /\b(?:past|participle|plural|singular|present|third-person|comparative|superlative|gerund)\b|^form of /i;
+// Everyday speech, not slang: a form's own colloquial meaning ("got": "Have/has.") isn't marginal.
+const EVERYDAY_LABELS = new Set(['informal', 'colloquial']);
 const LABEL_PENALTY = new Set(['slang', 'Internet', 'humorous', 'literary', 'dialectal', 'uncommon', 'rare', 'euphemistic']);
+// A target gloss that lists the bridge term itself as an equivalent ("muốn": "to want"; "má": "mother;
+// mom") is a plain translation, but a short gloss can't earn definition overlap, since the term's own
+// words don't count. Wordier glosses did ("mắc": "to want to (go to the bathroom, laugh, etc.); to have
+// the desire to" overlapped "desire"), so a narrow use beat the everyday word. An exact equivalent
+// scores like one overlapping word, for main terms only: a side term's exact match ("corn" → "cereal" →
+// "ngũ cốc") is a looser equivalent.
+const EXACT_GLOSS_BONUS = 3;
+// The term narrowed by a parenthetical right after it ("to want to (go to the bathroom …)") is a
+// restricted use of the word, not its general meaning (see narrows()).
+const NARROWED_PENALTY = 1.5;
+// A parenthetical narrows a term when it names something the source meaning doesn't: "to want to (go to
+// the bathroom, laugh, etc.)", "in/at (an outdoor or external location)". Restatements ("ngầu": "cool
+// (awesome; fantastic; great)" for cool = awesome), grammar ("to wait (for)") and usage notes, which say
+// how the word is used rather than what it means ("dạ": "yes (answers a question)"), don't narrow.
+const USAGE_NOTE = /^\s*(?:used|said|\w+s\s+(?:a|an|the|that|for|to|with|about)\b)/i;
+function narrows(parenthetical, context) {
+    return contentWords(parenthetical).size > 0 && !USAGE_NOTE.test(parenthetical) && overlap(context, parenthetical) === 0;
+}
+// A target sense marked passive ("được": "to obtain, to get (passively)") is a different voice from an
+// active source meaning ("get": "To obtain; to acquire", where "lấy" is the everyday word). Sized to
+// offset a very common word's frequency: "được" is common mostly as a helper verb ("được đi", "làm
+// được"), and frequency is per word, not per meaning.
+const PASSIVE = /\bpassive(?:ly)?\b/i;
+const VOICE_MISMATCH_PENALTY = 3;
+function exactGloss(gloss, term, context) {
+    // "to wait for" is plain "wait", but a part with a narrowing parenthetical isn't ("to want to (…)").
+    // Like glossTerms, only the text after a colon is the meaning ("Used as an answer …: no"). A question
+    // ("dạ": "yes? (asks for more information)") isn't the plain word.
+    let cleaned = gloss.replace(/\(([^)]*)\)/g, (_, inner) => (narrows(inner, context) ? '(' : ' '));
+    if (cleaned.includes(':'))
+        cleaned = cleaned.slice(cleaned.lastIndexOf(':') + 1);
+    return cleaned.split(/[;,/]/).some((part) => {
+        if (part.includes('('))
+            return false;
+        const t = normalizeEnglish(part.replace(/[.!]+\s*$/, ''));
+        return t === term || t.replace(TRAILING_PARTICLE, '') === term;
+    });
+}
+function narrowed(gloss, term, context) {
+    const escaped = term.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const m = new RegExp(`\\b${escaped}\\b(?:\\s+to)?\\s*\\(([^)]*)`, 'i').exec(gloss);
+    return m !== null && narrows(m[1], context);
+}
 // Register: a polite source word should translate to a polite word, a casual one to a casual one.
 const POLITE = new Set(['polite', 'formal', 'honorific', 'literary']);
 const CASUAL = new Set(['informal', 'colloquial', 'slang', 'familiar', 'vulgar', 'Internet']);
@@ -147,16 +199,25 @@ function registerFit(source, target, wanted) {
 // what the word means. Without the jargon, Vietnamese "con" ("used when talking to someone older than
 // the speaker") matched English "I" ("the speaker or writer") on "speaker".
 const STOPWORDS = new Set(('a an the to of or and in on for with by as at from that this be is are was it its used use any some one ' +
-    'something someone very more most usually especially often also who which what when being having into ' +
+    'something someone very more most usually especially often also who which what when being have has having into ' +
     'speaker speakers writer referred refer refers referring grammatical subject object sentence clause ' +
     'word words form forms term expression phrase talking speaking addressed addressing person people ' +
     'particular certain various generally sense usage meaning').split(' '));
-function contentWords(text) {
+function contentWords(text, keep) {
     return new Set(text
         .toLowerCase()
         .replace(/[^a-z' ]+/g, ' ')
         .split(' ')
-        .filter((w) => w.length > 2 && !STOPWORDS.has(w)));
+        .filter((w) => w.length > 2 && (!STOPWORDS.has(w) || keep?.has(w))));
+}
+// The caller's `meaning` words all count, even ones too common to count in definitions ("have" picks
+// "got" = "To have", not "To obtain").
+function meaningOverlap(words, text) {
+    let n = 0;
+    for (const w of contentWords(text, words))
+        if (words.has(w))
+            n++;
+    return n;
 }
 function overlap(a, text) {
     let n = 0;
@@ -187,10 +248,15 @@ function bridgeTerms(sense, from) {
     }
     // Headings ("As a copulative verb:") carry no meaning, so the specific definitions are used.
     const glosses = sense.glosses.filter((g) => !g.trim().endsWith(':'));
+    // A first definition that is only a short list of equivalents ("To fetch, bring, take.") names the
+    // meaning with every item equally, so all of them are main terms ("take" → "lấy" scored no position
+    // bonus, and words found only through the ambiguous "get" itself came first: hóng, bắt, ra khỏi).
     glosses.slice(0, 2).forEach((gloss, gi) => {
-        for (const [term, position] of glossTerms(gloss)) {
+        const found = glossTerms(gloss);
+        const list = gi === 0 && isTermList(gloss, found.length);
+        for (const [term, position] of found) {
             terms.push(term);
-            if (gi === 0 && position === 0)
+            if (gi === 0 && (position === 0 || list))
                 main.add(term);
         }
     });
@@ -206,6 +272,11 @@ function bridgeTerms(sense, from) {
     }
     return { terms: unique.slice(0, 8), synonymsFrom, main };
 }
+// Every comma/semicolon part of the definition became a term, and each is at most three words.
+function isTermList(gloss, termCount) {
+    const parts = gloss.replace(/\.\s*$/, '').split(/[;,]/);
+    return termCount >= 2 && parts.length === termCount && parts.every((p) => p.trim().split(/\s+/).length <= 3);
+}
 export function createTranslator(options = {}) {
     const cache = new Map();
     const dict = (lang) => {
@@ -351,34 +422,37 @@ export function createTranslator(options = {}) {
         }
         return hits;
     }
-    // The translation-table words for a source sense in the target language. English senses carry their
-    // table; for other languages, the English sense whose table lists the source word (in the source
-    // language) is the same meaning, and its target-language list applies.
-    async function tableFor(sense, from, to, bridge) {
+    async function englishMeanings(sense, from, bridge) {
         if (from === 'en')
-            return to === 'en' ? [] : (sense.translations?.[to] ?? []);
+            return [{ word: sense.lemma, pos: sense.pos, gloss: sense.glosses[0] ?? '', translations: sense.translations }];
         const found = [];
-        const add = (list) => {
-            for (const t of list ?? [])
-                if (!found.some((f) => f.word === t.word))
-                    found.push(t);
-        };
         for (const term of bridge.slice(0, 3)) {
             for (const entry of await dict('en').lookup(term)) {
                 for (const s of entry.senses) {
                     const own = s.translations?.[from];
                     if (!own?.some((t) => t.word === sense.lemma || t.word === sense.word))
                         continue;
-                    // Into English, the English word whose table lists the source word is itself the translation.
-                    if (to === 'en')
-                        add([{ word: entry.word }]);
-                    else
-                        add(s.translations?.[to]);
+                    if (!found.some((f) => f.word === entry.word && f.gloss === s.glosses[0])) {
+                        found.push({ word: entry.word, pos: entry.pos, gloss: s.glosses[0], translations: s.translations });
+                    }
                 }
             }
         }
         return found;
     }
+    async function tableFor(sense, from, to, bridge) {
+        if (from === 'en')
+            return to === 'en' ? [] : (sense.translations?.[to] ?? []);
+        const found = [];
+        for (const m of await englishMeanings(sense, from, bridge)) {
+            // Into English, the English word whose table lists the source word is itself the translation.
+            const list = to === 'en' ? [{ word: m.word }] : (m.translations?.[to] ?? []);
+            for (const t of list)
+                if (!found.some((f) => f.word === t.word))
+                    found.push(t);
+        }
+        return found;
+    }
     // Which of the target's regions a table tag names ("Latin-America" -> its countries), if any.
     function tagRegions(tags, meta) {
         const out = new Set();
@@ -480,8 +554,12 @@ export function createTranslator(options = {}) {
     }
     const api = {
         senses,
-        async translate(word, { from, to, fromRegion, toRegion, pos, meaning, register: wantedRegister, listener, about, speaker, exclude = DEFAULT_EXCLUDED_LABELS, limit = 5, allSenses = false }) {
+        async translate(word, { from, to, fromRegion, toRegion, pos, meaning, register: wantedRegister, listener, about, speaker, exclude = DEFAULT_EXCLUDED_LABELS, limit = 5, allSenses = false, picks: usePicks = true }) {
             const [sourceSenses, toMeta, fromMeta] = await Promise.all([senses(word, { from, fromRegion, pos }), dict(to).meta(), dict(from).meta()]);
+            // The target language's hand-picked words for English meanings (picks.json), when it has any.
+            const pickRows = usePicks && to !== 'en' && toMeta.picks ? await dict(to).picks() : [];
+            // Senses whose pick row asks to come first when the caller gives no pos or meaning.
+            const pickedFirst = new Set();
             // The target's pronoun table, for personal-pronoun senses (throws for an unknown listener/about).
             const pronounRows = toMeta.pronouns && sourceSenses.some((s) => personOf(s, from))
                 ? await dict(to).pronouns({ region: toRegion, speaker, exclude })
@@ -492,7 +570,7 @@ export function createTranslator(options = {}) {
                 await dict(to).pronouns({ listener: about });
             const toWanted = resolveRegion(toMeta, toRegion);
             const hasFrequencies = Boolean(toMeta.frequencySource);
-            const meaningWords = meaning ? contentWords(meaning) : null;
+            const meaningWords = meaning ? contentWords(meaning, new Set(meaning.toLowerCase().split(/[^a-z']+/))) : null;
             const groups = [];
             for (const sense of sourceSenses) {
                 const { terms: bridge, synonymsFrom, main } = bridgeTerms(sense, from);
@@ -523,6 +601,7 @@ export function createTranslator(options = {}) {
                     // The term's own words say nothing about which meaning matched, so they don't count as overlap.
                     const termWords = contentWords(term);
                     const ctx = new Set([...context].filter((w) => !termWords.has(w)));
+                    const isMain = main.has(term) || termIndex === 0;
                     const hits = to === 'en'
                         ? await englishCandidates(term, posList, toMeta, toRegion, exclude)
                         // A generous limit: the dictionary's quick ranking puts region-tagged words first, and the
@@ -546,7 +625,10 @@ export function createTranslator(options = {}) {
                         // less (common words win anyway), and kinship words list "you" after "I/me" (Vietnamese "anh"),
                         // so the penalty is small then.
                         const score = 3 * overlap(ctx, hit.gloss) +
-                            (main.has(term) || termIndex === 0 ? 2 : termIndex === 1 ? 1 : 0) +
+                            (isMain && exactGloss(hit.gloss, term, ctx) ? EXACT_GLOSS_BONUS : 0) -
+                            (narrowed(hit.gloss, term, ctx) ? NARROWED_PENALTY : 0) -
+                            (PASSIVE.test(hit.gloss) && !PASSIVE.test(sense.glosses.join(' ')) ? VOICE_MISMATCH_PENALTY : 0) +
+                            (isMain ? 2 : termIndex === 1 ? 1 : 0) +
                             (hit.primary ? 1 : 0) +
                             // Tagged for the target region: a full bonus when the match is the word's main meaning, a
                             // small one otherwise ("bá cháy" is Southern for "awesome", not for "cool" the temperature).
@@ -608,6 +690,36 @@ export function createTranslator(options = {}) {
                             scored.set(t.word, { ...t, score: t.score + 4, bridge: 'synonym' });
                     }
                 }
+                // Hand-picked words for this meaning go first, in the listed order: a speaker's judgment of the
+                // natural word where the ranking puts another first. With a target region, picks tagged for it
+                // lead, and picks tagged only for other regions (or words not used there) are left to the
+                // ranking. The ranked words follow. (A pronoun-table row, below, still comes before them.)
+                const rows = pickRows.length
+                    ? await englishMeanings(sense, from, bridge).then((ms) => pickRows.filter((r) => ms.some((m) => m.word === r.word && m.pos === r.pos && m.gloss === r.gloss)))
+                    : [];
+                if (rows.some((r) => r.first))
+                    pickedFirst.add(sense);
+                const picked = [];
+                for (const t of rows.flatMap((r) => r.picks)) {
+                    if (picked.some((p) => p.hit.word === t.word))
+                        continue;
+                    const places = tagRegions(t.tags, toMeta);
+                    if (toWanted && places && ![...places].some((r) => toWanted.has(r)))
+                        continue;
+                    if (to === from && t.word === sense.lemma && !places?.size)
+                        continue;
+                    const hit = scored.get(t.word) ?? (await tableHit(t.word, to, posList, toWanted, exclude, bridge));
+                    if (!hit || hit.labels.some((l) => exclude.includes(l)))
+                        continue;
+                    if (!places && !intersects(hit.regions, toWanted))
+                        continue;
+                    picked.push({ hit, tagged: Boolean(toWanted && places) });
+                }
+                if (picked.length) {
+                    const ordered = [...picked.filter((p) => p.tagged), ...picked.filter((p) => !p.tagged)];
+                    const top = Math.max(0, ...[...scored.values()].map((t) => t.score));
+                    ordered.forEach(({ hit }, i) => scored.set(hit.word, { ...hit, score: top + 1 + (ordered.length - i) * 0.1, bridge: 'picked' }));
+                }
                 // Personal pronouns: the chosen row's words go first (the `listener`'s for I/you/we, the `about`'s
                 // for he/she/they, else the default row's), fitted to the pronoun's gender (he/she) and
                 // inclusiveness (we). Words tagged for the target region, then those fitting the register, lead.
@@ -706,15 +818,34 @@ export function createTranslator(options = {}) {
                 const chosen = ABOUT_PERSONS.has(p.person) ? about : listener;
                 return (chosen ? 10 : 0) - (hasSingular && !SINGULAR_PERSONS.has(p.person) ? 3 : 0);
             };
+            // A form with its own entries ("got": "Have/has.", colloquial) as well as its base word's ("get"):
+            // the form's own meanings are why it has entries at all, so they stay ahead of the base word's, and
+            // a colloquial/informal label doesn't push them behind (slang and Internet labels still do: "felt"
+            // "To thoroughly defeat", Internet). A construction ("Must; have/has (to).") then only reorders
+            // them among themselves.
+            // Only inflections ("got": simple past of get), not contractions ("kinda") or spelling variants.
+            const formWithBase = ownSenses && sourceSenses.some((s) => s.via && INFLECTION_VIA.test(s.via));
+            const labelRelevance = (g) => {
+                const { labels } = g.source;
+                const marginal = labels.length > 0 && labels.every((l) => MARGINAL_LABELS.has(l));
+                const everyday = labels.length > 0 && labels.every((l) => EVERYDAY_LABELS.has(l));
+                if (formWithBase && !g.source.via && (!marginal || everyday)) {
+                    return 1 - (CONSTRUCTION.test(g.source.glosses.join(' ')) ? 0.5 : 0);
+                }
+                return marginal ? -1 : 0;
+            };
             const relevance = (g) => (meaningWords
-                ? 10 * overlap(meaningWords, g.source.glosses.join(' ')) + 5 * overlap(meaningWords, g.translations[0]?.gloss ?? '')
+                ? 10 * meaningOverlap(meaningWords, g.source.glosses.join(' ')) + 5 * meaningOverlap(meaningWords, g.translations[0]?.gloss ?? '')
                 : 0) -
                 (ownSenses && g.source.via && SPELLING_VIA.test(g.source.via) ? 2 : 0) +
                 (fromRegion && g.source.regionTagged ? 3 : 0) +
-                pronounRelevance(g) -
-                (g.source.labels.length && g.source.labels.every((l) => MARGINAL_LABELS.has(l)) ? 1 : 0);
+                pronounRelevance(g) +
+                labelRelevance(g) +
+                (!meaning && pickedFirst.has(g.source) ? 5 : 0);
+            // A sense with no translations says nothing, so it goes after the ones that do ("got": "Expressing
+            // obligation; used with have." finds nothing; "Must; have/has (to)." gives "phải").
             const ordered = groups
-                .map((g, i) => ({ g, i, r: relevance(g) }))
+                .map((g, i) => ({ g, i, r: relevance(g) - (g.translations.length ? 0 : 100) }))
                 .sort((a, b) => b.r - a.r || a.i - b.i)
                 .map((x) => x.g);
             if (allSenses)

package/dist/types.d.ts

@@ -108,6 +108,24 @@ export type LanguageMeta = {
     shardLength?: number;
     /** true when the language has a pronoun table (pronouns.json, see PronounRow). */
     pronouns?: boolean;
+    /** true when the language has hand-picked translations (picks.json, see PickRow). */
+    picks?: boolean;
+};
+/**
+ * Hand-picked first choices for one English meaning, in one target language (picks.json). A speaker's
+ * judgment of the natural word where the data ranks another first ("get", "To fetch, bring, take" →
+ * Vietnamese "lấy", not "đưa"). Keyed by English meaning, so each language needs one list, and
+ * translating between two other languages reaches it through the English meaning.
+ */
+export type PickRow = {
+    /** The English headword, part of speech and first definition of the meaning, as in the English data. */
+    word: string;
+    pos: string;
+    gloss: string;
+    /** Best first. `tags` name regions like translation-table tags ("Southern"). */
+    picks: TableTranslation[];
+    /** Put this meaning first when the caller gives no `pos` or `meaning` ("got" → "Have/has."). */
+    first?: boolean;
 };
 /**
  * One word in the pronoun table: how to say "I", "you", "he/she", "we", plural "you" or "they" in one
@@ -218,6 +236,7 @@ export declare function normalizeEnglish(term: string): string;
  * headings ending in ":" are skipped in favor of the specific definition.
  */
 export declare function displayGloss(glosses: string[]): string;
+export declare const TRAILING_PARTICLE: RegExp;
 /**
  * Splits an English gloss into search terms, main meaning first: "now, today, this time" ->
  * [["now", 0], ["today", 1], ["this time", 2]]. Parenthesized notes and final punctuation are dropped.

package/dist/types.js

@@ -55,7 +55,7 @@ export function displayGloss(glosses) {
     return glosses.find((g) => !g.trim().endsWith(':')) ?? glosses[0] ?? '';
 }
 // Trailing words dropped to also match the bare verb: "wait for" is found by "wait" too.
-const TRAILING_PARTICLE = / (for|to|at|on|with|about|of|in|into|up|out|off|over)$/;
+export const TRAILING_PARTICLE = / (for|to|at|on|with|about|of|in|into|up|out|off|over)$/;
 /**
  * Splits an English gloss into search terms, main meaning first: "now, today, this time" ->
  * [["now", 0], ["today", 1], ["this time", 2]]. Parenthesized notes and final punctuation are dropped.
@@ -72,8 +72,11 @@ export function glossTerms(gloss) {
         cleaned = cleaned.slice(cleaned.lastIndexOf(':') + 1);
     const terms = [];
     let position = 0;
-    // "I/me" lists two meanings, like "I; me".
-    for (const part of cleaned.split(/[;,/]/)) {
+    // "I/me" lists two meanings, like "I; me". Sentences too: "To have. See usage notes." means "have",
+    // and cross-references ("See usage notes", "Compare shall", "Synonym: …") aren't meanings.
+    for (const part of cleaned.split(/[;,/]|\.\s+/)) {
+        if (/^\s*(?:see|compare|cf|synonyms?|antonyms?)\b/i.test(part))
+            continue;
         // "etc." is not a meaning: "walking etc" -> "walking", and a lone "etc" is skipped.
         const t = normalizeEnglish(part.replace(/[.!?]+\s*$/, '').replace(/\betc\.?$/i, '').trim());
         if (!t || t.split(' ').length > 4 || !/^[a-z][a-z' -]*$/.test(t))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "which-dialect",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Translate words between languages and dialects, meaning by meaning, starting with Vietnamese (Northern, Central, Southern) and English, with Wiktionary data loaded on demand. More languages are planned.",
   "type": "module",
   "main": "./dist/index.js",