cry-vetzdravila 1.0.0

package/src/register/helper/normalizirajNaziv.ts

@@ -0,0 +1,493 @@
+/**
+ * Normalizacija naziva zdravila
+ *
+ * Čiščenje in normalizacija imen zdravil za boljše iskanje.
+ */
+
+/**
+ * Enote za doziranje
+ */
+const ENOTE = [
+	"g", "mg", "mcg", "kg", "l", "ml", "dl", "deci", "ie", "tbl",
+	"cap", "caps", "kap", "kps", "kaps", "kapsula", "kapsul",
+	"doz", "doza", "doze",
+	"tub", "tubi", "tube", "tuba",
+	"ser",
+	"kos", "kosov", "kosa", "kosi",
+	"kom", "komadov", "komada", "komadi", "komad"
+] as const;
+
+/**
+ * Enote za količino (brez g, mg, mcg, kg, ml, dl, ie)
+ * Uporablja se za prepoznavanje količine na koncu naziva
+ */
+const ENOTE_KOLICINE = [
+	"tbl",
+	"cap", "caps", "kap", "kps", "kaps", "kapsula", "kapsul",
+	"doz", "doza", "doze",
+	"tub", "tubi", "tube", "tuba",
+	"ser",
+	"kos", "kosov", "kosa", "kosi",
+	"kom", "komadov", "komada", "komadi", "komad"
+] as const;
+
+/**
+ * 1. Pretvori v male črke za slovensko lokalizacijo
+ */
+function toLowerCaseSL(text: string): string {
+	return text.toLocaleLowerCase("sl-SI");
+}
+
+/**
+ * 2. Zamenjaj posebne znake + ( ) , ; * s presledki
+ */
+function replaceSpecialChars(text: string): string {
+	return text.replace(/[+(),;*]/g, " ");
+}
+
+/**
+ * 3. Zamenjaj decimalne vejice med dvema številkama z decimalno piko
+ * Primer: "50,5" → "50.5"
+ */
+function replaceDecimalCommas(text: string): string {
+	return text.replace(/(\d),(\d)/g, "$1.$2");
+}
+
+/**
+ * 4. Zamenjaj i.e. z ie
+ */
+function replaceIE(text: string): string {
+	return text.replace(/i\.e\./gi, "ie");
+}
+
+/**
+ * 5. Zamenjaj tablete, tablet, tabl, tableta, tab → tbl
+ */
+function normalizeTablete(text: string): string {
+	return text.replace(/\b(tablete|tablet|tableta|tabl|tab)\b/gi, "tbl");
+}
+
+/**
+ * 5b. Zamenjaj cap, caps, kap, kaps, kapsula, kapsul → kps
+ */
+function normalizeKapsule(text: string): string {
+	return text.replace(/\b(kapsul[ae]?|kaps|kap|caps|cap)\b/gi, "kps");
+}
+
+/**
+ * 5c. Zamenjaj deci → dl
+ */
+function normalizeDeci(text: string): string {
+	return text.replace(/\bdeci\b/gi, "dl");
+}
+
+/**
+ * 5d. Zamenjaj doza, doze → doz
+ */
+function normalizeDoz(text: string): string {
+	return text.replace(/\b(doza|doze)\b/gi, "doz");
+}
+
+/**
+ * 5d. Zamenjaj tube, tubi, tuba → tub
+ */
+function normalizeTub(text: string): string {
+	return text.replace(/\b(tube|tubi|tuba)\b/gi, "tub");
+}
+
+/**
+ * 5e. Zamenjaj kosov, kosa, kosi → kos
+ */
+function normalizeKos(text: string): string {
+	return text.replace(/\b(kosov|kosa|kosi)\b/gi, "kos");
+}
+
+/**
+ * 5f. Zamenjaj kom, komad, komada, komadi, komadov → kos
+ */
+function normalizeKom(text: string): string {
+	return text.replace(/\b(komadov|komada|komadi|komad|kom)\b/gi, "kos");
+}
+
+/**
+ * 6. Odstrani pike za enotami
+ * Primer: "100 gr." → "100 gr"
+ */
+function removeDotsAfterUnits(text: string): string {
+	const enotaPattern = ENOTE.join("|");
+	const regex = new RegExp(`(${enotaPattern})\\.(?!\\d)`, "gi");
+	return text.replace(regex, "$1");
+}
+
+/**
+ * 5. Izbriši presledke med številko in enoto / enoto
+ * Primer: "100 mg / g" → "100mg/g", "160 mg/ml" → "160mg/ml", "330 mg / 100 mg" → "330mg/100mg"
+ */
+function normalizeUnitSlash(text: string): string {
+	const enotaPattern = ENOTE.join("|");
+
+	// Vzorec 1: številka enota / številka enota (z ali brez presledkov)
+	// Primer: "330 mg / 100 mg" → "330mg/100mg"
+	const regex1 = new RegExp(
+		`(\\d+(?:\\.\\d+)?)\\s*(${enotaPattern})\\s*/\\s*(\\d+(?:\\.\\d+)?)\\s*(${enotaPattern})`,
+		"gi"
+	);
+	let result = text.replace(regex1, "$1$2/$3$4");
+
+	// Vzorec 2: številka enota / enota (z ali brez presledkov okoli /)
+	// Primer: "160 mg/ml" → "160mg/ml", "100 mg / g" → "100mg/g"
+	const regex2 = new RegExp(`(\\d+(?:\\.\\d+)?)\\s*(${enotaPattern})\\s*/\\s*(${enotaPattern})`, "gi");
+	result = result.replace(regex2, "$1$2/$3");
+
+	// Vzorec 3: enota / enota (brez številke, z ali brez presledkov)
+	// Primer: "mg / ml" → "mg/ml"
+	const regex3 = new RegExp(`(${enotaPattern})\\s*/\\s*(${enotaPattern})`, "gi");
+	result = result.replace(regex3, "$1/$2");
+
+	return result;
+}
+
+/**
+ * 6. Izbriši presledke med številko in enoto
+ * Primer: "50.5 mg" → "50.5mg", "200 mg 50 mg" → "200mg 50mg"
+ */
+function normalizeUnitSpaces(text: string): string {
+	const enotaPattern = ENOTE.join("|");
+	const regex = new RegExp(`(\\d+(?:\\.\\d+)?)\\s+(${enotaPattern})(?![a-z])`, "gi");
+	return text.replace(regex, "$1$2");
+}
+
+/**
+ * 7. Zamenjaj pike pred enoto s presledki
+ * Primer: "inj.100ml" → "inj 100ml"
+ * Ohrani decimalne pike (pika med dvema številkama)
+ */
+function replaceDotsBeforeUnits(text: string): string {
+	const enotaPattern = ENOTE.join("|");
+	// Zahtevaj črko pred piko, da ne zamenjamo decimalnih pik
+	const regex = new RegExp(`([a-zA-ZčšžćđČŠŽĆĐ])\\.(\\d+(?:\\.\\d+)?(?:${enotaPattern}))`, "gi");
+	return text.replace(regex, "$1 $2");
+}
+
+/**
+ * 7b. Odstrani vse pike pred presledkom
+ * Primer: "inj. 100ml" → "inj 100ml"
+ */
+function removeDotsBeforeSpaces(text: string): string {
+	return text.replace(/\.\s+/g, " ");
+}
+
+/**
+ * 13. Odstrani vse pike za črkami
+ * Primer: "inj." → "inj", "sol." → "sol"
+ */
+function removeDotsAfterLetters(text: string): string {
+	return text.replace(/([a-zA-ZčšžćđČŠŽĆĐ])\./g, "$1");
+}
+
+/**
+ * 14. Zamenjaj pike med črkami s presledki
+ * Primer: "ANTIPAR.ŠAMPON" → "ANTIPAR ŠAMPON"
+ */
+function replaceDotsWithSpaces(text: string): string {
+	return text.replace(/([a-zA-ZčšžćđČŠŽĆĐ])\.([a-zA-ZčšžćđČŠŽĆĐ])/g, "$1 $2");
+}
+
+/**
+ * 15. Zamenjaj enoto gr z g
+ * Primer: "10gr" → "10g", "100gr/ml" → "100g/ml"
+ */
+function normalizeGr(text: string): string {
+	return text.replace(/(\d)gr\b/gi, "$1g");
+}
+
+/**
+ * Pomožna funkcija za odstranitev decimalk pri teži >= 1kg
+ * "40.1" → "40", "0.5" → "0.5" (ohrani za < 1kg)
+ */
+function removeDecimalIfOver1kg(val: string): string {
+	const normalized = val.replace(",", ".");
+	const num = parseFloat(normalized);
+	if (num >= 1) {
+		return Math.floor(num).toString();
+	}
+	return normalized;
+}
+
+/**
+ * 7. Strni teže živali v kg
+ * Primeri:
+ * - "od 40,1 do 60,0 kg" → "40-60kg"
+ * - "od 40,1 kg do 60,0 kg" → "40-60kg"
+ * - "nad 40,1 kg" → "40kg-"
+ * - "vsaj 40 kg" → "40kg-"
+ * - "najmanj 5 kg" → "5kg-"
+ * - "pod 40,1 kg" → "-40kg"
+ * - "do 40,1 kg" → "-40kg"
+ * - "največ 40 kg" → "-40kg"
+ * - "od 40kg - 60kg" → "40-60kg"
+ * Decimalke se odstranijo za teže >= 1kg
+ */
+function normalizeWeightRanges(text: string): string {
+	let result = text;
+
+	// "od X do Y kg" ali "od X kg do Y kg"
+	result = result.replace(
+		/od\s+(\d+(?:[.,]\d+)?)\s*(?:kg\s+)?do\s+(\d+(?:[.,]\d+)?)\s*kg/gi,
+		(_, from, to) => `${removeDecimalIfOver1kg(from)}-${removeDecimalIfOver1kg(to)}kg`
+	);
+
+	// "od Xkg - Ykg" (z vezajem)
+	result = result.replace(
+		/od\s+(\d+(?:[.,]\d+)?)\s*kg\s*-\s*(\d+(?:[.,]\d+)?)\s*kg/gi,
+		(_, from, to) => `${removeDecimalIfOver1kg(from)}-${removeDecimalIfOver1kg(to)}kg`
+	);
+
+	// "nad X kg" ali "vsaj X kg" ali "najmanj X kg" (od te teže naprej)
+	result = result.replace(/(?:nad|vsaj|najmanj)\s+(\d+(?:[.,]\d+)?)\s*kg/gi, (_, val) => `${removeDecimalIfOver1kg(val)}kg-`);
+
+	// "pod X kg" ali "do X kg" ali "največ X kg" (do te teže)
+	result = result.replace(/(?:pod|do|največ)\s+(\d+(?:[.,]\d+)?)\s*kg/gi, (_, val) => `-${removeDecimalIfOver1kg(val)}kg`);
+
+	return result;
+}
+/**
+ * 17. Dodaj kg za vsako številko v teži
+ * Primer: "40-60kg" → "40kg-60kg", "-40kg" → "-40kg", "40kg-" → "40kg-"
+ */
+function addKgToWeight(text: string): string {
+	// Vzorec za razpon tež: X-Ykg → Xkg-Ykg
+	let result = text.replace(/(\d+)-(\d+)kg/g, "$1kg-$2kg");
+	// Vzorec za teže brez kg na prvi številki: -Xkg ostane -Xkg (že pravilno)
+	// Vzorec za teže brez kg na zadnji številki: Xkg- ostane Xkg- (že pravilno)
+	return result;
+}
+
+/**
+ * 10. Odstrani " za "
+ */
+function removeZa(text: string): string {
+	return text.replace(/\s+za\s+/gi, " ");
+}
+
+/**
+ * 19. Normalizira količine na koncu naziva
+ * - Odstrani presledke okrog x ali *
+ * - Zamenja a/á + številka → številka (brez a/á)
+ * - Odstrani začetni x pred številko
+ * - Če je številka "1", jo odstrani
+ * Primeri:
+ * - "zdravilo 10 x 5" → "zdravilo 10x5"
+ * - "zdravilo 5 * 10" → "zdravilo 5*10"
+ * - "zdravilo a 7 tbl" → "zdravilo 7tbl"
+ * - "zdravilo á7tbl" → "zdravilo 7tbl"
+ * - "ypozane 15mg x7tbl" → "ypozane 15mg 7tbl"
+ * - "1kom" → "kom"
+ */
+function normalizeTrailingQuantity(text: string): string {
+	let result = text;
+	// Odstrani presledke okrog x ali *
+	result = result.replace(/(\d+)\s*[x×]\s*(\d+)/gi, "$1x$2");
+	result = result.replace(/(\d+)\s*\*\s*(\d+)/g, "$1*$2");
+	// Zamenja a/á + morda presledki + številka → številka (brez a/á)
+	// Uporabi (?<![a-zA-ZčšžćđČŠŽĆĐ]) namesto \b ker \b ne deluje z á
+	result = result.replace(/(?<![a-zA-ZčšžćđČŠŽĆĐ])[aá]\s*(\d+)/gi, "$1");
+	// Odstrani začetni x pred številko (x7tbl → 7tbl)
+	result = result.replace(/\bx(\d+)/gi, "$1");
+	// Če je številka "1" pred enoto, jo odstrani (1kom → kom)
+	const enotaPattern = ENOTE.join("|");
+	const regex1 = new RegExp(`\\b1(${enotaPattern})\\b`, "gi");
+	result = result.replace(regex1, "$1");
+	return result;
+}
+
+/**
+ * 12. Zamenjaj " / " s presledki
+ * Dodaj presledek na konec, nato zamenjaj vse " / " s presledki
+ * Primer: "zdravilo / oblika" → "zdravilo oblika"
+ */
+function replaceSlashWithSpace(text: string): string {
+	return (text + " ").replace(/\s+\/\s+/g, " ");
+}
+
+/**
+ * 13. Zamenjaj živalske vrste
+ * psi, pse, psa → pse
+ * mačko, mačka, mačke → mačke
+ * krava, krave, telice → govedo
+ */
+function normalizeAnimalSpecies(text: string): string {
+	return text
+		.replace(/\b(psi|psa)\b/gi, "pse")
+		.replace(/\b(mačko|mačka)\b/gi, "mačke")
+		.replace(/\b(krava|krave|telice)\b/gi, "govedo");
+}
+
+/**
+ * 14. Odstrani vse znake / za presledkom
+ * Primer: "zdravilo / test" → "zdravilo test" (že urejeno z replaceSlashWithSpace)
+ * Primer: "zdravilo /" → "zdravilo"
+ */
+function removeSlashAfterSpace(text: string): string {
+	return text.replace(/\s+\/\s*/g, " ").replace(/\s+\/$/g, "");
+}
+
+
+/**
+ * Glavna funkcija za normalizacijo naziva
+ */
+export function normalizirajNaziv(naziv: string): string {
+	let result = naziv;
+
+	// 1. Male črke
+	result = toLowerCaseSL(result);
+
+	// 2. Odstrani " za "
+	result = removeZa(result);
+
+	// 3. Decimalne vejice
+	result = replaceDecimalCommas(result);
+
+	// 4. Posebni znaki + ( ) , ; * → presledki
+	result = replaceSpecialChars(result);
+
+	// 5. i.e. → ie
+	result = replaceIE(result);
+
+	// 6. tablete/tablet/tabl/tableta/tab → tbl
+	result = normalizeTablete(result);
+
+	// 6b. kapsul/kapsula/kaps/kap/caps → cap
+	result = normalizeKapsule(result);
+
+	// 6c. deci → dl
+	result = normalizeDeci(result);
+
+	// 6d. doza/doze → doz
+	result = normalizeDoz(result);
+
+	// 6d. tube/tubi/tuba → tub
+	result = normalizeTub(result);
+
+	// 6e. kosov/kosa/kosi → kos
+	result = normalizeKos(result);
+
+	// 6f. kom/komad/komada/komadi/komadov → kos
+	result = normalizeKom(result);
+
+	// 7. Odstrani pike za enotami
+	result = removeDotsAfterUnits(result);
+
+	// 8. Enota/enota brez presledkov
+	result = normalizeUnitSlash(result);
+
+	// 9. Številka enota brez presledkov
+	result = normalizeUnitSpaces(result);
+
+	// 10. Pike pred enoto → presledki
+	result = replaceDotsBeforeUnits(result);
+
+	// 10b. Pike pred presledkom → odstrani
+	result = removeDotsBeforeSpaces(result);
+
+	// 13. Pike za črkami → odstrani
+	result = removeDotsAfterLetters(result);
+
+	// 14. Pike med črkami → presledki
+	result = replaceDotsWithSpaces(result);
+
+	// 15. gr → g
+	result = normalizeGr(result);
+
+	// 12. Teže živali (decimalke se odstranijo znotraj funkcije)
+	result = normalizeWeightRanges(result);
+
+	// 17. Dodaj kg za vsako številko v teži
+	result = addKgToWeight(result);
+
+	// 15. Normaliziraj količine na koncu
+	result = normalizeTrailingQuantity(result);
+
+	// 16. Zamenjaj " / " s presledki
+	result = replaceSlashWithSpace(result);
+
+	// 16b. Odstrani / za presledkom
+	result = removeSlashAfterSpace(result);
+
+	// 17. Zamenjaj živalske vrste
+	result = normalizeAnimalSpecies(result);
+
+	// 18. Počisti odvečne presledke
+	result = result.replace(/\s+/g, " ").trim();
+
+	return result;
+}
+
+/**
+ * Rezultat razčlenitve naziva zdravila
+ */
+export interface RazclenjeniNaziv {
+	izvorni_naziv: string;
+	normaliziran_naziv: string;
+	teza: string | null;
+	kolicina: string | null;
+	doze: string[];
+	besede: string[];
+	zivalskeVrste: string[];
+}
+
+/**
+ * Vzorec za prepoznavanje doz (kombinacija številk, enot in "/")
+ * Primeri: 100mcg, 2mg/5ml, 2x3ml
+ */
+const DOZA_PATTERN = new RegExp(
+	`^(\\d+(?:\\.\\d+)?(?:x\\d+)?(?:${ENOTE.join("|")})(?:/(?:\\d+(?:\\.\\d+)?)?(?:${ENOTE.join("|")}))?)$`,
+	"i"
+);
+
+/**
+ * Vzorec za prepoznavanje količine na koncu naziva
+ * Primeri: 7tbl, 10x5, 5*10, kos (brez mg, ml, g, kg, mcg, dl, ie)
+ */
+const KOLICINA_PATTERN = new RegExp(
+	`((?:\\d+(?:[x*]\\d+)?)?(?:${ENOTE_KOLICINE.join("|")})|\\d+[x*]\\d+)\\*?$`,
+	"i"
+);
+
+/**
+ * Vzorec za prepoznavanje teže
+ * Primeri: 40kg-60kg, -40kg, 40kg-, 0.5kg
+ */
+const TEZA_PATTERN = /^-?\d+(?:\.\d+)?kg(?:-(?:\d+(?:\.\d+)?kg)?)?$/i;
+
+// Izvozi tudi posamezne funkcije za testiranje
+export {
+	toLowerCaseSL,
+	replaceSpecialChars,
+	replaceDecimalCommas,
+	replaceIE,
+	normalizeTablete,
+	normalizeKapsule,
+	normalizeDeci,
+	normalizeDoz,
+	normalizeTub,
+	normalizeKos,
+	normalizeKom,
+	removeDotsAfterUnits,
+	normalizeUnitSlash,
+	normalizeUnitSpaces,
+	replaceDotsBeforeUnits,
+	removeDotsBeforeSpaces,
+	removeDotsAfterLetters,
+	normalizeGr,
+	normalizeWeightRanges,
+	addKgToWeight,
+	removeZa,
+	normalizeTrailingQuantity,
+	replaceSlashWithSpace,
+	removeSlashAfterSpace,
+	normalizeAnimalSpecies,
+	DOZA_PATTERN,
+	KOLICINA_PATTERN,
+	TEZA_PATTERN,
+};

