feat: add video duration parser

codegen/src/collect_video_durations.rs

@@ -1,4 +1,8 @@
-use std::{collections::BTreeMap, fs::File};
+use std::{
+    collections::{BTreeMap, HashMap},
+    fs::File,
+    io::BufReader,
+};
 
 use anyhow::Result;
 use futures::{stream, StreamExt};
@@ -9,7 +13,7 @@ use rustypipe::{
 };
 
 use crate::{
-    model::{Channel, QBrowse},
+    model::{Channel, QBrowse, TimeAgo, TimeUnit},
     util::{self, DICT_DIR},
 };
 
@@ -57,6 +61,205 @@ pub async fn collect_video_durations(concurrency: usize) {
     serde_json::to_writer_pretty(file, &durations).unwrap();
 }
 
+pub fn parse_video_durations() {
+    let json_path = path!(*DICT_DIR / "video_duration_samples.json");
+    let json_file = File::open(json_path).unwrap();
+    let durations: CollectedDurations = serde_json::from_reader(BufReader::new(json_file)).unwrap();
+
+    let mut dict = util::read_dict();
+    let langs = dict.keys().map(|k| k.to_owned()).collect::<Vec<_>>();
+
+    for lang in langs {
+        let dict_entry = dict.entry(lang).or_default();
+
+        let mut e_langs = dict_entry.equivalent.clone();
+        e_langs.push(lang);
+
+        for lang in e_langs {
+            let mut words = HashMap::new();
+
+            fn check_add_word(
+                words: &mut HashMap<String, Option<TimeAgo>>,
+                by_char: bool,
+                val: u32,
+                expect: u32,
+                w: String,
+                unit: TimeUnit,
+            ) -> bool {
+                let ok = val == expect || val * 2 == expect;
+                if ok {
+                    let mut ins = |w: &str, val: &mut TimeAgo| {
+                        // Filter stop words
+                        if matches!(
+                            w,
+                            "na" | "y"
+                                | "و"
+                                | "ja"
+                                | "et"
+                                | "e"
+                                | "i"
+                                | "և"
+                                | "og"
+                                | "en"
+                                | "и"
+                                | "a"
+                                | "és"
+                                | "ir"
+                                | "un"
+                                | "și"
+                                | "in"
+                                | "และ"
+                                | "\u{0456}"
+                                | "鐘"
+                                | "eta"
+                                | "અને"
+                                | "और"
+                                | "കൂടാതെ"
+                                | "සහ"
+                        ) {
+                            return;
+                        }
+
+                        let entry = words.entry(w.to_owned()).or_insert(Some(*val));
+                        if let Some(e) = entry {
+                            if e != val {
+                                *entry = None;
+                            }
+                        }
+                    };
+
+                    let mut val = TimeAgo {
+                        n: (expect / val).try_into().unwrap(),
+                        unit,
+                    };
+
+                    if by_char {
+                        w.chars().for_each(|c| {
+                            if !c.is_whitespace() {
+                                ins(&c.to_string(), &mut val);
+                            }
+                        });
+                    } else {
+                        w.split_whitespace().for_each(|w| ins(w, &mut val));
+                    }
+                }
+                ok
+            }
+
+            fn parse(
+                words: &mut HashMap<String, Option<TimeAgo>>,
+                lang: Language,
+                by_char: bool,
+                txt: &str,
+                d: u32,
+            ) {
+                let (m, s) = split_duration(d);
+
+                let mut parts =
+                    split_duration_txt(txt, matches!(lang, Language::Si | Language::Sw))
+                        .into_iter();
+
+                let p1 = parts.next().unwrap();
+                let p1_n = p1.digits.parse::<u32>().unwrap_or(1);
+                let p2: Option<DurationTxtSegment> = parts.next();
+
+                match p2 {
+                    Some(p2) => {
+                        let p2_n = p2.digits.parse::<u32>().unwrap_or(1);
+
+                        assert!(
+                            check_add_word(words, by_char, p1_n, m, p1.word, TimeUnit::Minute),
+                            "{txt}: min parse error"
+                        );
+                        assert!(
+                            check_add_word(words, by_char, p2_n, s, p2.word, TimeUnit::Second),
+                            "{txt}: sec parse error"
+                        );
+                    }
+                    None => {
+                        if s == 0 {
+                            assert!(
+                                check_add_word(words, by_char, p1_n, m, p1.word, TimeUnit::Minute),
+                                "{txt}: min parse error"
+                            );
+                        } else if m == 0 {
+                            assert!(
+                                check_add_word(words, by_char, p1_n, s, p1.word, TimeUnit::Second),
+                                "{txt}: sec parse error"
+                            );
+                        } else {
+                            let p = txt
+                                .find([',', 'و'])
+                                .unwrap_or_else(|| panic!("`{txt}`: only 1 part"));
+                            parse(words, lang, by_char, &txt[0..p], m);
+                            parse(words, lang, by_char, &txt[p..], s);
+                        }
+                    }
+                }
+
+                assert!(parts.next().is_none(), "`{txt}`: more than 2 parts");
+            }
+
+            for (txt, d) in &durations[&lang] {
+                parse(&mut words, lang, dict_entry.by_char, txt, *d);
+            }
+
+            // dbg!(&words);
+
+            words.into_iter().for_each(|(k, v)| {
+                if let Some(v) = v {
+                    dict_entry.timeago_tokens.insert(k, v.to_string());
+                }
+            });
+        }
+    }
+
+    util::write_dict(dict);
+}
+
+fn split_duration(d: u32) -> (u32, u32) {
+    (d / 60, d % 60)
+}
+
+#[derive(Debug, Default)]
+struct DurationTxtSegment {
+    digits: String,
+    word: String,
+}
+
+fn split_duration_txt(txt: &str, start_c: bool) -> Vec<DurationTxtSegment> {
+    let mut segments = Vec::new();
+
+    // 1: parse digits, 2: parse word
+    let mut state: u8 = 0;
+    let mut seg = DurationTxtSegment::default();
+
+    for c in txt.chars() {
+        if c.is_ascii_digit() {
+            if state == 2 && (!seg.digits.is_empty() || (!start_c && segments.is_empty())) {
+                segments.push(seg);
+                seg = DurationTxtSegment::default();
+            }
+            seg.digits.push(c);
+            state = 1;
+        } else {
+            if (state == 1) && (!seg.word.is_empty() || (start_c && segments.is_empty())) {
+                segments.push(seg);
+                seg = DurationTxtSegment::default();
+            }
+            if c != ',' {
+                c.to_lowercase().for_each(|c| seg.word.push(c));
+            }
+            state = 2;
+        }
+    }
+    if !seg.word.is_empty() || !seg.digits.is_empty() {
+        segments.push(seg);
+    }
+
+    segments
+}
+
 async fn get_channel_vlengths(
     query: &RustyPipeQuery,
     channel_id: &str,
@@ -129,10 +332,6 @@ mod tests {
     use intl_pluralrules::{PluralRuleType, PluralRules};
     use unic_langid::LanguageIdentifier;
 
-    fn split_duration(d: u32) -> (u32, u32) {
-        (d / 60, d % 60)
-    }
-
     /// Verify that the duration sample set covers all pluralization variants of the languages
     #[test]
     fn check_video_duration_samples() {
@@ -173,4 +372,11 @@ mod tests {
 
         assert!(!failed);
     }
+
+    #[test]
+    fn t_split_duration_text() {
+        // video duration:
+        let res = split_duration_txt("دقيقة وثانيتان", true);
+        dbg!(&res);
+    }
 }

codegen/src/main.rs

@@ -28,6 +28,7 @@ enum Commands {
     ParsePlaylistDates,
     ParseLargeNumbers,
     ParseAlbumTypes,
+    ParseVideoDurations,
     GenLocales,
     GenDict,
     DownloadTestfiles,
@@ -60,6 +61,7 @@ async fn main() {
         Commands::ParsePlaylistDates => collect_playlist_dates::write_samples_to_dict(),
         Commands::ParseLargeNumbers => collect_large_numbers::write_samples_to_dict(),
         Commands::ParseAlbumTypes => collect_album_types::write_samples_to_dict(),
+        Commands::ParseVideoDurations => collect_video_durations::parse_video_durations(),
         Commands::GenLocales => {
             gen_locales::generate_locales().await;
         }

codegen/src/model.rs

@@ -51,6 +51,27 @@ pub struct DictEntry {
     pub album_types: BTreeMap<String, AlbumType>,
 }
 
+/// Parsed TimeAgo string, contains amount and time unit.
+///
+/// Example: "14 hours ago" => `TimeAgo {n: 14, unit: TimeUnit::Hour}`
+#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct TimeAgo {
+    /// Number of time units
+    pub n: u8,
+    /// Time unit
+    pub unit: TimeUnit,
+}
+
+impl ToString for TimeAgo {
+    fn to_string(&self) -> String {
+        if self.n > 1 {
+            format!("{}{}", self.n, self.unit.as_str())
+        } else {
+            self.unit.as_str().to_owned()
+        }
+    }
+}
+
 /// Parsed time unit
 #[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
 #[serde(rename_all = "lowercase")]
@@ -64,6 +85,20 @@ pub enum TimeUnit {
     Year,
 }
 
+impl TimeUnit {
+    pub fn as_str(&self) -> &str {
+        match self {
+            TimeUnit::Second => "s",
+            TimeUnit::Minute => "m",
+            TimeUnit::Hour => "h",
+            TimeUnit::Day => "D",
+            TimeUnit::Week => "W",
+            TimeUnit::Month => "M",
+            TimeUnit::Year => "Y",
+        }
+    }
+}
+
 #[derive(Debug, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct QBrowse<'a> {

src/client/response/video_item.rs

@@ -4,7 +4,7 @@ use serde::Deserialize;
 use serde_with::{
     json::JsonString, rust::deserialize_ignore_any, serde_as, DefaultOnError, VecSkipError,
 };
-use time::{Duration, OffsetDateTime};
+use time::OffsetDateTime;
 
 use super::{url_endpoint::NavigationEndpoint, ChannelBadge, ContinuationEndpoint, Thumbnails};
 use crate::{
@@ -501,8 +501,11 @@ impl<T> YouTubeListMapper<T> {
             length: video.accessibility.and_then(|acc| {
                 ACCESSIBILITY_SEP_REGEX.captures(&acc).and_then(|cap| {
                     cap.get(1).and_then(|c| {
-                        timeago::parse_timeago_or_warn(self.lang, c.as_str(), &mut self.warnings)
+                        timeago::parse_video_duration_or_warn(
-                            .map(|ta| Duration::from(ta).whole_seconds() as u32)
+                            self.lang,
+                            c.as_str(),
+                            &mut self.warnings,
+                        )
                     })
                 })
             }),

src/util/dictionary.rs

@@ -144,27 +144,30 @@ pub(crate) fn entry(lang: Language) -> Entry {
         },
         Language::Am => Entry {
             timeago_tokens: ::phf::Map {
-                key: 15467950696543387533,
+                key: 10121458955350035957,
                 disps: &[
-                    (0, 9),
+                    (2, 0),
-                    (7, 0),
+                    (0, 0),
-                    (5, 3),
+                    (6, 2),
+                    (0, 11),
                 ],
                 entries: &[
-                    ("ደቂቃ", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
                     ("ሳምንታት", TaToken { n: 1, unit: Some(TimeUnit::Week) }),
+                    ("ዓመታት", TaToken { n: 1, unit: Some(TimeUnit::Year) }),
+                    ("ዓመት", TaToken { n: 1, unit: Some(TimeUnit::Year) }),
+                    ("ወር", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
+                    ("ሰዓቶች", TaToken { n: 1, unit: Some(TimeUnit::Hour) }),
+                    ("ደቂቃዎች፣", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
+                    ("ሳምንት", TaToken { n: 1, unit: Some(TimeUnit::Week) }),
+                    ("ሰከንዶች", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
+                    ("ቀናት", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
+                    ("ደቂቃ", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
+                    ("ደቂቃዎች", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
+                    ("ደቂቃ፣", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
                     ("ሰዓት", TaToken { n: 1, unit: Some(TimeUnit::Hour) }),
                     ("ቀን", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
-                    ("ወራት", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
-                    ("ሰዓቶች", TaToken { n: 1, unit: Some(TimeUnit::Hour) }),
-                    ("ወር", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
-                    ("ሰከንዶች", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
-                    ("ዓመት", TaToken { n: 1, unit: Some(TimeUnit::Year) }),
                     ("ሰከንድ", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
-                    ("ቀናት", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
+                    ("ወራት", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
-                    ("ደቂቃዎች", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
-                    ("ዓመታት", TaToken { n: 1, unit: Some(TimeUnit::Year) }),
-                    ("ሳምንት", TaToken { n: 1, unit: Some(TimeUnit::Week) }),
                 ],
             },
             date_order: &[DateCmp::D, DateCmp::Y],
@@ -237,39 +240,44 @@ pub(crate) fn entry(lang: Language) -> Entry {
         },
         Language::Ar => Entry {
             timeago_tokens: ::phf::Map {
-                key: 15467950696543387533,
+                key: 10121458955350035957,
                 disps: &[
-                    (1, 9),
+                    (1, 6),
-                    (5, 0),
+                    (0, 21),
-                    (10, 4),
+                    (1, 15),
-                    (0, 1),
+                    (1, 23),
-                    (7, 19),
+                    (2, 10),
+                    (2, 0),
                 ],
                 entries: &[
-                    ("سنتين", TaToken { n: 2, unit: Some(TimeUnit::Year) }),
-                    ("سنة", TaToken { n: 1, unit: Some(TimeUnit::Year) }),
-                    ("دقائق", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
-                    ("ساعة", TaToken { n: 1, unit: Some(TimeUnit::Hour) }),
-                    ("ثوان\u{64d}", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
-                    ("ثانية", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
-                    ("ثانيتين", TaToken { n: 2, unit: Some(TimeUnit::Second) }),
-                    ("أسبوعين", TaToken { n: 2, unit: Some(TimeUnit::Week) }),
-                    ("أسبوع", TaToken { n: 1, unit: Some(TimeUnit::Week) }),
-                    ("يومين", TaToken { n: 2, unit: Some(TimeUnit::Day) }),
-                    ("شهر\u{64b}ا", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
-                    ("أيام", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
-                    ("شهر", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
-                    ("يوم", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
-                    ("سنوات", TaToken { n: 1, unit: Some(TimeUnit::Year) }),
-                    ("يوم\u{64b}ا", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
-                    ("شهرين", TaToken { n: 2, unit: Some(TimeUnit::Month) }),
                     ("دقيقة", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
-                    ("ثوان\u{650}", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
-                    ("دقيقتين", TaToken { n: 2, unit: Some(TimeUnit::Minute) }),
                     ("أسابيع", TaToken { n: 1, unit: Some(TimeUnit::Week) }),
+                    ("دقيقتين", TaToken { n: 2, unit: Some(TimeUnit::Minute) }),
+                    ("شهر\u{64b}ا", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
+                    ("ثانية", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
+                    ("دقائق", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
+                    ("دقيقتان", TaToken { n: 2, unit: Some(TimeUnit::Minute) }),
+                    ("سنتين", TaToken { n: 2, unit: Some(TimeUnit::Year) }),
                     ("ساعات", TaToken { n: 1, unit: Some(TimeUnit::Hour) }),
-                    ("أشهر", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
+                    ("وثانية", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
+                    ("ثوان", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
+                    ("وثانيتان", TaToken { n: 2, unit: Some(TimeUnit::Second) }),
+                    ("أسبوعين", TaToken { n: 2, unit: Some(TimeUnit::Week) }),
+                    ("ساعة", TaToken { n: 1, unit: Some(TimeUnit::Hour) }),
+                    ("ثانيتين", TaToken { n: 2, unit: Some(TimeUnit::Second) }),
+                    ("شهرين", TaToken { n: 2, unit: Some(TimeUnit::Month) }),
+                    ("يوم\u{64b}ا", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
+                    ("سنة", TaToken { n: 1, unit: Some(TimeUnit::Year) }),
+                    ("ثوان\u{650}", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
+                    ("سنوات", TaToken { n: 1, unit: Some(TimeUnit::Year) }),
+                    ("أيام", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
                     ("ساعتين", TaToken { n: 2, unit: Some(TimeUnit::Hour) }),
+                    ("أشهر", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
+                    ("يوم", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
+                    ("أسبوع", TaToken { n: 1, unit: Some(TimeUnit::Week) }),
+                    ("ثوان\u{64d}", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
+                    ("يومين", TaToken { n: 2, unit: Some(TimeUnit::Day) }),
+                    ("شهر", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
                 ],
             },
             date_order: &[DateCmp::D, DateCmp::M, DateCmp::Y],
@@ -496,39 +504,42 @@ pub(crate) fn entry(lang: Language) -> Entry {
         },
         Language::Be => Entry {
             timeago_tokens: ::phf::Map {
-                key: 10121458955350035957,
+                key: 14108922650502679131,
                 disps: &[
-                    (2, 0),
+                    (1, 19),
-                    (3, 15),
+                    (15, 14),
-                    (9, 23),
+                    (1, 2),
-                    (1, 18),
+                    (12, 0),
-                    (1, 7),
+                    (2, 10),
+                    (0, 0),
                 ],
                 entries: &[
-                    ("месяца", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
-                    ("хвіліну", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
-                    ("дні", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
-                    ("секунды", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
-                    ("года", TaToken { n: 1, unit: Some(TimeUnit::Year) }),
-                    ("секунд", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
-                    ("гадоў", TaToken { n: 1, unit: Some(TimeUnit::Year) }),
-                    ("месяцы", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
-                    ("гадзіну", TaToken { n: 1, unit: Some(TimeUnit::Hour) }),
-                    ("год", TaToken { n: 1, unit: Some(TimeUnit::Year) }),
-                    ("гады", TaToken { n: 1, unit: Some(TimeUnit::Year) }),
-                    ("тыдні", TaToken { n: 1, unit: Some(TimeUnit::Week) }),
-                    ("гадзін", TaToken { n: 1, unit: Some(TimeUnit::Hour) }),
-                    ("дня", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
-                    ("хвілін", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
-                    ("дзень", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
-                    ("хвіліны", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
-                    ("секунду", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
-                    ("тыдня", TaToken { n: 1, unit: Some(TimeUnit::Week) }),
-                    ("гадзіны", TaToken { n: 1, unit: Some(TimeUnit::Hour) }),
-                    ("месяцаў", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
-                    ("месяц", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
                     ("тыдзень", TaToken { n: 1, unit: Some(TimeUnit::Week) }),
+                    ("секунды", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
+                    ("дзень", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
+                    ("секунда", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
+                    ("года", TaToken { n: 1, unit: Some(TimeUnit::Year) }),
+                    ("месяцаў", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
+                    ("тыдня", TaToken { n: 1, unit: Some(TimeUnit::Week) }),
+                    ("месяца", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
+                    ("тыдні", TaToken { n: 1, unit: Some(TimeUnit::Week) }),
+                    ("хвілін", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
+                    ("секунду", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
+                    ("гадзіну", TaToken { n: 1, unit: Some(TimeUnit::Hour) }),
+                    ("дня", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
+                    ("год", TaToken { n: 1, unit: Some(TimeUnit::Year) }),
                     ("дзён", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
+                    ("гадзіны", TaToken { n: 1, unit: Some(TimeUnit::Hour) }),
+                    ("месяцы", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
+                    ("хвіліну", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
+                    ("месяц", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
+                    ("гадзін", TaToken { n: 1, unit: Some(TimeUnit::Hour) }),
+                    ("гадоў", TaToken { n: 1, unit: Some(TimeUnit::Year) }),
+                    ("хвіліны", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
+                    ("хвіліна", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
+                    ("гады", TaToken { n: 1, unit: Some(TimeUnit::Year) }),
+                    ("дні", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
+                    ("секунд", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
                 ],
             },
             date_order: &[DateCmp::D, DateCmp::Y],
@@ -962,32 +973,36 @@ pub(crate) fn entry(lang: Language) -> Entry {
         },
         Language::Cs => Entry {
             timeago_tokens: ::phf::Map {
-                key: 15467950696543387533,
+                key: 12913932095322966823,
                 disps: &[
-                    (0, 14),
+                    (1, 0),
-                    (0, 8),
+                    (1, 7),
-                    (0, 0),
+                    (14, 20),
-                    (5, 13),
+                    (1, 11),
+                    (1, 20),
                 ],
                 entries: &[
                     ("minutami", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
                     ("měsícem", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
-                    ("sekunda", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
-                    ("sekundou", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
-                    ("sekund", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
-                    ("sekundami", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
-                    ("hodinami", TaToken { n: 1, unit: Some(TimeUnit::Hour) }),
-                    ("minutou", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
-                    ("hodinou", TaToken { n: 1, unit: Some(TimeUnit::Hour) }),
-                    ("lety", TaToken { n: 1, unit: Some(TimeUnit::Year) }),
-                    ("týdny", TaToken { n: 1, unit: Some(TimeUnit::Week) }),
-                    ("týdnem", TaToken { n: 1, unit: Some(TimeUnit::Week) }),
                     ("dnem", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
                     ("měsíci", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
-                    ("roky", TaToken { n: 1, unit: Some(TimeUnit::Year) }),
+                    ("týdnem", TaToken { n: 1, unit: Some(TimeUnit::Week) }),
-                    ("rokem", TaToken { n: 1, unit: Some(TimeUnit::Year) }),
+                    ("minutou", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
-                    ("dny", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
+                    ("sekund", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
+                    ("lety", TaToken { n: 1, unit: Some(TimeUnit::Year) }),
                     ("minuta", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
+                    ("sekundou", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
+                    ("minuty", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
+                    ("sekundy", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
+                    ("rokem", TaToken { n: 1, unit: Some(TimeUnit::Year) }),
+                    ("týdny", TaToken { n: 1, unit: Some(TimeUnit::Week) }),
+                    ("hodinou", TaToken { n: 1, unit: Some(TimeUnit::Hour) }),
+                    ("sekundami", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
+                    ("hodinami", TaToken { n: 1, unit: Some(TimeUnit::Hour) }),
+                    ("roky", TaToken { n: 1, unit: Some(TimeUnit::Year) }),
+                    ("dny", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
+                    ("sekunda", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
+                    ("minut", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
                 ],
             },
             date_order: &[DateCmp::D, DateCmp::M, DateCmp::Y],
@@ -2737,31 +2752,32 @@ pub(crate) fn entry(lang: Language) -> Entry {
         },
         Language::Is => Entry {
             timeago_tokens: ::phf::Map {
-                key: 10121458955350035957,
+                key: 12913932095322966823,
                 disps: &[
-                    (1, 9),
+                    (2, 0),
-                    (5, 0),
+                    (1, 6),
-                    (0, 5),
+                    (5, 16),
-                    (12, 10),
+                    (4, 6),
                 ],
                 entries: &[
+                    ("vikum", TaToken { n: 1, unit: Some(TimeUnit::Week) }),
+                    ("degi", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
+                    ("mínútum", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
                     ("mínúta", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
                     ("mánuðum", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
-                    ("sekúnda", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
-                    ("klukkustund", TaToken { n: 1, unit: Some(TimeUnit::Hour) }),
-                    ("sekúndum", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
-                    ("mánuði", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
-                    ("ári", TaToken { n: 1, unit: Some(TimeUnit::Year) }),
-                    ("vikum", TaToken { n: 1, unit: Some(TimeUnit::Week) }),
-                    ("mínútum", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
-                    ("viku", TaToken { n: 1, unit: Some(TimeUnit::Week) }),
-                    ("sekúndu", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
-                    ("klukkustundum", TaToken { n: 1, unit: Some(TimeUnit::Hour) }),
                     ("mínútu", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
+                    ("klukkustundum", TaToken { n: 1, unit: Some(TimeUnit::Hour) }),
+                    ("sekúndum", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
+                    ("sekúnda", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
                     ("árum", TaToken { n: 1, unit: Some(TimeUnit::Year) }),
+                    ("mínútur", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
+                    ("ári", TaToken { n: 1, unit: Some(TimeUnit::Year) }),
                     ("dögum", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
-                    ("degi", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
                     ("sekúndur", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
+                    ("mánuði", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
+                    ("viku", TaToken { n: 1, unit: Some(TimeUnit::Week) }),
+                    ("klukkustund", TaToken { n: 1, unit: Some(TimeUnit::Hour) }),
+                    ("sekúndu", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
                 ],
             },
             date_order: &[DateCmp::D, DateCmp::Y],
@@ -3354,30 +3370,31 @@ pub(crate) fn entry(lang: Language) -> Entry {
         },
         Language::Kn => Entry {
             timeago_tokens: ::phf::Map {
-                key: 12913932095322966823,
+                key: 15467950696543387533,
                 disps: &[
-                    (1, 3),
+                    (0, 4),
-                    (9, 6),
+                    (8, 2),
-                    (0, 6),
+                    (8, 0),
-                    (0, 0),
+                    (0, 2),
                 ],
                 entries: &[
-                    ("ತ\u{cbf}ಂಗಳ", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
-                    ("ಗಂಟ\u{cc6}ಗಳ", TaToken { n: 1, unit: Some(TimeUnit::Hour) }),
                     ("ನ\u{cbf}ಮ\u{cbf}ಷದ", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
-                    ("ವರ\u{ccd}ಷಗಳ", TaToken { n: 1, unit: Some(TimeUnit::Year) }),
+                    ("ಸ\u{cc6}ಕ\u{cc6}ಂಡುಗಳು", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
+                    ("ನ\u{cbf}ಮ\u{cbf}ಷಗಳು", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
+                    ("ನ\u{cbf}ಮ\u{cbf}ಷಗಳ", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
+                    ("ಸ\u{cc6}ಕ\u{cc6}ಂಡುಗಳ", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
+                    ("ಸ\u{cc6}ಕ\u{cc6}ಂಡ\u{ccd}", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
+                    ("ವರ\u{ccd}ಷದ", TaToken { n: 1, unit: Some(TimeUnit::Year) }),
+                    ("ತ\u{cbf}ಂಗಳ", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
+                    ("ಗಂಟ\u{cc6}", TaToken { n: 1, unit: Some(TimeUnit::Hour) }),
+                    ("ದ\u{cbf}ನದ", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
+                    ("ದ\u{cbf}ನಗಳ", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
                     ("ವಾರಗಳ", TaToken { n: 1, unit: Some(TimeUnit::Week) }),
                     ("ನ\u{cbf}ಮ\u{cbf}ಷವು", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
                     ("ತ\u{cbf}ಂಗಳುಗಳ", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
-                    ("ಸ\u{cc6}ಕ\u{cc6}ಂಡ\u{ccd}", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
                     ("ವಾರದ", TaToken { n: 1, unit: Some(TimeUnit::Week) }),
-                    ("ಸ\u{cc6}ಕ\u{cc6}ಂಡುಗಳು", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
+                    ("ಗಂಟ\u{cc6}ಗಳ", TaToken { n: 1, unit: Some(TimeUnit::Hour) }),
-                    ("ಸ\u{cc6}ಕ\u{cc6}ಂಡುಗಳ", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
+                    ("ವರ\u{ccd}ಷಗಳ", TaToken { n: 1, unit: Some(TimeUnit::Year) }),
-                    ("ದ\u{cbf}ನಗಳ", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
-                    ("ನ\u{cbf}ಮ\u{cbf}ಷಗಳ", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
-                    ("ದ\u{cbf}ನದ", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
-                    ("ವರ\u{ccd}ಷದ", TaToken { n: 1, unit: Some(TimeUnit::Year) }),
-                    ("ಗಂಟ\u{cc6}", TaToken { n: 1, unit: Some(TimeUnit::Hour) }),
                 ],
             },
             date_order: &[DateCmp::D, DateCmp::Y],
@@ -3695,36 +3712,37 @@ pub(crate) fn entry(lang: Language) -> Entry {
                 key: 12913932095322966823,
                 disps: &[
                     (0, 0),
-                    (0, 5),
+                    (3, 23),
-                    (5, 17),
+                    (18, 5),
-                    (13, 13),
+                    (3, 9),
-                    (19, 12),
+                    (2, 17),
                 ],
                 entries: &[
-                    ("sekundes", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
-                    ("dieną", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
-                    ("minutę", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
-                    ("mėnesį", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
-                    ("valandų", TaToken { n: 1, unit: Some(TimeUnit::Hour) }),
-                    ("minutes", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
-                    ("dienų", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
-                    ("sekundžių", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
-                    ("sekundę", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
-                    ("dienas", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
-                    ("sekundė", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
-                    ("savaičių", TaToken { n: 1, unit: Some(TimeUnit::Week) }),
-                    ("minutė", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
-                    ("d.", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
-                    ("sekundės", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
-                    ("metus", TaToken { n: 1, unit: Some(TimeUnit::Year) }),
                     ("valandas", TaToken { n: 1, unit: Some(TimeUnit::Hour) }),
-                    ("savaites", TaToken { n: 1, unit: Some(TimeUnit::Week) }),
+                    ("savaičių", TaToken { n: 1, unit: Some(TimeUnit::Week) }),
-                    ("valandą", TaToken { n: 1, unit: Some(TimeUnit::Hour) }),
                     ("minučių", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
-                    ("mėnesius", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
+                    ("dienų", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
+                    ("sekundės", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
+                    ("mėnesį", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
+                    ("dienas", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
+                    ("minutes", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
+                    ("sekundė", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
+                    ("valandų", TaToken { n: 1, unit: Some(TimeUnit::Hour) }),
+                    ("minutę", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
+                    ("sekundžių", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
+                    ("minutės", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
+                    ("d.", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
+                    ("dieną", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
+                    ("metų", TaToken { n: 1, unit: Some(TimeUnit::Year) }),
                     ("mėnesių", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
                     ("savaitę", TaToken { n: 1, unit: Some(TimeUnit::Week) }),
-                    ("metų", TaToken { n: 1, unit: Some(TimeUnit::Year) }),
+                    ("valandą", TaToken { n: 1, unit: Some(TimeUnit::Hour) }),
+                    ("sekundes", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
+                    ("metus", TaToken { n: 1, unit: Some(TimeUnit::Year) }),
+                    ("mėnesius", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
+                    ("minutė", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
+                    ("sekundę", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
+                    ("savaites", TaToken { n: 1, unit: Some(TimeUnit::Week) }),
                 ],
             },
             date_order: &[DateCmp::Y, DateCmp::M, DateCmp::D],
@@ -3782,27 +3800,32 @@ pub(crate) fn entry(lang: Language) -> Entry {
         },
         Language::Lv => Entry {
             timeago_tokens: ::phf::Map {
-                key: 15467950696543387533,
+                key: 10121458955350035957,
                 disps: &[
-                    (2, 0),
+                    (2, 4),
-                    (1, 12),
+                    (5, 0),
-                    (0, 4),
+                    (0, 17),
+                    (5, 6),
                 ],
                 entries: &[
-                    ("dienām", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
+                    ("gada", TaToken { n: 1, unit: Some(TimeUnit::Year) }),
+                    ("sekunžu", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
+                    ("sekundēm", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
+                    ("gadiem", TaToken { n: 1, unit: Some(TimeUnit::Year) }),
+                    ("mēneša", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
+                    ("nedēļas", TaToken { n: 1, unit: Some(TimeUnit::Week) }),
                     ("sekundes", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
                     ("stundām", TaToken { n: 1, unit: Some(TimeUnit::Hour) }),
-                    ("stundas", TaToken { n: 1, unit: Some(TimeUnit::Hour) }),
+                    ("minūšu", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
-                    ("nedēļas", TaToken { n: 1, unit: Some(TimeUnit::Week) }),
-                    ("minūtēm", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
                     ("minūtes", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
                     ("nedēļām", TaToken { n: 1, unit: Some(TimeUnit::Week) }),
-                    ("gadiem", TaToken { n: 1, unit: Some(TimeUnit::Year) }),
+                    ("sekunde", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
-                    ("gada", TaToken { n: 1, unit: Some(TimeUnit::Year) }),
+                    ("minūtēm", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
-                    ("mēneša", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
+                    ("dienām", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
-                    ("sekundēm", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
+                    ("stundas", TaToken { n: 1, unit: Some(TimeUnit::Hour) }),
-                    ("mēnešiem", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
+                    ("minūte", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
                     ("dienas", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
+                    ("mēnešiem", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
                 ],
             },
             date_order: &[DateCmp::Y, DateCmp::D],
@@ -4110,30 +4133,31 @@ pub(crate) fn entry(lang: Language) -> Entry {
         },
         Language::Mr => Entry {
             timeago_tokens: ::phf::Map {
-                key: 10121458955350035957,
+                key: 12913932095322966823,
                 disps: &[
                     (0, 0),
-                    (1, 9),
+                    (0, 8),
-                    (0, 12),
+                    (7, 4),
-                    (12, 10),
+                    (1, 6),
                 ],
                 entries: &[
-                    ("दिवसा\u{902}प\u{942}र\u{94d}वी", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
-                    ("वर\u{94d}षाप\u{942}र\u{94d}वी", TaToken { n: 1, unit: Some(TimeUnit::Year) }),
-                    ("मिनिटाप\u{942}र\u{94d}वी", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
-                    ("आठवड\u{94d}याप\u{942}र\u{94d}वी", TaToken { n: 1, unit: Some(TimeUnit::Week) }),
-                    ("वर\u{94d}षा\u{902}प\u{942}र\u{94d}वी", TaToken { n: 1, unit: Some(TimeUnit::Year) }),
-                    ("महिन\u{94d}या\u{902}प\u{942}र\u{94d}वी", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
-                    ("स\u{947}क\u{902}द", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
-                    ("मिनिट", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
-                    ("तासा\u{902}प\u{942}र\u{94d}वी", TaToken { n: 1, unit: Some(TimeUnit::Hour) }),
-                    ("महिन\u{94d}याप\u{942}र\u{94d}वी", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
-                    ("तासाप\u{942}र\u{94d}वी", TaToken { n: 1, unit: Some(TimeUnit::Hour) }),
                     ("दिवसाप\u{942}र\u{94d}वी", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
+                    ("महिन\u{94d}या\u{902}प\u{942}र\u{94d}वी", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
+                    ("दिवसा\u{902}प\u{942}र\u{94d}वी", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
+                    ("आठवड\u{94d}याप\u{942}र\u{94d}वी", TaToken { n: 1, unit: Some(TimeUnit::Week) }),
+                    ("मिनिटाप\u{942}र\u{94d}वी", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
+                    ("स\u{947}क\u{902}द", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
+                    ("तासा\u{902}प\u{942}र\u{94d}वी", TaToken { n: 1, unit: Some(TimeUnit::Hour) }),
                     ("स\u{947}क\u{902}दा\u{902}प\u{942}र\u{94d}वी", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
-                    ("स\u{947}क\u{902}दाप\u{942}र\u{94d}वी", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
                     ("मिनिटा\u{902}प\u{942}र\u{94d}वी", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
+                    ("महिन\u{94d}याप\u{942}र\u{94d}वी", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
+                    ("स\u{947}क\u{902}दाप\u{942}र\u{94d}वी", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
+                    ("मिनिट", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
                     ("आठवड\u{94d}या\u{902}प\u{942}र\u{94d}वी", TaToken { n: 1, unit: Some(TimeUnit::Week) }),
+                    ("वर\u{94d}षाप\u{942}र\u{94d}वी", TaToken { n: 1, unit: Some(TimeUnit::Year) }),
+                    ("मिनिट\u{947}", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
+                    ("तासाप\u{942}र\u{94d}वी", TaToken { n: 1, unit: Some(TimeUnit::Hour) }),
+                    ("वर\u{94d}षा\u{902}प\u{942}र\u{94d}वी", TaToken { n: 1, unit: Some(TimeUnit::Year) }),
                 ],
             },
             date_order: &[DateCmp::D, DateCmp::Y],
@@ -4294,18 +4318,19 @@ pub(crate) fn entry(lang: Language) -> Entry {
             timeago_tokens: ::phf::Map {
                 key: 15467950696543387533,
                 disps: &[
-                    (4, 0),
+                    (0, 0),
-                    (3, 5),
+                    (7, 3),
                 ],
                 entries: &[
+                    ("မ\u{102d}နစ\u{103a}န\u{103e}င\u{1037}\u{103a}", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
                     ("န\u{103e}စ\u{103a}", TaToken { n: 1, unit: Some(TimeUnit::Year) }),
+                    ("နာရ\u{102e}", TaToken { n: 1, unit: Some(TimeUnit::Hour) }),
+                    ("လ", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
+                    ("စက\u{1039}ကန\u{1037}\u{103a}", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
+                    ("ရက\u{103a}", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
+                    ("ပတ\u{103a}", TaToken { n: 1, unit: Some(TimeUnit::Week) }),
                     ("ရက\u{103a}က", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
                     ("မ\u{102d}နစ\u{103a}", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
-                    ("လ", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
-                    ("နာရ\u{102e}", TaToken { n: 1, unit: Some(TimeUnit::Hour) }),
-                    ("ရက\u{103a}", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
-                    ("စက\u{1039}ကန\u{1037}\u{103a}", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
-                    ("ပတ\u{103a}", TaToken { n: 1, unit: Some(TimeUnit::Week) }),
                 ],
             },
             date_order: &[DateCmp::Y, DateCmp::D],
@@ -5196,34 +5221,37 @@ pub(crate) fn entry(lang: Language) -> Entry {
         },
         Language::Ru => Entry {
             timeago_tokens: ::phf::Map {
-                key: 15467950696543387533,
+                key: 12913932095322966823,
                 disps: &[
-                    (17, 15),
+                    (2, 0),
-                    (7, 8),
+                    (0, 18),
-                    (4, 0),
+                    (0, 9),
-                    (0, 0),
+                    (7, 3),
+                    (16, 13),
                 ],
                 entries: &[
-                    ("часа", TaToken { n: 1, unit: Some(TimeUnit::Hour) }),
-                    ("год", TaToken { n: 1, unit: Some(TimeUnit::Year) }),
                     ("недели", TaToken { n: 1, unit: Some(TimeUnit::Week) }),
-                    ("дней", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
+                    ("месяца", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
-                    ("минуты", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
+                    ("месяц", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
-                    ("секунду", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
+                    ("месяцев", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
-                    ("часов", TaToken { n: 1, unit: Some(TimeUnit::Hour) }),
-                    ("секунд", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
-                    ("минуту", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
                     ("дня", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
                     ("лет", TaToken { n: 1, unit: Some(TimeUnit::Year) }),
-                    ("неделю", TaToken { n: 1, unit: Some(TimeUnit::Week) }),
+                    ("минуты", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
-                    ("секунды", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
-                    ("час", TaToken { n: 1, unit: Some(TimeUnit::Hour) }),
-                    ("месяцев", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
-                    ("месяц", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
-                    ("минут", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
-                    ("года", TaToken { n: 1, unit: Some(TimeUnit::Year) }),
                     ("день", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
-                    ("месяца", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
+                    ("года", TaToken { n: 1, unit: Some(TimeUnit::Year) }),
+                    ("секунду", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
+                    ("секунда", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
+                    ("секунд", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
+                    ("неделю", TaToken { n: 1, unit: Some(TimeUnit::Week) }),
+                    ("дней", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
+                    ("час", TaToken { n: 1, unit: Some(TimeUnit::Hour) }),
+                    ("часа", TaToken { n: 1, unit: Some(TimeUnit::Hour) }),
+                    ("минут", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
+                    ("минуту", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
+                    ("секунды", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
+                    ("год", TaToken { n: 1, unit: Some(TimeUnit::Year) }),
+                    ("минута", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
+                    ("часов", TaToken { n: 1, unit: Some(TimeUnit::Hour) }),
                 ],
             },
             date_order: &[DateCmp::D, DateCmp::Y],
@@ -5379,31 +5407,34 @@ pub(crate) fn entry(lang: Language) -> Entry {
         },
         Language::Sk => Entry {
             timeago_tokens: ::phf::Map {
-                key: 12913932095322966823,
+                key: 15467950696543387533,
                 disps: &[
-                    (0, 4),
+                    (0, 0),
-                    (5, 16),
+                    (1, 8),
-                    (0, 12),
+                    (1, 1),
-                    (2, 0),
+                    (0, 17),
                 ],
                 entries: &[
-                    ("dňami", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
-                    ("sekundami", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
-                    ("týždňami", TaToken { n: 1, unit: Some(TimeUnit::Week) }),
-                    ("hodinou", TaToken { n: 1, unit: Some(TimeUnit::Hour) }),
-                    ("hodinami", TaToken { n: 1, unit: Some(TimeUnit::Hour) }),
-                    ("rokom", TaToken { n: 1, unit: Some(TimeUnit::Year) }),
-                    ("sekundou", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
-                    ("minútami", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
                     ("minútou", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
-                    ("dňom", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
+                    ("sekundami", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
+                    ("minút", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
+                    ("týždňami", TaToken { n: 1, unit: Some(TimeUnit::Week) }),
                     ("sekunda", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
+                    ("sekundy", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
+                    ("týždňom", TaToken { n: 1, unit: Some(TimeUnit::Week) }),
+                    ("sekúnd", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
+                    ("hodinami", TaToken { n: 1, unit: Some(TimeUnit::Hour) }),
+                    ("hodinou", TaToken { n: 1, unit: Some(TimeUnit::Hour) }),
+                    ("mesiacom", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
+                    ("rokom", TaToken { n: 1, unit: Some(TimeUnit::Year) }),
+                    ("minútami", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
+                    ("minúty", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
                     ("mesiacmi", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
+                    ("dňom", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
+                    ("dňami", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
+                    ("sekundou", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
                     ("minúta", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
                     ("rokmi", TaToken { n: 1, unit: Some(TimeUnit::Year) }),
-                    ("týždňom", TaToken { n: 1, unit: Some(TimeUnit::Week) }),
-                    ("mesiacom", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
-                    ("sekúnd", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
                 ],
             },
             date_order: &[DateCmp::D, DateCmp::M, DateCmp::Y],
@@ -5463,38 +5494,44 @@ pub(crate) fn entry(lang: Language) -> Entry {
             timeago_tokens: ::phf::Map {
                 key: 12913932095322966823,
                 disps: &[
-                    (0, 21),
+                    (1, 2),
-                    (3, 17),
+                    (5, 22),
-                    (0, 8),
+                    (2, 4),
-                    (15, 7),
+                    (0, 22),
-                    (0, 0),
+                    (13, 22),
+                    (2, 0),
                 ],
                 entries: &[
-                    ("sekundo", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
+                    ("sekund", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
+                    ("dnem", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
+                    ("sekunde", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
+                    ("tednoma", TaToken { n: 1, unit: Some(TimeUnit::Week) }),
+                    ("minuta", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
+                    ("meseci", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
+                    ("minuti", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
+                    ("minute", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
                     ("minuto", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
                     ("urami", TaToken { n: 1, unit: Some(TimeUnit::Hour) }),
-                    ("meseci", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
-                    ("sekunda", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
-                    ("mesecema", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
-                    ("leti", TaToken { n: 1, unit: Some(TimeUnit::Year) }),
-                    ("dnem", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
-                    ("minuta", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
-                    ("sekund", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
-                    ("dnevi", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
-                    ("tedni", TaToken { n: 1, unit: Some(TimeUnit::Week) }),
                     ("minutami", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
-                    ("letom", TaToken { n: 1, unit: Some(TimeUnit::Year) }),
-                    ("minutama", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
-                    ("uro", TaToken { n: 1, unit: Some(TimeUnit::Hour) }),
-                    ("tednom", TaToken { n: 1, unit: Some(TimeUnit::Week) }),
-                    ("mesecem", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
-                    ("letoma", TaToken { n: 1, unit: Some(TimeUnit::Year) }),
                     ("dnevoma", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
-                    ("dnevom", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
+                    ("sekundi", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
+                    ("uro", TaToken { n: 1, unit: Some(TimeUnit::Hour) }),
+                    ("dnevi", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
+                    ("sekunda", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
+                    ("mesecem", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
+                    ("mesecema", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
+                    ("minutama", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
+                    ("sekundo", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
+                    ("letoma", TaToken { n: 1, unit: Some(TimeUnit::Year) }),
+                    ("letom", TaToken { n: 1, unit: Some(TimeUnit::Year) }),
+                    ("tednom", TaToken { n: 1, unit: Some(TimeUnit::Week) }),
                     ("urama", TaToken { n: 1, unit: Some(TimeUnit::Hour) }),
+                    ("dnevom", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
+                    ("minut", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
                     ("sekundami", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
+                    ("tedni", TaToken { n: 1, unit: Some(TimeUnit::Week) }),
+                    ("leti", TaToken { n: 1, unit: Some(TimeUnit::Year) }),
                     ("sekundama", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
-                    ("tednoma", TaToken { n: 1, unit: Some(TimeUnit::Week) }),
                 ],
             },
             date_order: &[DateCmp::D, DateCmp::Y],
@@ -6000,30 +6037,31 @@ pub(crate) fn entry(lang: Language) -> Entry {
         },
         Language::Ta => Entry {
             timeago_tokens: ::phf::Map {
-                key: 7485420634051515786,
+                key: 8694567506910003252,
                 disps: &[
-                    (5, 15),
+                    (5, 3),
-                    (4, 0),
+                    (2, 13),
-                    (0, 9),
+                    (11, 0),
-                    (0, 9),
+                    (1, 10),
                 ],
                 entries: &[
                     ("விந\u{bbe}டிகள\u{bcd}", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
-                    ("நிமிடங\u{bcd}களுக\u{bcd}கு", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
+                    ("ம\u{bbe}தத\u{bcd}துக\u{bcd}கு", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
-                    ("மணிநேரம\u{bcd}", TaToken { n: 1, unit: Some(TimeUnit::Hour) }),
+                    ("நிமிடத\u{bcd}திற\u{bcd}கு", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
                     ("விந\u{bbe}டிகளுக\u{bcd}கு", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
+                    ("நிமிடங\u{bcd}களுக\u{bcd}கு", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
+                    ("ஆண\u{bcd}டிற\u{bcd}கு", TaToken { n: 1, unit: Some(TimeUnit::Year) }),
+                    ("நிமிடங\u{bcd}கள\u{bcd}", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
                     ("வ\u{bbe}ரங\u{bcd}களுக\u{bcd}கு", TaToken { n: 1, unit: Some(TimeUnit::Week) }),
                     ("விந\u{bbe}டி", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
-                    ("ஆண\u{bcd}டிற\u{bcd}கு", TaToken { n: 1, unit: Some(TimeUnit::Year) }),
-                    ("வ\u{bbe}ரம\u{bcd}", TaToken { n: 1, unit: Some(TimeUnit::Week) }),
-                    ("நிமிடத\u{bcd}திற\u{bcd}கு", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
-                    ("ந\u{bbe}ட\u{bcd}களுக\u{bcd}கு", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
-                    ("ம\u{bbe}தங\u{bcd}களுக\u{bcd}கு", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
-                    ("நிமிடம\u{bcd}", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
-                    ("ந\u{bbe}ளுக\u{bcd}கு", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
-                    ("விந\u{bbe}டிக\u{bcd}கு", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
                     ("ஆண\u{bcd}டுகளுக\u{bcd}கு", TaToken { n: 1, unit: Some(TimeUnit::Year) }),
-                    ("ம\u{bbe}தத\u{bcd}துக\u{bcd}கு", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
+                    ("ம\u{bbe}தங\u{bcd}களுக\u{bcd}கு", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
+                    ("ந\u{bbe}ளுக\u{bcd}கு", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
+                    ("வ\u{bbe}ரம\u{bcd}", TaToken { n: 1, unit: Some(TimeUnit::Week) }),
+                    ("மணிநேரம\u{bcd}", TaToken { n: 1, unit: Some(TimeUnit::Hour) }),
+                    ("ந\u{bbe}ட\u{bcd}களுக\u{bcd}கு", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
+                    ("நிமிடம\u{bcd}", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
+                    ("விந\u{bbe}டிக\u{bcd}கு", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
                 ],
             },
             date_order: &[DateCmp::D, DateCmp::Y],
@@ -6097,26 +6135,28 @@ pub(crate) fn entry(lang: Language) -> Entry {
             timeago_tokens: ::phf::Map {
                 key: 15467950696543387533,
                 disps: &[
+                    (1, 4),
                     (1, 0),
-                    (7, 5),
+                    (5, 0),
-                    (1, 8),
+                    (9, 14),
                 ],
                 entries: &[
-                    ("న\u{c3f}మ\u{c3f}ష\u{c3e}ల", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
+                    ("వ\u{c3e}రం", TaToken { n: 1, unit: Some(TimeUnit::Week) }),
-                    ("స\u{c46}కను", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
+                    ("ర\u{c4b}జుల", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
+                    ("గంట", TaToken { n: 1, unit: Some(TimeUnit::Hour) }),
+                    ("వ\u{c3e}ర\u{c3e}ల", TaToken { n: 1, unit: Some(TimeUnit::Week) }),
+                    ("సంవత\u{c4d}సర\u{c3e}ల", TaToken { n: 1, unit: Some(TimeUnit::Year) }),
+                    ("స\u{c46}కన\u{c4d}ల", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
+                    ("న\u{c3f}మ\u{c3f}షం", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
+                    ("ర\u{c4b}జు", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
+                    ("న\u{c46}ల", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
                     ("స\u{c46}కన\u{c4d}లు", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
                     ("సంవత\u{c4d}సరం", TaToken { n: 1, unit: Some(TimeUnit::Year) }),
-                    ("సంవత\u{c4d}సర\u{c3e}ల", TaToken { n: 1, unit: Some(TimeUnit::Year) }),
+                    ("న\u{c3f}మ\u{c3f}ష\u{c3e}లు", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
-                    ("న\u{c46}ల", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
+                    ("స\u{c46}కను", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
-                    ("వ\u{c3e}రం", TaToken { n: 1, unit: Some(TimeUnit::Week) }),
-                    ("న\u{c46}లల", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
-                    ("ర\u{c4b}జుల", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
-                    ("ర\u{c4b}జు", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
-                    ("వ\u{c3e}ర\u{c3e}ల", TaToken { n: 1, unit: Some(TimeUnit::Week) }),
-                    ("న\u{c3f}మ\u{c3f}షం", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
                     ("గంటల", TaToken { n: 1, unit: Some(TimeUnit::Hour) }),
-                    ("స\u{c46}కన\u{c4d}ల", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
+                    ("న\u{c3f}మ\u{c3f}ష\u{c3e}ల", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
-                    ("గంట", TaToken { n: 1, unit: Some(TimeUnit::Hour) }),
+                    ("న\u{c46}లల", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
                 ],
             },
             date_order: &[DateCmp::D, DateCmp::Y],
@@ -6366,34 +6406,37 @@ pub(crate) fn entry(lang: Language) -> Entry {
         },
         Language::Uk => Entry {
             timeago_tokens: ::phf::Map {
-                key: 8694567506910003252,
+                key: 12913932095322966823,
                 disps: &[
-                    (0, 5),
+                    (1, 19),
-                    (6, 4),
+                    (10, 3),
-                    (4, 0),
+                    (15, 2),
-                    (2, 16),
+                    (0, 9),
+                    (0, 0),
                 ],
                 entries: &[
-                    ("місяців", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
-                    ("роки", TaToken { n: 1, unit: Some(TimeUnit::Year) }),
-                    ("років", TaToken { n: 1, unit: Some(TimeUnit::Year) }),
-                    ("секунду", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
-                    ("рік", TaToken { n: 1, unit: Some(TimeUnit::Year) }),
-                    ("секунд", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
-                    ("години", TaToken { n: 1, unit: Some(TimeUnit::Hour) }),
-                    ("місяць", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
-                    ("хвилину", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
-                    ("день", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
-                    ("місяці", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
-                    ("хвилини", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
-                    ("годину", TaToken { n: 1, unit: Some(TimeUnit::Hour) }),
-                    ("тижні", TaToken { n: 1, unit: Some(TimeUnit::Week) }),
-                    ("годин", TaToken { n: 1, unit: Some(TimeUnit::Hour) }),
-                    ("хвилин", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
                     ("тиждень", TaToken { n: 1, unit: Some(TimeUnit::Week) }),
+                    ("тижні", TaToken { n: 1, unit: Some(TimeUnit::Week) }),
+                    ("місяць", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
                     ("днів", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
+                    ("рік", TaToken { n: 1, unit: Some(TimeUnit::Year) }),
+                    ("секунду", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
                     ("секунди", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
+                    ("секунда", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
+                    ("хвилини", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
+                    ("хвилина", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
+                    ("місяці", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
+                    ("години", TaToken { n: 1, unit: Some(TimeUnit::Hour) }),
+                    ("секунд", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
+                    ("роки", TaToken { n: 1, unit: Some(TimeUnit::Year) }),
+                    ("хвилину", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
+                    ("годин", TaToken { n: 1, unit: Some(TimeUnit::Hour) }),
+                    ("день", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
+                    ("місяців", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
+                    ("годину", TaToken { n: 1, unit: Some(TimeUnit::Hour) }),
+                    ("років", TaToken { n: 1, unit: Some(TimeUnit::Year) }),
                     ("дні", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
+                    ("хвилин", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
                 ],
             },
             date_order: &[DateCmp::D, DateCmp::Y],
@@ -6466,26 +6509,27 @@ pub(crate) fn entry(lang: Language) -> Entry {
         },
         Language::Ur => Entry {
             timeago_tokens: ::phf::Map {
-                key: 7485420634051515786,
+                key: 12213676231523076107,
                 disps: &[
-                    (9, 10),
+                    (11, 7),
-                    (0, 11),
+                    (0, 10),
-                    (2, 0),
+                    (1, 0),
                 ],
                 entries: &[
-                    ("سیکنڈ", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
-                    ("سیکنڈز", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
-                    ("مہینہ", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
-                    ("ہفتے", TaToken { n: 1, unit: Some(TimeUnit::Week) }),
-                    ("منٹس", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
-                    ("ہفتہ", TaToken { n: 1, unit: Some(TimeUnit::Week) }),
-                    ("دنوں", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
-                    ("گھنٹہ", TaToken { n: 1, unit: Some(TimeUnit::Hour) }),
-                    ("سال", TaToken { n: 1, unit: Some(TimeUnit::Year) }),
-                    ("مہینے", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
-                    ("دن", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
                     ("منٹ", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
+                    ("ہفتے", TaToken { n: 1, unit: Some(TimeUnit::Week) }),
+                    ("ہفتہ", TaToken { n: 1, unit: Some(TimeUnit::Week) }),
+                    ("منٹ،", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
                     ("گھنٹے", TaToken { n: 1, unit: Some(TimeUnit::Hour) }),
+                    ("سال", TaToken { n: 1, unit: Some(TimeUnit::Year) }),
+                    ("سیکنڈز", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
+                    ("دن", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
+                    ("سیکنڈ", TaToken { n: 1, unit: Some(TimeUnit::Second) }),
+                    ("دنوں", TaToken { n: 1, unit: Some(TimeUnit::Day) }),
+                    ("منٹس", TaToken { n: 1, unit: Some(TimeUnit::Minute) }),
+                    ("مہینہ", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
+                    ("گھنٹہ", TaToken { n: 1, unit: Some(TimeUnit::Hour) }),
+                    ("مہینے", TaToken { n: 1, unit: Some(TimeUnit::Month) }),
                 ],
             },
             date_order: &[DateCmp::D, DateCmp::Y],

src/util/timeago.rs

@@ -76,6 +76,26 @@ pub enum DateCmp {
     D,
 }
 
+impl TimeUnit {
+    pub fn secs(&self) -> i64 {
+        match self {
+            TimeUnit::Second => 1,
+            TimeUnit::Minute => 60,
+            TimeUnit::Hour => 3600,
+            TimeUnit::Day => 24 * 3600,
+            TimeUnit::Week => 7 * 24 * 3600,
+            TimeUnit::Month => 30 * 24 * 3600,
+            TimeUnit::Year => 365 * 24 * 3600,
+        }
+    }
+}
+
+impl TimeAgo {
+    fn secs(&self) -> i64 {
+        i64::from(self.n) * self.unit.secs()
+    }
+}
+
 impl Mul<u8> for TimeAgo {
     type Output = Self;
 
@@ -89,15 +109,7 @@ impl Mul<u8> for TimeAgo {
 
 impl From<TimeAgo> for Duration {
     fn from(ta: TimeAgo) -> Self {
-        match ta.unit {
+        Duration::seconds(ta.secs())
-            TimeUnit::Second => Duration::seconds(ta.n as i64),
-            TimeUnit::Minute => Duration::minutes(ta.n as i64),
-            TimeUnit::Hour => Duration::hours(ta.n as i64),
-            TimeUnit::Day => Duration::days(ta.n as i64),
-            TimeUnit::Week => Duration::weeks(ta.n as i64),
-            TimeUnit::Month => Duration::days(ta.n as i64 * 30),
-            TimeUnit::Year => Duration::days(ta.n as i64 * 365),
-        }
     }
 }
 
@@ -172,6 +184,47 @@ fn parse_ta_token(
     }
 }
 
+fn parse_ta_tokens(
+    entry: &dictionary::Entry,
+    by_char: bool,
+    nd: bool,
+    filtered_str: &str,
+) -> Vec<TimeAgo> {
+    let tokens = match nd {
+        true => &entry.timeago_nd_tokens,
+        false => &entry.timeago_tokens,
+    };
+    let mut qu = 1;
+
+    if by_char {
+        filtered_str
+            .chars()
+            .filter_map(|word| {
+                tokens.get(&word.to_string()).and_then(|t| match t.unit {
+                    Some(unit) => Some(TimeAgo { n: t.n * qu, unit }),
+                    None => {
+                        qu = t.n;
+                        None
+                    }
+                })
+            })
+            .collect()
+    } else {
+        filtered_str
+            .split_whitespace()
+            .filter_map(|word| {
+                tokens.get(word).and_then(|t| match t.unit {
+                    Some(unit) => Some(TimeAgo { n: t.n * qu, unit }),
+                    None => {
+                        qu = t.n;
+                        None
+                    }
+                })
+            })
+            .collect()
+    }
+}
+
 fn parse_textual_month(entry: &dictionary::Entry, filtered_str: &str) -> Option<u8> {
     filtered_str
         .split_whitespace()
@@ -180,7 +233,7 @@ fn parse_textual_month(entry: &dictionary::Entry, filtered_str: &str) -> Option<
 
 /// Parse a TimeAgo string (e.g. "29 minutes ago") into a TimeAgo object.
 ///
-/// Returns None if the date could not be parsed.
+/// Returns [`None`] if the date could not be parsed.
 pub fn parse_timeago(lang: Language, textual_date: &str) -> Option<TimeAgo> {
     let entry = dictionary::entry(lang);
     let filtered_str = filter_str(textual_date);
@@ -192,23 +245,11 @@ pub fn parse_timeago(lang: Language, textual_date: &str) -> Option<TimeAgo> {
 
 /// Parse a TimeAgo string (e.g. "29 minutes ago") into a Chrono DateTime object.
 ///
-/// Returns None if the date could not be parsed.
+/// Returns [`None`] if the date could not be parsed.
 pub fn parse_timeago_dt(lang: Language, textual_date: &str) -> Option<OffsetDateTime> {
     parse_timeago(lang, textual_date).map(|ta| ta.into())
 }
 
-pub fn parse_timeago_or_warn(
-    lang: Language,
-    textual_date: &str,
-    warnings: &mut Vec<String>,
-) -> Option<TimeAgo> {
-    let res = parse_timeago(lang, textual_date);
-    if res.is_none() {
-        warnings.push(format!("could not parse timeago `{textual_date}`"));
-    }
-    res
-}
-
 pub fn parse_timeago_dt_or_warn(
     lang: Language,
     textual_date: &str,
@@ -223,7 +264,7 @@ pub fn parse_timeago_dt_or_warn(
 
 /// Parse a textual date (e.g. "29 minutes ago" or "Jul 2, 2014") into a ParsedDate object.
 ///
-/// Returns None if the date could not be parsed.
+/// Returns [`None`] if the date could not be parsed.
 pub fn parse_textual_date(lang: Language, textual_date: &str) -> Option<ParsedDate> {
     let entry = dictionary::entry(lang);
     let by_char = util::lang_by_char(lang);
@@ -291,6 +332,87 @@ pub fn parse_textual_date_or_warn(
     res
 }
 
+/// Parse a textual video duration (e.g. "11 minutes, 20 seconds")
+///
+/// Returns None if the duration could not be parsed
+pub fn parse_video_duration(lang: Language, video_duration: &str) -> Option<u32> {
+    let entry = dictionary::entry(lang);
+    let by_char = util::lang_by_char(lang);
+
+    let parts = split_duration_txt(video_duration, matches!(lang, Language::Si | Language::Sw));
+    let mut secs = 0;
+
+    for part in parts {
+        let mut n = if part.digits.is_empty() {
+            1
+        } else {
+            part.digits.parse::<u32>().ok()?
+        };
+        let tokens = parse_ta_tokens(&entry, by_char, false, &part.word);
+        if tokens.is_empty() {
+            return None;
+        }
+
+        tokens.iter().for_each(|ta| {
+            secs += n * ta.secs() as u32;
+            n = 1;
+        });
+    }
+
+    Some(secs)
+}
+
+pub fn parse_video_duration_or_warn(
+    lang: Language,
+    video_duration: &str,
+    warnings: &mut Vec<String>,
+) -> Option<u32> {
+    let res = parse_video_duration(lang, video_duration);
+    if res.is_none() {
+        warnings.push(format!("could not parse video duration `{video_duration}`"));
+    }
+    res
+}
+
+#[derive(Default)]
+struct DurationTxtSegment {
+    digits: String,
+    word: String,
+}
+
+fn split_duration_txt(txt: &str, start_c: bool) -> Vec<DurationTxtSegment> {
+    let mut segments = Vec::new();
+
+    // 1: parse digits, 2: parse word
+    let mut state: u8 = 0;
+    let mut seg = DurationTxtSegment::default();
+
+    for c in txt.chars() {
+        if c.is_ascii_digit() {
+            if state == 2 && (!seg.digits.is_empty() || (!start_c && segments.is_empty())) {
+                segments.push(seg);
+                seg = DurationTxtSegment::default();
+            }
+            seg.digits.push(c);
+            state = 1;
+        } else {
+            if (state == 1) && (!seg.word.is_empty() || (start_c && segments.is_empty())) {
+                segments.push(seg);
+                seg = DurationTxtSegment::default();
+            }
+            if c != ',' {
+                c.to_lowercase().for_each(|c| seg.word.push(c));
+            }
+            state = 2;
+        }
+    }
+    if !seg.word.is_empty() || !seg.digits.is_empty() {
+        segments.push(seg);
+    }
+
+    segments
+}
+
 #[cfg(test)]
 mod tests {
     use std::{collections::BTreeMap, fs::File, io::BufReader};
@@ -642,6 +764,36 @@ mod tests {
         })
     }
 
+    #[test]
+    fn t_parse_video_duration() {
+        let json_path = path!(*TESTFILES / "dict" / "video_duration_samples.json");
+        let json_file = File::open(json_path).unwrap();
+        let date_samples: BTreeMap<Language, BTreeMap<String, u32>> =
+            serde_json::from_reader(BufReader::new(json_file)).unwrap();
+
+        date_samples.iter().for_each(|(lang, samples)| {
+            samples.iter().for_each(|(txt, duration)| {
+                assert_eq!(
+                    parse_video_duration(*lang, txt),
+                    Some(*duration),
+                    "lang: {lang}; txt: `{txt}`"
+                );
+            })
+        });
+    }
+
+    #[rstest]
+    #[case(Language::Ar, "19 دقيقة وثانيتان", 1142)]
+    #[case(Language::Ar, "دقيقة و13 ثانية", 73)]
+    #[case(Language::Sw, "dakika 1 na sekunde 13", 73)]
+    fn t_parse_video_duration2(
+        #[case] lang: Language,
+        #[case] video_duration: &str,
+        #[case] expect: u32,
+    ) {
+        assert_eq!(parse_video_duration(lang, video_duration), Some(expect));
+    }
+
     #[test]
     fn t_to_datetime() {
         // Absolute date

testfiles/dict/dictionary.json

@@ -69,7 +69,9 @@
       "ዓመታት": "Y",
       "ዓመት": "Y",
       "ደቂቃ": "m",
-      "ደቂቃዎች": "m"
+      "ደቂቃዎች": "m",
+      "ደቂቃዎች፣": "m",
+      "ደቂቃ፣": "m"
     },
     "date_order": "DY",
     "months": {
@@ -118,10 +120,12 @@
       "أيام": "D",
       "ثانية": "s",
       "ثانيتين": "2s",
+      "ثوان": "s",
       "ثوانٍ": "s",
       "ثوانِ": "s",
       "دقائق": "m",
       "دقيقة": "m",
+      "دقيقتان": "2m",
       "دقيقتين": "2m",
       "ساعات": "h",
       "ساعة": "h",
@@ -132,6 +136,8 @@
       "شهر": "M",
       "شهرين": "2M",
       "شهرًا": "M",
+      "وثانية": "s",
+      "وثانيتان": "2s",
       "يوم": "D",
       "يومين": "2D",
       "يومًا": "D"
@@ -274,12 +280,14 @@
       "месяцаў": "M",
       "месяцы": "M",
       "секунд": "s",
+      "секунда": "s",
       "секунду": "s",
       "секунды": "s",
       "тыдзень": "W",
       "тыдня": "W",
       "тыдні": "W",
       "хвілін": "m",
+      "хвіліна": "m",
       "хвіліну": "m",
       "хвіліны": "m"
     },
@@ -538,9 +546,11 @@
       "hodinami": "h",
       "hodinou": "h",
       "lety": "Y",
+      "minut": "m",
       "minuta": "m",
       "minutami": "m",
       "minutou": "m",
+      "minuty": "m",
       "měsícem": "M",
       "měsíci": "M",
       "rokem": "Y",
@@ -549,6 +559,7 @@
       "sekunda": "s",
       "sekundami": "s",
       "sekundou": "s",
+      "sekundy": "s",
       "týdnem": "W",
       "týdny": "W"
     },
@@ -1572,6 +1583,7 @@
       "mínúta": "m",
       "mínútu": "m",
       "mínútum": "m",
+      "mínútur": "m",
       "sekúnda": "s",
       "sekúndu": "s",
       "sekúndum": "s",
@@ -1924,6 +1936,7 @@
       "ದಿನಗಳ": "D",
       "ದಿನದ": "D",
       "ನಿಮಿಷಗಳ": "m",
+      "ನಿಮಿಷಗಳು": "m",
       "ನಿಮಿಷದ": "m",
       "ನಿಮಿಷವು": "m",
       "ವರ್ಷಗಳ": "Y",
@@ -2115,6 +2128,7 @@
       "metų": "Y",
       "minutes": "m",
       "minutė": "m",
+      "minutės": "m",
       "minutę": "m",
       "minučių": "m",
       "mėnesius": "M",
@@ -2163,14 +2177,18 @@
       "dienām": "D",
       "gada": "Y",
       "gadiem": "Y",
+      "minūte": "m",
       "minūtes": "m",
       "minūtēm": "m",
+      "minūšu": "m",
       "mēneša": "M",
       "mēnešiem": "M",
       "nedēļas": "W",
       "nedēļām": "W",
+      "sekunde": "s",
       "sekundes": "s",
       "sekundēm": "s",
+      "sekunžu": "s",
       "stundas": "h",
       "stundām": "h"
     },
@@ -2352,6 +2370,7 @@
       "मिनिट": "m",
       "मिनिटांपूर्वी": "m",
       "मिनिटापूर्वी": "m",
+      "मिनिटे": "m",
       "वर्षांपूर्वी": "Y",
       "वर्षापूर्वी": "Y",
       "सेकंद": "s",
@@ -2452,6 +2471,7 @@
       "နှစ်": "Y",
       "ပတ်": "W",
       "မိနစ်": "m",
+      "မိနစ်နှင့်": "m",
       "ရက်": "D",
       "ရက်က": "D",
       "လ": "M"
@@ -2983,11 +3003,13 @@
       "месяца": "M",
       "месяцев": "M",
       "минут": "m",
+      "минута": "m",
       "минуту": "m",
       "минуты": "m",
       "недели": "W",
       "неделю": "W",
       "секунд": "s",
+      "секунда": "s",
       "секунду": "s",
       "секунды": "s",
       "час": "h",
@@ -3086,14 +3108,17 @@
       "hodinou": "h",
       "mesiacmi": "M",
       "mesiacom": "M",
+      "minút": "m",
       "minúta": "m",
       "minútami": "m",
       "minútou": "m",
+      "minúty": "m",
       "rokmi": "Y",
       "rokom": "Y",
       "sekunda": "s",
       "sekundami": "s",
       "sekundou": "s",
+      "sekundy": "s",
       "sekúnd": "s",
       "týždňami": "W",
       "týždňom": "W"
@@ -3135,14 +3160,19 @@
       "mesecem": "M",
       "mesecema": "M",
       "meseci": "M",
+      "minut": "m",
       "minuta": "m",
       "minutama": "m",
       "minutami": "m",
+      "minute": "m",
+      "minuti": "m",
       "minuto": "m",
       "sekund": "s",
       "sekunda": "s",
       "sekundama": "s",
       "sekundami": "s",
+      "sekunde": "s",
+      "sekundi": "s",
       "sekundo": "s",
       "tedni": "W",
       "tednom": "W",
@@ -3443,6 +3473,7 @@
       "நாட்களுக்கு": "D",
       "நாளுக்கு": "D",
       "நிமிடங்களுக்கு": "m",
+      "நிமிடங்கள்": "m",
       "நிமிடத்திற்கு": "m",
       "நிமிடம்": "m",
       "மணிநேரம்": "h",
@@ -3498,6 +3529,7 @@
       "గంటల": "h",
       "నిమిషం": "m",
       "నిమిషాల": "m",
+      "నిమిషాలు": "m",
       "నెల": "M",
       "నెలల": "M",
       "రోజు": "D",
@@ -3665,11 +3697,13 @@
       "років": "Y",
       "рік": "Y",
       "секунд": "s",
+      "секунда": "s",
       "секунди": "s",
       "секунду": "s",
       "тиждень": "W",
       "тижні": "W",
       "хвилин": "m",
+      "хвилина": "m",
       "хвилини": "m",
       "хвилину": "m"
     },
@@ -3719,6 +3753,7 @@
       "سیکنڈ": "s",
       "سیکنڈز": "s",
       "منٹ": "m",
+      "منٹ،": "m",
       "منٹس": "m",
       "مہینہ": "M",
       "مہینے": "M",