cry-search 2.1.0 → 2.2.0

package/dist/vet/index.js

@@ -177,6 +177,369 @@ dodajVrsto("jelen", ["jelena", "jeleni", "jelenov", "jelenjad"]);
 dodajVrsto("srna", ["srne", "srni", "srn", "srnjak", "srnjaka", "srnjaki"]);
 dodajVrsto("divjad", ["divjadi", "divjadjo"]);
 
+// src/vet/data/prevodi.ts
+var PREVODI = {
+  dog: "pes",
+  dogs: "pes",
+  pse: "pes",
+  puppy: "mladič",
+  puppies: "mladič",
+  cat: "mačka",
+  cats: "mačka",
+  kitten: "mladič",
+  kittens: "mladič",
+  rabbit: "zajec",
+  bunny: "zajec",
+  chicken: "piščanec",
+  chick: "piščanec",
+  hen: "kokoš",
+  turkey: "puran",
+  duck: "raca",
+  goose: "gos",
+  quail: "prepelica",
+  pheasant: "fazan",
+  beef: "govedina",
+  veal: "teletina",
+  pork: "svinjina",
+  lamb: "jagnjetina",
+  mutton: "jagnjetina",
+  sheep: "ovca",
+  goat: "koza",
+  horse: "konj",
+  buffalo: "bivol",
+  bison: "bizon",
+  venison: "divjačina",
+  boar: "divji prašič",
+  salmon: "losos",
+  trout: "postrv",
+  cod: "polenovka",
+  codfish: "polenovka",
+  hake: "oslič",
+  herring: "sled",
+  sardine: "sardela",
+  anchovy: "inčun",
+  mackerel: "skuša",
+  shrimp: "rakci",
+  prawn: "rakci",
+  krill: "kril",
+  crab: "rakovice",
+  lobster: "jastog",
+  squid: "lignji",
+  octopus: "hobotnica",
+  clam: "skoljke",
+  mussel: "skoljke",
+  egg: "jajce",
+  eggs: "jajce",
+  milk: "mleko",
+  cheese: "sir",
+  yogurt: "jogurt",
+  insect: "žuželke",
+  fish: "riba",
+  salmonoil: "ribje olje",
+  rice: "riž",
+  potato: "krompir",
+  potatoes: "krompir",
+  potatoe: "krompir",
+  grain: "žita",
+  grains: "žita",
+  wheat: "pšenica",
+  corn: "koruza",
+  maize: "koruza",
+  oat: "oves",
+  oats: "oves",
+  barley: "ječmen",
+  rye: "rž",
+  spelt: "pira",
+  spelled: "pira",
+  millet: "proso",
+  sorghum: "sirek",
+  quinoa: "kvinoja",
+  buckwheat: "ajda",
+  pea: "grah",
+  peas: "grah",
+  chickpea: "čiček",
+  lentil: "leča",
+  bean: "fižol",
+  beans: "fižol",
+  carrot: "korenje",
+  carrots: "korenje",
+  spinach: "špinača",
+  broccoli: "brokoli",
+  tomato: "paradižnik",
+  tomatoes: "paradižnik",
+  beet: "pesa",
+  beetroot: "pesa",
+  pumpkin: "buča",
+  courgette: "bučke",
+  zucchini: "bučke",
+  kale: "ohrovt",
+  cabbage: "zelje",
+  apple: "jabolko",
+  apples: "jabolko",
+  pomegranate: "granatno jabolko",
+  pomeg: "granatno jabolko",
+  orange: "pomaranča",
+  lemon: "limona",
+  pear: "hruška",
+  blueberry: "borovnica",
+  blueberries: "borovnica",
+  cranberry: "brusnica",
+  cranberries: "brusnica",
+  raspberry: "malina",
+  strawberry: "jagoda",
+  blackberry: "robida",
+  cherry: "češnja",
+  apricot: "marelica",
+  peach: "breskev",
+  pineapple: "ananas",
+  papaya: "papaja",
+  kiwi: "kivi",
+  melon: "melona",
+  melons: "melona",
+  watermelon: "lubenica",
+  cantaloupe: "melona",
+  coconut: "kokoš",
+  almond: "mandelj",
+  walnuts: "oreski",
+  peanut: "arašid",
+  seaweed: "alge",
+  kelp: "alge",
+  yucca: "juka",
+  alfalfa: "lucerna",
+  mint: "meta",
+  chamomile: "kamilica",
+  fennel: "komarček",
+  parsley: "peteršilj",
+  garlic: "česen",
+  flaxseed: "laneno seme",
+  flax: "lan",
+  sesame: "sezam",
+  sunflower: "sončnice",
+  herbal: "zeleni",
+  tablet: "tbl",
+  tablets: "tbl",
+  capsule: "kps",
+  capsules: "kps",
+  injection: "inj",
+  injections: "inj",
+  suspension: "suspenzija",
+  solution: "raztopina",
+  powder: "prašek",
+  granulate: "granulat",
+  granules: "granulat",
+  drops: "kapljice",
+  shampoo: "šampon",
+  conditioner: "balzam",
+  paste: "pasta",
+  pate: "pašteta",
+  syrup: "sirup",
+  spray: "sprej",
+  pipette: "pipeta",
+  ampoule: "ampula",
+  vial: "viala",
+  sachet: "vrecka",
+  pouch: "vrecka",
+  can: "konzerva",
+  cans: "konzerva",
+  tin: "konzerva",
+  bag: "vrecka",
+  tube: "tuba",
+  bottle: "steklenička",
+  jar: "kozarec",
+  collar: "ovratnica",
+  harness: "ovratnica",
+  leash: "povodec",
+  lead: "povodec",
+  muzzle: "nagobcnik",
+  toy: "igraca",
+  toys: "igraca",
+  brush: "krtača",
+  comb: "glavnik",
+  clipper: "škarje",
+  scissors: "škarje",
+  wipes: "brisače",
+  pads: "blazinice",
+  biscuit: "piškot",
+  biscuits: "piškot",
+  stick: "palčka",
+  sticks: "palčka",
+  bone: "kost",
+  jerky: "suseno",
+  chew: "žvečenje",
+  chewable: "žvečljiv",
+  jelly: "žele",
+  gravy: "omaka",
+  sauce: "omaka",
+  mousse: "pena",
+  loaf: "hlod",
+  cream: "krema",
+  oil: "olje",
+  balm: "balzam",
+  tonic: "tonik",
+  lotion: "losjon",
+  urinary: "urinarne",
+  renal: "ledvično",
+  kidney: "ledvica",
+  dental: "zobno",
+  hairball: "dlake",
+  joint: "sklepi",
+  joints: "sklepi",
+  skin: "koza",
+  coat: "dlaka",
+  stomach: "želodec",
+  gastric: "prebavno",
+  digestive: "prebavni",
+  digestion: "prebava",
+  intestinal: "črevesni",
+  hepatic: "jetrni",
+  liver: "jetra",
+  cardiac: "srčni",
+  heart: "srce",
+  respiratory: "dihala",
+  breath: "dihala",
+  ear: "ušesa",
+  eye: "oci",
+  eyes: "oci",
+  oral: "oralno",
+  hypoallergenic: "hipoalergen",
+  hypoall: "hipoalergen",
+  allergenic: "alergen",
+  allergy: "alergija",
+  sensitive: "občutljiv",
+  sterilised: "steriliziran",
+  sterilized: "steriliziran",
+  steril: "steriliziran",
+  neutered: "steriliziran",
+  neutred: "steriliziran",
+  neuter: "steriliziran",
+  castrated: "kastriran",
+  obesity: "debelost",
+  obese: "debel",
+  overweight: "predebel",
+  diabetic: "diabetik",
+  mobility: "mobilnost",
+  weight: "teža",
+  growth: "rast",
+  recovery: "okrevanje",
+  convalescence: "okrevanje",
+  calm: "pomiritev",
+  relaxing: "pomiritev",
+  vitality: "vitalnost",
+  immune: "imunski",
+  immunity: "imunost",
+  supplement: "dodatek",
+  supplements: "dodatek",
+  probiotic: "probiotik",
+  probiotics: "probiotik",
+  antioxidant: "antioksidant",
+  fibre: "vlaknine",
+  fiber: "vlaknine",
+  protein: "beljakovine",
+  fat: "maščobe",
+  ash: "pepel",
+  moisture: "vlaga",
+  veterinary: "veterinarski",
+  diet: "dieta",
+  dietary: "dietna",
+  adult: "odrasel",
+  wet: "mokra",
+  dry: "suha",
+  food: "hrana",
+  snack: "priboljsek",
+  snacks: "priboljsek",
+  treat: "priboljsek",
+  treats: "priboljsek",
+  complete: "popolna",
+  balanced: "uravnotežena",
+  daily: "dnevni",
+  special: "specialni",
+  intensive: "intenzivni",
+  support: "podpora",
+  protection: "zaščita",
+  control: "nadzor",
+  hygiene: "higiena",
+  fresh: "sveze",
+  grainfree: "brez zita",
+  bite: "grizljaj",
+  flavour: "okus",
+  flavor: "okus",
+  taste: "okus",
+  chickpomeg: "piscanec granatno jabolko",
+  chpom: "piscanec granatno jabolko",
+  cant: "melona",
+  cantmelon: "melona",
+  neut: "steriliziran",
+  vacc: "cepivo",
+  vaccin: "cepivo",
+  vaccine: "cepivo",
+  haem: "hem",
+  canine: "pasji",
+  feline: "mačji",
+  satiety: "sitost",
+  gastrointestinal: "prebavni",
+  pisc: "piščanec",
+  piscji: "piščanec",
+  krom: "krompir",
+  kromp: "krompir",
+  granat: "granatno",
+  ovck: "ovčka",
+  priboljski: "priboljšek"
+};
+var STOP_BESEDE = [
+  "and",
+  "with",
+  "for",
+  "the",
+  "of",
+  "in",
+  "on",
+  "to",
+  "from",
+  "per",
+  "care",
+  "health",
+  "healthy",
+  "premium",
+  "quality",
+  "test"
+];
+var STAROSTI = {
+  mladic: "mladič",
+  mladicek: "mladič",
+  puppy: "mladič",
+  puppies: "mladič",
+  kitten: "mladič",
+  kittens: "mladič",
+  junior: "mladič",
+  juniors: "mladič",
+  baby: "mladič",
+  weaning: "mladič",
+  odrasel: "odrasel",
+  odrasli: "odrasel",
+  adult: "odrasel",
+  adults: "odrasel",
+  mature: "odrasel",
+  senior: "senior",
+  seniors: "senior",
+  seniorji: "senior",
+  geriatric: "senior",
+  aged: "senior"
+};
+var VELIKOSTI_EN = {
+  small: "s",
+  medium: "m",
+  large: "l",
+  giant: "xl",
+  xlarge: "xl",
+  extralarge: "xl"
+};
+var VELIKOSTI_OKRAJSAVE = {
+  med: "medium",
+  max: "maxi",
+  min: "mini"
+};
+var PREVODI_VIR = "ročno kurirano 2026-10-04 (besedišče izmerjeno v tackakp + SI_TACKA)";
+
 // src/vet/data/znamke.gen.ts
 var ZNAMKE_GEN = {
   vir: "/Users/primozk/devmt/panthenImport",
@@ -924,6 +1287,14 @@ 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;
+var BESEDA_Z_VEZNIKOM = /(?<![\p{L}\p{N}])([\p{L}]+)\s*[&+]\s*([\p{L}]+)(?![\p{L}\p{N}])/gu;
+var VELIKOSTNE_BESEDE = new Set([
+  ...Object.keys(VELIKOSTI_OKRAJSAVE),
+  ...Object.keys(VELIKOSTI_EN),
+  "mini",
+  "maxi",
+  ...Object.keys(VELIKOSTI_SINONIMI)
+]);
 function kanonicaVelika(enota) {
   return enota.toUpperCase();
 }
@@ -1009,19 +1380,90 @@ var vrstaNormalizator = {
     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 TIPSKE_OZNAKE = new Set(ZNAMKE_GEN.tipskeOznake.map(kljucBesede).filter((t) => t.length >= 2 && !PREVODI[t]));
+var razdeljevalciNormalizator = {
+  fn: (v) => {
+    let spremenjeno = false;
+    let besedilo = v.replace(BESEDA_Z_VEZNIKOM, (ujemanje, a, b) => {
+      const ka = kljucBesede(a);
+      const kb = kljucBesede(b);
+      if (!VELIKOSTNE_BESEDE.has(ka) || !VELIKOSTNE_BESEDE.has(kb))
+        return ujemanje;
+      const razsiri = (k) => VELIKOSTI_OKRAJSAVE[k] ?? VELIKOSTI_EN[k] ?? k;
+      spremenjeno = true;
+      return `${razsiri(ka)} ${razsiri(kb)}`;
+    });
+    const zLocili = besedilo.replace(/\s*[&+,;|]\s*/g, " ").replace(/(?<=[\p{L}\p{N}]{2})\s*\/\s*(?=[\p{L}\p{N}]{2})/gu, " ").replace(/(?<![\d])([\p{L}]{2,})\.(?=\s|$)/gu, "$1").replace(/(?<=\p{L})\.(?=\p{L})/gu, " ");
+    if (zLocili !== besedilo)
+      spremenjeno = true;
+    besedilo = zLocili;
+    return spremenjeno ? besedilo.replace(/\s+/g, " ").trim() : undefined;
+  }
+};
+var PREVODI_MAP = new Map(Object.entries(PREVODI));
+var STOP_MAP = new Set(STOP_BESEDE);
+var prevodiNormalizator = {
+  fn: (v) => {
+    let spremenjeno = false;
+    const izhod = v.replace(BESEDA, (ujemanje) => {
+      const kljuc = kljucBesede(ujemanje);
+      if (STOP_MAP.has(kljuc)) {
+        spremenjeno = true;
+        return " ";
+      }
+      const prevod = PREVODI_MAP.get(kljuc);
+      if (!prevod)
+        return ujemanje;
+      spremenjeno = true;
+      return prevod.toUpperCase();
+    });
+    return spremenjeno ? izhod.replace(/\s+/g, " ").trim() : undefined;
+  }
+};
+var starostNormalizator = {
+  fn: (v) => {
+    const najdene = [];
+    const izhod = v.replace(BESEDA, (ujemanje) => {
+      const starost = STAROSTI[kljucBesede(ujemanje)];
+      if (!starost)
+        return ujemanje;
+      if (!najdene.includes(starost))
+        najdene.push(starost);
+      return " ";
+    });
+    if (!najdene.length)
+      return;
+    return { text: izhod.replace(/\s+/g, " ").trim(), classes: { starost: najdene } };
+  }
+};
 var VRSTE_ZA_RAZRED = new Set(["pes", "macka"]);
 var OKRAJSAVE_ZNAMK = new Map;
 var LINIJE_ZNAMK = new Map;
+var ZNANE_ZNAMKE = new Map([["n&d", "NATURAL DELICIOUS"]]);
+var OBIČAJNE_BESEDE = new Set([
+  ...Object.keys(PREVODI),
+  ...STOP_BESEDE,
+  ...Object.keys(STAROSTI),
+  ...Object.keys(VELIKOSTI_EN),
+  ...Object.keys(VELIKOSTI_SINONIMI),
+  ...Object.keys(VRSTE_SINONIMI)
+]);
+var BESEDE_ZNAMK = new Set(ZNAMKE_GEN.okrajsave.flatMap((o) => o.znamka.toLowerCase().split(/[^\p{L}\p{N}]+/u)).filter(Boolean));
 for (const zapis of ZNAMKE_GEN.okrajsave) {
   const kljuc = zapis.okrajsava.toLowerCase();
   if (zapis.zaupanje === "splet")
     continue;
+  if (kljuc.length <= 4 && OBIČAJNE_BESEDE.has(kljuc))
+    continue;
+  if (BESEDE_ZNAMK.has(kljuc))
+    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 (OBIČAJNE_BESEDE.has(kljuc))
+    continue;
   if (!LINIJE_ZNAMK.has(kljuc))
     LINIJE_ZNAMK.set(kljuc, linija.znamka);
 }
@@ -1030,7 +1472,7 @@ var znamkaNormalizator = {
     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);
+      const znamka = ZNANE_ZNAMKE.get(kljuc) ?? OKRAJSAVE_ZNAMK.get(kljuc);
       if (znamka) {
         const besedeCilja = znamka.toLowerCase().split(/[^\p{L}\p{N}]+/u).filter(Boolean);
         if (besedeCilja.includes(kljuc))
@@ -1041,7 +1483,8 @@ var znamkaNormalizator = {
       const linija = LINIJE_ZNAMK.get(kljuc);
       if (linija) {
         spremenjeno = true;
-        return `${linija.toUpperCase()} ${ujemanje.toUpperCase()}`;
+        const ze = v.toLowerCase().includes(linija.toLowerCase());
+        return ze ? ujemanje.toUpperCase() : `${linija.toUpperCase()} ${ujemanje.toUpperCase()}`;
       }
       return ujemanje;
     });
@@ -1075,7 +1518,7 @@ var velikostNormalizator = {
     const najdene = [];
     const izhod = v.replace(BESEDA, (ujemanje, ...args) => {
       const kljuc = kljucBesede(ujemanje);
-      const velikost = VELIKOSTI_SINONIMI[kljuc];
+      const velikost = VELIKOSTI_SINONIMI[kljuc] ?? VELIKOSTI_EN[kljuc];
       if (!velikost)
         return ujemanje;
       const mesto = args[args.length - 2];
@@ -1129,11 +1572,14 @@ var VET_NORMALIZATORJI = [
   kodiranjeNormalizator,
   decimalkeNormalizator,
   pantheonOznakaNormalizator,
-  tipskeOznakeNormalizator,
   enoteNormalizator,
   znamkaNormalizator,
+  razdeljevalciNormalizator,
+  prevodiNormalizator,
+  tipskeOznakeNormalizator,
   kolicinaNormalizator,
   velikostNormalizator,
+  starostNormalizator,
   vrstaNormalizator,
   oznakeNormalizator
 ];
@@ -1142,6 +1588,10 @@ var VET_TABELA = {
   linije: LINIJE_ZNAMK,
   dobavitelji: DOBAVITELJI,
   oznake: OZNAKE,
+  prevodi: PREVODI_MAP,
+  stopBesede: STOP_MAP,
+  starosti: STAROSTI,
+  velikostiEn: VELIKOSTI_EN,
   vir: ZNAMKE_GEN.vir
 };
 // src/vet/spec.ts
@@ -1943,14 +2393,17 @@ var KAZEN = {
   kolicina: 150,
   pakiranje: 150,
   velikost: 300,
-  pantheon: 100
+  pantheon: 100,
+  starost: 400
 };
+var VETO_RAZREDI = new Set(["vrsta"]);
 var BONUS = {
   razpon: 150,
   vrsta: 200,
   kolicina: 100,
   pakiranje: 100,
-  velikost: 150
+  velikost: 150,
+  starost: 200
 };
 function kotSeznam(v) {
   if (v === undefined)
@@ -1962,6 +2415,32 @@ function staVNasprotju(a, b) {
     return false;
   return !a.some((x) => b.includes(x));
 }
+var NORMALIZIRANO = new Map;
+function normalizirajNaziv(naziv) {
+  const shranjeno = NORMALIZIRANO.get(naziv);
+  if (shranjeno)
+    return shranjeno;
+  let text = naziv;
+  const classes = {};
+  for (const n of VET_NORMALIZATORJI) {
+    const r = n.fn(text, "naziv");
+    if (r === undefined)
+      continue;
+    if (typeof r === "string") {
+      text = r;
+      continue;
+    }
+    text = r.text;
+    for (const [kljuc, vrednost] of Object.entries(r.classes ?? {})) {
+      classes[kljuc] = Array.isArray(vrednost) ? vrednost.map(String) : [String(vrednost)];
+    }
+  }
+  const rezultat = { text: text.replace(/\s+/g, " ").trim(), classes };
+  if (NORMALIZIRANO.size > 60000)
+    NORMALIZIRANO.clear();
+  NORMALIZIRANO.set(naziv, rezultat);
+  return rezultat;
+}
 function kljuc(beseda) {
   return beseda.toLowerCase().normalize("NFD").replace(/[\u0300-\u036f]/g, "").replace(/[^a-z0-9]/g, "");
 }
@@ -1991,8 +2470,16 @@ function prestaneVratar(besedePoizvedbe, besedeKandidata) {
 }
 function oceniPar(poizvedba, kandidat, nastavitve = {}, razredi) {
   const n = { ...PRIVZETO, ...nastavitve };
-  const q = razcleniNaziv(poizvedba);
-  const c = razcleniNaziv(kandidat);
+  const qNorm = normalizirajNaziv(poizvedba);
+  const cNorm = normalizirajNaziv(kandidat);
+  const q = razcleniNaziv(qNorm.text);
+  const c = razcleniNaziv(cNorm.text);
+  const qSurov = razcleniNaziv(poizvedba);
+  const cSurov = razcleniNaziv(kandidat);
+  const razrediSkupni = {
+    poizvedba: { ...qNorm.classes, ...razredi?.poizvedba ?? {} },
+    kandidat: { ...cNorm.classes, ...razredi?.kandidat ?? {} }
+  };
   const prazna = {
     ocena: 0,
     sprejeto: false,
@@ -2004,52 +2491,85 @@ function oceniPar(poizvedba, kandidat, nastavitve = {}, razredi) {
   };
   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 vrednostiRazredov = (m) => Object.values(m).flat().map((v) => String(v).toLowerCase()).filter((v) => v.length > 0);
+  const qSurovTok = [
+    ...new Set([
+      ...[...qSurov.besede, ...qSurov.zivalskeVrste, ...qSurov.dozirneOblike].map((t) => t.toLowerCase()),
+      ...vrednostiRazredov(razrediSkupni["poizvedba"] ?? {})
+    ])
+  ];
+  const cSurovTok = [
+    ...new Set([
+      ...[...cSurov.besede, ...cSurov.zivalskeVrste, ...cSurov.dozirneOblike].map((t) => t.toLowerCase()),
+      ...vrednostiRazredov(razrediSkupni["kandidat"] ?? {})
+    ])
+  ];
+  const qTok = [
+    ...new Set([
+      ...[...q.besede, ...q.zivalskeVrste, ...q.dozirneOblike].map((t) => t.toLowerCase()),
+      ...vrednostiRazredov(razrediSkupni["poizvedba"] ?? {})
+    ])
+  ];
+  const cTok = [
+    ...new Set([
+      ...[...c.besede, ...c.zivalskeVrste, ...c.dozirneOblike].map((t) => t.toLowerCase()),
+      ...vrednostiRazredov(razrediSkupni["kandidat"] ?? {})
+    ])
+  ];
+  const izracunajPokritost = (qZetoni, cZetoni) => {
+    const qStevci = new Map;
+    for (const t of qZetoni)
+      qStevci.set(t, (qStevci.get(t) ?? 0) + 1);
+    const cStevci = new Map;
+    for (const t of cZetoni)
+      cStevci.set(t, (cStevci.get(t) ?? 0) + 1);
+    const porabljeno = new Map;
+    let ujemajoce = 0;
+    let ujemajoceCele = 0;
+    const skupne2 = [];
+    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 qKljuc = kljuc(qZeton);
+        const cKljuc = kljuc(cZeton);
+        const cela = qKljuc === cKljuc;
+        const predpona = !cela && (cKljuc.startsWith(qKljuc) || qKljuc.startsWith(cKljuc));
+        const razmerje = Math.min(qKljuc.length, cKljuc.length) / Math.max(qKljuc.length, cKljuc.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 (!skupne2.includes(qZeton))
+          skupne2.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 pokritostKandidata2 = cZetoni.length ? ujemajoce / cZetoni.length : 0;
+    const pokritostPoizvedbe2 = qZetoni.length ? ujemajoce / qZetoni.length : 0;
+    const dovoljDolg = [...porabljeno.keys()].some((t) => kljuc(t).length >= 5);
+    const popolno = pokritostKandidata2 === 1 && pokritostPoizvedbe2 === 1;
+    const ok = ujemajoce >= 1 && pokritostKandidata2 >= n.pokritostKandidata && pokritostPoizvedbe2 >= n.pokritostPoizvedbe && (popolno || ujemajoceCele >= 2 || dovoljDolg);
+    return { ok, pokritostKandidata: pokritostKandidata2, pokritostPoizvedbe: pokritostPoizvedbe2, skupne: skupne2, nasprotja: [] };
+  };
+  const kanonicno = izracunajPokritost(qTok, cTok);
+  const surovo = izracunajPokritost(qSurovTok, cSurovTok);
+  const izbrano = kanonicno.ok || kanonicno.pokritostKandidata >= surovo.pokritostKandidata ? kanonicno : surovo;
+  const { pokritostKandidata, pokritostPoizvedbe, skupne } = izbrano;
+  const pokritostOk = kanonicno.ok || surovo.ok;
+  let ocena = Math.max(oceniPodobnost(q, c).ocena, oceniPodobnost(qSurov, cSurov).ocena);
   const nasprotja = [];
-  const kljuci = ["razpon", "vrsta", "kolicina", "pakiranje", "velikost", "pantheon"];
+  const kljuci = ["razpon", "vrsta", "kolicina", "pakiranje", "velikost", "starost", "pantheon"];
   for (const kljuc2 of kljuci) {
-    const a = kotSeznam(razredi?.poizvedba?.[kljuc2]);
-    const b = kotSeznam(razredi?.kandidat?.[kljuc2]);
+    const a = kotSeznam(razrediSkupni["poizvedba"]?.[kljuc2]);
+    const b = kotSeznam(razrediSkupni["kandidat"]?.[kljuc2]);
     if (staVNasprotju(a, b)) {
       ocena -= KAZEN[kljuc2] ?? 0;
       nasprotja.push(`${kljuc2}: ${a.join("/")} ≠ ${b.join("/")}`);
@@ -2057,8 +2577,9 @@ function oceniPar(poizvedba, kandidat, nastavitve = {}, razredi) {
       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)} %)`;
+  const veto = nasprotja.some((n2) => VETO_RAZREDI.has(n2.split(":")[0] ?? ""));
+  const sprejeto = pokritostOk && !veto && 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("; ")}` : "") : veto ? `nasprotje v razredu (${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
@@ -2222,76 +2743,87 @@ function naSezname(classes) {
   }
   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;
+function matchOne(prepared, query, indeks, options, porabljeni) {
+  const { queryOf, idOf, limit = 3, minScore = 0, 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);
+  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 } : {} });
     }
-    kosZbirka.push({
-      id,
-      ...queryClasses ? { queryClasses } : {},
-      kandidati
+    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);
+  }
+  return {
+    id,
+    ...queryClasses ? { queryClasses } : {},
+    kandidati
+  };
+}
+function matchManySync(prepared, queries, options) {
+  const porabljeni = options.samoEnolicno ? new Set : undefined;
+  const izhod = new Array(queries.length);
+  for (let indeks = 0;indeks < queries.length; indeks++) {
+    izhod[indeks] = matchOne(prepared, queries[indeks], indeks, options, porabljeni);
+  }
+  return izhod;
+}
+async function* matchMany(prepared, queries, options) {
+  const kos = options.kos ?? 50;
+  const porabljeni = options.samoEnolicno ? new Set : undefined;
+  let kosZbirka = [];
+  for (let indeks = 0;indeks < queries.length; indeks++) {
+    kosZbirka.push(matchOne(prepared, queries[indeks], indeks, options, porabljeni));
     if (kosZbirka.length >= kos) {
       yield kosZbirka;
       kosZbirka = [];
@@ -2373,7 +2905,9 @@ async function* upariArtikle(prepared, artikli, nastavitve = {}) {
     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,
+    ...nastavitve.vrniNesprejete ? {} : {
+      accept: (kandidat, poizvedba) => oceni(poizvedba.text, String(kandidat.item.naziv), poizvedba.classes, kandidat.classes).sprejeto
+    },
     ...uporabiZozeno ? {
       alternativnePoizvedbe: (z) => zoziPoizvedbo(z.naziv),
       alternativneLeCeNiZadetkov: true
@@ -2398,6 +2932,58 @@ async function* upariArtikle(prepared, artikli, nastavitve = {}) {
     yield izhod;
   }
 }
+function upariVseSync(prepared, artikli, nastavitve = {}) {
+  const { limit = 3, retrievalLimit = 10, samoEnolicno, ocena: pragOcene } = nastavitve;
+  const uporabiZozeno = nastavitve.zozenaPoizvedba !== false;
+  const nazivPoId = new Map;
+  for (const artikel of artikli)
+    nazivPoId.set(String(artikel._id), artikel.naziv);
+  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 rezultati = matchManySync(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,
+    ...samoEnolicno ? { samoEnolicno: true } : {},
+    opts: vetQueryOpts(),
+    primaryTextOf: (item) => item.naziv,
+    rank: (kandidat, poizvedba) => oceni(poizvedba.text, String(kandidat.item.naziv), poizvedba.classes, kandidat.classes).ocena,
+    ...nastavitve.vrniNesprejete ? {} : {
+      accept: (kandidat, poizvedba) => oceni(poizvedba.text, String(kandidat.item.naziv), poizvedba.classes, kandidat.classes).sprejeto
+    },
+    ...uporabiZozeno ? { alternativnePoizvedbe: (z) => zoziPoizvedbo(z.naziv), alternativneLeCeNiZadetkov: true } : {}
+  });
+  return rezultati.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 } : {}
+      };
+    })
+  }));
+}
 async function upariVse(prepared, artikli, nastavitve = {}) {
   const izhod = [];
   for await (const kos of upariArtikle(prepared, artikli, nastavitve))
@@ -2406,6 +2992,12 @@ async function upariVse(prepared, artikli, nastavitve = {}) {
 }
 export {
   ENOTE_SINONIMI,
+  PREVODI,
+  PREVODI_VIR,
+  STAROSTI,
+  STOP_BESEDE,
+  VELIKOSTI_EN,
+  VELIKOSTI_OKRAJSAVE,
   VET_NORMALIZATORJI,
   VET_TABELA,
   VRSTE_SINONIMI,
@@ -2416,9 +3008,14 @@ export {
   normalizeQueryWithOpts,
   oceniPar,
   oznakeNormalizator,
+  prevodiNormalizator,
   pripraviVetIndeks,
+  razdeljevalciNormalizator,
+  starostNormalizator,
   upariArtikle,
   upariVse,
+  upariVseSync,
+  velikostNormalizator,
   vetArtikelSpec,
   vetQueryOpts,
   vrstaNormalizator,