cry-search 2.0.3 → 2.1.0

package/dist/vet/index.js

@@ -0,0 +1,2426 @@
+// src/vet/data/enote.ts
+var ENOTE_SINONIMI = {
+  tab: "tbl",
+  tabs: "tbl",
+  tabl: "tbl",
+  tablet: "tbl",
+  tableta: "tbl",
+  tablete: "tbl",
+  tabletka: "tbl",
+  tabletke: "tbl",
+  kaps: "kps",
+  kapsula: "kps",
+  kapsule: "kps",
+  kps: "kps",
+  cap: "kps",
+  caps: "kps",
+  amp: "amp",
+  ampula: "amp",
+  ampule: "amp",
+  ampul: "amp",
+  inj: "inj",
+  inekcija: "inj",
+  gram: "g",
+  grami: "g",
+  kilogram: "kg",
+  kilogrami: "kg",
+  miligram: "mg",
+  mikrogram: "mcg",
+  mililiter: "ml",
+  mililitri: "ml",
+  deciliter: "dl",
+  liter: "l",
+  litri: "l",
+  iu: "ie",
+  kos: "kos",
+  kosa: "kos",
+  kosi: "kos",
+  kom: "kos",
+  komad: "kos",
+  komadi: "kos",
+  vrecka: "vrecka",
+  vrecke: "vrecke",
+  vrecica: "vrecka",
+  vrecice: "vrecke",
+  tuba: "tuba",
+  tube: "tuba",
+  steklenicka: "steklenicka",
+  steklenicke: "steklenicke",
+  steklenicka1: "steklenicka",
+  zlicka: "zlicka",
+  zlicke: "zlicke",
+  plocevinka: "plocevinka",
+  plocevinke: "plocevinke",
+  konzerva: "konzerva",
+  konzerve: "konzerve",
+  vial: "viala",
+  viala: "viala",
+  vile: "viala",
+  pasta: "pasta",
+  gel: "gel",
+  mazilo: "mazilo",
+  sprej: "sprej",
+  prasilo: "prasilo",
+  prasek: "prasek",
+  sirup: "sirup",
+  raztopina: "raztopina",
+  suspenzija: "suspenzija",
+  kapsula1: "kps"
+};
+var ENOTE_SESTAVLJENE = {
+  m: "ml",
+  gr: "g",
+  grm: "g",
+  ml: "ml",
+  l: "l",
+  g: "g",
+  kg: "kg",
+  tbl: "tbl",
+  tab: "tbl",
+  kps: "kps",
+  amp: "amp",
+  kos: "kos",
+  kom: "kos"
+};
+var VELIKOSTI_SINONIMI = {
+  s: "s",
+  m: "m",
+  l: "l",
+  xl: "xl",
+  xxl: "xxl",
+  xs: "xs",
+  xxs: "xxs",
+  majhen: "s",
+  majhna: "s",
+  mala: "s",
+  mali: "s",
+  male: "s",
+  srednji: "m",
+  srednja: "m",
+  srednje: "m",
+  velik: "l",
+  velika: "l",
+  velike: "l",
+  veliki: "l"
+};
+var VRSTE_SINONIMI = {
+  pes: "pes",
+  pse: "pes",
+  psi: "pes",
+  psa: "pes",
+  psov: "pes",
+  psu: "pes",
+  psicka: "pes",
+  psice: "pes",
+  pesjan: "pes",
+  dog: "pes",
+  dogs: "pes",
+  puppy: "pes",
+  macka: "macka",
+  macke: "macka",
+  macki: "macka",
+  macko: "macka",
+  macek: "macka",
+  macki2: "macka",
+  macji: "macka",
+  macje: "macka",
+  cat: "macka",
+  cats: "macka",
+  kitten: "macka"
+};
+var VRSTE_NORMALIZACIJA = {};
+function kljucVrste(beseda) {
+  return beseda.toLowerCase().normalize("NFD").replace(/[\u0300-\u036f]/g, "").trim();
+}
+function dodajVrsto(imenovalnik, oblike) {
+  VRSTE_NORMALIZACIJA[kljucVrste(imenovalnik)] = imenovalnik;
+  for (const oblika of oblike)
+    VRSTE_NORMALIZACIJA[kljucVrste(oblika)] = imenovalnik;
+}
+dodajVrsto("kokoš", ["kokos", "kokosi", "kokosjo", "kokosji"]);
+dodajVrsto("petelin", ["petelina", "petelini", "petelinov"]);
+dodajVrsto("piščanec", ["piscanec", "piščanca", "piscanca", "piščanci", "piscanci", "piščancev", "piscancev"]);
+dodajVrsto("puran", ["purana", "purani", "puranov"]);
+dodajVrsto("gos", ["gosi", "goske", "gosk", "gosak", "gosaka", "gosaki"]);
+dodajVrsto("raca", ["race", "raco", "raci", "rac", "raček", "racek", "račke", "racke"]);
+dodajVrsto("prepelica", ["prepelice", "prepelico", "prepelic", "prepeličke"]);
+dodajVrsto("fazan", ["fazana", "fazani", "fazanov"]);
+dodajVrsto("jerebica", ["jerebice", "jerebic"]);
+dodajVrsto("papiga", ["papige", "papig", "papagaj", "papagaja", "papagaji"]);
+dodajVrsto("kanarček", ["kanarcek", "kanarčka", "kanarcka", "kanarčki", "kanarcki", "kanarčkov"]);
+dodajVrsto("ptica", ["ptice", "ptic", "ptič", "ptiči"]);
+dodajVrsto("perutnina", ["perutnine", "perutnini", "perutnino"]);
+dodajVrsto("govedo", ["goveda", "govedu", "govedom", "govedi"]);
+dodajVrsto("krava", ["krave", "kravi", "kravo", "krav", "kravica", "kravice"]);
+dodajVrsto("tele", ["teleta", "teletu", "teletom", "teleti", "telet"]);
+dodajVrsto("bik", ["bika", "biku", "biki", "bikov", "bikca", "bikci"]);
+dodajVrsto("vol", ["vola", "volu", "voli", "volov"]);
+dodajVrsto("ovca", ["ovce", "ovci", "ovco", "ovac", "jagnje", "jagnjeta", "jagnjet", "jagnjič"]);
+dodajVrsto("oven", ["ovna", "ovni", "ovnov"]);
+dodajVrsto("koza", ["koze", "kozi", "kozo", "koz", "kozel", "kozla", "kozli", "kozlov"]);
+dodajVrsto("prašič", ["prasic", "prašiča", "prasica", "prašiči", "prasici", "prašičev", "prasicev", "pujs", "pujsa", "pujsi", "pujskov"]);
+dodajVrsto("pujsek", ["pujska", "pujski", "pujskov"]);
+dodajVrsto("konj", ["konja", "konju", "konji", "konjev", "konjič", "konjiča", "konjički"]);
+dodajVrsto("kobila", ["kobile", "kobili", "kobil"]);
+dodajVrsto("žrebec", ["zrebec", "žrebca", "zrebca", "žrebci", "zrebci", "žrebcev"]);
+dodajVrsto("osel", ["osla", "osli", "oslov", "osliček", "oslicka"]);
+dodajVrsto("kunec", ["kunca", "kuncu", "kunci", "kuncev", "kunčji", "kunce"]);
+dodajVrsto("zajec", ["zajca", "zajcu", "zajci", "zajcev", "zajčji", "zajcke"]);
+dodajVrsto("hrček", ["hrcek", "hrčka", "hrcka", "hrčki", "hrcki", "hrčkov"]);
+dodajVrsto("glodalec", ["glodalca", "glodalci", "glodalcev", "glodavci", "glodavca"]);
+dodajVrsto("prašiček", ["prasicek", "prašička", "prasicka", "prašički", "prasicki", "prašičkov", "prasickov"]);
+dodajVrsto("riba", ["ribe", "ribi", "ribo", "rib", "ribice", "ribic"]);
+dodajVrsto("želva", ["zelve", "želve", "želvi", "zelvi", "želv", "zelv"]);
+dodajVrsto("kača", ["kaca", "kače", "kace", "kači", "kaci", "kač", "kac"]);
+dodajVrsto("kuščar", ["kuscar", "kuščarja", "kuscarja", "kuščarji", "kuscarji", "kuščarjev"]);
+dodajVrsto("jelen", ["jelena", "jeleni", "jelenov", "jelenjad"]);
+dodajVrsto("srna", ["srne", "srni", "srn", "srnjak", "srnjaka", "srnjaki"]);
+dodajVrsto("divjad", ["divjadi", "divjadjo"]);
+
+// src/vet/data/znamke.gen.ts
+var ZNAMKE_GEN = {
+  vir: "/Users/primozk/devmt/panthenImport",
+  okrajsave: [
+    {
+      okrajsava: "RC",
+      znamka: "Royal Canin",
+      zaupanje: "potrjeno",
+      pojavitve: 4444
+    },
+    {
+      okrajsava: "ROYAL",
+      znamka: "Royal Canin",
+      zaupanje: "verjetno",
+      pojavitve: 933
+    },
+    {
+      okrajsava: "ALSA",
+      znamka: "Alsa Nature",
+      zaupanje: "verjetno",
+      pojavitve: 613
+    },
+    {
+      okrajsava: "AC",
+      znamka: "A-Cerumen",
+      zaupanje: "verjetno",
+      pojavitve: 600
+    },
+    {
+      okrajsava: "ROY",
+      znamka: "Royal Canin",
+      zaupanje: "potrjeno",
+      pojavitve: 596
+    },
+    {
+      okrajsava: "GB",
+      znamka: "Gebr De Boon",
+      zaupanje: "verjetno",
+      pojavitve: 490
+    },
+    {
+      okrajsava: "F4D",
+      znamka: "Fish4Dogs",
+      zaupanje: "potrjeno",
+      pojavitve: 442
+    },
+    {
+      okrajsava: "PET",
+      znamka: "Pet Secret",
+      zaupanje: "verjetno",
+      pojavitve: 346
+    },
+    {
+      okrajsava: "TOW",
+      znamka: "Taste of the Wild",
+      zaupanje: "potrjeno",
+      pojavitve: 339
+    },
+    {
+      okrajsava: "NM",
+      znamka: "Natures Menu",
+      zaupanje: "verjetno",
+      pojavitve: 317
+    },
+    {
+      okrajsava: "M&M",
+      znamka: "Markus Muhle",
+      zaupanje: "verjetno",
+      pojavitve: 306
+    },
+    {
+      okrajsava: "ND",
+      znamka: "Natural & Delicious",
+      zaupanje: "verjetno",
+      pojavitve: 263
+    },
+    {
+      okrajsava: "VL",
+      znamka: "Versele-Laga",
+      zaupanje: "potrjeno",
+      pojavitve: 260
+    },
+    {
+      okrajsava: "FE",
+      znamka: "Fruit of the Earth",
+      zaupanje: "verjetno",
+      pojavitve: 244
+    },
+    {
+      okrajsava: "BUDDY",
+      znamka: "Buddy Pet Foods",
+      zaupanje: "verjetno",
+      pojavitve: 244
+    },
+    {
+      okrajsava: "ALPHA",
+      znamka: "Alpha Spirit",
+      zaupanje: "verjetno",
+      pojavitve: 230
+    },
+    {
+      okrajsava: "ET",
+      znamka: "Exo Terra",
+      zaupanje: "potrjeno",
+      pojavitve: 217
+    },
+    {
+      okrajsava: "CA",
+      znamka: "Company Of Animals",
+      zaupanje: "verjetno",
+      pojavitve: 198
+    },
+    {
+      okrajsava: "SP",
+      znamka: "Super Pet",
+      zaupanje: "verjetno",
+      pojavitve: 189
+    },
+    {
+      okrajsava: "PLAQUE",
+      znamka: "PlaqueOff",
+      zaupanje: "verjetno",
+      pojavitve: 182
+    },
+    {
+      okrajsava: "BH",
+      znamka: "Barking Heads",
+      zaupanje: "verjetno",
+      pojavitve: 156
+    },
+    {
+      okrajsava: "PP",
+      znamka: "Pramy Prama",
+      zaupanje: "verjetno",
+      pojavitve: 117
+    },
+    {
+      okrajsava: "MH",
+      znamka: "Meowing Heads",
+      zaupanje: "verjetno",
+      pojavitve: 105
+    },
+    {
+      okrajsava: "AG",
+      znamka: "Arden Grange",
+      zaupanje: "potrjeno",
+      pojavitve: 98
+    },
+    {
+      okrajsava: "MP",
+      znamka: "Matis Pet",
+      zaupanje: "verjetno",
+      pojavitve: 97
+    },
+    {
+      okrajsava: "TF3",
+      znamka: "Trainer Fitness 3",
+      zaupanje: "verjetno",
+      pojavitve: 96
+    },
+    {
+      okrajsava: "SY",
+      znamka: "Sustainbly Yours",
+      zaupanje: "verjetno",
+      pojavitve: 81
+    },
+    {
+      okrajsava: "WP",
+      znamka: "Wörwag Pharma",
+      zaupanje: "verjetno",
+      pojavitve: 80
+    },
+    {
+      okrajsava: "NL",
+      znamka: "Nature Land",
+      zaupanje: "verjetno",
+      pojavitve: 77
+    },
+    {
+      okrajsava: "EC",
+      znamka: "Ever Clean",
+      zaupanje: "potrjeno",
+      pojavitve: 76
+    },
+    {
+      okrajsava: "TC",
+      znamka: "Tender Corporation",
+      zaupanje: "verjetno",
+      pojavitve: 75
+    },
+    {
+      okrajsava: "SEA",
+      znamka: "Sea Band",
+      zaupanje: "verjetno",
+      pojavitve: 69
+    },
+    {
+      okrajsava: "FD",
+      znamka: "Funky Dog",
+      zaupanje: "verjetno",
+      pojavitve: 68
+    },
+    {
+      okrajsava: "FP",
+      znamka: "Focus Pharmaceuticals",
+      zaupanje: "verjetno",
+      pojavitve: 66
+    },
+    {
+      okrajsava: "MULTI",
+      znamka: "Multi-Gyn",
+      zaupanje: "verjetno",
+      pojavitve: 63
+    },
+    {
+      okrajsava: "PASJA",
+      znamka: "Pasja Pekarna PIKA",
+      zaupanje: "verjetno",
+      pojavitve: 60
+    },
+    {
+      okrajsava: "VITA",
+      znamka: "Vita Care Plus",
+      zaupanje: "verjetno",
+      pojavitve: 58
+    },
+    {
+      okrajsava: "ON",
+      znamka: "Oropharma Nv",
+      zaupanje: "verjetno",
+      pojavitve: 56
+    },
+    {
+      okrajsava: "AD",
+      znamka: "A-Derma",
+      zaupanje: "verjetno",
+      pojavitve: 55
+    },
+    {
+      okrajsava: "BOB",
+      znamka: "Bags On Board",
+      zaupanje: "potrjeno",
+      pojavitve: 53
+    },
+    {
+      okrajsava: "LILY",
+      znamka: "Lily's Kitchen",
+      zaupanje: "verjetno",
+      pojavitve: 52
+    },
+    {
+      okrajsava: "JP",
+      znamka: "JW Pet",
+      zaupanje: "verjetno",
+      pojavitve: 51
+    },
+    {
+      okrajsava: "AS",
+      znamka: "Alpha Spirit",
+      zaupanje: "potrjeno",
+      pojavitve: 44
+    },
+    {
+      okrajsava: "SNACK",
+      znamka: "Snackers",
+      zaupanje: "verjetno",
+      pojavitve: 36
+    },
+    {
+      okrajsava: "LILY&",
+      znamka: "Lily's Kitchen",
+      zaupanje: "verjetno",
+      pojavitve: 34
+    },
+    {
+      okrajsava: "OMEGA",
+      znamka: "Omega Pharma",
+      zaupanje: "verjetno",
+      pojavitve: 31
+    },
+    {
+      okrajsava: "LAB",
+      znamka: "Lab. ASEPTA",
+      zaupanje: "verjetno",
+      pojavitve: 29
+    },
+    {
+      okrajsava: "LK",
+      znamka: "Lily's Kitchen",
+      zaupanje: "potrjeno",
+      pojavitve: 27
+    },
+    {
+      okrajsava: "SMART",
+      znamka: "Smart Pet",
+      zaupanje: "verjetno",
+      pojavitve: 26
+    },
+    {
+      okrajsava: "HAGEN",
+      znamka: "Hagen Living World",
+      zaupanje: "verjetno",
+      pojavitve: 24
+    },
+    {
+      okrajsava: "SORIA",
+      znamka: "Soria Natural",
+      zaupanje: "verjetno",
+      pojavitve: 21
+    },
+    {
+      okrajsava: "ENTERO",
+      znamka: "Enterozoo",
+      zaupanje: "verjetno",
+      pojavitve: 19
+    },
+    {
+      okrajsava: "SS",
+      znamka: "Simple Solution",
+      zaupanje: "verjetno",
+      pojavitve: 17
+    },
+    {
+      okrajsava: "KASPER",
+      znamka: "Kasper Arie Blok",
+      zaupanje: "verjetno",
+      pojavitve: 17
+    },
+    {
+      okrajsava: "WOOF",
+      znamka: "Woof znamka",
+      zaupanje: "verjetno",
+      pojavitve: 16
+    },
+    {
+      okrajsava: "WOOFF",
+      znamka: "Woof znamka",
+      zaupanje: "verjetno",
+      pojavitve: 15
+    },
+    {
+      okrajsava: "WATER",
+      znamka: "Water-Jel",
+      zaupanje: "verjetno",
+      pojavitve: 14
+    },
+    {
+      okrajsava: "DINGO",
+      znamka: "Red Dingo",
+      zaupanje: "potrjeno",
+      pojavitve: 12
+    },
+    {
+      okrajsava: "SPARKY",
+      znamka: "SPARK PAW",
+      zaupanje: "verjetno",
+      pojavitve: 10
+    },
+    {
+      okrajsava: "HILL&",
+      znamka: "Hill's",
+      zaupanje: "verjetno",
+      pojavitve: 9
+    },
+    {
+      okrajsava: "MARKUS",
+      znamka: "Markus Muhle",
+      zaupanje: "verjetno",
+      pojavitve: 9
+    },
+    {
+      okrajsava: "BEST",
+      znamka: "Vet's Best",
+      zaupanje: "potrjeno",
+      pojavitve: 7
+    },
+    {
+      okrajsava: "VIGOR",
+      znamka: "Vigor & Sage",
+      zaupanje: "verjetno",
+      pojavitve: 7
+    },
+    {
+      okrajsava: "POOCH",
+      znamka: "Pooch&Mutt",
+      zaupanje: "verjetno",
+      pojavitve: 7
+    },
+    {
+      okrajsava: "BOIL",
+      znamka: "Boil & Broth",
+      zaupanje: "verjetno",
+      pojavitve: 5
+    },
+    {
+      okrajsava: "INTERS",
+      znamka: "Intersand",
+      zaupanje: "verjetno",
+      pojavitve: 5
+    },
+    {
+      okrajsava: "BIOD",
+      znamka: "Bioderma",
+      zaupanje: "verjetno",
+      pojavitve: 5
+    },
+    {
+      okrajsava: "WILDES",
+      znamka: "Wild & Seed",
+      zaupanje: "verjetno",
+      pojavitve: 4
+    },
+    {
+      okrajsava: "KIWI",
+      znamka: "Kiwi Walker",
+      zaupanje: "verjetno",
+      pojavitve: 4
+    },
+    {
+      okrajsava: "TENDER",
+      znamka: "Tender Corporation",
+      zaupanje: "verjetno",
+      pojavitve: 3
+    },
+    {
+      okrajsava: "CANIN",
+      znamka: "Caninsulin",
+      zaupanje: "potrjeno",
+      pojavitve: 1
+    },
+    {
+      okrajsava: "N&D",
+      znamka: "Natural & Delicious",
+      zaupanje: "splet",
+      pojavitve: 0
+    },
+    {
+      okrajsava: "FERIBELLA",
+      znamka: "Ferribella",
+      zaupanje: "potrjeno",
+      pojavitve: 0
+    },
+    {
+      okrajsava: "AFP",
+      znamka: "All For Paws",
+      zaupanje: "splet",
+      pojavitve: 0
+    },
+    {
+      okrajsava: "EBI",
+      znamka: "Ear Band-it",
+      zaupanje: "splet",
+      pojavitve: 0
+    },
+    {
+      okrajsava: "FISH4DOGS",
+      znamka: "Fish4Dogs",
+      zaupanje: "potrjeno",
+      pojavitve: 0
+    }
+  ],
+  znamke: [
+    "NexGard",
+    "Bravecto",
+    "Simparica",
+    "Credelio",
+    "Stronghold",
+    "Milprazon",
+    "Caninsulin",
+    "ForteKor",
+    "Flexadin",
+    "Zylkene",
+    "Caniverm",
+    "Meloxidyl",
+    "Medrol",
+    "Dermoguard",
+    "Specific",
+    "Clorexyderm",
+    "Amoksiklav",
+    "Surgicryl",
+    "Ferribella",
+    "Gosbi",
+    "Karlie",
+    "Daytona",
+    "Cunipic",
+    "Red Dingo",
+    "Vet's Best",
+    "Taste of the Wild",
+    "Fish4Dogs",
+    "Royal Canin"
+  ],
+  linije: [
+    {
+      linija: "SHN",
+      znamka: "Royal Canin",
+      vir: "proizvajalec",
+      opomba: "Size Health Nutrition"
+    },
+    {
+      linija: "SHB",
+      znamka: "Royal Canin",
+      vir: "proizvajalec",
+      opomba: "pasemska linija"
+    },
+    {
+      linija: "FHN",
+      znamka: "Royal Canin",
+      vir: "proizvajalec",
+      opomba: "Feline Health Nutrition"
+    },
+    {
+      linija: "FCN",
+      znamka: "Royal Canin",
+      vir: "proizvajalec",
+      opomba: "Feline Care Nutrition"
+    },
+    {
+      linija: "VDF",
+      znamka: "Royal Canin",
+      vir: "proizvajalec",
+      opomba: "Veterinary Diet Feline"
+    },
+    {
+      linija: "VD",
+      znamka: "Royal Canin",
+      vir: "proizvajalec",
+      opomba: "Veterinary Diet"
+    },
+    {
+      linija: "URINARY",
+      znamka: "Royal Canin",
+      vir: "proizvajalec",
+      opomba: "tudi Hills ima linijo Urinary"
+    },
+    {
+      linija: "RENAL",
+      znamka: "Royal Canin",
+      vir: "proizvajalec",
+      opomba: "tudi Hills ima linijo Renal"
+    },
+    {
+      linija: "SATIETY",
+      znamka: "Royal Canin",
+      vir: "proizvajalec"
+    },
+    {
+      linija: "GASTROINTESTINAL",
+      znamka: "Royal Canin",
+      vir: "proizvajalec"
+    },
+    {
+      linija: "FEL",
+      znamka: "Hills",
+      vir: "proizvajalec",
+      opomba: "Feline"
+    },
+    {
+      linija: "CANINE",
+      znamka: "Hills",
+      vir: "proizvajalec",
+      opomba: "Canine"
+    },
+    {
+      linija: "FELINE",
+      znamka: "Hills",
+      vir: "proizvajalec",
+      opomba: "Feline"
+    },
+    {
+      linija: "VETLIFE",
+      znamka: "Vet Life",
+      vir: "katalog",
+      opomba: "stisnjen zapis imena"
+    }
+  ],
+  dobavitelji: [
+    {
+      zeton: "KRKA",
+      vir: "rocno"
+    },
+    {
+      zeton: "MELISA",
+      vir: "klasifikacija"
+    },
+    {
+      zeton: "VETPROMET",
+      vir: "klasifikacija"
+    },
+    {
+      zeton: "IRIS",
+      vir: "klasifikacija"
+    },
+    {
+      zeton: "PANAKEA",
+      vir: "klasifikacija"
+    },
+    {
+      zeton: "ANIMALIS",
+      vir: "klasifikacija"
+    },
+    {
+      zeton: "SALUS",
+      vir: "rocno"
+    },
+    {
+      zeton: "KRU",
+      vir: "rocno"
+    }
+  ],
+  oznake: [
+    {
+      oznaka: "IPV",
+      pomen: "izjemna uporaba v veterinarstvu"
+    },
+    {
+      oznaka: "IPH",
+      pomen: "izjemna poraba humanega zdravila"
+    }
+  ],
+  tipskeOznake: [
+    "IGR",
+    "OVR",
+    "PRIB",
+    "OPR",
+    "POV",
+    "POS",
+    "LEZISCE",
+    "A",
+    "TR",
+    "NP",
+    "NAGOBCNIK",
+    "KRTACA",
+    "PRASKALNIK",
+    "OVRATNICA",
+    "IGRACA",
+    "PLASC",
+    "PULOVER",
+    "PLASCEK",
+    "VK",
+    "WC",
+    "AKV",
+    "POSODA",
+    "PRO",
+    "OVRATNIK",
+    "BLAZINA",
+    "POVODEC",
+    "GLAVNIK",
+    "PESEK",
+    "DEZNI",
+    "VACC",
+    "TRANSPORTER",
+    "OPR+POV",
+    "DN",
+    "VRECKE",
+    "SAMPON",
+    "IGLA",
+    "KLETKA",
+    "HLADILNA",
+    "NAPAJALNIK",
+    "RN",
+    "TORBICA",
+    "BRIZGA",
+    "T",
+    "ROKAVICE",
+    "KANILA",
+    "M",
+    "PODLOGA",
+    "SKARJE",
+    "OPRSNICA",
+    "TUBUS",
+    "RD",
+    "DDD",
+    "SF",
+    "DOG",
+    "POVOJ",
+    "IPTS",
+    "TORBA",
+    "OBLEKA",
+    "ZASCITNI",
+    "S",
+    "KLESCE",
+    "NOSILEC",
+    "VRECKA",
+    "PLENICNE",
+    "CAT",
+    "HISICA",
+    "KOMPRESA",
+    "SENO",
+    "ZOGA",
+    "OBESEK",
+    "KOST",
+    "FILTER",
+    "VATA",
+    "TERMOMETER",
+    "GIMPET",
+    "HLACKE",
+    "POTOVALNA",
+    "VITAMIN",
+    "PLENICE",
+    "CAM",
+    "KATETER",
+    "MACJA",
+    "KRMILNIK",
+    "POSTELJA",
+    "ZARNICA",
+    "ZASCITNA",
+    "SPREJ",
+    "C",
+    "GNEZDO",
+    "KOV",
+    "KAMEN",
+    "SET",
+    "MACJI",
+    "KOVINSKA"
+  ]
+};
+
+// src/vet/normalizatorji.ts
+var decimalkeNormalizator = {
+  fn: (v) => {
+    const popravljeno = v.replace(/(\d)\s*,\s*(\d)/g, "$1.$2");
+    return popravljeno === v ? undefined : popravljeno;
+  }
+};
+var enoteNormalizator = {
+  fn: (v) => {
+    let spremenjeno = false;
+    const razbito = v.replace(/(\d+(?:\.\d+)?)([\p{L}]{1,4})(?![\p{L}\p{N}])/gu, (ujemanje, stevilo, crke) => {
+      if (!(ENOTE_SESTAVLJENE[kljucBesede(crke)] ?? ENOTE_SINONIMI[kljucBesede(crke)]))
+        return ujemanje;
+      spremenjeno = true;
+      return `${stevilo} ${crke}`;
+    });
+    const izhod = razbito.replace(BESEDA, (ujemanje) => {
+      const kanonicna = ENOTE_SINONIMI[kljucBesede(ujemanje)] ?? ENOTE_SESTAVLJENE[kljucBesede(ujemanje)];
+      if (!kanonicna)
+        return ujemanje;
+      spremenjeno = true;
+      return kanonicaVelika(kanonicna);
+    });
+    return spremenjeno ? izhod : undefined;
+  }
+};
+function kljucBesede(beseda) {
+  return beseda.toLowerCase().normalize("NFD").replace(/[\u0300-\u036f]/g, "").replace(/[^a-z0-9]+$/, "");
+}
+var BESEDA = /(?<![\p{L}\p{N}])([\p{L}\p{N}]+)(?![\p{L}\p{N}])/gu;
+function kanonicaVelika(enota) {
+  return enota.toUpperCase();
+}
+var KOLICINA_Z_ENOTO = /(\d+(?:\.\d+)?)\s*(ml|dl|l|g|mg|mcg|kg|ie|tbl|kps|amp|inj|kos|kom|vrecka|vrecke|tuba|steklenicka|zlicka|plocevinka|konzerva|viala)\b/gi;
+var RAZPON = /(\d+(?:\.\d+)?)\s*(kg)?\s*[-\u2013]\s*(\d+(?:\.\d+)?)\s*(kg)?/i;
+var PAKIRANJE = /(\d+)\s*(?:x\s*)?(tbl|kps|amp|kos|kom|vrecka|vrecke|konzerva)\b/gi;
+var RAZMERJE_PAKIRANJA = /(\d{1,3})\s*\/\s*(\d{1,3})\b/g;
+var kolicinaNormalizator = {
+  fn: (v) => {
+    const razredi = {};
+    let besedilo = v;
+    const razpon = RAZPON.exec(besedilo);
+    if (razpon && razpon[1] && razpon[3]) {
+      razredi["razpon"] = `${razpon[1]}-${razpon[3]}`;
+      const enotaRazpona = razpon[2] ?? razpon[4] ?? "";
+      besedilo = besedilo.replace(razpon[0], enotaRazpona ? ` ${enotaRazpona.toUpperCase()} ` : " ");
+    }
+    besedilo = besedilo.replace(KOLICINA_Z_ENOTO, (_ujemanje, stevilo, enota) => {
+      const kljuc = razredi["kolicina"] === undefined ? "kolicina" : "pakiranje";
+      const vrednost = `${stevilo} ${enota.toUpperCase()}`;
+      const obstojece = razredi[kljuc];
+      if (obstojece === undefined)
+        razredi[kljuc] = vrednost;
+      else if (Array.isArray(obstojece))
+        obstojece.push(vrednost);
+      else
+        razredi[kljuc] = [obstojece, vrednost];
+      return ` ${enota.toUpperCase()} `;
+    });
+    besedilo = besedilo.replace(RAZMERJE_PAKIRANJA, (_ujemanje, a, b) => {
+      const vrednost = `${a}/${b}`;
+      const obstojece = razredi["pakiranje"];
+      if (obstojece === undefined)
+        razredi["pakiranje"] = vrednost;
+      else if (Array.isArray(obstojece))
+        obstojece.push(vrednost);
+      else
+        razredi["pakiranje"] = [obstojece, vrednost];
+      return " ";
+    });
+    {
+      besedilo = besedilo.replace(PAKIRANJE, (_ujemanje, stevilo, enota) => {
+        const vrednost = `${stevilo} ${enota.toUpperCase()}`;
+        const obstojece = razredi["pakiranje"];
+        if (obstojece === undefined)
+          razredi["pakiranje"] = vrednost;
+        else if (Array.isArray(obstojece))
+          obstojece.push(vrednost);
+        else
+          razredi["pakiranje"] = [obstojece, vrednost];
+        return ` ${enota.toUpperCase()} `;
+      });
+    }
+    if (!Object.keys(razredi).length)
+      return;
+    return { text: besedilo.replace(/\s+/g, " ").trim(), classes: razredi };
+  }
+};
+var vrstaNormalizator = {
+  fn: (v) => {
+    const najdene = [];
+    let spremenjeno = false;
+    const izhod = v.replace(BESEDA, (ujemanje) => {
+      const kljuc = kljucBesede(ujemanje);
+      const vrsta = VRSTE_SINONIMI[kljuc];
+      if (vrsta) {
+        if (!VRSTE_ZA_RAZRED.has(vrsta))
+          return ujemanje;
+        if (!najdene.includes(vrsta))
+          najdene.push(vrsta);
+        return " ";
+      }
+      const lemma = VRSTE_NORMALIZACIJA[kljuc];
+      if (lemma) {
+        spremenjeno = true;
+        return lemma.toUpperCase();
+      }
+      return ujemanje;
+    });
+    if (!najdene.length && !spremenjeno)
+      return;
+    const ocisceno = izhod.replace(/\s+/g, " ").trim();
+    return najdene.length ? { text: ocisceno, classes: { vrsta: najdene } } : ocisceno;
+  }
+};
+var TIPSKE_OZNAKE = new Set(ZNAMKE_GEN.tipskeOznake.map(kljucBesede).filter((t) => t.length >= 2));
+var VRSTE_ZA_RAZRED = new Set(["pes", "macka"]);
+var OKRAJSAVE_ZNAMK = new Map;
+var LINIJE_ZNAMK = new Map;
+for (const zapis of ZNAMKE_GEN.okrajsave) {
+  const kljuc = zapis.okrajsava.toLowerCase();
+  if (zapis.zaupanje === "splet")
+    continue;
+  if (!OKRAJSAVE_ZNAMK.has(kljuc))
+    OKRAJSAVE_ZNAMK.set(kljuc, zapis.znamka);
+}
+for (const linija of ZNAMKE_GEN.linije) {
+  const kljuc = linija.linija.toLowerCase();
+  if (!LINIJE_ZNAMK.has(kljuc))
+    LINIJE_ZNAMK.set(kljuc, linija.znamka);
+}
+var znamkaNormalizator = {
+  fn: (v) => {
+    let spremenjeno = false;
+    const izhod = v.replace(/(?<![\p{L}\p{N}])([\p{L}\p{N}&]+)(?![\p{L}\p{N}])/gu, (ujemanje) => {
+      const kljuc = kljucBesede(ujemanje);
+      const znamka = OKRAJSAVE_ZNAMK.get(kljuc);
+      if (znamka) {
+        const besedeCilja = znamka.toLowerCase().split(/[^\p{L}\p{N}]+/u).filter(Boolean);
+        if (besedeCilja.includes(kljuc))
+          return ujemanje;
+        spremenjeno = true;
+        return znamka.toLowerCase() === znamka ? znamka.toUpperCase() : znamka;
+      }
+      const linija = LINIJE_ZNAMK.get(kljuc);
+      if (linija) {
+        spremenjeno = true;
+        return `${linija.toUpperCase()} ${ujemanje.toUpperCase()}`;
+      }
+      return ujemanje;
+    });
+    return spremenjeno ? izhod : undefined;
+  }
+};
+var DOBAVITELJI = new Set(ZNAMKE_GEN.dobavitelji.map((d) => kljucBesede(d.zeton)));
+var OZNAKE = new Set(ZNAMKE_GEN.oznake.map((o) => kljucBesede(o.oznaka)));
+var oznakeNormalizator = {
+  fn: (v) => {
+    const razredi = {};
+    const izhod = v.replace(BESEDA, (ujemanje) => {
+      const kljuc = kljucBesede(ujemanje);
+      if (OZNAKE.has(kljuc)) {
+        razredi["oznaka"] = [...Array.isArray(razredi["oznaka"]) ? razredi["oznaka"] : razredi["oznaka"] ? [razredi["oznaka"]] : [], ujemanje.toUpperCase()];
+        return " ";
+      }
+      if (DOBAVITELJI.has(kljuc)) {
+        razredi["dobavitelj"] = [...Array.isArray(razredi["dobavitelj"]) ? razredi["dobavitelj"] : razredi["dobavitelj"] ? [razredi["dobavitelj"]] : [], ujemanje.toUpperCase()];
+        return " ";
+      }
+      return ujemanje;
+    });
+    if (!Object.keys(razredi).length)
+      return;
+    return { text: izhod.replace(/\s+/g, " ").trim(), classes: razredi };
+  }
+};
+var velikostNormalizator = {
+  fn: (v) => {
+    const najdene = [];
+    const izhod = v.replace(BESEDA, (ujemanje, ...args) => {
+      const kljuc = kljucBesede(ujemanje);
+      const velikost = VELIKOSTI_SINONIMI[kljuc];
+      if (!velikost)
+        return ujemanje;
+      const mesto = args[args.length - 2];
+      const prej = v.slice(0, mesto).trimEnd();
+      if (velikost.length <= 1 && /\d$/.test(prej))
+        return ujemanje;
+      if (!najdene.includes(velikost))
+        najdene.push(velikost);
+      return " ";
+    });
+    if (!najdene.length)
+      return;
+    return { text: izhod.replace(/\s+/g, " ").trim(), classes: { velikost: najdene } };
+  }
+};
+var pantheonOznakaNormalizator = {
+  fn: (v) => {
+    const ujemanje = /^\s*(\*{1,3})\s*/.exec(v);
+    if (!ujemanje)
+      return;
+    const zvezdice = ujemanje[1];
+    return {
+      text: v.slice(ujemanje[0].length),
+      classes: { pantheon: [zvezdice.length >= 2 ? "neaktivno" : "prosto"] }
+    };
+  }
+};
+var kodiranjeNormalizator = {
+  fn: (v) => {
+    const ocisceno = v.replace(/_x00[0-9a-fA-F]{2}_?/g, "").replace(/\s+/g, " ").trim();
+    return ocisceno === v ? undefined : ocisceno;
+  }
+};
+var tipskeOznakeNormalizator = {
+  fn: (v) => {
+    const najdene = [];
+    const izhod = v.replace(/(?<![\p{L}\p{N}])([\p{L}]+)(?![\p{L}\p{N}])/gu, (ujemanje) => {
+      const kljuc = kljucBesede(ujemanje);
+      if (kljuc.length < 2 || !TIPSKE_OZNAKE.has(kljuc))
+        return ujemanje;
+      if (!najdene.includes(ujemanje.toUpperCase()))
+        najdene.push(ujemanje.toUpperCase());
+      return " ";
+    });
+    if (!najdene.length)
+      return;
+    return { text: izhod.replace(/\s+/g, " ").trim(), classes: { tip: najdene } };
+  }
+};
+var VET_NORMALIZATORJI = [
+  kodiranjeNormalizator,
+  decimalkeNormalizator,
+  pantheonOznakaNormalizator,
+  tipskeOznakeNormalizator,
+  enoteNormalizator,
+  znamkaNormalizator,
+  kolicinaNormalizator,
+  velikostNormalizator,
+  vrstaNormalizator,
+  oznakeNormalizator
+];
+var VET_TABELA = {
+  okrajsave: OKRAJSAVE_ZNAMK,
+  linije: LINIJE_ZNAMK,
+  dobavitelji: DOBAVITELJI,
+  oznake: OZNAKE,
+  vir: ZNAMKE_GEN.vir
+};
+// src/vet/spec.ts
+function vetArtikelSpec(nastavitve = {}) {
+  const polja = nastavitve.polja ?? ["naziv"];
+  return {
+    searchInFields: [...polja],
+    keyFields: [...nastavitve.keyFields ?? polja],
+    ...nastavitve.prviTokeni !== undefined ? { firstTokensN: nastavitve.prviTokeni } : {},
+    valueNormalizers: [...VET_NORMALIZATORJI, ...nastavitve.dodatniNormalizatorji ?? []]
+  };
+}
+function vetQueryOpts(dodatni = {}) {
+  return { ...dodatni, queryNormalizers: [...VET_NORMALIZATORJI, ...dodatni.queryNormalizers ?? []] };
+}
+// src/types/index.ts
+var DEFAULT_PHONE_FIELDS = ["telefon", "phone", "gsm", "msisdn"];
+var DEFAULT_FIRST_TOKENS_N = 8;
+var DEFAULT_SEARCH_OPTS = {
+  matchWords: "start",
+  matchNumbers: "startEnd",
+  matchNumbersShort: "start",
+  matchNumbersThreshold: 6
+};
+function arrayToSearchableData(items) {
+  const map = new Map;
+  for (const item of items) {
+    map.set(item._id, item);
+  }
+  return map;
+}
+// src/utils/tokenRegistry.ts
+var INITIAL_CAPACITY = 10 * 1000;
+var tokens = new Array(INITIAL_CAPACITY);
+var tokenCount = 0;
+function findTokenId(token) {
+  for (let i = 0;i < tokenCount; i++) {
+    if (tokens[i] === token) {
+      return i;
+    }
+  }
+  return -1;
+}
+function registerToken(token) {
+  const id = tokenCount;
+  tokens[id] = token;
+  tokenCount++;
+  return id;
+}
+function getOrCreateTokenId(token, tokensMap) {
+  const existing = tokensMap.get(token);
+  if (existing !== undefined) {
+    return existing;
+  }
+  const id = registerToken(token);
+  tokensMap.set(token, id);
+  return id;
+}
+function createTokensMap() {
+  const map = new Map;
+  for (let i = 0;i < tokenCount; i++) {
+    map.set(tokens[i], i);
+  }
+  return map;
+}
+function clearTokensMap(tokensMap) {
+  tokensMap.clear();
+}
+
+// src/utils/normalizeDates.ts
+var MONTH_NAMES = {
+  jan: "01",
+  feb: "02",
+  mar: "03",
+  apr: "04",
+  maj: "05",
+  jun: "06",
+  jul: "07",
+  avg: "08",
+  sep: "09",
+  okt: "10",
+  nov: "11",
+  dec: "12",
+  januar: "01",
+  februar: "02",
+  marec: "03",
+  april: "04",
+  junij: "06",
+  julij: "07",
+  avgust: "08",
+  september: "09",
+  oktober: "10",
+  november: "11",
+  december: "12",
+  january: "01",
+  february: "02",
+  march: "03",
+  may: "05",
+  june: "06",
+  july: "07",
+  august: "08",
+  october: "10"
+};
+var RE_DATE_ISO = /\b(\d{4})-(\d{2})-(\d{2})(?:T[\d:.]+Z?)?\b/g;
+var RE_DATE_ISO_YM = /\b(\d{4})-(\d{2})\b/g;
+var RE_DATE_DMY = /\b(\d{1,2})\.(\d{1,2})\.(\d{4})\b/g;
+var RE_DATE_DMY_SHORT = /\b(\d{1,2})\.(\d{1,2})\.(\d{2})\b/g;
+var RE_DATE_MY = /\b(\d{1,2})\.(\d{4})\b/g;
+var RE_DATE_MY_SLASH_DASH = /\b(\d{1,2})[-/](\d{4})\b/g;
+var RE_DATE_MY_SLASH_SHORT = /\b(\d{1,2})\/(\d{2})\b/g;
+var RE_DATE_MMYYYY = /\b(0[1-9]|1[0-2])(20\d{2})\b/g;
+var RE_DATE_DDMMYYYY = /\b(0[1-9]|[12]\d|3[01])(0[1-9]|1[0-2])(20\d{2})\b/g;
+var RE_DATE_MONTH_YEAR = new RegExp(`\\b(${Object.keys(MONTH_NAMES).join("|")})\\s*(\\d{4})\\b`, "gi");
+function pad(num, length) {
+  return num.padStart(length, "0");
+}
+function normalizeDates(input) {
+  let result = input;
+  result = result.replace(RE_DATE_ISO, (_match, year, month, day) => {
+    return `${year}${month}${day}`;
+  });
+  result = result.replace(RE_DATE_ISO_YM, (_match, year, month) => {
+    return `${year}${month}`;
+  });
+  result = result.replace(RE_DATE_DMY, (_match, day, month, year) => {
+    return `${year}${pad(month, 2)}${pad(day, 2)}`;
+  });
+  result = result.replace(RE_DATE_DMY_SHORT, (_match, day, month, year) => {
+    return `20${year}${pad(month, 2)}${pad(day, 2)}`;
+  });
+  result = result.replace(RE_DATE_MY, (_match, month, year) => {
+    return `${year}${pad(month, 2)}`;
+  });
+  result = result.replace(RE_DATE_MY_SLASH_DASH, (_match, month, year) => {
+    const y = parseInt(year, 10);
+    if (y > 2000 && y < 2100) {
+      return `${year}${pad(month, 2)}`;
+    }
+    return _match;
+  });
+  result = result.replace(RE_DATE_MY_SLASH_SHORT, (_match, month, year) => {
+    const m = parseInt(month, 10);
+    if (m >= 1 && m <= 12) {
+      return `20${year}${pad(month, 2)}`;
+    }
+    return _match;
+  });
+  result = result.replace(RE_DATE_DDMMYYYY, (_match, day, month, year) => {
+    return `${year}${month}${day}`;
+  });
+  result = result.replace(RE_DATE_MMYYYY, (_match, month, year) => {
+    return `${year}${month}`;
+  });
+  result = result.replace(RE_DATE_MONTH_YEAR, (_match, monthName, year) => {
+    const monthNum = MONTH_NAMES[monthName.toLowerCase()];
+    if (monthNum) {
+      return `${year}${monthNum}`;
+    }
+    return _match;
+  });
+  return result;
+}
+
+// src/utils/preprocessString.ts
+var RE_LEADING_ZEROS = /\b0+(\d)/g;
+var RE_DECIMAL_COMMA = /(\d),(\d)/g;
+var RE_STANDALONE_COMMA = /(?<!\d),(\d)/g;
+var RE_ZERO_DECIMAL = /\b0+\./g;
+var RE_PURE_DECIMAL = /(?<![a-zčćšžđñ\d.])(\d+)\.(\d+)(?![a-zčćšžđñ.\d])/gi;
+var RE_DIGIT_DASH = /(\d)\s*-\s*(\d)/g;
+var RE_LETTER_DASH_DIGIT = /([a-zčćšžđñ])-(\d)/gi;
+var RE_DIGIT_DASH_LETTER = /(\d)-([a-zčćšžđñ])/gi;
+var RE_LETTER_DASH_LETTER = /(?<=[a-zčćšžđñ])-(?=[a-zčćšžđñ])/gi;
+var RE_LETTERS_DIGITS = /(^|\s)([a-zčćšžđñ]+)(\d+)(?=\s|$)/gi;
+var RE_DIGITS_LETTERS = /(^|\s)(\d+)([a-zčćšžđñ]+)(?=\s|$)/gi;
+function preprocessString(input) {
+  let result = input;
+  result = result.replace(RE_LEADING_ZEROS, "$1");
+  result = result.replace(RE_DECIMAL_COMMA, "$1.$2");
+  result = result.replace(RE_STANDALONE_COMMA, ".$1");
+  result = result.replace(RE_ZERO_DECIMAL, ".");
+  result = result.replace(RE_PURE_DECIMAL, "$1$2");
+  result = result.replace(RE_DIGIT_DASH, "$1-$2");
+  result = result.replace(RE_LETTER_DASH_DIGIT, "$1 $2");
+  result = result.replace(RE_DIGIT_DASH_LETTER, "$1 $2");
+  result = result.replace(RE_LETTER_DASH_LETTER, " ");
+  result = result.replace(RE_LETTERS_DIGITS, "$1$2 $3");
+  result = result.replace(RE_DIGITS_LETTERS, "$1$2 $3");
+  return result;
+}
+
+// src/utils/sanitiseString.ts
+var RE_DIACRITICS = /[\u0300-\u036f]/g;
+var RE_INVALID_CHARS = /[^a-z0-9.\-~<>+*!=? ]/g;
+function sanitiseString(input) {
+  let result = input;
+  result = result.toLowerCase();
+  result = result.normalize("NFD").replace(RE_DIACRITICS, "");
+  result = result.replace(RE_INVALID_CHARS, " ");
+  return result;
+}
+
+// src/utils/tokenize.ts
+var DEFAULT_REPLACE_TOKENS = new Map([
+  ["zdravilo", "zdr"],
+  ["izdelek", "izd"],
+  ["material", "mat"],
+  ["pes", "ps"],
+  ["psi", "ps"],
+  ["dog", "ps"],
+  ["cat", "mk"],
+  ["macka", "mk"],
+  ["macke", "mk"],
+  ["ulica", "ul"],
+  ["cesta", "ces"],
+  ["mesanec", "mes"],
+  ["nova", "nv"]
+]);
+var DEFAULT_REMOVE_TOKENS = new Set([
+  "s",
+  "z",
+  "-",
+  "in",
+  "na",
+  "v",
+  "po",
+  "za",
+  "se"
+]);
+var DEFAULT_TOKENIZE_CONFIG = {
+  replaceTokens: DEFAULT_REPLACE_TOKENS,
+  removeTokens: DEFAULT_REMOVE_TOKENS
+};
+function tokenize(input, config) {
+  let tokens2 = input.split(" ").map((token) => token.trim()).filter((token) => token.length > 0);
+  if (config?.replaceTokens) {
+    tokens2 = tokens2.map((token) => {
+      if (token.length > 2 && token.startsWith("--")) {
+        const withoutPrefix = token.slice(2);
+        const replaced = config.replaceTokens.get(withoutPrefix);
+        return replaced ? "--" + replaced : token;
+      }
+      if (token.length > 1 && token[0] === "-" && /^[a-zčćšžđñ]/i.test(token[1])) {
+        const withoutPrefix = token.slice(1);
+        const replaced = config.replaceTokens.get(withoutPrefix);
+        return replaced ? "-" + replaced : token;
+      }
+      return config.replaceTokens.get(token) ?? token;
+    });
+  }
+  if (config?.removeTokens) {
+    tokens2 = tokens2.filter((token) => !config.removeTokens.has(token));
+  }
+  return tokens2;
+}
+
+// src/utils/prepareStringForSearchNumeric.ts
+function prepareStringForSearchNumeric(input, tokensMap) {
+  const datesNormalized = normalizeDates(input);
+  const preprocessed = preprocessString(datesNormalized);
+  const sanitised = sanitiseString(preprocessed);
+  const stringTokens = tokenize(sanitised, DEFAULT_TOKENIZE_CONFIG);
+  const numericTokens = new Array(stringTokens.length);
+  for (let i = 0;i < stringTokens.length; i++) {
+    numericTokens[i] = getOrCreateTokenId(stringTokens[i], tokensMap);
+  }
+  const unsorted = Uint32Array.from(numericTokens);
+  const sortedArr = numericTokens.slice().sort((a, b) => a - b);
+  const sorted = Uint32Array.from(sortedArr);
+  return { sorted, unsorted };
+}
+
+// src/utils/phoneNormalization.ts
+var RE_ASCII_DIGITS = /^[0-9]+$/;
+var RE_PHONE_LIKE_QUERY = /^[\d+()/\-. ]+$/;
+var MIN_PHONE_DIGITS = 4;
+var defaultPhoneNormalizer = (value) => {
+  const digits = value.replace(/\D/g, "");
+  return digits.length >= MIN_PHONE_DIGITS ? digits : undefined;
+};
+var defaultQueryPhoneNormalizer = (query) => {
+  if (!RE_PHONE_LIKE_QUERY.test(query))
+    return;
+  return defaultPhoneNormalizer(query);
+};
+function validateNormalizedPhone(normalized, normalizerName) {
+  if (normalized === undefined)
+    return;
+  if (typeof normalized !== "string" || !RE_ASCII_DIGITS.test(normalized)) {
+    throw new Error(`${normalizerName} must return an ASCII digit string or undefined`);
+  }
+  return normalized;
+}
+
+// src/common/numeric/createSearchArrayMetadata.ts
+function isDeletedOrBlocked(obj) {
+  return obj._deleted != null || obj._blocked != null;
+}
+var PREFIX_TO_MATCH_MODE = {
+  "<": "start",
+  ">": "end",
+  "+": "startEnd",
+  "*": "anywhere",
+  "!": "whole",
+  "=": "whole",
+  "?": "anywhere"
+};
+var MATCH_MODE_BITS = {
+  start: 0,
+  end: 1,
+  startEnd: 2,
+  anywhere: 3,
+  whole: 4
+};
+var MODE_SHIFT = 29;
+var TOKEN_ID_MASK = (1 << MODE_SHIFT) - 1;
+function encodeTokenWithMode(tokenId, mode) {
+  return tokenId | MATCH_MODE_BITS[mode] << MODE_SHIFT;
+}
+function decodeTokenId(encoded) {
+  return encoded & TOKEN_ID_MASK;
+}
+function decodeMatchMode(encoded) {
+  const modeBits = encoded >>> MODE_SHIFT;
+  switch (modeBits) {
+    case 1:
+      return "end";
+    case 2:
+      return "startEnd";
+    case 3:
+      return "anywhere";
+    case 4:
+      return "whole";
+    default:
+      return "start";
+  }
+}
+var DEFAULT_EXCLUDED_FIELDS = new Set(["_id", "_deleted", "_blocked"]);
+function getValueByPath(obj, path) {
+  const parts = path.split(".");
+  let current = obj;
+  for (let i = 0;i < parts.length; i++) {
+    if (current == null)
+      return;
+    const part = parts[i];
+    if (Array.isArray(current)) {
+      const remainingPath = parts.slice(i).join(".");
+      const results = [];
+      for (const item of current) {
+        const value = getValueByPath(item, remainingPath);
+        if (value !== undefined) {
+          if (Array.isArray(value)) {
+            results.push(...value);
+          } else {
+            results.push(value);
+          }
+        }
+      }
+      return results.length > 0 ? results : undefined;
+    }
+    if (typeof current === "object") {
+      current = current[part];
+    } else {
+      return;
+    }
+  }
+  return current;
+}
+function isDotNotation(field) {
+  return field.includes(".");
+}
+function extractStringsFromValue(value, results) {
+  if (value == null)
+    return;
+  if (typeof value === "string") {
+    results.push(value);
+  } else if (typeof value === "number") {
+    results.push(String(value));
+  } else if (value instanceof Date) {
+    results.push(value.toISOString());
+  } else if (Array.isArray(value)) {
+    for (const item of value) {
+      extractStringsFromValue(item, results);
+    }
+  } else if (typeof value === "object") {
+    for (const v of Object.values(value)) {
+      extractStringsFromValue(v, results);
+    }
+  }
+}
+function applyValueNormalizers(value, field, normalizers) {
+  let text = value;
+  const classes = {};
+  if (!normalizers?.length)
+    return { text, classes };
+  for (const normalizer of normalizers) {
+    if (normalizer.fields && !normalizer.fields.includes(field))
+      continue;
+    const izhod = normalizer.fn(text, field);
+    if (izhod === undefined)
+      continue;
+    if (typeof izhod === "string") {
+      text = izhod;
+      continue;
+    }
+    text = izhod.text;
+    for (const [kljuc, vrednost] of Object.entries(izhod.classes ?? {})) {
+      const seznam = Array.isArray(vrednost) ? vrednost : [vrednost];
+      const obstojeci = classes[kljuc] ?? [];
+      for (const v of seznam) {
+        if (v != null && v !== "" && !obstojeci.includes(String(v)))
+          obstojeci.push(String(v));
+      }
+      classes[kljuc] = obstojeci;
+    }
+  }
+  return { text, classes };
+}
+function itemClasses(metadata, id) {
+  const zapis = metadata.classes?.get(id);
+  return zapis && Object.keys(zapis).length ? zapis : undefined;
+}
+function prepareObjectForSearchNumeric(obj, spec, tokensMap) {
+  if (isDeletedOrBlocked(obj)) {
+    return;
+  }
+  if (spec?.enrichSearchObjectFn) {
+    spec.enrichSearchObjectFn(obj, spec.searchContext);
+  }
+  const classes = {};
+  const sorted = spec?.extractSearchableStringFn ? buildSortedFromExtractFn(obj, spec.extractSearchableStringFn, tokensMap) : buildSortedFromFields(obj, spec, tokensMap, classes);
+  if (sorted === undefined)
+    return;
+  const firstN = spec?.keyFields && spec.keyFields.length > 0 ? buildFirstNFromKeyFields(obj, spec.keyFields, spec.firstTokensN ?? DEFAULT_FIRST_TOKENS_N, spec.phoneFields ?? DEFAULT_PHONE_FIELDS, tokensMap, spec.valueNormalizers) : undefined;
+  return Object.keys(classes).length ? { sorted, firstN, classes } : { sorted, firstN };
+}
+function buildSortedFromExtractFn(obj, extractFn, tokensMap) {
+  const str = extractFn(obj);
+  if (str === undefined)
+    return;
+  return prepareStringForSearchNumeric(str, tokensMap).sorted;
+}
+function buildSortedFromFields(obj, spec, tokensMap, classesOut = {}) {
+  const allTokens = [];
+  const fieldMatchModes = spec?.fieldMatchModes;
+  const fieldsToSearch = spec?.searchInFields ?? Object.keys(obj);
+  const fieldsToExclude = new Set((spec?.dontSearchInFields ?? []).map(String));
+  const phoneFields = new Set(spec?.phoneFields ?? DEFAULT_PHONE_FIELDS);
+  const phoneNormalizer = spec?.phoneNormalizer ?? defaultPhoneNormalizer;
+  for (const key of fieldsToSearch) {
+    const keyStr = key;
+    if (!spec?.searchInFields && DEFAULT_EXCLUDED_FIELDS.has(keyStr))
+      continue;
+    if (fieldsToExclude.has(key))
+      continue;
+    const isDot = isDotNotation(keyStr);
+    const value = isDot ? getValueByPath(obj, keyStr) : obj[keyStr];
+    if (value == null)
+      continue;
+    const matchMode = fieldMatchModes?.[key];
+    const fieldStrings = [];
+    extractStringsFromValue(value, fieldStrings);
+    if (phoneFields.has(keyStr)) {
+      const phoneMatchMode = spec?.phoneMatchMode ?? "anywhere";
+      for (const fieldString of fieldStrings) {
+        const normalized = validateNormalizedPhone(phoneNormalizer(fieldString), `Phone normalizer for field "${keyStr}"`);
+        if (normalized === undefined)
+          continue;
+        const tokenId = getOrCreateTokenId(normalized, tokensMap);
+        allTokens.push(encodeTokenWithMode(tokenId, phoneMatchMode));
+      }
+      continue;
+    }
+    if (fieldStrings.length === 0)
+      continue;
+    const normalizirane = spec?.valueNormalizers?.length ? fieldStrings.map((s) => applyValueNormalizers(s, keyStr, spec.valueNormalizers)) : undefined;
+    const fieldText = normalizirane ? normalizirane.map((n) => n.text).join(" ") : fieldStrings.join(" ");
+    if (normalizirane) {
+      for (const n of normalizirane) {
+        for (const [kljuc, vrednosti] of Object.entries(n.classes)) {
+          const obstojeci = classesOut[kljuc] ?? [];
+          for (const v of vrednosti)
+            if (!obstojeci.includes(v))
+              obstojeci.push(v);
+          classesOut[kljuc] = obstojeci;
+        }
+      }
+    }
+    const datesNormalized = normalizeDates(fieldText);
+    const preprocessed = preprocessString(datesNormalized);
+    const sanitised = sanitiseString(preprocessed);
+    const stringTokens = tokenize(sanitised, DEFAULT_TOKENIZE_CONFIG);
+    const effectiveMode = matchMode ?? (keyStr === "_id" ? "whole" : undefined);
+    for (const token of stringTokens) {
+      const tokenId = getOrCreateTokenId(token, tokensMap);
+      if (effectiveMode) {
+        allTokens.push(encodeTokenWithMode(tokenId, effectiveMode));
+      } else {
+        allTokens.push(tokenId);
+      }
+    }
+  }
+  const uniqueTokens = [...new Set(allTokens)].sort((a, b) => a - b);
+  return new Uint32Array(uniqueTokens);
+}
+function buildFirstNFromKeyFields(obj, keyFields, n, phoneFields, tokensMap, normalizers) {
+  const strings = [];
+  const phoneFieldPaths = new Set(phoneFields);
+  for (const field of keyFields) {
+    const keyStr = field;
+    if (phoneFieldPaths.has(keyStr))
+      continue;
+    const value = isDotNotation(keyStr) ? getValueByPath(obj, keyStr) : obj[field];
+    if (value == null)
+      continue;
+    const zacasno = [];
+    extractStringsFromValue(value, zacasno);
+    strings.push(...normalizers?.length ? zacasno.map((s) => applyValueNormalizers(s, keyStr, normalizers).text) : zacasno);
+  }
+  if (strings.length === 0)
+    return;
+  const text = strings.join(" ");
+  const datesNormalized = normalizeDates(text);
+  const preprocessed = preprocessString(datesNormalized);
+  const sanitised = sanitiseString(preprocessed);
+  const stringTokens = tokenize(sanitised, DEFAULT_TOKENIZE_CONFIG);
+  if (stringTokens.length === 0)
+    return;
+  const sliced = stringTokens.slice(0, n);
+  const out = new Uint32Array(sliced.length);
+  for (let i = 0;i < sliced.length; i++) {
+    out[i] = getOrCreateTokenId(sliced[i], tokensMap);
+  }
+  return out;
+}
+function createSearchArrayMetadataNumeric(data, spec) {
+  const tokensMap = createTokensMap();
+  try {
+    const metadata = emptyNumericSearchMetadata();
+    for (const [id, item] of data) {
+      const result = prepareObjectForSearchNumeric(item, spec, tokensMap);
+      if (result !== undefined) {
+        metadata.sorted.set(id, result.sorted);
+        if (result.firstN !== undefined) {
+          metadata.unsorted.set(id, result.firstN);
+        }
+        if (result.classes !== undefined) {
+          (metadata.classes ??= new Map).set(id, result.classes);
+        }
+      }
+    }
+    return metadata;
+  } finally {
+    clearTokensMap(tokensMap);
+  }
+}
+function emptyNumericSearchMetadata() {
+  return { sorted: new Map, unsorted: new Map };
+}
+
+// src/utils/matchTokenNumeric.ts
+var RE_NUMERIC = /^[\d.\-]+$/;
+function countDigits(str) {
+  let count = 0;
+  for (let i = 0;i < str.length; i++) {
+    const c = str[i];
+    if (c !== "." && c !== "-")
+      count++;
+  }
+  return count;
+}
+function getNumericMatchMode(str, opts) {
+  const threshold = opts?.matchNumbersThreshold ?? DEFAULT_SEARCH_OPTS.matchNumbersThreshold;
+  const digitCount = countDigits(str);
+  if (digitCount <= threshold) {
+    return opts?.matchNumbersShort ?? DEFAULT_SEARCH_OPTS.matchNumbersShort;
+  }
+  return opts?.matchNumbers ?? DEFAULT_SEARCH_OPTS.matchNumbers;
+}
+function prepareQueryTokens(queryTokenStrs) {
+  return queryTokenStrs.filter((str) => {
+    if (str === "-" || str === "--" || str === "~")
+      return false;
+    return true;
+  }).map((str) => {
+    let overrideMode;
+    let negated = false;
+    let cleanStr = str;
+    if (str.length > 2 && str.startsWith("--")) {
+      negated = true;
+      cleanStr = str.slice(2);
+    } else if (str.length > 1 && str[0] === "-" && /^[a-zčćšžđñ]/i.test(str[1])) {
+      negated = true;
+      cleanStr = str.slice(1);
+    } else if (str.length > 1 && str.startsWith("~")) {
+      negated = true;
+      cleanStr = str.slice(1);
+    } else if (str.length > 3 && str.startsWith("...")) {
+      overrideMode = "end";
+      cleanStr = str.slice(3);
+    } else if (str.length > 2 && str.startsWith("..")) {
+      overrideMode = "end";
+      cleanStr = str.slice(2);
+    } else if (str.length > 3 && str.endsWith("...")) {
+      overrideMode = "start";
+      cleanStr = str.slice(0, -3);
+    } else if (str.length > 2 && str.endsWith("..")) {
+      overrideMode = "start";
+      cleanStr = str.slice(0, -2);
+    } else if (str.length > 1) {
+      const firstChar = str[0];
+      if (firstChar && PREFIX_TO_MATCH_MODE[firstChar]) {
+        overrideMode = PREFIX_TO_MATCH_MODE[firstChar];
+        cleanStr = str.slice(1);
+      }
+    }
+    if (!negated && cleanStr.length > 1 && cleanStr[0] === "-" && /\d/.test(cleanStr[1])) {
+      cleanStr = cleanStr.slice(1);
+    }
+    const result = {
+      str: cleanStr,
+      id: findTokenId(cleanStr),
+      isNumeric: RE_NUMERIC.test(cleanStr)
+    };
+    if (overrideMode)
+      result.overrideMode = overrideMode;
+    if (negated)
+      result.negated = true;
+    return result;
+  });
+}
+function matchWithModeNumeric(searchTokenId, searchTokenStr, targetTokenEncoded, opts, overrideMode) {
+  const targetTokenId = decodeTokenId(targetTokenEncoded);
+  const targetTokenStr = tokens[targetTokenId];
+  if (!targetTokenStr)
+    return false;
+  const hasExplicitMode = targetTokenEncoded !== targetTokenId;
+  let mode;
+  if (overrideMode) {
+    mode = overrideMode;
+  } else if (hasExplicitMode) {
+    mode = decodeMatchMode(targetTokenEncoded);
+  } else {
+    const isTargetNumeric = RE_NUMERIC.test(targetTokenStr);
+    mode = isTargetNumeric ? getNumericMatchMode(targetTokenStr, opts) : opts?.matchWords ?? DEFAULT_SEARCH_OPTS.matchWords;
+  }
+  switch (mode) {
+    case "start":
+      return targetTokenStr.startsWith(searchTokenStr);
+    case "end":
+      return targetTokenStr.endsWith(searchTokenStr);
+    case "startEnd":
+      return targetTokenStr.startsWith(searchTokenStr) || targetTokenStr.endsWith(searchTokenStr);
+    case "anywhere":
+      return targetTokenStr.includes(searchTokenStr);
+    case "whole":
+      if (!hasExplicitMode && !overrideMode) {
+        return searchTokenId === targetTokenId;
+      }
+      return targetTokenStr === searchTokenStr;
+  }
+}
+function binarySearchUint32(arr, target) {
+  let left = 0;
+  let right = arr.length - 1;
+  while (left <= right) {
+    const mid = left + right >>> 1;
+    const val = arr[mid];
+    if (val === target)
+      return true;
+    if (val < target) {
+      left = mid + 1;
+    } else {
+      right = mid - 1;
+    }
+  }
+  return false;
+}
+function matchPreparedTokenInSortedList(preparedToken, targetTokens, opts) {
+  const { str: searchTokenStr, id: searchTokenId, overrideMode, negated } = preparedToken;
+  if (overrideMode === "whole" && searchTokenId !== -1) {
+    let hasEncodedTokens = false;
+    for (let i = 0;i < targetTokens.length; i++) {
+      if (targetTokens[i] > TOKEN_ID_MASK) {
+        hasEncodedTokens = true;
+        break;
+      }
+    }
+    if (!hasEncodedTokens) {
+      return binarySearchUint32(targetTokens, searchTokenId);
+    }
+  }
+  for (let i = 0;i < targetTokens.length; i++) {
+    const targetEncoded = targetTokens[i];
+    if (matchWithModeNumeric(searchTokenId, searchTokenStr, targetEncoded, opts, overrideMode)) {
+      return true;
+    }
+    if (negated) {
+      const targetTokenId = decodeTokenId(targetEncoded);
+      const targetTokenStr = tokens[targetTokenId];
+      if (targetTokenStr) {
+        const hasExplicitMode = targetEncoded !== targetTokenId;
+        let targetMode;
+        if (overrideMode) {
+          targetMode = overrideMode;
+        } else if (hasExplicitMode) {
+          targetMode = decodeMatchMode(targetEncoded);
+        } else {
+          const isTargetNumeric = RE_NUMERIC.test(targetTokenStr);
+          targetMode = isTargetNumeric ? getNumericMatchMode(targetTokenStr, opts) : opts?.matchWords ?? DEFAULT_SEARCH_OPTS.matchWords;
+        }
+        if ((targetMode === "start" || targetMode === "startEnd") && searchTokenStr.startsWith(targetTokenStr)) {
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+}
+function allPreparedTokensMatch(preparedTokens, targetTokens, opts) {
+  for (const preparedToken of preparedTokens) {
+    const matches = matchPreparedTokenInSortedList(preparedToken, targetTokens, opts);
+    if (preparedToken.negated) {
+      if (matches)
+        return false;
+    } else {
+      if (!matches)
+        return false;
+    }
+  }
+  return true;
+}
+
+// src/utils/prepareStringForSearch.ts
+function prepareStringForSearch(input) {
+  const datesNormalized = normalizeDates(input);
+  const preprocessed = preprocessString(datesNormalized);
+  const sanitised = sanitiseString(preprocessed);
+  const tokens2 = tokenize(sanitised, DEFAULT_TOKENIZE_CONFIG);
+  return tokens2.sort();
+}
+
+// src/common/numeric/prepareQueryVariants.ts
+function normalizeQueryWithOpts(query, opts) {
+  const normalizers = opts?.queryNormalizers;
+  if (!normalizers?.length)
+    return { text: query, classes: {} };
+  let text = query;
+  const classes = {};
+  for (const normalizer of normalizers) {
+    const fn = typeof normalizer === "function" ? normalizer : normalizer.fn;
+    const izhod = fn(text, "");
+    if (izhod === undefined)
+      continue;
+    if (typeof izhod === "string") {
+      text = izhod;
+      continue;
+    }
+    text = izhod.text;
+    for (const [kljuc, vrednost] of Object.entries(izhod.classes ?? {})) {
+      const seznam = Array.isArray(vrednost) ? vrednost : [vrednost];
+      const obstojeci = classes[kljuc] ?? [];
+      for (const v of seznam) {
+        if (v != null && v !== "" && !obstojeci.includes(String(v)))
+          obstojeci.push(String(v));
+      }
+      classes[kljuc] = obstojeci;
+    }
+  }
+  return { text, classes };
+}
+function prepareQueryVariants(query, opts) {
+  const { text: normalizirano, classes } = normalizeQueryWithOpts(query, opts);
+  const rawTokenStrs = prepareStringForSearch(normalizirano);
+  const rawTokens = prepareQueryTokens(rawTokenStrs);
+  const normalizers = opts?.phoneQueryNormalizers ?? [defaultQueryPhoneNormalizer];
+  const seenPhones = new Set;
+  const phoneTokens = [];
+  for (const normalizer of normalizers) {
+    const normalized = validateNormalizedPhone(normalizer(normalizirano), "Phone query normalizer");
+    if (normalized === undefined || seenPhones.has(normalized))
+      continue;
+    seenPhones.add(normalized);
+    phoneTokens.push(prepareQueryTokens([normalized]));
+  }
+  return { rawTokenStrs, rawTokens, phoneTokens, classes };
+}
+// src/vet/ocena.ts
+import { oceniPodobnost, razcleniNaziv } from "cry-vetzdravila";
+var PRIVZETO = {
+  predponaDelez: 0.8,
+  pokritostKandidata: 0.75,
+  pokritostPoizvedbe: 0.5,
+  minOcena: 0
+};
+var KAZEN = {
+  razpon: 300,
+  vrsta: 400,
+  kolicina: 150,
+  pakiranje: 150,
+  velikost: 300,
+  pantheon: 100
+};
+var BONUS = {
+  razpon: 150,
+  vrsta: 200,
+  kolicina: 100,
+  pakiranje: 100,
+  velikost: 150
+};
+function kotSeznam(v) {
+  if (v === undefined)
+    return [];
+  return (Array.isArray(v) ? v : [v]).map((x) => String(x).toLowerCase());
+}
+function staVNasprotju(a, b) {
+  if (!a.length || !b.length)
+    return false;
+  return !a.some((x) => b.includes(x));
+}
+function kljuc(beseda) {
+  return beseda.toLowerCase().normalize("NFD").replace(/[\u0300-\u036f]/g, "").replace(/[^a-z0-9]/g, "");
+}
+var PRESKOCENE_VODILNE = new Set([
+  ...ZNAMKE_GEN.tipskeOznake.map(kljuc),
+  ...ZNAMKE_GEN.znamke.flatMap((z) => z.split(/\s+/).map(kljuc)),
+  ...ZNAMKE_GEN.okrajsave.map((o) => kljuc(o.okrajsava))
+]);
+function prvaPovedna(besede, poizvedba = []) {
+  const poizvedbeni = new Set(poizvedba.map(kljuc));
+  let zacetek = 0;
+  while (zacetek < besede.length - 1) {
+    const kljucBesede2 = kljuc(besede[zacetek]);
+    const preskocimo = PRESKOCENE_VODILNE.has(kljucBesede2) && !poizvedbeni.has(kljucBesede2);
+    if (!preskocimo)
+      break;
+    zacetek++;
+  }
+  const preostale = besede.slice(zacetek);
+  return preostale.find((b) => kljuc(b).length > 2) ?? preostale[0];
+}
+function prestaneVratar(besedePoizvedbe, besedeKandidata) {
+  const prva = prvaPovedna(besedeKandidata, besedePoizvedbe);
+  if (!prva)
+    return false;
+  return besedePoizvedbe.some((b) => b.startsWith(prva) || prva.startsWith(b));
+}
+function oceniPar(poizvedba, kandidat, nastavitve = {}, razredi) {
+  const n = { ...PRIVZETO, ...nastavitve };
+  const q = razcleniNaziv(poizvedba);
+  const c = razcleniNaziv(kandidat);
+  const prazna = {
+    ocena: 0,
+    sprejeto: false,
+    razlog: "vratar: prva beseda kandidata se ne ujema s poizvedbo",
+    pokritostKandidata: 0,
+    pokritostPoizvedbe: 0,
+    skupneBesede: [],
+    nasprotja: []
+  };
+  if (!prestaneVratar(q.besede, c.besede))
+    return prazna;
+  const qTok = [...new Set([...q.besede, ...q.zivalskeVrste, ...q.dozirneOblike].map((t) => t.toLowerCase()))];
+  const cTok = [...new Set([...c.besede, ...c.zivalskeVrste, ...c.dozirneOblike].map((t) => t.toLowerCase()))];
+  const qStevci = new Map;
+  for (const t of qTok)
+    qStevci.set(t, (qStevci.get(t) ?? 0) + 1);
+  const cStevci = new Map;
+  for (const t of cTok)
+    cStevci.set(t, (cStevci.get(t) ?? 0) + 1);
+  const porabljeno = new Map;
+  let ujemajoce = 0;
+  let ujemajoceCele = 0;
+  const skupne = [];
+  for (const [qZeton, kolikoQ] of qStevci) {
+    let potrebnih = kolikoQ;
+    for (const [cZeton, kolikoC] of cStevci) {
+      if (potrebnih === 0)
+        break;
+      const prostih = kolikoC - (porabljeno.get(cZeton) ?? 0);
+      if (prostih <= 0)
+        continue;
+      const cela = qZeton === cZeton;
+      const predpona = !cela && (cZeton.startsWith(qZeton) || qZeton.startsWith(cZeton));
+      const razmerje = Math.min(qZeton.length, cZeton.length) / Math.max(qZeton.length, cZeton.length);
+      if (!cela && !(predpona && razmerje >= n.predponaDelez))
+        continue;
+      const vzem = Math.min(potrebnih, prostih);
+      porabljeno.set(cZeton, (porabljeno.get(cZeton) ?? 0) + vzem);
+      ujemajoce += vzem;
+      if (cela)
+        ujemajoceCele += vzem;
+      if (!skupne.includes(qZeton))
+        skupne.push(qZeton);
+      potrebnih -= vzem;
+    }
+  }
+  const pokritostKandidata = cTok.length ? ujemajoce / cTok.length : 0;
+  const pokritostPoizvedbe = qTok.length ? ujemajoce / qTok.length : 0;
+  const dovoljDolg = [...porabljeno.keys()].some((t) => t.length >= 5);
+  const popolno = pokritostKandidata === 1 && pokritostPoizvedbe === 1;
+  const pokritostOk = ujemajoce >= 1 && pokritostKandidata >= n.pokritostKandidata && pokritostPoizvedbe >= n.pokritostPoizvedbe && (popolno || ujemajoceCele >= 2 || dovoljDolg);
+  let ocena = oceniPodobnost(q, c).ocena;
+  const nasprotja = [];
+  const kljuci = ["razpon", "vrsta", "kolicina", "pakiranje", "velikost", "pantheon"];
+  for (const kljuc2 of kljuci) {
+    const a = kotSeznam(razredi?.poizvedba?.[kljuc2]);
+    const b = kotSeznam(razredi?.kandidat?.[kljuc2]);
+    if (staVNasprotju(a, b)) {
+      ocena -= KAZEN[kljuc2] ?? 0;
+      nasprotja.push(`${kljuc2}: ${a.join("/")} ≠ ${b.join("/")}`);
+    } else if (a.length && b.length && a.some((x) => b.includes(x))) {
+      ocena += BONUS[kljuc2] ?? 0;
+    }
+  }
+  const sprejeto = pokritostOk && ocena >= n.minOcena;
+  const razlog = sprejeto ? `pokritost kandidata ${Math.round(pokritostKandidata * 100)} %, poizvedbe ${Math.round(pokritostPoizvedbe * 100)} %` + (skupne.length ? `; skupne besede: ${skupne.slice(0, 5).join(", ")}` : "") + (nasprotja.length ? `; nasprotja: ${nasprotja.join("; ")}` : "") : `pokritost prenizka (kandidat ${Math.round(pokritostKandidata * 100)} %, poizvedba ${Math.round(pokritostPoizvedbe * 100)} %)`;
+  return { ocena, sprejeto, razlog, pokritostKandidata, pokritostPoizvedbe, skupneBesede: skupne.slice(0, 5), nasprotja };
+}
+// src/common/numeric/scoring.ts
+function orderedTokenize(input) {
+  return tokenize(sanitiseString(preprocessString(normalizeDates(input))), DEFAULT_TOKENIZE_CONFIG);
+}
+function scoreOne(query, qTokens, itemTokens, exactKeys) {
+  if (exactKeys && exactKeys.length > 0) {
+    for (let i = 0;i < exactKeys.length; i++) {
+      if (exactKeys[i] === query)
+        return 1e5;
+    }
+  }
+  if (qTokens.length === 0)
+    return 0;
+  if (itemTokens.length === 0)
+    return 1;
+  let qi = 0;
+  const positions = [];
+  for (let i = 0;i < itemTokens.length; i++) {
+    if (qi < qTokens.length && itemTokens[i].startsWith(qTokens[qi])) {
+      positions.push(i);
+      qi++;
+    }
+  }
+  if (qi === 0)
+    return 1;
+  let score = 50;
+  if (qi === qTokens.length)
+    score += 100;
+  if (positions[0] === 0)
+    score += 50;
+  let perfect = qi === qTokens.length;
+  if (perfect) {
+    for (let i = 0;i < positions.length; i++) {
+      if (positions[i] !== i) {
+        perfect = false;
+        break;
+      }
+    }
+  }
+  if (perfect)
+    score += 80;
+  if (positions.length >= 2) {
+    const span = positions[positions.length - 1] - positions[0] + 1;
+    score += positions.length / span * 30;
+  }
+  let totalLen = 0;
+  for (const t of itemTokens)
+    totalLen += t.length + 1;
+  score -= totalLen * 0.1;
+  return score;
+}
+
+// src/common/numeric/searchInData.ts
+function searchInDataReturnIdsNumeric(query, metadata, opts) {
+  return searchInDataReturnIdsWithLimitNumeric(query, metadata, Infinity, opts);
+}
+function searchInDataReturnIdsWithLimitNumeric(query, metadata, limit, opts) {
+  const { rawTokens, phoneTokens } = prepareQueryVariants(query, opts);
+  const phoneCandidates = findMatchingCandidates(metadata, phoneTokens, opts);
+  const candidates = phoneCandidates.length > 0 ? phoneCandidates : findMatchingCandidates(metadata, rawTokens.length > 0 ? [rawTokens] : [], opts);
+  if (candidates.length === 0)
+    return [];
+  const qText = normalizeQueryWithOpts(query, opts).text;
+  const qTokens = orderedTokenize(qText);
+  const hasUnsorted = metadata.unsorted.size > 0;
+  if (!hasUnsorted) {
+    if (limit === Infinity || limit >= candidates.length)
+      return candidates;
+    return candidates.slice(0, limit);
+  }
+  const scored = new Array(candidates.length);
+  for (let i = 0;i < candidates.length; i++) {
+    const id = candidates[i];
+    const unsortedIds = metadata.unsorted.get(id);
+    if (unsortedIds === undefined) {
+      scored[i] = { id, score: 0, order: i };
+      continue;
+    }
+    const itemTokens = new Array(unsortedIds.length);
+    for (let j = 0;j < unsortedIds.length; j++) {
+      itemTokens[j] = tokens[unsortedIds[j]] ?? "";
+    }
+    scored[i] = { id, score: scoreOne(qText, qTokens, itemTokens), order: i };
+  }
+  scored.sort((a, b) => {
+    if (a.score !== b.score)
+      return b.score - a.score;
+    return a.order - b.order;
+  });
+  const out = [];
+  const max = limit === Infinity ? scored.length : Math.min(limit, scored.length);
+  for (let i = 0;i < max; i++)
+    out.push(scored[i].id);
+  return out;
+}
+function findMatchingCandidates(metadata, variants, opts) {
+  if (variants.length === 0)
+    return [];
+  const candidates = [];
+  for (const [id, targetTokens] of metadata.sorted) {
+    for (const preparedTokens of variants) {
+      if (allPreparedTokensMatch(preparedTokens, targetTokens, opts)) {
+        candidates.push(id);
+        break;
+      }
+    }
+  }
+  return candidates;
+}
+
+// src/common/numeric/searchAndRank.ts
+function tokenIdsToStrings(tokenIds) {
+  if (tokenIds === undefined)
+    return;
+  const out = new Array(tokenIds.length);
+  for (let i = 0;i < tokenIds.length; i++) {
+    out[i] = tokens[tokenIds[i]] ?? "";
+  }
+  return out;
+}
+function searchAndRankNumeric(query, data, metadata, options) {
+  const { primaryTextFn, exactKeysFn, limit, opts } = options;
+  const ids = searchInDataReturnIdsNumeric(query, metadata, opts);
+  if (ids.length === 0)
+    return [];
+  const qText = normalizeQueryWithOpts(query, opts).text;
+  const qTokens = orderedTokenize(qText);
+  const scored = [];
+  for (const id of ids) {
+    const item = data.get(id);
+    if (!item)
+      continue;
+    const itemTokens = tokenIdsToStrings(metadata.unsorted.get(id)) ?? orderedTokenize(primaryTextFn(item) || "");
+    const exactKeys = exactKeysFn?.(item);
+    const score = scoreOne(qText, qTokens, itemTokens, exactKeys);
+    scored.push({ id, item, score });
+  }
+  scored.sort((x, y) => {
+    if (y.score !== x.score)
+      return y.score - x.score;
+    const xText = primaryTextFn(x.item) || "";
+    const yText = primaryTextFn(y.item) || "";
+    return xText.localeCompare(yText);
+  });
+  if (limit === undefined || limit === Infinity || limit >= scored.length)
+    return scored;
+  return scored.slice(0, limit);
+}
+
+// src/common/numeric/matchMany.ts
+function naSezname(classes) {
+  if (!classes)
+    return;
+  const out = {};
+  for (const [kljuc2, vrednost] of Object.entries(classes)) {
+    const seznam = Array.isArray(vrednost) ? vrednost.map(String) : [String(vrednost)];
+    if (seznam.length)
+      out[kljuc2] = seznam;
+  }
+  return Object.keys(out).length ? out : undefined;
+}
+async function* matchMany(prepared, queries, options) {
+  const { queryOf, idOf, limit = 3, minScore = 0, kos = 50, samoEnolicno, rank, accept, opts } = options;
+  const retrievalLimit = options.retrievalLimit ?? Math.max(20, limit * 4);
+  const primaryTextOf = options.primaryTextOf ?? ((item) => item["naziv"]);
+  const porabljeni = samoEnolicno ? new Set : undefined;
+  let kosZbirka = [];
+  for (let indeks = 0;indeks < queries.length; indeks++) {
+    const query = queries[indeks];
+    const vhod = queryOf(query);
+    const text = typeof vhod === "string" ? vhod : vhod.text;
+    const queryClasses = typeof vhod === "string" ? undefined : naSezname(vhod.classes);
+    const id = idOf ? idOf(query, indeks) : String(query["_id"] ?? query["id"] ?? indeks);
+    const poisciKandidate = (besedilo, razredi) => {
+      if (!besedilo.trim())
+        return { kandidati: [], zadetkov: 0 };
+      const zadetki = searchAndRankNumeric(besedilo, prepared.data, prepared.metadata, {
+        primaryTextFn: primaryTextOf,
+        ...options.exactKeysOf ? { exactKeysFn: options.exactKeysOf } : {},
+        ...opts ? { opts } : {},
+        limit: retrievalLimit
+      });
+      const poizvedbaZaDomeno = { text: besedilo, ...razredi ? { classes: razredi } : {} };
+      const najdeni = [];
+      for (const zadetek of zadetki) {
+        const classes = itemClasses(prepared.metadata, zadetek.id);
+        const kandidat = {
+          id: zadetek.id,
+          item: zadetek.item,
+          ...classes ? { classes } : {}
+        };
+        if (accept && !accept(kandidat, poizvedbaZaDomeno))
+          continue;
+        const ocena = rank ? rank(kandidat, poizvedbaZaDomeno) : zadetek.score;
+        if (ocena < minScore)
+          continue;
+        if (porabljeni?.has(zadetek.id))
+          continue;
+        najdeni.push({ id: zadetek.id, item: zadetek.item, score: ocena, ...classes ? { classes } : {} });
+      }
+      najdeni.sort((a, b) => {
+        if (b.score !== a.score)
+          return b.score - a.score;
+        return (primaryTextOf(a.item) ?? "").localeCompare(primaryTextOf(b.item) ?? "");
+      });
+      if (najdeni.length > limit)
+        najdeni.length = limit;
+      return { kandidati: najdeni, zadetkov: zadetki.length };
+    };
+    let { kandidati, zadetkov } = poisciKandidate(text, queryClasses);
+    const poskusiAlternative = kandidati.length === 0 && (options.alternativneLeCeNiZadetkov ? zadetkov === 0 : true);
+    if (poskusiAlternative && options.alternativnePoizvedbe) {
+      for (const alternativa of options.alternativnePoizvedbe(query)) {
+        const altBesedilo = typeof alternativa === "string" ? alternativa : alternativa.text;
+        if (!altBesedilo?.trim() || altBesedilo === text)
+          continue;
+        const altRazredi = typeof alternativa === "string" ? undefined : naSezname(alternativa.classes);
+        ({ kandidati } = poisciKandidate(altBesedilo, altRazredi));
+        if (kandidati.length)
+          break;
+      }
+    }
+    if (porabljeni) {
+      for (const kandidat of kandidati)
+        porabljeni.add(kandidat.id);
+    }
+    kosZbirka.push({
+      id,
+      ...queryClasses ? { queryClasses } : {},
+      kandidati
+    });
+    if (kosZbirka.length >= kos) {
+      yield kosZbirka;
+      kosZbirka = [];
+    }
+  }
+  if (kosZbirka.length)
+    yield kosZbirka;
+}
+
+// src/vet/uparjanje.ts
+function zoziPoizvedbo(naziv, najvec = 4) {
+  const besede = naziv.split(/\s+/).filter(Boolean);
+  if (besede.length < 3)
+    return [];
+  const zanimivost = (b) => {
+    const cisto = b.replace(/[^\p{L}\p{N}]/gu, "");
+    if (/^\d+$/.test(cisto))
+      return 0;
+    if (cisto.length <= 2)
+      return 1;
+    if (/^\d/.test(cisto))
+      return 2;
+    return 3 + Math.min(cisto.length, 10);
+  };
+  const vrstniRed = [...besede].sort((a, b) => zanimivost(a) - zanimivost(b));
+  const variante = [];
+  for (const beseda of vrstniRed) {
+    if (variante.length >= najvec)
+      break;
+    const mesto = besede.indexOf(beseda);
+    if (mesto < 0)
+      continue;
+    const zozena = [...besede.slice(0, mesto), ...besede.slice(mesto + 1)].join(" ");
+    if (zozena.trim() && !variante.includes(zozena))
+      variante.push(zozena);
+  }
+  return variante;
+}
+function pripraviVetIndeks(artikli, nastavitve = {}) {
+  const data = arrayToSearchableData(artikli);
+  const metadata = createSearchArrayMetadataNumeric(data, vetArtikelSpec({ ...nastavitve.polja ? { polja: nastavitve.polja } : {} }));
+  return { data, metadata };
+}
+async function* upariArtikle(prepared, artikli, nastavitve = {}) {
+  const {
+    limit = 3,
+    retrievalLimit = 10,
+    kos = 50,
+    samoEnolicno,
+    ocena: pragOcene
+  } = nastavitve;
+  const uporabiZozeno = nastavitve.zozenaPoizvedba !== false;
+  const pomnilnik = new Map;
+  const oceni = (poizvedba, kandidat, razrediPoizvedbe, razrediKandidata) => {
+    const kljuc2 = `${poizvedba}\x00${kandidat}`;
+    let rezultat = pomnilnik.get(kljuc2);
+    if (!rezultat) {
+      rezultat = oceniPar(poizvedba, kandidat, pragOcene, {
+        ...razrediPoizvedbe ? { poizvedba: razrediPoizvedbe } : {},
+        ...razrediKandidata ? { kandidat: razrediKandidata } : {}
+      });
+      pomnilnik.set(kljuc2, rezultat);
+    }
+    return rezultat;
+  };
+  const nazivPoId = new Map;
+  for (const artikel of artikli)
+    nazivPoId.set(String(artikel._id), artikel.naziv);
+  const iterator = matchMany(prepared, artikli, {
+    queryOf: (z) => {
+      const { classes } = normalizeQueryWithOpts(z.naziv, vetQueryOpts());
+      return { text: z.naziv, ...Object.keys(classes).length ? { classes } : {} };
+    },
+    idOf: (z) => String(z._id),
+    limit,
+    ...retrievalLimit !== undefined ? { retrievalLimit } : {},
+    kos,
+    ...samoEnolicno ? { samoEnolicno: true } : {},
+    opts: vetQueryOpts(),
+    primaryTextOf: (item) => item.naziv,
+    rank: (kandidat, poizvedba) => oceni(poizvedba.text, String(kandidat.item.naziv), poizvedba.classes, kandidat.classes).ocena,
+    accept: (kandidat, poizvedba) => oceni(poizvedba.text, String(kandidat.item.naziv), poizvedba.classes, kandidat.classes).sprejeto,
+    ...uporabiZozeno ? {
+      alternativnePoizvedbe: (z) => zoziPoizvedbo(z.naziv),
+      alternativneLeCeNiZadetkov: true
+    } : {}
+  });
+  for await (const kosRezultatov of iterator) {
+    const izhod = kosRezultatov.map((rezultat) => ({
+      id: rezultat.id,
+      kandidati: rezultat.kandidati.map((kandidat) => {
+        const classes = itemClasses(prepared.metadata, kandidat.id);
+        const ocena = oceni(nazivPoId.get(rezultat.id) ?? "", String(kandidat.item.naziv), rezultat.queryClasses, classes);
+        return {
+          id: String(kandidat.id),
+          item: kandidat.item,
+          score: kandidat.score,
+          sprejeto: ocena.sprejeto,
+          ocena,
+          ...classes ? { classes } : {}
+        };
+      })
+    }));
+    yield izhod;
+  }
+}
+async function upariVse(prepared, artikli, nastavitve = {}) {
+  const izhod = [];
+  for await (const kos of upariArtikle(prepared, artikli, nastavitve))
+    izhod.push(...kos);
+  return izhod;
+}
+export {
+  ENOTE_SINONIMI,
+  VET_NORMALIZATORJI,
+  VET_TABELA,
+  VRSTE_SINONIMI,
+  ZNAMKE_GEN,
+  decimalkeNormalizator,
+  enoteNormalizator,
+  kolicinaNormalizator,
+  normalizeQueryWithOpts,
+  oceniPar,
+  oznakeNormalizator,
+  pripraviVetIndeks,
+  upariArtikle,
+  upariVse,
+  vetArtikelSpec,
+  vetQueryOpts,
+  vrstaNormalizator,
+  znamkaNormalizator
+};