greek-name-correction 2.0.0 → 2.1.0

package/README.md

@@ -494,7 +494,7 @@ Contributions are welcome! Please feel free to submit a Pull Request. For major
 ### Development
 ```bash
 # Clone the repository
-git clone https://github.com/yourusername/greek-name-correction.git
+git clone https://github.com/sraftopo/greek-name-correction.git
 
 # Install dependencies (none currently!)
 npm install
@@ -522,7 +522,13 @@ The test suite covers:
 
 ## Changelog
 
-### Version 2.0.0 (Current)
+### Version 2.1.0 (Current)
+- 🏗️ **Modular Architecture** - Complete codebase refactoring into logical modules
+- 📦 **Improved Structure** - Separated into `transliteration.js`, `cases.js`, `validation.js`, `utils.js`, `constants.js`
+- 🔧 **Better Maintainability** - Clean separation of concerns for easier testing and development
+- ✨ **Enhanced Code Organization** - Each module has a single, clear responsibility
+
+### Version 2.0.0
 - ✨ Added transliteration support (Greeklish ↔ Greek ↔ Latin)
 - ✨ Added genitive case conversion
 - ✨ Added diminutive detection
@@ -548,7 +554,7 @@ MIT © Stavros
 
 ## Support
 
-For bugs, questions, and discussions please use the [GitHub Issues](https://github.com/yourusername/greek-name-correction/issues).
+For bugs, questions, and discussions please use the [GitHub Issues](https://github.com/sraftopo/greek-name-correction/issues).
 
 ## Acknowledgments
 
@@ -565,4 +571,4 @@ Special thanks to all contributors and users who help improve this library.
 
 **Made in Greece 🇬🇷**
 
-If you find this library helpful, please consider giving it a ⭐️ on GitHub!
+If you find this library helpful, please consider giving it a ⭐️ on GitHub!

package/index.js

@@ -1,557 +1,4 @@
-// index.js
-'use strict';
+// index.js - Backward compatibility re-export
+"use strict";
 
-/**
- * GreekNameCorrection - A zero-dependency library for correcting and formatting Greek names
- * @param {string|string[]|Object|Object[]} input - Name(s) to correct
- * @param {Object} options - Configuration options
- * @returns {string|string[]|Object|Object[]} Corrected name(s) in same format as input
- */
-function GreekNameCorrection(input, options = {}) {
-  const defaults = {
-    jsonKey: 'fullname',
-    preserveOriginal: false,
-    outputKey: 'correctedFullname',
-    splitNames: true,
-    detectGender: false,
-    normalizeTonotics: true,
-    handleDiacritics: true,
-    strictMode: false,
-    removeExtraSpaces: true,
-    handleParticles: true,
-    // New features
-    convertToGenitive: false,
-    transliterate: null, // 'greeklish-to-greek', 'greek-to-latin', 'greek-to-greeklish'
-    detectDiminutive: false,
-    handleTitles: true,
-    suggestCorrections: false,
-    recognizeKatharevousa: false,
-    databaseSafe: false,
-    generateSortKey: false,
-    statistics: false
-  };
-
-  const config = { ...defaults, ...options };
-
-  // Transliteration maps
-  const greeklishToGreekMap = {
-    'a': 'α', 'b': 'β', 'g': 'γ', 'd': 'δ', 'e': 'ε', 'z': 'ζ',
-    'h': 'η', 'th': 'θ', 'i': 'ι', 'k': 'κ', 'l': 'λ', 'm': 'μ',
-    'n': 'ν', 'x': 'ξ', 'o': 'ο', 'p': 'π', 'r': 'ρ', 's': 'σ',
-    't': 'τ', 'y': 'υ', 'f': 'φ', 'ch': 'χ', 'ps': 'ψ', 'w': 'ω',
-    'ks': 'ξ', 'ou': 'ου', 'ai': 'αι', 'ei': 'ει', 'oi': 'οι',
-    'ui': 'υι', 'au': 'αυ', 'eu': 'ευ', 'ou': 'ου', 'iu': 'ιου',
-    'mp': 'μπ', 'nt': 'ντ', 'gk': 'γκ', 'gg': 'γγ', 'ts': 'τσ',
-    'tz': 'τζ', 'dz': 'ντζ'
-  };
-
-  const greekToLatinMap = {
-    'α': 'a', 'ά': 'a', 'β': 'v', 'γ': 'g', 'δ': 'd', 'ε': 'e', 'έ': 'e',
-    'ζ': 'z', 'η': 'i', 'ή': 'i', 'θ': 'th', 'ι': 'i', 'ί': 'i', 'ϊ': 'i', 'ΐ': 'i',
-    'κ': 'k', 'λ': 'l', 'μ': 'm', 'ν': 'n', 'ξ': 'x', 'ο': 'o', 'ό': 'o',
-    'π': 'p', 'ρ': 'r', 'σ': 's', 'ς': 's', 'τ': 't', 'υ': 'y', 'ύ': 'y', 'ϋ': 'y', 'ΰ': 'y',
-    'φ': 'f', 'χ': 'ch', 'ψ': 'ps', 'ω': 'o', 'ώ': 'o',
-    'Α': 'A', 'Ά': 'A', 'Β': 'V', 'Γ': 'G', 'Δ': 'D', 'Ε': 'E', 'Έ': 'E',
-    'Ζ': 'Z', 'Η': 'I', 'Ή': 'I', 'Θ': 'Th', 'Ι': 'I', 'Ί': 'I', 'Ϊ': 'I',
-    'Κ': 'K', 'Λ': 'L', 'Μ': 'M', 'Ν': 'N', 'Ξ': 'X', 'Ο': 'O', 'Ό': 'O',
-    'Π': 'P', 'Ρ': 'R', 'Σ': 'S', 'Τ': 'T', 'Υ': 'Y', 'Ύ': 'Y', 'Ϋ': 'Y',
-    'Φ': 'F', 'Χ': 'Ch', 'Ψ': 'Ps', 'Ω': 'O', 'Ώ': 'O'
-  };
-
-  const greekToGreeklishMap = {
-    'α': 'a', 'ά': 'a', 'β': 'v', 'γ': 'g', 'δ': 'd', 'ε': 'e', 'έ': 'e',
-    'ζ': 'z', 'η': 'i', 'ή': 'i', 'θ': 'th', 'ι': 'i', 'ί': 'i', 'ϊ': 'i', 'ΐ': 'i',
-    'κ': 'k', 'λ': 'l', 'μ': 'm', 'ν': 'n', 'ξ': 'ks', 'ο': 'o', 'ό': 'o',
-    'π': 'p', 'ρ': 'r', 'σ': 's', 'ς': 's', 'τ': 't', 'υ': 'u', 'ύ': 'u', 'ϋ': 'u', 'ΰ': 'u',
-    'φ': 'f', 'χ': 'x', 'ψ': 'ps', 'ω': 'w', 'ώ': 'w',
-    'Α': 'A', 'Ά': 'A', 'Β': 'V', 'Γ': 'G', 'Δ': 'D', 'Ε': 'E', 'Έ': 'E',
-    'Ζ': 'Z', 'Η': 'I', 'Ή': 'I', 'Θ': 'Th', 'Ι': 'I', 'Ί': 'I', 'Ϊ': 'I',
-    'Κ': 'K', 'Λ': 'L', 'Μ': 'M', 'Ν': 'N', 'Ξ': 'Ks', 'Ο': 'O', 'Ό': 'O',
-    'Π': 'P', 'Ρ': 'R', 'Σ': 'S', 'Τ': 'T', 'Υ': 'U', 'Ύ': 'U', 'Ϋ': 'U',
-    'Φ': 'F', 'Χ': 'X', 'Ψ': 'Ps', 'Ω': 'W', 'Ώ': 'W'
-  };
-
-  // Diminutive patterns
-  const diminutivePatterns = {
-    'άκης': 'ας/ης', 'ούλης': 'ος', 'ίτσα': 'α', 'ούλα': 'α',
-    'άκι': 'ο', 'ούλι': 'ο', 'ίτσας': 'ας', 'ούλας': 'ας',
-    'ίκος': 'ος', 'ούκος': 'ος', 'ίκη': 'η', 'ούκα': 'α'
-  };
-
-  // Common Greek titles
-  const titles = [
-    'Κος', 'Κα', 'Δις', 'Κυρ', 'Κυρία', 'Κύριος', 'Δεσποινίς',
-    'Δρ', 'Καθ', 'Καθηγητής', 'Καθηγήτρια', 'Πρωθυπουργός',
-    'Υπουργός', 'Βουλευτής', 'Δήμαρχος', 'Περιφερειάρχης',
-    'Αρχιεπίσκοπος', 'Μητροπολίτης', 'Επίσκοπος', 'Πατήρ',
-    'Στρατηγός', 'Ταξίαρχος', 'Συνταγματάρχης', 'Αντισυνταγματάρχης'
-  ];
-
-  // Katharevousa endings to modern Greek
-  const katharevousaMap = {
-    'ιον': 'ιο', 'ειον': 'ειο', 'αιον': 'αιο',
-    'ου': 'ου', 'ων': 'ων', 'ας': 'ας', 'ης': 'ης'
-  };
-
-  // Common name misspellings
-  const commonCorrections = {
-    'γιοργος': 'γιώργος', 'γεωργιος': 'γεώργιος',
-    'δημητρης': 'δημήτρης', 'δημητριος': 'δημήτριος',
-    'νικος': 'νίκος', 'νικολαος': 'νικόλαος',
-    'μαρια': 'μαρία', 'ελενη': 'ελένη',
-    'κωνσταντινος': 'κωνσταντίνος', 'κωστας': 'κώστας',
-    'ιωαννης': 'ιωάννης', 'γιαννης': 'γιάννης',
-    'αναστασια': 'αναστασία', 'σοφια': 'σοφία',
-    'παναγιωτης': 'παναγιώτης', 'παναγιωτα': 'παναγιώτα'
-  };
-
-  // Main processing function
-  function processName(name) {
-    if (typeof name !== 'string' || name.trim() === '') {
-      return config.strictMode ? null : name;
-    }
-
-    let processed = name;
-    let extractedTitle = null;
-
-    // Extract and handle titles
-    if (config.handleTitles) {
-      const titleResult = extractTitle(processed);
-      extractedTitle = titleResult.title;
-      processed = titleResult.name;
-    }
-
-    // Transliteration
-    if (config.transliterate) {
-      processed = transliterate(processed, config.transliterate);
-    }
-
-    // Remove extra spaces
-    if (config.removeExtraSpaces) {
-      processed = processed.replace(/\s+/g, ' ').trim();
-    }
-
-    // Recognize and convert Katharevousa forms
-    if (config.recognizeKatharevousa) {
-      processed = convertKatharevousa(processed);
-    }
-
-    // Suggest corrections for common misspellings
-    let suggestion = null;
-    if (config.suggestCorrections) {
-      suggestion = suggestCorrection(processed);
-      if (suggestion) {
-        processed = suggestion;
-      }
-    }
-
-    // Normalize Greek tonetics
-    if (config.normalizeTonotics) {
-      processed = normalizeGreekTonotics(processed);
-    }
-
-    // Handle diacritics properly
-    if (config.handleDiacritics) {
-      processed = handleGreekDiacritics(processed);
-    }
-
-    // Split and capitalize each part
-    if (config.splitNames) {
-      const parts = processed.split(/\s+/);
-      processed = parts.map((part, index) => {
-        // Handle Greek name particles
-        if (config.handleParticles && isGreekParticle(part.toLowerCase())) {
-          return part.toLowerCase();
-        }
-        return capitalizeGreekName(part);
-      }).join(' ');
-    } else {
-      processed = capitalizeGreekName(processed);
-    }
-
-    // Convert to genitive case
-    let genitiveForm = null;
-    if (config.convertToGenitive) {
-      genitiveForm = convertToGenitive(processed);
-    }
-
-    // Database-safe output
-    if (config.databaseSafe) {
-      processed = makeDatabaseSafe(processed);
-    }
-
-    // Re-attach title if it was extracted
-    if (extractedTitle) {
-      processed = extractedTitle + ' ' + processed;
-    }
-
-    const result = {
-      corrected: processed,
-      original: name,
-      isValid: validateGreekName(processed, config.strictMode)
-    };
-
-    if (extractedTitle) {
-      result.title = extractedTitle;
-    }
-
-    if (config.detectGender) {
-      result.gender = detectGender(processed);
-    }
-
-    if (config.splitNames) {
-      result.parts = splitNameParts(processed);
-    }
-
-    if (config.detectDiminutive) {
-      result.diminutive = detectDiminutive(processed);
-    }
-
-    if (genitiveForm) {
-      result.genitive = genitiveForm;
-    }
-
-    if (config.generateSortKey) {
-      result.sortKey = generateSortKey(processed);
-    }
-
-    if (config.statistics) {
-      result.statistics = generateStatistics(processed, name);
-    }
-
-    if (suggestion && config.suggestCorrections) {
-      result.wasCorrected = true;
-      result.suggestedCorrection = suggestion;
-    }
-
-    return config.preserveOriginal ? result : processed;
-  }
-
-  // Extract title from name
-  function extractTitle(name) {
-    const words = name.trim().split(/\s+/);
-    const firstWord = words[0];
-    
-    // Check if first word is a title (case-insensitive)
-    const foundTitle = titles.find(t => 
-      firstWord.toLowerCase() === t.toLowerCase() || 
-      firstWord.toLowerCase() + '.' === t.toLowerCase() ||
-      firstWord.toLowerCase() === t.toLowerCase() + '.'
-    );
-
-    if (foundTitle) {
-      return {
-        title: capitalizeGreekName(foundTitle),
-        name: words.slice(1).join(' ')
-      };
-    }
-
-    return { title: null, name: name };
-  }
-
-  // Transliteration function
-  function transliterate(text, mode) {
-    if (mode === 'greeklish-to-greek') {
-      return greeklishToGreek(text);
-    } else if (mode === 'greek-to-latin') {
-      return greekToLatin(text);
-    } else if (mode === 'greek-to-greeklish') {
-      return greekToGreeklish(text);
-    }
-    return text;
-  }
-
-  // Greeklish to Greek conversion
-  function greeklishToGreek(text) {
-    let result = text.toLowerCase();
-    
-    // Sort by length (longest first) to handle multi-character combinations
-    const sortedKeys = Object.keys(greeklishToGreekMap).sort((a, b) => b.length - a.length);
-    
-    for (const key of sortedKeys) {
-      const regex = new RegExp(key, 'gi');
-      result = result.replace(regex, greeklishToGreekMap[key]);
-    }
-    
-    return result;
-  }
-
-  // Greek to Latin conversion
-  function greekToLatin(text) {
-    let result = '';
-    for (let i = 0; i < text.length; i++) {
-      const char = text[i];
-      result += greekToLatinMap[char] || char;
-    }
-    return result;
-  }
-
-  // Greek to Greeklish conversion
-  function greekToGreeklish(text) {
-    let result = '';
-    for (let i = 0; i < text.length; i++) {
-      const char = text[i];
-      result += greekToGreeklishMap[char] || char;
-    }
-    return result;
-  }
-
-  // Convert Katharevousa to modern Greek
-  function convertKatharevousa(text) {
-    let result = text;
-    
-    for (const [old, modern] of Object.entries(katharevousaMap)) {
-      const regex = new RegExp(old + '$', 'i');
-      result = result.replace(regex, modern);
-    }
-    
-    return result;
-  }
-
-  // Suggest correction for common misspellings
-  function suggestCorrection(text) {
-    const words = text.toLowerCase().split(/\s+/);
-    let corrected = false;
-    
-    const correctedWords = words.map(word => {
-      if (commonCorrections[word]) {
-        corrected = true;
-        return commonCorrections[word];
-      }
-      return word;
-    });
-    
-    return corrected ? correctedWords.join(' ') : null;
-  }
-
-  // Convert to genitive case
-  function convertToGenitive(name) {
-    const parts = name.split(/\s+/);
-    const lastName = parts[parts.length - 1];
-    const lowerLast = lastName.toLowerCase();
-    
-    let genitive = lastName;
-    
-    // Male genitive rules
-    if (lowerLast.endsWith('ος')) {
-      genitive = lastName.slice(0, -2) + 'ου';
-    } else if (lowerLast.endsWith('ας')) {
-      genitive = lastName.slice(0, -2) + 'α';
-    } else if (lowerLast.endsWith('ης')) {
-      genitive = lastName.slice(0, -2) + 'η';
-    }
-    // Female names often stay the same or change differently
-    else if (lowerLast.endsWith('ου')) {
-      genitive = lastName; // Already genitive
-    } else if (lowerLast.endsWith('α')) {
-      genitive = lastName.slice(0, -1) + 'ας';
-    } else if (lowerLast.endsWith('η')) {
-      genitive = lastName.slice(0, -1) + 'ης';
-    }
-    
-    parts[parts.length - 1] = genitive;
-    return parts.join(' ');
-  }
-
-  // Detect diminutive forms
-  function detectDiminutive(name) {
-    const parts = name.toLowerCase().split(/\s+/);
-    const results = [];
-    
-    for (const part of parts) {
-      for (const [ending, baseEnding] of Object.entries(diminutivePatterns)) {
-        if (part.endsWith(ending)) {
-          results.push({
-            word: capitalizeGreekName(part),
-            isDiminutive: true,
-            possibleBase: part.slice(0, -ending.length) + baseEnding,
-            diminutiveType: ending
-          });
-          break;
-        }
-      }
-    }
-    
-    return results.length > 0 ? results : null;
-  }
-
-  // Make database-safe
-  function makeDatabaseSafe(text) {
-    // Remove potentially problematic characters for databases
-    return text
-      .replace(/[^\u0370-\u03FF\u1F00-\u1FFF\w\s\-']/g, '')
-      .trim()
-      .replace(/\s+/g, ' ');
-  }
-
-  // Generate sorting key (remove accents for sorting)
-  function generateSortKey(text) {
-    const accentMap = {
-      'ά': 'α', 'έ': 'ε', 'ή': 'η', 'ί': 'ι', 'ό': 'ο', 'ύ': 'υ', 'ώ': 'ω',
-      'Ά': 'Α', 'Έ': 'Ε', 'Ή': 'Η', 'Ί': 'Ι', 'Ό': 'Ο', 'Ύ': 'Υ', 'Ώ': 'Ω',
-      'ϊ': 'ι', 'ϋ': 'υ', 'ΐ': 'ι', 'ΰ': 'υ', 'Ϊ': 'Ι', 'Ϋ': 'Υ',
-      'ς': 'σ'
-    };
-    
-    let sortKey = text.toLowerCase();
-    for (const [accented, plain] of Object.entries(accentMap)) {
-      sortKey = sortKey.replace(new RegExp(accented, 'g'), plain);
-    }
-    
-    return sortKey;
-  }
-
-  // Generate statistics
-  function generateStatistics(processed, original) {
-    const words = processed.split(/\s+/).filter(w => !isGreekParticle(w.toLowerCase()));
-    
-    const stats = {
-      length: processed.length,
-      originalLength: original.length,
-      wordCount: words.length,
-      hasParticles: processed.split(/\s+/).some(w => isGreekParticle(w.toLowerCase())),
-      hasAccents: /[άέήίόύώΆΈΉΊΌΎΏ]/.test(processed),
-      hasDiaeresis: /[ϊϋΐΰ]/.test(processed),
-      isAllCaps: original === original.toUpperCase() && /[Α-Ωα-ω]/.test(original),
-      isAllLower: original === original.toLowerCase() && /[Α-Ωα-ω]/.test(original),
-      hasNumbers: /\d/.test(processed),
-      hasSpecialChars: /[^Α-Ωα-ωίϊΐόάέύϋΰήώ\s\-']/.test(processed)
-    };
-    
-    return stats;
-  }
-
-  // Capitalize Greek names properly
-  function capitalizeGreekName(str) {
-    if (!str || str.length === 0) return str;
-    
-    const first = str.charAt(0).toUpperCase();
-    const rest = str.slice(1).toLowerCase();
-    
-    return first + rest;
-  }
-
-  // Normalize Greek tonetics
-  function normalizeGreekTonotics(str) {
-    const tonoticMap = {
-      'ά': 'ά', 'έ': 'έ', 'ή': 'ή', 'ί': 'ί', 'ό': 'ό', 'ύ': 'ύ', 'ώ': 'ώ',
-      'Ά': 'Ά', 'Έ': 'Έ', 'Ή': 'Ή', 'Ί': 'Ί', 'Ό': 'Ό', 'Ύ': 'Ύ', 'Ώ': 'Ώ',
-      'ϊ': 'ϊ', 'ϋ': 'ϋ', 'ΐ': 'ΐ', 'ΰ': 'ΰ',
-      'Ϊ': 'Ϊ', 'Ϋ': 'Ϋ'
-    };
-
-    return str.split('').map(char => tonoticMap[char] || char).join('');
-  }
-
-  // Handle Greek diacritics
-  function handleGreekDiacritics(str) {
-    return str.normalize('NFC');
-  }
-
-  // Check if word is a Greek particle
-  function isGreekParticle(word) {
-    const particles = [
-      'του', 'της', 'των', 'τον', 'την', 'τα', 'το',
-      'και', 'ή', 'ειδών', 'εκ', 'εξ'
-    ];
-    return particles.includes(word);
-  }
-
-  // Validate Greek name
-  function validateGreekName(name, strict = false) {
-    if (!name || name.trim() === '') return false;
-    
-    const greekPattern = /^[Α-Ωα-ωίϊΐόάέύϋΰήώ\s\-']+$/;
-    
-    if (strict) {
-      return greekPattern.test(name);
-    }
-    
-    const hasGreek = /[Α-Ωα-ω]/.test(name);
-    const validChars = /^[A-Za-zΑ-Ωα-ωίϊΐόάέύϋΰήώ\s\-']+$/.test(name);
-    
-    return hasGreek && validChars;
-  }
-
-  // Detect gender from name endings
-  function detectGender(fullname) {
-    // Remove title if present
-    const parts = fullname.split(/\s+/).filter(w => !titles.includes(w));
-    const lastName = parts[parts.length - 1]?.toLowerCase();
-    
-    if (!lastName) return 'unknown';
-
-    const maleEndings = ['ος', 'ης', 'ας', 'ούς'];
-    const femaleEndings = ['ου', 'α', 'η'];
-    
-    for (const ending of maleEndings) {
-      if (lastName.endsWith(ending)) return 'male';
-    }
-    
-    for (const ending of femaleEndings) {
-      if (lastName.endsWith(ending)) return 'female';
-    }
-    
-    return 'unknown';
-  }
-
-  // Split name into parts
-  function splitNameParts(fullname) {
-    const parts = fullname.split(/\s+/).filter(p => 
-      !isGreekParticle(p.toLowerCase()) && !titles.includes(p)
-    );
-    
-    if (parts.length === 0) return { firstName: '', lastName: '' };
-    if (parts.length === 1) return { firstName: parts[0], lastName: '' };
-    if (parts.length === 2) return { firstName: parts[0], lastName: parts[1] };
-    
-    return {
-      firstName: parts[0],
-      middleName: parts.slice(1, -1).join(' '),
-      lastName: parts[parts.length - 1]
-    };
-  }
-
-  // Handle different input types
-  if (typeof input === 'string') {
-    return processName(input);
-  }
-
-  if (Array.isArray(input)) {
-    return input.map(item => {
-      if (typeof item === 'string') {
-        return processName(item);
-      }
-      if (typeof item === 'object' && item !== null) {
-        const result = { ...item };
-        if (item[config.jsonKey]) {
-          const processed = processName(item[config.jsonKey]);
-          if (config.preserveOriginal && typeof processed === 'object') {
-            Object.assign(result, processed);
-          } else {
-            result[config.outputKey] = processed;
-          }
-        }
-        return result;
-      }
-      return item;
-    });
-  }
-
-  if (typeof input === 'object' && input !== null) {
-    const result = { ...input };
-    if (input[config.jsonKey]) {
-      const processed = processName(input[config.jsonKey]);
-      if (config.preserveOriginal && typeof processed === 'object') {
-        Object.assign(result, processed);
-      } else {
-        result[config.outputKey] = processed;
-      }
-    }
-    return result;
-  }
-
-  return input;
-}
-
-module.exports = GreekNameCorrection;
+module.exports = require("./src/index");

package/package.json

@@ -1,27 +1,64 @@
 {
     "name": "greek-name-correction",
-    "version": "2.0.0",
+    "version": "2.1.0",
     "description": "A zero-dependency Node.js library for correcting and formatting Greek names with transliteration, genitive conversion, and advanced features",
-    "main": "index.js",
+    "main": "src/index.js",
     "scripts": {
-      "test": "node test.js"
+        "test": "jest",
+        "test:watch": "jest --watch",
+        "test:coverage": "jest --coverage"
     },
     "keywords": [
-      "greek",
-      "names",
-      "correction",
-      "formatting",
-      "validation",
-      "normalization",
-      "transliteration",
-      "greeklish",
-      "genitive",
-      "greek-language",
-      "katharevousa"
+        "greek",
+        "names",
+        "correction",
+        "formatting",
+        "validation",
+        "normalization",
+        "transliteration",
+        "greeklish",
+        "genitive",
+        "greek-language",
+        "katharevousa"
     ],
     "author": "Stavros",
     "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/sraftopo/greek-name-correction.git"
+    },
+    "bugs": {
+        "url": "https://github.com/sraftopo/greek-name-correction/issues"
+    },
+    "homepage": "https://github.com/sraftopo/greek-name-correction#readme",
     "engines": {
-      "node": ">=12.0.0"
+        "node": ">=12.0.0"
+    },
+    "files": [
+        "src/",
+        "index.js",
+        "README.md",
+        "LICENSE"
+    ],
+    "devDependencies": {
+        "jest": "^29.7.0"
+    },
+    "jest": {
+        "testEnvironment": "node",
+        "collectCoverageFrom": [
+            "src/**/*.js"
+        ],
+        "coveragePathIgnorePatterns": [
+            "/node_modules/",
+            "/test/"
+        ],
+        "coverageThreshold": {
+            "global": {
+                "branches": 70,
+                "functions": 70,
+                "lines": 70,
+                "statements": 70
+            }
+        }
     }
-  }
+}