@lacspace/nepali-match 1.0.0 → 1.1.0

package/README.md

@@ -36,17 +36,20 @@ normaliseNe("काठमाडौँ") === normaliseNe("काठमाडौ
 6. Devanagari digits → ASCII.
 7. Whitespace collapses.
 
-`loose: true` also folds श/ष → स, व → ब and ण → न. Latin text is left as it is.
+`loose: true` also folds श/ष → स, व → ब and ण → न. `hyphenAsSpace: true` treats hyphens as spaces, so "Solu Khumbu" matches "Solu-Khumbu" and "Bardaghat-Susta". Latin text is left as it is.
 
 **Nepali terms** match as whole words:
 - Nothing may stand before the word except a space or punctuation.
 - After the word, a chain of up to three `POSTPOSITIONS` may follow: मा, को, का, की, ले, लाई, बाट, सँग, देखि, सम्म, तिर, भित्र, हरू, मै, बाटै, नै … Anything else after it means it's a different word.
-- Turn this off with `postpositions: false`. Add your own with `extraSuffixes`.
+- Turn the built-in list off with `postpositions: false`. Add your own with `extraSuffixes`; with `postpositions: false` they become the only suffixes allowed.
+- "Like" (जस्तो) is deliberately not in the list: "काठमाडौंजस्तो ठूलो सहर" is a comparison, not a location.
+- With `joinNepali: true`, any space in a multi-word Nepali term is optional, so "बर्दघाट सुस्ता पूर्व" also matches "बर्दघाट सुस्तापूर्व".
 
 **English terms** match as whole words, ignoring case. Exceptions:
 - Under the default `caseSensitive: "auto"` rule, an all-caps term of 2–5 letters (SEE, NEB, PSC) must match its case exactly.
 - Set `caseSensitive` per term or per matcher to change this.
-- An all-caps headline ("COME AND SEE") still matches SEE. Check the case of the surrounding text if your input has shouty headlines.
+- An exact-case term longer than 5 letters also matches in ALL CAPS, so "KATHMANDU" in a headline counts. Turn this off with `allCaps: false`.
+- Short acronyms can't tell a shouted headline apart: "COME AND SEE" still matches SEE. Check the case of the surrounding text if your input has shouty headlines.
 
 **Overlaps:** the longest match wins, so "Nawalparasi West" beats "Nawalparasi". Pass `overlaps: true` to keep both.
 
@@ -54,20 +57,27 @@ Every match carries `index`/`end` offsets into the original text (after NFC), so
 
 ## API
 
-- **`createMatcher(terms, options?)`** returns `{ find(text), test(text, id?), ids(text), size }`. Compile it once and reuse it.
+- **`createMatcher(terms, options?)`** returns `{ find(text), test(text, id?), ids(text), prepare(text), size }`. Compile it once and reuse it.
+- **`prepare(text, options?)`** / **`matcher.prepare(text)`** normalise text once. Every `find`, `test`, `ids`, `findTerms`, `contains` and `near` accepts the result in place of a string, so a rules loop over one article normalises it once, not once per rule. A prepared text made with different options is re-prepared automatically.
   - A term is either a string, or `{ id?, en?, ne?, aliases?, caseSensitive? }`. `en` and `ne` each take one spelling or an array.
 - **`findTerms(text, terms, options?)`** and **`contains(text, terms, options?)`** are one-off shortcuts.
 - **`near(text, a, b, maxChars | options, sameSentence?)`** returns the closest `{ a, b, gap }` pair of matches within `maxChars` (default 60), in either order, or null.
+  - `a` and `b` can be terms, a compiled `Matcher`, or a `Match[]` you already found in the same text.
   - By default both must sit in the same sentence. A sentence ends at । ॥ ? ! or a newline, or at "." before a space.
   - Dotted abbreviations such as ने.क.पा. and U.S. never end a sentence.
 - **`sentenceSpans(text)`** returns the sentence boundaries `near` uses.
 - **`splitSuffix(word)`**: for example, `"जिल्लाहरूमा"` → `{ stem: "जिल्ला", suffixes: ["हरु", "मा"] }`.
 - **`districtTerms()`** returns all 77 districts.
   - **Names and ids:** names come from `@lacspace/nepali-utils`. Ids are slugs such as `"nawalparasi-east"`, and `province` is a number.
-  - **Spellings:** each district carries the spellings seen in real copy: Kavre/काभ्रे, Rukum East/रुकुम पूर्व, Kapilbastu, मोरंग/मोरङ…
-  - **Case:** English district names are exact-case, so "dang it" is not Dang.
+  - **Spellings:** each district carries the spellings seen in real copy, plus every alias in `@lacspace/nepali-utils`: Kavre/काभ्रे, Rukum East/Rukum Purba/रुकुम पूर्व, Parasi/परासी, Bardaghat Susta West, Kapilbastu, मोरंग/मोरङ…
+  - **Case:** English district names are exact-case, so "dang it" is not Dang. Names over 5 letters also match in ALL CAPS.
+  - **Known edge:** a place that shares a district's name still matches it. For example, Nawalpur in Sarlahi matches the Nawalpur alias of Nawalparasi East.
   - **`ambiguous: true`:** marks Parbat, because पर्वत also means "mountain". Confirm it with `near()` or with district/area context before you tag a story.
 
+## Speed
+
+A ~1,500-character article checked against all 77 districts (258 spellings) takes about 0.16 ms once prepared, and about 0.3 ms from a raw string.
+
 ## Limits
 
 - The matcher is rule-based and does no stemming beyond postpositions. Verb forms and compounds won't match, which is the point.

package/dist/index.cjs

@@ -93,8 +93,9 @@ var ALIASES = {
   Kathmandu: { en: ["Katmandu"], ne: ["\u0915\u093E\u0920\u092E\u093E\u0923\u094D\u0921\u094C", "\u0915\u093E\u0920\u092E\u093E\u0928\u094D\u0921\u0941"] },
   Kavrepalanchok: { en: ["Kavre", "Kabhre", "Kabhrepalanchok", "Kavrepalanchowk"], ne: ["\u0915\u093E\u092D\u094D\u0930\u0947", "\u0915\u093E\u092D\u094D\u0930\u0947\u092A\u0932\u093E\u0928\u094D\u091A\u094B\u0915"] },
   Sindhupalchok: { en: ["Sindhupalchowk"] },
-  "Nawalparasi East": { en: ["Nawalparasi (East)", "East Nawalparasi", "Nawalpur"], ne: ["\u0928\u0935\u0932\u092A\u0930\u093E\u0938\u0940 \u092A\u0942\u0930\u094D\u0935", "\u092A\u0942\u0930\u094D\u0935\u0940 \u0928\u0935\u0932\u092A\u0930\u093E\u0938\u0940", "\u0928\u0935\u0932\u092A\u0941\u0930"] },
-  "Nawalparasi West": { en: ["Nawalparasi (West)", "West Nawalparasi"], ne: ["\u0928\u0935\u0932\u092A\u0930\u093E\u0938\u0940 \u092A\u0936\u094D\u091A\u093F\u092E", "\u092A\u0936\u094D\u091A\u093F\u092E\u0940 \u0928\u0935\u0932\u092A\u0930\u093E\u0938\u0940"] },
+  Solukhumbu: { en: ["Solu Khumbu"], ne: ["\u0938\u094B\u0932\u0941 \u0916\u0941\u092E\u094D\u092C\u0941"] },
+  "Nawalparasi East": { en: ["Nawalparasi (East)", "East Nawalparasi", "Nawalpur", "Bardaghat Susta East"], ne: ["\u0928\u0935\u0932\u092A\u0930\u093E\u0938\u0940 \u092A\u0942\u0930\u094D\u0935", "\u092A\u0942\u0930\u094D\u0935\u0940 \u0928\u0935\u0932\u092A\u0930\u093E\u0938\u0940", "\u0928\u0935\u0932\u092A\u0941\u0930", "\u092C\u0930\u094D\u0926\u0918\u093E\u091F \u0938\u0941\u0938\u094D\u0924\u093E \u092A\u0942\u0930\u094D\u0935"] },
+  "Nawalparasi West": { en: ["Nawalparasi (West)", "West Nawalparasi", "Bardaghat Susta West"], ne: ["\u0928\u0935\u0932\u092A\u0930\u093E\u0938\u0940 \u092A\u0936\u094D\u091A\u093F\u092E", "\u092A\u0936\u094D\u091A\u093F\u092E\u0940 \u0928\u0935\u0932\u092A\u0930\u093E\u0938\u0940", "\u092C\u0930\u094D\u0926\u0918\u093E\u091F \u0938\u0941\u0938\u094D\u0924\u093E \u092A\u0936\u094D\u091A\u093F\u092E"] },
   "Eastern Rukum": { en: ["Rukum East", "East Rukum", "Rukum (East)"], ne: ["\u0930\u0941\u0915\u0941\u092E \u092A\u0942\u0930\u094D\u0935"] },
   "Western Rukum": { en: ["Rukum West", "West Rukum", "Rukum (West)"], ne: ["\u0930\u0941\u0915\u0941\u092E \u092A\u0936\u094D\u091A\u093F\u092E"] },
   Tanahun: { en: ["Tanahu"], ne: ["\u0924\u0928\u0939\u0941"] },
@@ -119,11 +120,13 @@ var slug = (s) => s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g,
 function districtTerms() {
   return DISTRICTS.map((d) => {
     const extra = ALIASES[d.name] ?? {};
-    const ne = /* @__PURE__ */ new Set([d.nameNp, ...extra.ne ?? []]);
+    const own = d.aliases ?? [];
+    const isNe = (x) => /[\u0900-\u097f]/.test(x);
+    const ne = /* @__PURE__ */ new Set([d.nameNp, ...extra.ne ?? [], ...own.filter(isNe)]);
     for (const n of [...ne]) if (n.endsWith("\u0919")) ne.add(n.slice(0, -1) + "\u0902\u0917");
     return {
       id: slug(d.name),
-      en: [d.name, ...extra.en ?? []],
+      en: [.../* @__PURE__ */ new Set([d.name, ...extra.en ?? [], ...own.filter((x) => !isNe(x))])],
       ne: [...ne],
       province: d.province,
       ...AMBIGUOUS.has(d.name) ? { ambiguous: true } : {},
@@ -133,7 +136,7 @@ function districtTerms() {
 }
 
 // src/index.ts
-var VERSION = "1.0.0";
+var VERSION = "1.1.0";
 var NUKTA = 2364;
 var HALANT = 2381;
 var NASALS = /* @__PURE__ */ new Set([2329, 2334, 2339, 2344, 2350]);
@@ -160,6 +163,8 @@ var LOOSE = {
   2339: 2344
   // ण → न
 };
+var isSpace = (c) => c === 32 || c >= 9 && c <= 13 || c === 160 || c === 5760 || c >= 8192 && c <= 8202 || c === 8232 || c === 8233 || c === 8239 || c === 8287 || c === 12288;
+var isHyphen = (c) => c === 45 || c === 8208 || c === 8209;
 var isConsonant = (c) => c >= 2325 && c <= 2361 || c >= 2392 && c <= 2399;
 function mapNormalise(input, opts = {}) {
   const digits = opts.digits !== false;
@@ -179,7 +184,7 @@ function mapNormalise(input, opts = {}) {
   for (let i = 0; i < s.length; i++) {
     let c = s.charCodeAt(i);
     if (DROP.has(c)) continue;
-    if (/\s/.test(s[i])) {
+    if (isSpace(c) || opts.hyphenAsSpace && isHyphen(c)) {
       if (!lastSpace) push(" ", i);
       lastSpace = true;
       continue;
@@ -253,7 +258,12 @@ var POSTPOSITIONS = [
   "\u0935\u093E\u0938\u0940",
   "\u092C\u093E\u0938\u0940",
   "\u0938\u094D\u0925\u093F\u0924",
-  "\u0928\u093F\u0935\u093E\u0938\u0940"
+  "\u0928\u093F\u0935\u093E\u0938\u0940",
+  "\u092E\u093E\u0930\u094D\u092B\u0924",
+  "\u092C\u093E\u0930\u0947",
+  "\u0905\u0928\u094D\u0924\u0930\u094D\u0917\u0924",
+  "\u092E\u093E\u0924\u094D\u0930",
+  "\u091C\u0938\u094D\u0924\u093E"
 ];
 var isNeLetter = (c) => c >= 2304 && c <= 2403 || c >= 2417 && c <= 2431;
 var isWordChar = (ch) => !!ch && /[\p{L}\p{M}\p{N}]/u.test(ch);
@@ -263,9 +273,18 @@ function autoCase(term) {
   const letters = term.replace(/[^\p{L}]/gu, "");
   return letters.length >= 2 && letters.length <= 5 && letters === letters.toUpperCase() && letters !== letters.toLowerCase();
 }
+var optsKey = (o) => `${o.loose ? 1 : 0}${o.digits === false ? 0 : 1}${o.hyphenAsSpace ? 1 : 0}`;
+function prepare(text, opts = {}) {
+  const nfc = text.normalize("NFC");
+  const { text: n, map } = mapNormalise(nfc, opts);
+  return { kind: "prepared", original: nfc, text: n, map, key: optsKey(opts) };
+}
+var isPrepared = (x) => typeof x === "object" && x !== null && x.kind === "prepared";
 function createMatcher(terms, opts = {}) {
-  const nopts = { loose: opts.loose, digits: opts.digits };
-  const suffixes = opts.postpositions === false ? [] : [...new Set([...POSTPOSITIONS, ...opts.extraSuffixes ?? []].map((s) => normaliseNe(s, nopts)))].sort((a, b) => b.length - a.length);
+  const nopts = { loose: opts.loose, digits: opts.digits, hyphenAsSpace: opts.hyphenAsSpace };
+  const key = optsKey(nopts);
+  const allCaps = opts.allCaps !== false;
+  const suffixes = [...new Set([...opts.postpositions === false ? [] : POSTPOSITIONS, ...opts.extraSuffixes ?? []].map((s) => normaliseNe(s, nopts)))].filter(Boolean).sort((a, b) => b.length - a.length);
   const variants = [];
   for (const t of terms) {
     const obj = typeof t === "string" ? { id: t, aliases: [t] } : t;
@@ -274,12 +293,26 @@ function createMatcher(terms, opts = {}) {
     const id = obj.id ?? spellings[0] ?? "";
     for (const sp of new Set(spellings)) {
       if (hasDevanagari(sp)) {
-        variants.push({ id, term: sp, lang: "ne", key: normaliseNe(sp, nopts) });
+        const k = normaliseNe(sp, nopts);
+        variants.push({ id, term: sp, lang: "ne", key: k });
+        if (opts.joinNepali && k.includes(" ")) {
+          const parts = k.split(" ");
+          const gaps = Math.min(parts.length - 1, 4);
+          for (let mask = 1; mask < 1 << gaps; mask++) {
+            let joined = parts[0];
+            for (let g = 1; g < parts.length; g++) joined += (g <= gaps && mask & 1 << g - 1 ? "" : " ") + parts[g];
+            variants.push({ id, term: sp, lang: "ne", key: joined });
+          }
+        }
       } else {
         const rule = obj.caseSensitive ?? opts.caseSensitive ?? "auto";
         const exact = rule === "auto" ? autoCase(sp) : rule;
-        const body = sp.split(/\s+/).map(escapeRe).join("\\s+");
-        variants.push({ id, term: sp, lang: "en", key: sp, re: new RegExp(body, exact ? "gu" : "giu") });
+        const words = normaliseNe(sp, nopts).split(" ").filter(Boolean);
+        const body = words.map(escapeRe).join(" ");
+        const letters = sp.replace(/[^\p{L}]/gu, "");
+        const shout = exact && allCaps && letters.length > 5 && sp !== sp.toUpperCase();
+        const alt = shout ? `|${words.map((w) => escapeRe(w.toUpperCase())).join(" ")}` : "";
+        variants.push({ id, term: sp, lang: "en", key: sp, re: new RegExp(`(?:${body}${alt})`, exact ? "gu" : "giu") });
       }
     }
   }
@@ -294,10 +327,11 @@ function createMatcher(terms, opts = {}) {
     }
     return -1;
   };
-  const find = (text) => {
-    const { text: n, map } = mapNormalise(text, nopts);
-    const toOrig = (i) => i >= map.length ? text.normalize("NFC").length : map[i];
-    const nfc = text.normalize("NFC");
+  const prep = (text) => prepare(text, nopts);
+  const find = (input) => {
+    const p = isPrepared(input) ? input.key === key ? input : prep(input.original) : prep(input);
+    const { text: n, map, original: nfc } = p;
+    const toOrig = (i) => i >= map.length ? nfc.length : map[i];
     const found = [];
     for (const v of variants) {
       if (v.lang === "ne") {
@@ -345,9 +379,11 @@ function createMatcher(terms, opts = {}) {
     find,
     test: (text, id) => find(text).some((m) => id === void 0 || m.id === id),
     ids: (text) => [...new Set(find(text).map((m) => m.id))],
+    prepare: prep,
     get size() {
       return variants.length;
-    }
+    },
+    kind: "matcher"
   };
 }
 function findTerms(text, terms, opts) {
@@ -370,6 +406,8 @@ function splitSuffix(word) {
   }
   return { stem: nfc.slice(0, end >= n.length ? nfc.length : map[end]), suffixes: out };
 }
+var isMatcher = (x) => typeof x === "object" && x !== null && x.kind === "matcher";
+var isMatchList = (x) => Array.isArray(x) && (x.length === 0 || typeof x[0] === "object" && x[0] !== null && typeof x[0].index === "number" && typeof x[0].end === "number");
 var dottedAbbr = (s, i) => {
   let j = i - 1;
   while (j >= 0 && !/\s/.test(s[j])) j--;
@@ -395,10 +433,16 @@ function near(text, a, b, maxCharsOrOpts = {}, sameSentence) {
   if (sameSentence !== void 0) opts.sameSentence = sameSentence;
   const max = opts.maxChars ?? 60;
   const same = opts.sameSentence !== false;
-  const am = findTerms(text, a, opts);
-  const bm = findTerms(text, b, opts);
-  if (!am.length || !bm.length) return null;
-  const spans = same ? sentenceSpans(text) : [];
+  const resolve = (src) => {
+    if (isMatcher(src)) return src.find(text);
+    if (isMatchList(src)) return src;
+    return findTerms(text, src, opts);
+  };
+  const am = resolve(a);
+  if (!am.length) return null;
+  const bm = resolve(b);
+  if (!bm.length) return null;
+  const spans = same ? sentenceSpans(isPrepared(text) ? text.original : text) : [];
   const sentenceOf = (i) => spans.findIndex(([s, e]) => i >= s && i < e);
   let best = null;
   for (const x of am) {
@@ -422,6 +466,7 @@ exports.findTerms = findTerms;
 exports.near = near;
 exports.normaliseNe = normaliseNe;
 exports.normalizeNe = normalizeNe;
+exports.prepare = prepare;
 exports.sentenceSpans = sentenceSpans;
 exports.splitSuffix = splitSuffix;
 //# sourceMappingURL=index.cjs.map