Fix han+kvip and vocative mat/hat

vidyut-prakriya/src/angasya.rs

@@ -1054,7 +1054,12 @@ pub fn run_before_dvitva(p: &mut Prakriya, is_lun: bool, skip_at_agama: bool) ->
         } else if n.first().is_san() && anga.has_u("tanu~^") {
             p.optional_run_at("6.4.17", i_anga, |t| t.set_upadha("A"));
         } else if anga.has_antya(ANUNASIKA) && (n.first().is(K::kvip) || jhal_knit()) {
-            if (anga.has_text("kzam") && n.last().has_lakara(Lit) && n.last().is_atmanepada())
+            if anga.has_text("han") {
+                // Varttika: block 6.4.15 dirgha for `han` (e.g. AN + han + kvip -> Ahan).
+                p.step(Varttika("6.4.15.1"));
+            } else if (anga.has_text("kzam")
+                && n.last().has_lakara(Lit)
+                && n.last().is_atmanepada())
                 || (anga.has_u("Dana~") && n.last().is_tin())
             {
                 // TODO: log samjna-purvaka-vidhir anityaH

vidyut-prakriya/src/angasya/subanta.rs

@@ -558,6 +558,8 @@ fn try_anga_adesha_after_vibhakti_changes(p: &mut Prakriya) -> Option<()> {
     }
 
     if anga.has_text_in(&["yuzmad", "asmad"]) {
+        let is_asmad = anga.has_text("asmad");
+        let is_yuzmad = anga.has_text("yuzmad");
         let anadesha = !sup.last().has_tag(T::Adesha);
 
         if sup.has_adi(AC) && anadesha {
@@ -612,6 +614,68 @@ fn try_anga_adesha_after_vibhakti_changes(p: &mut Prakriya) -> Option<()> {
                 t.find_and_replace_text("asm", "ma");
             });
         }
+
+        // Enclitic variants for dative/genitive pronouns.
+        let (i_sup_start, i_sup_end, is_v4, is_v6, is_ekavacana, is_dvivacana, is_bahuvacana) = {
+            let sup_view = p.pratyaya(i_sup)?;
+            let sup = sup_view.last();
+            (
+                sup_view.start(),
+                sup_view.end(),
+                sup.has_tag(T::V4),
+                sup.has_tag(T::V6),
+                sup.has_tag(T::Ekavacana),
+                sup.has_tag(T::Dvivacana),
+                sup.has_tag(T::Bahuvacana),
+            )
+        };
+        let is_dative_or_genitive = is_v4 || is_v6;
+
+        let set_sup_text = |p: &mut Prakriya, text: &str| {
+            if text.is_empty() {
+                p.set(i_sup_start, op::luk);
+            } else {
+                p.set(i_sup_start, |t| t.set_text(text));
+            }
+            for j in (i_sup_start + 1)..=i_sup_end {
+                p.set(j, op::luk);
+            }
+        };
+
+        if is_dative_or_genitive {
+            if is_ekavacana {
+                p.optional_run(Varttika("7.2.95.1"), |p| {
+                    if is_asmad {
+                        p.set(i, op::text("me"));
+                    } else if is_yuzmad {
+                        p.set(i, op::text("te"));
+                    }
+                    if is_v6 {
+                        set_sup_text(p, "s");
+                    } else {
+                        set_sup_text(p, "");
+                    }
+                });
+            } else if is_dvivacana {
+                p.optional_run(Varttika("7.2.95.2"), |p| {
+                    if is_asmad {
+                        p.set(i, op::text("nO"));
+                    } else if is_yuzmad {
+                        p.set(i, op::text("vAm"));
+                    }
+                    set_sup_text(p, "");
+                });
+            } else if is_bahuvacana {
+                p.optional_run(Varttika("7.2.95.3"), |p| {
+                    if is_asmad {
+                        p.set(i, op::text("naH"));
+                    } else if is_yuzmad {
+                        p.set(i, op::text("vaH"));
+                    }
+                    set_sup_text(p, "");
+                });
+            }
+        }
     } else if anga.has_u("idam") && anga.has_antya('a') {
         if sup.last().has_tag_in(&[T::V1, T::V2]) {
             // imam

vidyut-prakriya/src/tripadi/pada_8_2.rs

@@ -315,6 +315,21 @@ fn try_lopa_of_samyoganta_and_s(p: &mut Prakriya) {
     iter_terms(p, |p, i| {
         if p.is_pada(i) && p.has(i, |t| !t.is_empty()) {
             loop {
+                let text = p.view(0, i)?.text().to_string();
+                let ends_with_mat = text.ends_with("mat");
+                let ends_with_hat = text.ends_with("hat");
+                if p.has_tag(PT::Sambodhana) && p.has_tag(PT::Ekavacana) {
+                    if ends_with_mat || ends_with_hat {
+                        // mAmat -> mAman, mAmahat -> mAmahan (vocative singular)
+                        p.run_at("8.2.23", i, |t| {
+                            if t.has_text("at") {
+                                t.set_text("an");
+                            } else if ends_with_mat {
+                                t.find_and_replace_text("mat", "man");
+                            }
+                        });
+                    }
+                }
                 let view = p.view(0, i)?;
                 if view
                     .last()

vidyut-prakriya/src/wasm.rs

@@ -152,7 +152,15 @@ struct KrdantaArgs {
 #[derive(Serialize, Deserialize)]
 struct PratipadikaArgs {
     basic: Option<String>,
+    nyap: Option<String>,
     krdanta: Option<KrdantaArgs>,
+    taddhitanta: Option<TaddhitantaArgsInner>,
+}
+
+#[derive(Serialize, Deserialize)]
+struct TaddhitantaArgsInner {
+    stem: String,
+    taddhita: Taddhita,
 }
 
 #[derive(Serialize, Deserialize)]
@@ -173,6 +181,12 @@ struct TinantaArgs {
     pada: Option<DhatuPada>,
 }
 
+#[derive(Serialize, Deserialize)]
+struct TaddhitantaArgs {
+    pratipadika: PratipadikaArgs,
+    taddhita: Taddhita,
+}
+
 /// Shorthand for result type
 pub type Result<T> = std::result::Result<T, Error>;
 
@@ -212,12 +226,31 @@ impl SubantaArgs {
         let pratipadika = match self.pratipadika {
             PratipadikaArgs {
                 basic: Some(basic),
+                nyap: None,
                 krdanta: None,
+                taddhitanta: None,
             } => Pratipadika::basic(Slp1String::from(basic).expect("ok")),
             PratipadikaArgs {
                 basic: None,
+                nyap: Some(nyap),
+                krdanta: None,
+                taddhitanta: None,
+            } => Pratipadika::nyap(Slp1String::from(nyap).expect("ok")),
+            PratipadikaArgs {
+                basic: None,
+                nyap: None,
                 krdanta: Some(krt),
+                taddhitanta: None,
             } => Pratipadika::Krdanta(Box::new(krt.into_rust()?)),
+            PratipadikaArgs {
+                basic: None,
+                nyap: None,
+                krdanta: None,
+                taddhitanta: Some(tad),
+            } => {
+                let base = Pratipadika::basic(Slp1String::from(tad.stem).expect("ok"));
+                Pratipadika::Taddhitanta(Box::new(Taddhitanta::new(base, tad.taddhita)))
+            }
             // TODO: improve error handling, remove placeholder
             _ => Pratipadika::basic(Slp1String::from("doza").expect("ok")),
         };
@@ -245,6 +278,33 @@ impl TinantaArgs {
     }
 }
 
+impl TaddhitantaArgs {
+    fn into_rust(self) -> Result<Taddhitanta> {
+        let pratipadika = match self.pratipadika {
+            PratipadikaArgs {
+                basic: Some(basic),
+                nyap: None,
+                krdanta: None,
+                taddhitanta: None,
+            } => Pratipadika::basic(Slp1String::from(basic).expect("ok")),
+            PratipadikaArgs {
+                basic: None,
+                nyap: Some(nyap),
+                krdanta: None,
+                taddhitanta: None,
+            } => Pratipadika::nyap(Slp1String::from(nyap).expect("ok")),
+            PratipadikaArgs {
+                basic: None,
+                nyap: None,
+                krdanta: Some(krt),
+                taddhitanta: None,
+            } => Pratipadika::Krdanta(Box::new(krt.into_rust()?)),
+            _ => Pratipadika::basic(Slp1String::from("doza").expect("ok")),
+        };
+        Ok(Taddhitanta::new(pratipadika, self.taddhita))
+    }
+}
+
 /// WebAssembly API for vidyut-prakriya.
 ///
 /// Within reason, we have tried to mimic a native JavaScript API. At some point, we wish to
@@ -343,4 +403,23 @@ impl Vidyut {
             }
         }
     }
+
+    /// Wrapper for `Vyakarana::derive_taddhitantas`.
+    #[allow(non_snake_case)]
+    pub fn deriveTaddhitantas(&self, val: JsValue) -> JsValue {
+        let v = Vyakarana::new();
+        let js_args: TaddhitantaArgs = serde_wasm_bindgen::from_value(val).unwrap();
+
+        match js_args.into_rust() {
+            Ok(args) => {
+                let prakriyas = v.derive_taddhitantas(&args);
+                let web_prakriyas = to_web_prakriyas(&prakriyas);
+                serde_wasm_bindgen::to_value(&web_prakriyas).expect("wasm")
+            }
+            Err(_) => {
+                error(&format!("[vidyut] Derivation error"));
+                serde_wasm_bindgen::to_value(&Vec::<WebPrakriya>::new()).expect("wasm")
+            }
+        }
+    }
 }

vidyut-prakriya/tests/integration/kashika_6_1.rs

@@ -1291,15 +1291,15 @@ fn sutra_6_1_199() {
 #[test]
 fn sutra_6_1_211() {
     let s = get_tester();
-    s.assert_has_sup_6s("yuzmad", Pum, &["ta/va"]);
-    s.assert_has_sup_6s("asmad", Pum, &["ma/ma"]);
+    s.assert_has_sup_6s("yuzmad", Pum, &["ta/va", "te/"]);
+    s.assert_has_sup_6s("asmad", Pum, &["ma/ma", "me/"]);
 }
 
 #[test]
 fn sutra_6_1_212() {
     let s = get_tester();
-    s.assert_has_sup_4s("yuzmad", Pum, &["tu/Byam"]);
-    s.assert_has_sup_4s("asmad", Pum, &["ma/hyam"]);
+    s.assert_has_sup_4s("yuzmad", Pum, &["tu/Byam", "te/"]);
+    s.assert_has_sup_4s("asmad", Pum, &["ma/hyam", "me/"]);
 }
 
 #[test]

vidyut-prakriya/tests/integration/kashika_7_1.rs

@@ -296,14 +296,14 @@ fn sutra_7_1_25() {
 
 #[test]
 fn sutra_7_1_27() {
-    assert_has_sup_6s("asmad", Pum, &["mama"]);
-    assert_has_sup_6s("yuzmad", Pum, &["tava"]);
+    assert_has_sup_6s("asmad", Pum, &["mama", "me"]);
+    assert_has_sup_6s("yuzmad", Pum, &["tava", "te"]);
 }
 
 #[test]
 fn sutra_7_1_28() {
-    assert_has_sup_4s("asmad", Pum, &["mahyam"]);
-    assert_has_sup_4s("yuzmad", Pum, &["tuByam"]);
+    assert_has_sup_4s("asmad", Pum, &["mahyam", "me"]);
+    assert_has_sup_4s("yuzmad", Pum, &["tuByam", "te"]);
 
     assert_has_sup_1s("yuzmad", Pum, &["tvam"]);
     assert_has_sup_1s("asmad", Pum, &["aham"]);
@@ -325,8 +325,8 @@ fn sutra_7_1_29() {
 
 #[test]
 fn sutra_7_1_30() {
-    assert_has_sup_4p("asmad", Pum, &["asmaByam"]);
-    assert_has_sup_4p("yuzmad", Pum, &["yuzmaByam"]);
+    assert_has_sup_4p("asmad", Pum, &["asmaByam", "naH"]);
+    assert_has_sup_4p("yuzmad", Pum, &["yuzmaByam", "vaH"]);
 }
 
 #[test]
@@ -343,8 +343,27 @@ fn sutra_7_1_32() {
 
 #[test]
 fn sutra_7_1_33() {
-    assert_has_sup_6p("asmad", Pum, &["asmAkam"]);
-    assert_has_sup_6p("yuzmad", Pum, &["yuzmAkam"]);
+    assert_has_sup_6p("asmad", Pum, &["asmAkam", "naH"]);
+    assert_has_sup_6p("yuzmad", Pum, &["yuzmAkam", "vaH"]);
+}
+
+#[test]
+fn pronoun_enclitics() {
+    // Enclitic variants for asmad/yuzmad in dative+genitive slots.
+    assert_has_sup_4s("asmad", Pum, &["mahyam", "me"]);
+    assert_has_sup_4s("yuzmad", Pum, &["tuByam", "te"]);
+    assert_has_sup_6s("asmad", Pum, &["mama", "me"]);
+    assert_has_sup_6s("yuzmad", Pum, &["tava", "te"]);
+
+    assert_has_sup_4d("asmad", Pum, &["AvAByAm", "nO"]);
+    assert_has_sup_4d("yuzmad", Pum, &["yuvAByAm", "vAm"]);
+    assert_has_sup_6d("asmad", Pum, &["AvayoH", "nO"]);
+    assert_has_sup_6d("yuzmad", Pum, &["yuvayoH", "vAm"]);
+
+    assert_has_sup_4p("asmad", Pum, &["asmaByam", "naH"]);
+    assert_has_sup_4p("yuzmad", Pum, &["yuzmaByam", "vaH"]);
+    assert_has_sup_6p("asmad", Pum, &["asmAkam", "naH"]);
+    assert_has_sup_6p("yuzmad", Pum, &["yuzmAkam", "vaH"]);
 }
 
 #[test]

vidyut-prakriya/tests/integration/kashika_7_2.rs

@@ -1484,8 +1484,8 @@ fn sutra_7_2_88() {
     assert_has_sup_1d("yuzmad", Pum, &["yuvAm"]);
     assert_has_sup_1d("asmad", Pum, &["AvAm"]);
 
-    assert_has_sup_6d("yuzmad", Pum, &["yuvayoH"]);
-    assert_has_sup_6d("asmad", Pum, &["AvayoH"]);
+    assert_has_sup_6d("yuzmad", Pum, &["yuvayoH", "vAm"]);
+    assert_has_sup_6d("asmad", Pum, &["AvayoH", "nO"]);
     assert_has_sup_1s("yuzmad", Pum, &["tvam"]);
     assert_has_sup_1s("asmad", Pum, &["aham"]);
     assert_has_sup_1p("yuzmad", Pum, &["yUyam"]);
@@ -1514,18 +1514,18 @@ fn sutra_7_2_90() {
     assert_has_sup_1s("asmad", Pum, &["aham"]);
     assert_has_sup_1p("yuzmad", Pum, &["yUyam"]);
     assert_has_sup_1p("asmad", Pum, &["vayam"]);
-    assert_has_sup_4s("yuzmad", Pum, &["tuByam"]);
-    assert_has_sup_4s("asmad", Pum, &["mahyam"]);
-    assert_has_sup_4p("yuzmad", Pum, &["yuzmaByam"]);
-    assert_has_sup_4p("asmad", Pum, &["asmaByam"]);
+    assert_has_sup_4s("yuzmad", Pum, &["tuByam", "te"]);
+    assert_has_sup_4s("asmad", Pum, &["mahyam", "me"]);
+    assert_has_sup_4p("yuzmad", Pum, &["yuzmaByam", "vaH"]);
+    assert_has_sup_4p("asmad", Pum, &["asmaByam", "naH"]);
     assert_has_sup_5s("yuzmad", Pum, &["tvat"]);
     assert_has_sup_5s("asmad", Pum, &["mat"]);
     assert_has_sup_5p("yuzmad", Pum, &["yuzmat"]);
     assert_has_sup_5p("asmad", Pum, &["asmat"]);
-    assert_has_sup_6s("yuzmad", Pum, &["tava"]);
-    assert_has_sup_6s("asmad", Pum, &["mama"]);
-    assert_has_sup_6p("yuzmad", Pum, &["yuzmAkam"]);
-    assert_has_sup_6p("asmad", Pum, &["asmAkam"]);
+    assert_has_sup_6s("yuzmad", Pum, &["tava", "te"]);
+    assert_has_sup_6s("asmad", Pum, &["mama", "me"]);
+    assert_has_sup_6p("yuzmad", Pum, &["yuzmAkam", "vaH"]);
+    assert_has_sup_6p("asmad", Pum, &["asmAkam", "naH"]);
 }
 
 #[test]
@@ -1534,8 +1534,8 @@ fn sutra_7_2_92() {
     assert_has_sup_1d("asmad", Pum, &["AvAm"]);
     assert_has_sup_3d("yuzmad", Pum, &["yuvAByAm"]);
     assert_has_sup_3d("asmad", Pum, &["AvAByAm"]);
-    assert_has_sup_6d("yuzmad", Pum, &["yuvayoH"]);
-    assert_has_sup_6d("asmad", Pum, &["AvayoH"]);
+    assert_has_sup_6d("yuzmad", Pum, &["yuvayoH", "vAm"]);
+    assert_has_sup_6d("asmad", Pum, &["AvayoH", "nO"]);
     // TODO: others
 }
 
@@ -1555,15 +1555,15 @@ fn sutra_7_2_94() {
 
 #[test]
 fn sutra_7_2_95() {
-    assert_has_sup_4s("yuzmad", Pum, &["tuByam"]);
-    assert_has_sup_4s("asmad", Pum, &["mahyam"]);
+    assert_has_sup_4s("yuzmad", Pum, &["tuByam", "te"]);
+    assert_has_sup_4s("asmad", Pum, &["mahyam", "me"]);
     // TODO: others
 }
 
 #[test]
 fn sutra_7_2_96() {
-    assert_has_sup_6s("yuzmad", Pum, &["tava"]);
-    assert_has_sup_6s("asmad", Pum, &["mama"]);
+    assert_has_sup_6s("yuzmad", Pum, &["tava", "te"]);
+    assert_has_sup_6s("asmad", Pum, &["mama", "me"]);
     // TODO: others
 }