greek-name-correction 2.2.1 → 2.2.3

package/README.md

@@ -1,10 +1,11 @@
 # GreekNameCorrection
 
-A powerful, zero-dependency Node.js library for correcting, formatting, and validating Greek names with advanced features including transliteration, genitive conversion, and intelligent name processing.
+A powerful, zero-dependency library for correcting, formatting, and validating Greek names with advanced features including transliteration, genitive conversion, and intelligent name processing. Works seamlessly in both Node.js and browser environments.
 
 ![NPM Version](https://img.shields.io/npm/v/greek-name-correction)
 ![License](https://img.shields.io/npm/l/greek-name-correction)
 ![Node Version](https://img.shields.io/node/v/greek-name-correction)
+![Codecov](https://codecov.io/gh/sraftopo/greek-name-correction/branch/main/graph/badge.svg)
 
 ## Features
 
@@ -14,7 +15,7 @@ A powerful, zero-dependency Node.js library for correcting, formatting, and vali
 📝 **Smart Formatting** - Proper capitalization and syntax  
 👔 **Title Support** - Handles Greek honorifics (Δρ., Καθ., etc.)  
 🎩 **Auto Title Addition** - Automatically adds general titles (Κ. for men, Κα for women)  
-🔀 **Case Conversion** - Genitive, vocative, and accusative forms  
+🔀 **Case Conversion** - Genitive, vocative (κλητική), and accusative (αιτιατική); distinct rules for names like Πρόδρομος → Πρόδρομο / Πρόδρομε  
 🎯 **Gender Detection** - Identifies gender from name endings  
 📊 **Statistics** - Comprehensive name analysis  
 🔍 **Diminutive Detection** - Recognizes nickname patterns  
@@ -120,10 +121,14 @@ greek-name-correction -name "Μαρία Κωνσταντίνου" -detectGender
 ### Examples
 
 ```bash
-# Vocative case conversion
-greek-name-correction -name "Γιώργος Παπαδόπουλος" -convertToCase vocative
+# Vocative (addressing): Πρόδρομος → Πρόδρομε
+greek-name-correction -name "Πρόδρομος" -convertToCase vocative
+
+# Accusative (direct object): Πρόδρομος → Πρόδρομο
+greek-name-correction -name "Πρόδρομος" -convertToCase accusative
 
-# Accusative case conversion
+# Full name examples
+greek-name-correction -name "Γιώργος Παπαδόπουλος" -convertToCase vocative
 greek-name-correction -name "Δημήτρης Νικολάου" -convertToCase accusative
 
 # Transliteration
@@ -216,7 +221,10 @@ GreekNameCorrection('Γιώργος Παπαδόπουλος', {
 //   }
 ```
 
-### Vocative Case Conversion
+### Vocative Case Conversion (Κλητική)
+
+Use `convertToCase: 'vocative'` when **addressing** someone directly (e.g. «Γεια σου, …», «Αγαπητέ …»).
+
 ```javascript
 // Convert to vocative case (for addressing someone)
 GreekNameCorrection('Γιώργος Παπαδόπουλος', {
@@ -224,6 +232,13 @@ GreekNameCorrection('Γιώργος Παπαδόπουλος', {
 });
 // → "Γιώργο Παπαδόπουλο"
 
+// Longer first names often form vocative in -ε
+GreekNameCorrection('Στέφανος', { convertToCase: 'vocative' });
+// → "Στέφανε"
+
+GreekNameCorrection('Πρόδρομος', { convertToCase: 'vocative' });
+// → "Πρόδρομε"
+
 // With preserveOriginal to get both forms
 GreekNameCorrection('Γιάννης Αλεξίου', {
   convertToCase: 'vocative',
@@ -241,7 +256,23 @@ GreekNameCorrection('Μαρία Κωνσταντίνου', {
 // → "Μαρία Κωνσταντίνου"
 ```
 
-### Accusative Case Conversion
+**Masculine names ending in -ος (vocative)** depend on the name and position (first name vs surname):
+
+| Pattern | Examples (nominative → vocative) |
+|--------|-----------------------------------|
+| Common short first names → **-ο** | Γιώργος → Γιώργο, Νίκος → Νίκο, Πέτρος → Πέτρο |
+| Listed longer first names → **-ε** | Στέφανος → Στέφανε, Κωνσταντίνος → Κωνσταντίνε, Αλέξανδρος → Αλέξανδρε |
+| Other longer first names (3+ syllables) → **-ε** | Πρόδρομος → Πρόδρομε |
+| Paroxytone surnames → **-ο** | Παπαδόπουλος → Παπαδόπουλο |
+| Oxytone surnames → **-ε** | Ξινός → Ξινέ |
+| Oxytone first names | Often unchanged (e.g. Νικολός) |
+
+Rules are loaded from `names_klitiki.md` in Node.js when available, with the same logic as hard-coded fallbacks in `src/cases.js` and `src/constants.js`.
+
+### Accusative Case Conversion (Αιτιατική)
+
+Use `convertToCase: 'accusative'` for **direct objects** (e.g. «Είδα τον …», «Καλώ την …»).
+
 ```javascript
 // Convert to accusative case (for direct objects)
 GreekNameCorrection('Γιώργος Παπαδόπουλος', {
@@ -249,6 +280,13 @@ GreekNameCorrection('Γιώργος Παπαδόπουλος', {
 });
 // → "Γιώργο Παπαδόπουλο"
 
+// All masculine -ος names → -ο in accusative (unlike vocative)
+GreekNameCorrection('Πρόδρομος', { convertToCase: 'accusative' });
+// → "Πρόδρομο"
+
+GreekNameCorrection('Στέφανος', { convertToCase: 'accusative' });
+// → "Στέφανο"
+
 // With preserveOriginal to get both forms
 GreekNameCorrection('Κώστας Παπαδάκης', {
   convertToCase: 'accusative',
@@ -266,6 +304,39 @@ GreekNameCorrection('Μαρία Κωνσταντίνου', {
 // → "Μαρία Κωνσταντίνου"
 ```
 
+**Masculine accusative endings** (consistent; no stress-based split for -ος):
+
+| Ending | Rule | Examples |
+|--------|------|----------|
+| **-ος** | Always **-ο** | Πρόδρομος → Πρόδρομο, Στέφανος → Στέφανο, Γιώργος → Γιώργο |
+| **-ης** | **-η** | Δημήτρης → Δημήτρη, Γιάννης → Γιάννη |
+| **-ας** | **-α** (or **-η** if name follows -ης pattern) | Κώστας → Κώστα, Θανάσης → Θανάση |
+| **-ούς** | **-ού** | (rare in names) |
+
+Rules are loaded from `names_aitiatiki.md` in Node.js when available.
+
+### Vocative vs Accusative (do not confuse)
+
+For the same nominative name, **vocative** and **accusative** can differ when the vocative uses **-ε**:
+
+```javascript
+const name = 'Πρόδρομος';
+
+GreekNameCorrection(name, { convertToCase: 'accusative' }); // → "Πρόδρομο"  (τον Πρόδρομο)
+GreekNameCorrection(name, { convertToCase: 'vocative' });   // → "Πρόδρομε"  (direct address)
+
+GreekNameCorrection('Στέφανος', { convertToCase: 'accusative' }); // → "Στέφανο"
+GreekNameCorrection('Στέφανος', { convertToCase: 'vocative' });   // → "Στέφανε"
+```
+
+| Name (ονομαστική) | Accusative (αιτιατική) | Vocative (κλητική) | Typical use |
+|-------------------|------------------------|-------------------|-------------|
+| Πρόδρομος | Πρόδρομο | Πρόδρομε | τον Πρόδρομο / «Πρόδρομε!» |
+| Στέφανος | Στέφανο | Στέφανε | τον Στέφανο / «Στέφανε!» |
+| Γιώργος | Γιώργο | Γιώργο | τον Γιώργο / «Γιώργο!» |
+
+Use **vocative** for calling or greeting someone; use **accusative** for object forms after verbs or with **τον/την**.
+
 ### Title Handling
 ```javascript
 GreekNameCorrection('δρ. γιώργος παπαδόπουλος', {
@@ -631,6 +702,295 @@ const { corrected, sortKey } = GreekNameCorrection(name, {
 // [corrected, sortKey]
 ```
 
+## Option Interactions and Processing Order
+
+When using multiple options together, it's important to understand the processing order and how options interact with each other. This section explains the execution pipeline, option conflicts, and best practices.
+
+### Processing Order
+
+The library processes names in a specific order to ensure correct results. Here's the exact sequence:
+
+```mermaid
+flowchart TD
+    Start[Input Name] --> ExtractTitle[1. Extract Title<br/>handleTitles]
+    ExtractTitle --> Transliterate[2. Transliteration<br/>transliterate]
+    Transliterate --> RemoveSpaces[3. Remove Extra Spaces<br/>removeExtraSpaces]
+    RemoveSpaces --> Katharevousa[4. Katharevousa Conversion<br/>recognizeKatharevousa]
+    Katharevousa --> Suggest[5. Suggest Corrections<br/>suggestCorrections]
+    Suggest --> Normalize[6. Normalize Tonotics<br/>normalizeTonotics]
+    Normalize --> Diacritics[7. Handle Diacritics<br/>handleDiacritics]
+    Diacritics --> Capitalize[8. Capitalize & Split<br/>splitNames]
+    Capitalize --> AddAccents[9. Add Accents<br/>addAccents]
+    AddAccents --> Genitive[10. Convert to Genitive<br/>convertToGenitive<br/>stored separately]
+    Genitive --> DatabaseSafe[11. Database-Safe<br/>databaseSafe]
+    DatabaseSafe --> AddTitle[12. Add General Title<br/>addGeneralTitle]
+    AddTitle --> CaseConvert[13. Convert to Case<br/>convertToCase]
+    CaseConvert --> ReattachTitle[14. Re-attach Title]
+    ReattachTitle --> Metadata[15. Generate Metadata<br/>detectGender, detectDiminutive<br/>generateSortKey, statistics]
+    Metadata --> End[Output Result]
+```
+
+#### Detailed Processing Steps
+
+1. **Title Extraction** (`handleTitles: true` by default)
+   - Extracts titles like "Δρ.", "Καθ.", "Κ." from the beginning of the name
+   - Title is stored separately and removed from processing
+
+2. **Transliteration** (`transliterate`)
+   - Converts between Greek, Greeklish, and Latin scripts
+   - Applied early to ensure subsequent steps work on the correct script
+
+3. **Space Normalization** (`removeExtraSpaces: true` by default)
+   - Removes extra whitespace and trims the name
+
+4. **Katharevousa Recognition** (`recognizeKatharevousa`)
+   - Converts archaic Greek forms to modern Greek
+
+5. **Suggestion Corrections** (`suggestCorrections`)
+   - Suggests corrections for common misspellings
+   - Applied before normalization to fix errors early
+
+6. **Tonotic Normalization** (`normalizeTonotics: true` by default)
+   - Normalizes Greek accent marks to standard forms
+
+7. **Diacritic Handling** (`handleDiacritics: true` by default)
+   - Properly handles Greek diacritics (diaeresis, etc.)
+
+8. **Capitalization & Splitting** (`splitNames: true` by default)
+   - Splits name into parts and capitalizes each part
+   - Handles particles (του/της/των) if `handleParticles: true`
+
+9. **Accent Addition** (`addAccents`)
+   - Adds accents to unaccented Greek names
+   - Uses comprehensive name dictionary with fallback rules
+
+10. **Genitive Conversion** (`convertToGenitive`)
+    - Converts to genitive case
+    - **Stored separately** in result object, doesn't modify main processed name
+
+11. **Database-Safe Conversion** (`databaseSafe`)
+    - Removes problematic characters for database storage
+
+12. **General Title Addition** (`addGeneralTitle`)
+    - Adds "Κ." (for men) or "Κα" (for women) if no title exists
+    - Only adds if no title was extracted in step 1
+
+13. **Case Conversion** (`convertToCase: 'vocative' | 'accusative'`)
+    - **Vocative (κλητική):** name-dependent **-ο** / **-ε** for masculine **-ος** (see [Vocative Case Conversion](#vocative-case-conversion-κλητική))
+    - **Accusative (αιτιατική):** masculine **-ος** always → **-ο**; **-ης** → **-η**; **-ας** → **-α** (see [Accusative Case Conversion](#accusative-case-conversion-αιτιατική))
+    - **Stored separately** in result object
+    - If `preserveOriginal: false`, returns case form directly
+
+14. **Title Re-attachment**
+    - Re-attaches extracted or added title to the processed name
+
+15. **Metadata Generation**
+    - `detectGender`: Detects gender from name endings
+    - `detectDiminutive`: Detects diminutive forms
+    - `generateSortKey`: Generates accent-free sort key
+    - `statistics`: Generates comprehensive name statistics
+
+### Option Conflicts and Incompatibilities
+
+Some options don't work well together or have special behaviors:
+
+#### Conflicting Combinations
+
+| Combination | Issue | Solution |
+|------------|-------|----------|
+| `transliterate: 'greek-to-latin'` + `addAccents` | Accents can't be added to Latin text | Use `addAccents` only with Greek text |
+| `transliterate: 'greek-to-latin'` + `convertToCase` | Case conversion only works on Greek text | Case conversion requires Greek input |
+| `transliterate: 'greek-to-greeklish'` + `convertToCase` | Case conversion only works on Greek text | Case conversion requires Greek input |
+| `databaseSafe: true` + `addAccents` | Database-safe may remove characters needed for accents | Apply `addAccents` before `databaseSafe` (automatic) |
+| `convertToCase` + `preserveOriginal: false` | Returns case form string, not main corrected name | Use `preserveOriginal: true` to get both forms |
+
+#### Special Behaviors
+
+**Case Conversion Return Value**
+- When `convertToCase` is set and `preserveOriginal: false`, the function returns the case form string directly (not the nominative form)
+- When `preserveOriginal: true`, both the corrected nominative and case forms are included in the result object
+
+```javascript
+// Returns case form directly
+GreekNameCorrection('Γιώργος Παπαδόπουλος', {
+  convertToCase: 'vocative'
+});
+// → "Γιώργο Παπαδόπουλο"
+
+// Returns object with both forms
+GreekNameCorrection('Γιώργος Παπαδόπουλος', {
+  convertToCase: 'vocative',
+  preserveOriginal: true
+});
+// → {
+//     corrected: "Γιώργος Παπαδόπουλος",
+//     vocative: "Γιώργο Παπαδόπουλο",
+//     ...
+//   }
+```
+
+**Genitive and Case Conversion Together**
+- Both `convertToGenitive` and `convertToCase` can be used together
+- Genitive form is stored in `result.genitive`
+- Case form is stored in `result.vocative` or `result.accusative`
+- The main `corrected` field contains the nominative form
+
+**General Title Addition**
+- `addGeneralTitle` only adds a title if no title was extracted in step 1
+- If a title already exists, it won't add another one
+
+**Accent Addition Limitations**
+- `addAccents` works best on Greek text
+- May not work correctly after transliteration to non-Greek scripts
+- Uses dictionary lookup first, then falls back to heuristic rules
+
+### Best Practices
+
+#### Recommended Combinations
+
+**Basic Name Correction**
+```javascript
+GreekNameCorrection('γιώργος παπαδόπουλος', {
+  addAccents: true,
+  normalizeTonotics: true,
+  handleDiacritics: true
+});
+// Safe and effective for most use cases
+```
+
+**Full Name Processing with Metadata**
+```javascript
+GreekNameCorrection('γιώργος παπαδόπουλος', {
+  preserveOriginal: true,
+  addAccents: true,
+  detectGender: true,
+  convertToGenitive: true,
+  generateSortKey: true
+});
+// Gets all information without conflicts
+```
+
+**Case Conversion with Full Details**
+```javascript
+GreekNameCorrection('Γιώργος Παπαδόπουλος', {
+  preserveOriginal: true,
+  convertToCase: 'vocative',
+  convertToGenitive: true,
+  detectGender: true
+});
+// Returns object with nominative, vocative, and genitive forms
+```
+
+**Transliteration Workflow**
+```javascript
+// Step 1: Convert Greeklish to Greek
+const greek = GreekNameCorrection('giorgos papadopoulos', {
+  transliterate: 'greeklish-to-greek',
+  addAccents: true
+});
+
+// Step 2: Process the Greek name
+const processed = GreekNameCorrection(greek, {
+  convertToCase: 'vocative',
+  detectGender: true
+});
+// Separate transliteration from case conversion
+```
+
+#### Problematic Combinations to Avoid
+
+**Don't combine transliteration to non-Greek with case conversion:**
+```javascript
+// ❌ Won't work - case conversion needs Greek text
+GreekNameCorrection('Γιώργος Παπαδόπουλος', {
+  transliterate: 'greek-to-latin',
+  convertToCase: 'vocative'
+});
+```
+
+**Don't use addAccents after transliteration to non-Greek:**
+```javascript
+// ❌ Won't work - accents can't be added to Latin
+GreekNameCorrection('Γιώργος Παπαδόπουλος', {
+  transliterate: 'greek-to-latin',
+  addAccents: true
+});
+```
+
+**Do use preserveOriginal when you need multiple forms:**
+```javascript
+// ✅ Correct - gets all forms
+GreekNameCorrection('Γιώργος Παπαδόπουλος', {
+  preserveOriginal: true,
+  convertToGenitive: true,
+  convertToCase: 'vocative'
+});
+```
+
+### Examples of Option Combinations
+
+#### Example 1: Safe Combination - All Features
+```javascript
+const result = GreekNameCorrection('dr giorgos tou papa', {
+  transliterate: 'greeklish-to-greek',
+  preserveOriginal: true,
+  handleTitles: true,
+  addGeneralTitle: true,
+  addAccents: true,
+  handleParticles: true,
+  suggestCorrections: true,
+  detectGender: true,
+  convertToGenitive: true,
+  convertToCase: 'vocative',
+  generateSortKey: true,
+  statistics: true,
+  detectDiminutive: true
+});
+
+// Result includes:
+// - corrected: Main corrected name
+// - genitive: Genitive form
+// - vocative: Vocative form
+// - gender: Detected gender
+// - sortKey: Sort key
+// - statistics: Name statistics
+// - diminutive: Diminutive detection
+// - title: Extracted title
+```
+
+#### Example 2: Database Integration
+```javascript
+const result = GreekNameCorrection('Γιώργος Παπαδόπουλος', {
+  preserveOriginal: true,
+  databaseSafe: true,
+  generateSortKey: true
+});
+
+// Safe for database storage
+// result.corrected - safe for display
+// result.sortKey - safe for sorting
+```
+
+#### Example 3: Case Conversion Only
+```javascript
+// Simple case conversion - returns string
+const vocative = GreekNameCorrection('Γιώργος Παπαδόπουλος', {
+  convertToCase: 'vocative'
+});
+// → "Γιώργο Παπαδόπουλο"
+```
+
+#### Example 4: Problematic Combination
+```javascript
+// ⚠️ Warning: This won't work as expected
+const result = GreekNameCorrection('Γιώργος Παπαδόπουλος', {
+  transliterate: 'greek-to-latin',
+  convertToCase: 'vocative',  // Won't work on Latin text
+  addAccents: true            // Won't work on Latin text
+});
+// Transliteration happens first, so case conversion and accent addition fail
+```
+
 ## Use Cases
 
 ### 1. Form Validation & Correction
@@ -685,18 +1045,20 @@ const recipient = GreekNameCorrection(name, {
 console.log(`Προς: ${recipient.genitive}`);
 
 // Use vocative case for addressing someone
-const addressee = GreekNameCorrection('Γιώργος Παπαδόπουλος', {
+const addressee = GreekNameCorrection('Πρόδρομος', {
   convertToCase: 'vocative'
 });
+console.log(`Γεια σου, ${addressee}!`); // "Γεια σου, Πρόδρομε!"
 
-console.log(`Αγαπητέ ${addressee},`); // "Αγαπητέ Γιώργο Παπαδόπουλο,"
-
-// Use accusative case for direct objects
-const object = GreekNameCorrection('Δημήτρης Νικολάου', {
+// Use accusative case for direct objects (with article τον/την)
+const object = GreekNameCorrection('Πρόδρομος', {
   convertToCase: 'accusative'
 });
+console.log(`Είδα τον ${object}.`); // "Είδα τον Πρόδρομο."
 
-console.log(`Είδα τον ${object}`); // "Είδα τον Δημήτρη Νικολάου"
+// Same name, different case — do not use vocative where accusative is required
+GreekNameCorrection('Στέφανος', { convertToCase: 'accusative' }); // → "Στέφανο" (τον Στέφανο)
+GreekNameCorrection('Στέφανος', { convertToCase: 'vocative' });   // → "Στέφανε" (Στέφανε!)
 ```
 
 ### 5. Gender-Based Processing
@@ -719,7 +1081,29 @@ console.log(`${pronoun} ${person.corrected}`);
 
 ## Browser Support
 
-While designed for Node.js, the library can be bundled for browser use with tools like Webpack or Browserify.
+The library is fully compatible with browser environments! It automatically detects the runtime environment and works seamlessly in both Node.js and browsers.
+
+### Features
+
+- ✅ **Automatic Environment Detection** - No configuration needed
+- ✅ **Zero Browser Errors** - No `__dirname` or Node.js-specific globals required
+- ✅ **Full Feature Support** - All features work in browsers, including case conversion
+- ✅ **Smart Fallback** - Uses hard-coded rules in browsers, markdown files in Node.js when available
+
+### Usage in Browser
+
+```javascript
+// Works directly in browser (with bundler like Webpack, Browserify, or Vite)
+import GreekNameCorrection from 'greek-name-correction';
+
+// All features work, including case conversion
+const result = GreekNameCorrection('Γιώργος Παπαδόπουλος', {
+  convertToCase: 'vocative',
+  detectGender: true
+});
+```
+
+The library automatically uses hard-coded rules for case conversion in browser environments, ensuring full functionality without file system access.
 
 ## TypeScript
 
@@ -804,7 +1188,7 @@ The test suite covers:
 - Array processing
 - Object processing
 - All transliteration modes
-- Case conversions (genitive, vocative, accusative)
+- Case conversions (genitive, vocative, accusative), including vocative vs accusative for names like Πρόδρομος
 - Title handling
 - Automatic general title addition
 - Accent addition
@@ -815,7 +1199,18 @@ The test suite covers:
 
 ## Changelog
 
-### Version 2.2.1 (Current)
+### Version 2.2.3 (Current)
+- 📖 **Case conversion documentation** - README documents vocative (κλητική) vs accusative (αιτιατική), including masculine **-ος** names where forms differ (e.g. Πρόδρομος → **Πρόδρομο** / **Πρόδρομε**; Στέφανος → **Στέφανο** / **Στέφανε**)
+- 🔧 **Vocative logic refactor** - Shared `resolveOsVocativeStyleEnding()` in `src/cases.js` for clearer **-ο** / **-ε** handling
+- ✅ **Accusative consistency** - Masculine **-ος** names always form accusative in **-ο**; vocative keeps separate name-dependent rules
+- ✅ **Tests** - Added coverage for Πρόδρομος accusative vs vocative forms
+- 📝 See [README_NOTES_2.2.3.md](./README_NOTES_2.2.3.md) for full release notes
+
+### Version 2.2.2
+- 🌐 **Browser compatibility** - Environment detection and fallback to hard-coded rules when `__dirname` / file system is unavailable
+- 🔧 **Package configuration** - Updated repository URL format in package.json
+
+### Version 2.2.1
 - 🔧 **Enhanced Accent Addition** - Improved `addAccents` feature with comprehensive name dictionary support. Now uses actual Greek name dictionaries from `generate_greek_names.js` for accurate accent placement on common names. Includes CLI support with `-addAccents` flag.
 - ✨ **Name Dictionary** - Built-in dictionary with 1,100+ Greek names (first names, surnames, compound surnames) for accurate accent placement
 - 🐛 **CLI Fix** - Added missing `-addAccents` flag to command-line interface

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "greek-name-correction",
-    "version": "2.2.1",
+    "version": "2.2.3",
     "description": "A zero-dependency Node.js library for correcting and formatting Greek names with transliteration, genitive conversion, and advanced features",
     "main": "src/index.js",
     "types": "index.d.ts",
@@ -26,7 +26,7 @@
     "license": "MIT",
     "repository": {
         "type": "git",
-        "url": "https://github.com/sraftopo/greek-name-correction.git"
+        "url": "git+https://github.com/sraftopo/greek-name-correction.git"
     },
     "bugs": {
         "url": "https://github.com/sraftopo/greek-name-correction/issues"
@@ -36,7 +36,7 @@
         "node": ">=12.0.0"
     },
     "bin": {
-        "greek-name-correction": "./bin/greek-name-correction.js"
+        "greek-name-correction": "bin/greek-name-correction.js"
     },
     "files": [
         "src/",
@@ -54,9 +54,15 @@
         "collectCoverageFrom": [
             "src/**/*.js"
         ],
+        "coverageDirectory": "coverage",
+        "coverageReporters": [
+            "text",
+            "lcov",
+            "json"
+        ],
         "coveragePathIgnorePatterns": [
-            "/node_modules/",
-            "/test/"
+            "node_modules",
+            "test"
         ],
         "coverageThreshold": {
             "global": {
@@ -67,4 +73,4 @@
             }
         }
     }
-}
+}

package/src/cases.js

@@ -163,6 +163,40 @@ function isDiminutivePattern(lowerPart) {
   );
 }
 
+// Resolve -ος ending as "ο", "ε", or null (unchanged) using vocative-style rules
+function resolveOsVocativeStyleEnding(part, index, totalParts, parsedRules) {
+  const lowerPart = part.toLowerCase();
+
+  if (isDiminutivePattern(lowerPart)) {
+    return "ο";
+  }
+
+  const firstNamesInO =
+    parsedRules?.osEndings?.firstNames?.paroxytone?.inO ||
+    vocativeInO_FirstNames;
+  const firstNamesInE =
+    parsedRules?.osEndings?.firstNames?.paroxytone?.inE ||
+    vocativeInE_FirstNames;
+  const firstNamesUnchanged =
+    parsedRules?.osEndings?.firstNames?.oxytone?.unchanged || oxytoneNames;
+
+  if (firstNamesInO.includes(lowerPart)) {
+    return "ο";
+  }
+  if (firstNamesInE.includes(lowerPart)) {
+    return "ε";
+  }
+  if (isLikelySurname(part, index, totalParts)) {
+    return isOxytoneSurname(part) ? "ε" : "ο";
+  }
+  if (firstNamesUnchanged.includes(lowerPart) || isOxytone(part)) {
+    return null;
+  }
+
+  const syllableCount = (part.match(/[αεηιουωάέήίόύώ]/gi) || []).length;
+  return syllableCount <= 2 ? "ο" : "ε";
+}
+
 // Convert to vocative case
 // Converts all name parts (first name and last name), but skips particles
 function convertToVocative(name, config) {
@@ -196,55 +230,14 @@ function convertToVocative(name, config) {
 
     // Handle masculine names ending in -ος
     if (lowerPart.endsWith("ος")) {
-      // Check if it's a diminutive pattern first
-      if (isDiminutivePattern(lowerPart)) {
-        // Diminutives: -ος → -ο
-        vocative = part.slice(0, -2) + "ο";
-      }
-      // Use parsed rules if available, otherwise use hard-coded lists
-      else {
-        // Get name lists from parsed rules or fallback to hard-coded
-        const firstNamesInO = parsedRules?.osEndings?.firstNames?.paroxytone?.inO || vocativeInO_FirstNames;
-        const firstNamesInE = parsedRules?.osEndings?.firstNames?.paroxytone?.inE || vocativeInE_FirstNames;
-        const firstNamesUnchanged = parsedRules?.osEndings?.firstNames?.oxytone?.unchanged || oxytoneNames;
-        
-        // Check explicit list of first names that form vocative in -ο
-        if (firstNamesInO.includes(lowerPart)) {
-          vocative = part.slice(0, -2) + "ο";
-        }
-        // Check explicit list of first names that form vocative in -ε
-        else if (firstNamesInE.includes(lowerPart)) {
-          vocative = part.slice(0, -2) + "ε";
-        }
-        // Check if it's likely a surname (by position or explicit list)
-        else if (isLikelySurname(part, index, totalParts)) {
-          // For surnames, check if oxytone
-          if (isOxytoneSurname(part)) {
-            // Oxytone surname: -ος → -ε
-            vocative = part.slice(0, -2) + "ε";
-          } else {
-            // Paroxytone surname: -ος → -ο
-            vocative = part.slice(0, -2) + "ο";
-          }
-        }
-        // It's a first name (not in explicit lists) - default behavior
-        else {
-          if (firstNamesUnchanged.includes(lowerPart) || isOxytone(part)) {
-            // Oxytone first name: remains unchanged
-            vocative = part;
-          } else {
-            // Paroxytone first name: default to -ο for common short names, -ε for longer names
-            // Default to -ο for disyllabic names, -ε for longer
-            const syllableCount = (part.match(/[αεηιουωάέήίόύώ]/gi) || []).length;
-            if (syllableCount <= 2) {
-              // Disyllabic: -ος → -ο
-              vocative = part.slice(0, -2) + "ο";
-            } else {
-              // Longer names: -ος → -ε
-              vocative = part.slice(0, -2) + "ε";
-            }
-          }
-        }
+      const ending = resolveOsVocativeStyleEnding(
+        part,
+        index,
+        totalParts,
+        parsedRules
+      );
+      if (ending) {
+        vocative = part.slice(0, -2) + ending;
       }
     }
     // Handle masculine names ending in -ης
@@ -290,7 +283,7 @@ function convertToVocative(name, config) {
 function convertToAccusative(name, config) {
   // Try to load parsed rules from markdown, fallback to hard-coded rules
   const parsedRules = getAccusativeRules();
-  
+
   const parts = name.split(/\s+/);
   const processedParts = parts.map((part) => {
     const lowerPart = part.toLowerCase();

package/src/rulesParser.js

@@ -1,8 +1,31 @@
 // rulesParser.js
 "use strict";
 
-const fs = require("fs");
-const path = require("path");
+// Browser environment detection
+// Check if Node.js globals are available
+function isNodeEnvironment() {
+  return (
+    typeof __dirname !== "undefined" &&
+    typeof require !== "undefined" &&
+    typeof module !== "undefined"
+  );
+}
+
+// Safely require Node.js modules only in Node.js environment
+let fs, path;
+if (isNodeEnvironment()) {
+  try {
+    fs = require("fs");
+    path = require("path");
+  } catch (e) {
+    // If require fails, we're likely in a browser environment
+    fs = null;
+    path = null;
+  }
+} else {
+  fs = null;
+  path = null;
+}
 
 /**
  * Parse markdown file and extract Greek name case conversion rules
@@ -10,6 +33,11 @@ const path = require("path");
  * @returns {Object} Parsed rules structure
  */
 function parseMarkdownRules(filePath) {
+  // In browser environments, fs is not available
+  if (!fs || !path) {
+    return null;
+  }
+  
   try {
     const content = fs.readFileSync(filePath, "utf8");
     return parseMarkdownContent(content);
@@ -260,6 +288,12 @@ function extractEnding(name) {
  * Parse vocative rules from names_klitiki.md
  */
 function parseVocativeRules() {
+  // In browser environments, skip file reading and return null
+  // This will trigger fallback to hard-coded rules in cases.js
+  if (!isNodeEnvironment() || !path || typeof __dirname === "undefined") {
+    return null;
+  }
+  
   const filePath = path.join(__dirname, "..", "names_klitiki.md");
   const rules = parseMarkdownRules(filePath);
   
@@ -448,6 +482,12 @@ function extractNameListsFromExamples(structuredRules, examples) {
  * Parse accusative rules from names_aitiatiki.md
  */
 function parseAccusativeRules() {
+  // In browser environments, skip file reading and return null
+  // This will trigger fallback to hard-coded rules in cases.js
+  if (!isNodeEnvironment() || !path || typeof __dirname === "undefined") {
+    return null;
+  }
+  
   const filePath = path.join(__dirname, "..", "names_aitiatiki.md");
   const rules = parseMarkdownRules(filePath);