package/src/register/helper/oblikujRezultatIskanja.ts

@@ -0,0 +1,15 @@
+import { ZdraviloZUtemeljitvijo } from "../types/ZdraviloZUtemeljitvijo";
+
+export function oblikujRezultatIskanja(rezultati: ZdraviloZUtemeljitvijo[]) {
+	const imamoNajboljsega = (rezultati?.length === 1)
+		||
+		(
+			(rezultati.length > 1)
+			&&
+			(rezultati[0].utemeljitev.ocena !== rezultati[1].utemeljitev.ocena)
+		);
+
+	const najboljsi = (imamoNajboljsega && rezultati[0].zdravilo) || undefined;
+	const zadetki = rezultati?.map?.(r => ({ zdravilo: r.zdravilo, ocena: r.utemeljitev.ocena })) || [];
+	return { zadetki, najboljsi };
+}

package/src/register/helper/oceniPodobnost.ts

@@ -0,0 +1,194 @@
+/**
+ * Ocena podobnosti med dvema razčlenjenima nazivoma zdravil
+ */
+
+import type { RazclenjeniNaziv } from "./normalizirajNaziv";
+
+/**
+ * Utemeljitev ocene podobnosti
+ */
+export interface UtemeljitevOcene {
+	/** Skupna ocena podobnosti */
+	ocena: number;
+	/** Ocena ujemanja prvih štirih besed v obe smeri (prva: 500, druga: 300, tretja: 200, četrta: 100) */
+	ocenaPrvihBesed: number;
+	/** Ocena ujemanja velikosti (male/mali, srednje/srednji, velike/veliki) - 70 za vsako */
+	ocenaVelikosti: number;
+	/** Ocena ujemanja doz (0-200) */
+	ocenaDoze: number;
+	/** Ocena ujemanja živalskih vrst (0-200) */
+	ocenaZivalskihVrst: number;
+	/** Ocena ujemanja teže (0 ali 300) */
+	ocenaTeze: number;
+	/** Ocena ujemanja količine (0 ali 200) */
+	ocenaKolicine: number;
+	/** Ocena ujemanja besed (0-200) */
+	ocenaBesed: number;
+	/** Kazen za razliko v številu besed (-10 * razlika) */
+	steviloBesed: number;
+	/** uporavljena razčlemba */
+	razclembaRegistra: RazclenjeniNaziv
+}
+
+/**
+ * Oceni podobnost med dvema razčlenjenima nazivoma
+ *
+ * @param razclembaVhoda - Razčlenjen vhodni naziv (iskalni niz)
+ * @param razclembaRegistra - Razčlenjen naziv iz registra zdravil
+ * @returns Utemeljitev z delnimi ocenami in skupno oceno
+ */
+export function oceniPodobnost(
+	razclembaVhoda: RazclenjeniNaziv,
+	razclembaRegistra: RazclenjeniNaziv
+): UtemeljitevOcene {
+	// 1. Ocena prvih štirih besed
+	// Če se prve štiri besede zdravila iz registra pojavljajo v seznamu besed vhoda
+	let ocenaPrvihBesed = 0;
+	const tockeZaBesedo = [500, 300, 200, 100]; // prva, druga, tretja, četrta beseda
+	for (let i = 0; i < Math.min(4, razclembaRegistra.besede.length); i++) {
+		const besedaRegistra = razclembaRegistra.besede[i];
+		if (razclembaVhoda.besede.includes(besedaRegistra)) {
+			ocenaPrvihBesed += tockeZaBesedo[i];
+		} else {
+			// Delno ujemanje - preveri če je katera beseda iz vhoda prefiks besede iz registra ali obratno
+			for (const besedaVhoda of razclembaVhoda.besede) {
+				if (besedaVhoda.length >= 3 && (besedaRegistra.startsWith(besedaVhoda) || besedaVhoda.startsWith(besedaRegistra))) {
+					ocenaPrvihBesed += tockeZaBesedo[i] / 2;
+					break;
+				}
+			}
+		}
+	}
+
+	// 1b. Dodatna ocena: če se prve štiri besede vhoda pojavljajo v registru
+	// To zagotovi, da dobimo višjo oceno, če ima register besede, ki jih iščemo
+	for (let i = 0; i < Math.min(4, razclembaVhoda.besede.length); i++) {
+		const besedaVhoda = razclembaVhoda.besede[i];
+		if (razclembaRegistra.besede.includes(besedaVhoda)) {
+			ocenaPrvihBesed += tockeZaBesedo[i];
+		} else {
+			// Delno ujemanje - preveri če je katera beseda iz registra prefiks besede iz vhoda ali obratno
+			for (const besedaRegistra of razclembaRegistra.besede) {
+				if (besedaVhoda.length >= 3 && (besedaVhoda.startsWith(besedaRegistra) || besedaRegistra.startsWith(besedaVhoda))) {
+					ocenaPrvihBesed += tockeZaBesedo[i] / 2;
+					break;
+				}
+			}
+		}
+	}
+
+	// 2. Ocena velikosti (male/mali, srednje/srednji, velike/veliki, zelo)
+	const VELIKOSTI = ["male", "mali", "srednje", "srednji", "velike", "veliki", "zelo"];
+	let ocenaVelikosti = 0;
+	for (const velikost of VELIKOSTI) {
+		const vVhodu = razclembaVhoda.besede.includes(velikost);
+		const vRegistru = razclembaRegistra.besede.includes(velikost);
+		if (vVhodu && vRegistru) {
+			ocenaVelikosti += 70;
+		}
+	}
+
+	// 3. Ocena doze
+	let ocenaDoze = 0;
+	if (razclembaRegistra.doze.length > 0) {
+		const tockeNaDozo = 200 / razclembaRegistra.doze.length;
+		const delneNaDozo = 100 / razclembaRegistra.doze.length;
+
+		for (const dozaVhoda of razclembaVhoda.doze) {
+			// Točno ujemanje
+			if (razclembaRegistra.doze.includes(dozaVhoda)) {
+				ocenaDoze += tockeNaDozo;
+			}
+			// Delno ujemanje - doza iz vhoda je začetek doze iz registra
+			else if (dozaVhoda.length > 3) {
+				for (const dozaRegistra of razclembaRegistra.doze) {
+					if (dozaRegistra.startsWith(dozaVhoda)) {
+						ocenaDoze += delneNaDozo;
+						break;
+					}
+				}
+			}
+		}
+
+		// Delno ujemanje - besede iz vhoda (številke brez enote) kot začetek doze iz registra
+		// Npr. "500" iz vhoda ujema "500mg" iz registra
+		for (const besedaVhoda of razclembaVhoda.besede) {
+			// Samo številke dolžine > 1
+			if (/^\d+$/.test(besedaVhoda) && besedaVhoda.length > 1) {
+				for (const dozaRegistra of razclembaRegistra.doze) {
+					if (dozaRegistra.startsWith(besedaVhoda)) {
+						ocenaDoze += delneNaDozo;
+						break;
+					}
+				}
+			}
+		}
+	}
+
+	// 3. Ocena živalskih vrst
+	let ocenaZivalskihVrst = 0;
+	if (razclembaRegistra.zivalskeVrste.length > 0) {
+		const tockeNaVrsto = 200 / razclembaRegistra.zivalskeVrste.length;
+
+		for (const vrstaRegistra of razclembaRegistra.zivalskeVrste) {
+			if (razclembaVhoda.zivalskeVrste.includes(vrstaRegistra)) {
+				ocenaZivalskihVrst += tockeNaVrsto;
+			}
+		}
+	}
+
+	// 4. Ocena teže
+	let ocenaTeze = 0;
+	if (razclembaRegistra.teza && razclembaVhoda.teza) {
+		if (razclembaRegistra.teza === razclembaVhoda.teza) {
+			ocenaTeze = 300;
+		}
+	}
+
+	// 5. Ocena količine
+	let ocenaKolicine = 0;
+	if (razclembaRegistra.kolicina && razclembaVhoda.kolicina) {
+		if (razclembaRegistra.kolicina === razclembaVhoda.kolicina) {
+			ocenaKolicine = 200;
+		}
+	}
+
+	// 7. Ocena besed
+	let ocenaBesed = 0;
+	for (const besedaVhoda of razclembaVhoda.besede) {
+		if (razclembaRegistra.besede.includes(besedaVhoda)) {
+			ocenaBesed += 10 * besedaVhoda.length;
+		}
+	}
+	// Omejitev na največ 200
+	ocenaBesed = Math.min(ocenaBesed, 200);
+
+	// 8. Kazen za razliko v številu besed
+	const razlikaBesed = Math.abs(razclembaVhoda.besede.length - razclembaRegistra.besede.length);
+	const steviloBesed = -10 * razlikaBesed;
+
+	// Skupna ocena
+	const ocena =
+		ocenaPrvihBesed +
+		ocenaVelikosti +
+		ocenaDoze +
+		ocenaZivalskihVrst +
+		ocenaTeze +
+		ocenaKolicine +
+		ocenaBesed +
+		steviloBesed;
+
+	return {
+		ocena,
+		ocenaPrvihBesed,
+		ocenaVelikosti,
+		ocenaDoze,
+		ocenaZivalskihVrst,
+		ocenaTeze,
+		ocenaKolicine,
+		ocenaBesed,
+		steviloBesed,
+		razclembaRegistra,
+	};
+}
+