@vspro/name-match-pro 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Your Name
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,185 @@
+# @vspro/name-match-pro
+
+A robust name matching library for Node.js and TypeScript that combines multiple strategies — initials handling, token swapping, fuzzy similarity, and prefix normalization — for accurate name matching in fintech, insurance, CRM, KYC, OCR and other applications.
+
+[![npm version](https://img.shields.io/npm/v/@vspro/name-match-pro)](https://www.npmjs.com/package/@vspro/name-match-pro)
+![Test Coverage](https://img.shields.io/badge/Test%20Coverage-98%25-brightgreen)
+![TypeScript](https://img.shields.io/badge/TypeScript-Supported-3178C6?logo=typescript&logoColor=white)
+![JavaScript](https://img.shields.io/badge/JavaScript-Supported-F7DF1E?logo=javascript&logoColor=black)
+![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)
+
+---
+
+## Features
+
+* **Multi-strategy Matching**: Combines exact match, initials handling, swapped tokens, and fuzzy Levenshtein similarity.
+* **Prefix Normalization**: Removes common prefixes like Mr, Mrs, Dr, Shri, Smt, etc.
+* **Initials Expansion & Merge**: Converts `K.S.` → `KS`, `KS` → `K S`, or merges initials intelligently.
+* **Swapped Tokens Handling**: Recognizes names in different order 
+(e.g., "Vijay Kumar Sharma" → "Sharma Vijay Kumar"
+"Vijay Kumar Sharma" → "Vijay K S").
+* **Scoring System**: Returns percentage similarity and descriptive remarks: Exact Match, High Similarity, Possible Match, Low Match.
+* **Fuzzy Matching**: Handles typos and variations using Levenshtein distance.
+* **Node.js & TypeScript Ready**: Works in JS, TS, and frameworks like Next.js.
+
+---
+
+## Installation
+
+```bash
+npm install @vspro/name-match-pro
+```
+
+Or yarn:
+
+```bash
+yarn add @vspro/name-match-pro
+```
+
+---
+
+## Quick Start (JavaScript)
+
+```javascript
+const { matchNames } = require('@vspro/name-match-pro');
+
+const result = matchNames('Sagar Kumar Jangid', 'Sagar Kumar J');
+
+console.log(result);
+/*
+{
+  inputName: 'Sagar Kumar Jangid',
+  givenName: 'Sagar Kumar J',
+  percentage: 95,
+  remark: 'High Similarity'
+}
+*/
+```
+
+---
+
+## TypeScript Example
+
+```ts
+import { matchNames } from '@vspro/name-match-pro';
+
+const result = matchNames('Sagar Kumar Jangid', 'Sagar Kumar J');
+
+console.log(result);
+/*
+{
+  inputName: 'Sagar Kumar Jangid',
+  givenName: 'Sagar Kumar J',
+  percentage: 95,
+  remark: 'High Similarity'
+}
+*/
+```
+
+---
+
+## Next.js API Example
+
+```ts
+// pages/api/match.ts
+import type { NextApiRequest, NextApiResponse } from 'next';
+import { matchNames } from '@vspro/name-match-pro';
+
+export default function handler(req: NextApiRequest, res: NextApiResponse) {
+  const { inputName, givenName } = req.query;
+
+  if (!inputName || !givenName) {
+    return res.status(400).json({ error: 'inputName and givenName are required' });
+  }
+
+  const result = matchNames(inputName as string, givenName as string);
+  res.status(200).json(result);
+}
+
+/*
+Request:
+GET /api/match?inputName=Gowri%20K%20S&givenName=GOWRI%20KS
+
+Response:
+{
+  "inputName": "Gowri K S",
+  "givenName": "GOWRI KS",
+  "percentage": 100,
+  "remark": "Exact Match"
+}
+*/
+```
+
+---
+
+## Advanced Usage
+
+```ts
+import { matchNames } from '@vspro/name-match-pro';
+
+const examples = [
+  { input: 'K S Gowri', given: 'Gowri K S' },
+  { input: 'Yadav Vijaysinh Ishwarsinh', given: 'VIJAYSINH ISHWARSINH YADAV' },
+  { input: 'Shilpa Deshpande', given: 'Shilpa P Deshpande' }
+];
+
+examples.forEach(({ input, given }) => {
+  const result = matchNames(input, given);
+  console.log({ input, given, result });
+});
+
+/*
+Sample Output:
+
+{ input: 'K S Gowri', given: 'Gowri K S', result: { inputName: 'K S Gowri', givenName: 'Gowri K S', percentage: 99, remark: 'High Similarity' } }
+
+{ input: 'Yadav Vijaysinh Ishwarsinh', given: 'VIJAYSINH ISHWARSINH YADAV', result: { inputName: 'Yadav Vijaysinh Ishwarsinh', givenName: 'VIJAYSINH ISHWARSINH YADAV', percentage: 100, remark: 'Exact Match' } }
+
+{ input: 'Shilpa Deshpande', given: 'Shilpa P Deshpande', result: { inputName: 'Shilpa Deshpande', givenName: 'Shilpa P Deshpande', percentage: 85, remark: 'Possible Match' } }
+*/
+```
+
+---
+
+## How It Works
+
+
+1. **Matching Strategies**
+
+   * **Exact Match** → 100%
+   * **Swapped Token Match** → 99%
+   * **Full Token Containment** → 90–99%
+   * **Fuzzy Levenshtein Match** → 60–95%
+   * **Initial-only Downgrade** → Avoids false positives
+
+2. **Scoring & Remark**
+
+   * 100 → Exact Match
+   * 90–99 → High Similarity
+   * 70–89 → Possible Match
+   * <70 → Low Match
+
+---
+
+## Challenges Handled
+
+* Different name orders (first last vs. last, first)
+* Middle names and initials
+* Nicknames and formal names
+* Suffixes (Jr, Sr, III)
+* Titles and prefixes (Mr, Dr, Smt)
+* Hyphenated or compound names
+* Case differences, spacing variations, special characters
+
+---
+
+
+## License
+
+MIT License © 2026 vspro
+
+---
+
+## Keywords
+
+`name-matching`, `name-matching-kyc`, `name-matching-ocr`, `fuzzy-match`, `initials`, `levenshtein`, `typescript`, `nodejs`, `nextjs`, `npm-package`, `name-validation`, `crm`, `fintech`, `insurance`, `KYC`, `OCR`, `CRM`

package/dist/examples/example.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/examples/example.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const nameMatchPro_1 = require("../utils/nameMatchPro");
+const examples = [
+    { input: "Vikash Yadav Luniwal", given: "Vikash Y L" },
+    { input: "Vikash Yadav Luniwal", given: "Vikash Yadav" },
+    { input: "Vikash Yadav Luniwal", given: "Vikash Luniwal Yadav" },
+    { input: "Vikash Yadav Luniwal", given: "Vikash Yadav Luniwal" },
+];
+examples.forEach(({ input, given }) => {
+    const result = (0, nameMatchPro_1.matchNames)(input, given);
+    console.log(result);
+});
+/*
+OUTPUT  :
+
+{
+  inputName: 'Vikash Yadav Luniwal',
+  givenName: 'Vikash Y L',
+  percentage: 90,
+  remark: 'High Similarity'
+}
+{
+  inputName: 'Vikash Yadav Luniwal',
+  givenName: 'Vikash Yadav',
+  percentage: 94,
+  remark: 'High Similarity'
+}
+{
+  inputName: 'Vikash Yadav Luniwal',
+  givenName: 'Vikash Luniwal Yadav',
+  percentage: 99,
+  remark: 'High Similarity'
+}
+{
+  inputName: 'Vikash Yadav Luniwal',
+  givenName: 'Vikash Yadav Luniwal',
+  percentage: 100,
+  remark: 'Exact Match'
+}
+*/ 

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from './utils/nameMatchPro';

package/dist/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./utils/nameMatchPro"), exports);

package/dist/utils/nameMatchPro.d.ts

@@ -0,0 +1,15 @@
+export interface MatchResult {
+    inputName: string;
+    givenName: string;
+    percentage: number;
+    remark: string;
+}
+export declare function normalizeName(name: string | undefined): string;
+export declare function mergeInitials(name: string): string;
+export declare function tokenize(name: string): string[];
+export declare function expandCombinedInitials(tokens: string[]): string[];
+export declare function normalizeInitialToken(token: string): string;
+export declare function levenshtein(a: string, b: string): number;
+export declare function isSwappedMatch(tokens1: string[], tokens2: string[]): boolean;
+export declare function isInitialMatch(token1: string, token2: string): boolean;
+export declare function matchNames(inputName: string, givenName: string): MatchResult;

package/dist/utils/nameMatchPro.js

@@ -0,0 +1,182 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeName = normalizeName;
+exports.mergeInitials = mergeInitials;
+exports.tokenize = tokenize;
+exports.expandCombinedInitials = expandCombinedInitials;
+exports.normalizeInitialToken = normalizeInitialToken;
+exports.levenshtein = levenshtein;
+exports.isSwappedMatch = isSwappedMatch;
+exports.isInitialMatch = isInitialMatch;
+exports.matchNames = matchNames;
+const COMMON_PREFIXES = ["mr", "mrs", "ms", "miss", "shri", "smt", "dr"];
+function normalizeName(name) {
+    if (!name)
+        return "";
+    return name
+        .toLowerCase()
+        .replace(/\./g, "")
+        .replace(/\s+/g, " ")
+        .trim()
+        .split(" ")
+        .filter((word) => !COMMON_PREFIXES.includes(word))
+        .join(" ");
+}
+function mergeInitials(name) {
+    return name.replace(/\b([a-z])\.\s*([a-z])\./g, "$1$2");
+}
+function tokenize(name) {
+    return name.split(" ").filter(Boolean);
+}
+function expandCombinedInitials(tokens) {
+    let expanded = [];
+    for (const token of tokens) {
+        if (/^[a-z]{2,4}$/.test(token) && !/[aeiou]/.test(token)) {
+            expanded.push(...token.split(""));
+        }
+        else {
+            expanded.push(token);
+        }
+    }
+    return expanded;
+}
+function normalizeInitialToken(token) {
+    if (token.length >= 2 && token.length <= 4 && /^[a-z]+$/.test(token) && !/[aeiou]/.test(token)) {
+        return token.split("").sort().join("");
+    }
+    return token;
+}
+function levenshtein(a, b) {
+    const matrix = [];
+    for (let i = 0; i <= b.length; i++)
+        matrix[i] = [i];
+    for (let j = 0; j <= a.length; j++)
+        matrix[0][j] = j;
+    for (let i = 1; i <= b.length; i++) {
+        for (let j = 1; j <= a.length; j++) {
+            if (b[i - 1] === a[j - 1]) {
+                matrix[i][j] = matrix[i - 1][j - 1];
+            }
+            else {
+                matrix[i][j] = Math.min(matrix[i - 1][j - 1] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j] + 1);
+            }
+        }
+    }
+    return matrix[b.length][a.length];
+}
+function isSwappedMatch(tokens1, tokens2) {
+    if (tokens1.length !== tokens2.length)
+        return false;
+    const sorted1 = tokens1.map(normalizeInitialToken).sort().join(" ");
+    const sorted2 = tokens2.map(normalizeInitialToken).sort().join(" ");
+    return sorted1 === sorted2;
+}
+function isInitialMatch(token1, token2) {
+    if (token1.length === 1 && token2.startsWith(token1))
+        return true;
+    if (token2.length === 1 && token1.startsWith(token2))
+        return true;
+    return false;
+}
+function matchNames(inputName, givenName) {
+    const originalInput = inputName;
+    const originalGiven = givenName;
+    inputName = mergeInitials(normalizeName(inputName));
+    givenName = mergeInitials(normalizeName(givenName));
+    let inputTokens = tokenize(inputName);
+    let givenTokens = tokenize(givenName);
+    inputTokens = expandCombinedInitials(inputTokens);
+    givenTokens = expandCombinedInitials(givenTokens);
+    let score = 0;
+    if (inputName === givenName)
+        score = 100;
+    else if (isSwappedMatch(inputTokens, givenTokens))
+        score = 99;
+    else if (givenTokens.every((t) => inputTokens.includes(t)) ||
+        inputTokens.every((t) => givenTokens.includes(t))) {
+        const longer = Math.max(inputTokens.length, givenTokens.length);
+        const shorter = Math.min(inputTokens.length, givenTokens.length);
+        const diff = longer - shorter;
+        const hasFullTokenMatch = givenTokens.some((t) => t.length > 1 && inputTokens.includes(t));
+        if (hasFullTokenMatch) {
+            if (diff === 0)
+                score = 99;
+            else if (diff === 1)
+                score = 94;
+            else
+                score = 90;
+        }
+        else {
+            const matchRatio = shorter / longer;
+            score = Math.round(matchRatio * 60);
+        }
+    }
+    else {
+        let matchedScore = 0;
+        const usedIndexes = new Set();
+        for (const g of givenTokens) {
+            let bestMatch = 0;
+            let bestIndex = -1;
+            inputTokens.forEach((i, idx) => {
+                if (usedIndexes.has(idx))
+                    return;
+                if (i.startsWith(g) || g.startsWith(i)) {
+                    const similarity = Math.min(1, (Math.min(i.length, g.length) / Math.max(i.length, g.length)) * 1.1);
+                    if (similarity > bestMatch) {
+                        bestMatch = similarity;
+                        bestIndex = idx;
+                    }
+                }
+                const distance = levenshtein(i, g);
+                const similarity = 1 - distance / Math.max(i.length, g.length);
+                const weighted = Math.min(1, similarity * 1.05);
+                if (weighted > bestMatch) {
+                    bestMatch = weighted;
+                    bestIndex = idx;
+                }
+                if (isInitialMatch(i, g)) {
+                    const initialScore = 0.85;
+                    if (initialScore > bestMatch) {
+                        bestMatch = initialScore;
+                        bestIndex = idx;
+                    }
+                }
+            });
+            if (bestIndex !== -1) {
+                usedIndexes.add(bestIndex);
+                matchedScore += bestMatch;
+            }
+        }
+        const coverage = matchedScore / inputTokens.length;
+        const precision = matchedScore / givenTokens.length;
+        score = Math.round((coverage * 0.6 + precision * 0.4) * 100);
+        if (score >= 98 && inputName !== givenName)
+            score = 95;
+    }
+    const inputHasFull = inputTokens.some((t) => t.length > 1);
+    const givenHasFull = givenTokens.some((t) => t.length > 1);
+    const inputAllInitials = inputTokens.every((t) => t.length === 1);
+    const givenAllInitials = givenTokens.every((t) => t.length === 1);
+    const fullTokenMatchExists = givenTokens.some((g) => g.length > 1 && inputTokens.includes(g));
+    if ((inputHasFull && givenAllInitials) || (givenHasFull && inputAllInitials)) {
+        score = Math.min(score, 65);
+    }
+    else if (inputHasFull && givenHasFull && !fullTokenMatchExists) {
+        score = Math.min(score, 65);
+    }
+    let remark;
+    if (score === 100)
+        remark = "Exact Match";
+    else if (score >= 90)
+        remark = "High Similarity";
+    else if (score >= 70)
+        remark = "Possible Match";
+    else
+        remark = "Low Match";
+    return {
+        inputName: originalInput,
+        givenName: originalGiven,
+        percentage: score,
+        remark,
+    };
+}

package/package.json

@@ -0,0 +1,17 @@
+{
+    "name": "@vspro/name-match-pro",
+    "version": "1.0.0",
+    "description": "A robust name matching utility with initials handling and fuzzy logic useful for fintech and insurance kyc, ocr and crm",
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "scripts": {
+      "build": "tsc",
+      "example": "ts-node src/examples/example.ts"
+    },
+    "keywords": ["name-matching", "fuzzy", "initials", "levenshtein", "name-matching-kyc", "name-matching-ocr"],
+    "license": "MIT",
+    "devDependencies": {
+      "ts-node": "^10.9.1",
+      "typescript": "^5.3.0"
+    }
+  }

package/src/examples/example.ts

@@ -0,0 +1,41 @@
+import { matchNames } from "../utils/nameMatchPro";
+const examples = [
+  { input: "Vikash Yadav Luniwal", given: "Vikash Y L" },
+  { input: "Vikash Yadav Luniwal", given: "Vikash Yadav" },
+  { input: "Vikash Yadav Luniwal", given: "Vikash Luniwal Yadav" },
+  { input: "Vikash Yadav Luniwal", given: "Vikash Yadav Luniwal" },
+];
+
+examples.forEach(({ input, given }) => {
+  const result = matchNames(input, given);
+  console.log(result);
+});
+
+/*
+OUTPUT  : 
+
+{
+  inputName: 'Vikash Yadav Luniwal',
+  givenName: 'Vikash Y L',
+  percentage: 90,
+  remark: 'High Similarity'
+}
+{
+  inputName: 'Vikash Yadav Luniwal',
+  givenName: 'Vikash Yadav',
+  percentage: 94,
+  remark: 'High Similarity'
+}
+{
+  inputName: 'Vikash Yadav Luniwal',
+  givenName: 'Vikash Luniwal Yadav',
+  percentage: 99,
+  remark: 'High Similarity'
+}
+{
+  inputName: 'Vikash Yadav Luniwal',
+  givenName: 'Vikash Yadav Luniwal',
+  percentage: 100,
+  remark: 'Exact Match'
+}
+*/

package/src/index.ts

@@ -0,0 +1 @@
+export * from './utils/nameMatchPro'

package/src/utils/nameMatchPro.ts

@@ -0,0 +1,199 @@
+
+const COMMON_PREFIXES = ["mr", "mrs", "ms", "miss", "shri", "smt", "dr"];
+
+export interface MatchResult {
+  inputName: string;
+  givenName: string;
+  percentage: number;
+  remark: string;
+}
+
+
+export function normalizeName(name: string | undefined): string {
+  if (!name) return "";
+
+  return name
+    .toLowerCase()
+    .replace(/\./g, "")
+    .replace(/\s+/g, " ")
+    .trim()
+    .split(" ")
+    .filter((word) => !COMMON_PREFIXES.includes(word))
+    .join(" ");
+}
+
+export function mergeInitials(name: string): string {
+  return name.replace(/\b([a-z])\.\s*([a-z])\./g, "$1$2");
+}
+
+export function tokenize(name: string): string[] {
+  return name.split(" ").filter(Boolean);
+}
+
+export function expandCombinedInitials(tokens: string[]): string[] {
+  let expanded: string[] = [];
+
+  for (const token of tokens) {
+    if (/^[a-z]{2,4}$/.test(token) && !/[aeiou]/.test(token)) {
+      expanded.push(...token.split(""));
+    } else {
+      expanded.push(token);
+    }
+  }
+
+  return expanded;
+}
+
+export function normalizeInitialToken(token: string): string {
+  if (token.length >= 2 && token.length <= 4 && /^[a-z]+$/.test(token) && !/[aeiou]/.test(token)) {
+    return token.split("").sort().join("");
+  }
+  return token;
+}
+
+export function levenshtein(a: string, b: string): number {
+  const matrix: number[][] = [];
+
+  for (let i = 0; i <= b.length; i++) matrix[i] = [i];
+  for (let j = 0; j <= a.length; j++) matrix[0][j] = j;
+
+  for (let i = 1; i <= b.length; i++) {
+    for (let j = 1; j <= a.length; j++) {
+      if (b[i - 1] === a[j - 1]) {
+        matrix[i][j] = matrix[i - 1][j - 1];
+      } else {
+        matrix[i][j] = Math.min(
+          matrix[i - 1][j - 1] + 1,
+          matrix[i][j - 1] + 1,
+          matrix[i - 1][j] + 1
+        );
+      }
+    }
+  }
+
+  return matrix[b.length][a.length];
+}
+
+export function isSwappedMatch(tokens1: string[], tokens2: string[]): boolean {
+  if (tokens1.length !== tokens2.length) return false;
+
+  const sorted1 = tokens1.map(normalizeInitialToken).sort().join(" ");
+  const sorted2 = tokens2.map(normalizeInitialToken).sort().join(" ");
+
+  return sorted1 === sorted2;
+}
+
+export function isInitialMatch(token1: string, token2: string): boolean {
+  if (token1.length === 1 && token2.startsWith(token1)) return true;
+  if (token2.length === 1 && token1.startsWith(token2)) return true;
+  return false;
+}
+
+export function matchNames(inputName: string, givenName: string): MatchResult {
+  const originalInput = inputName;
+  const originalGiven = givenName;
+
+  inputName = mergeInitials(normalizeName(inputName));
+  givenName = mergeInitials(normalizeName(givenName));
+
+  let inputTokens = tokenize(inputName);
+  let givenTokens = tokenize(givenName);
+
+  inputTokens = expandCombinedInitials(inputTokens);
+  givenTokens = expandCombinedInitials(givenTokens);
+
+  let score = 0;
+
+  if (inputName === givenName) score = 100;
+  else if (isSwappedMatch(inputTokens, givenTokens)) score = 99;
+  else if (
+    givenTokens.every((t) => inputTokens.includes(t)) ||
+    inputTokens.every((t) => givenTokens.includes(t))
+  ) {
+    const longer = Math.max(inputTokens.length, givenTokens.length);
+    const shorter = Math.min(inputTokens.length, givenTokens.length);
+    const diff = longer - shorter;
+
+    const hasFullTokenMatch = givenTokens.some((t) => t.length > 1 && inputTokens.includes(t));
+
+    if (hasFullTokenMatch) {
+      if (diff === 0) score = 99;
+      else if (diff === 1) score = 94;
+      else score = 90;
+    } else {
+      const matchRatio = shorter / longer;
+      score = Math.round(matchRatio * 60);
+    }
+  } else {
+    let matchedScore = 0;
+    const usedIndexes = new Set<number>();
+
+    for (const g of givenTokens) {
+      let bestMatch = 0;
+      let bestIndex = -1;
+
+      inputTokens.forEach((i, idx) => {
+        if (usedIndexes.has(idx)) return;
+
+        if (i.startsWith(g) || g.startsWith(i)) {
+          const similarity = Math.min(1, (Math.min(i.length, g.length) / Math.max(i.length, g.length)) * 1.1);
+          if (similarity > bestMatch) {
+            bestMatch = similarity;
+            bestIndex = idx;
+          }
+        }
+
+        const distance = levenshtein(i, g);
+        const similarity = 1 - distance / Math.max(i.length, g.length);
+        const weighted = Math.min(1, similarity * 1.05);
+        if (weighted > bestMatch) {
+          bestMatch = weighted;
+          bestIndex = idx;
+        }
+
+        if (isInitialMatch(i, g)) {
+          const initialScore = 0.85;
+          if (initialScore > bestMatch) {
+            bestMatch = initialScore;
+            bestIndex = idx;
+          }
+        }
+      });
+
+      if (bestIndex !== -1) {
+        usedIndexes.add(bestIndex);
+        matchedScore += bestMatch;
+      }
+    }
+
+    const coverage = matchedScore / inputTokens.length;
+    const precision = matchedScore / givenTokens.length;
+    score = Math.round((coverage * 0.6 + precision * 0.4) * 100);
+
+    if (score >= 98 && inputName !== givenName) score = 95;
+  }
+  const inputHasFull = inputTokens.some((t) => t.length > 1);
+  const givenHasFull = givenTokens.some((t) => t.length > 1);
+  const inputAllInitials = inputTokens.every((t) => t.length === 1);
+  const givenAllInitials = givenTokens.every((t) => t.length === 1);
+  const fullTokenMatchExists = givenTokens.some((g) => g.length > 1 && inputTokens.includes(g));
+
+  if ((inputHasFull && givenAllInitials) || (givenHasFull && inputAllInitials)) {
+    score = Math.min(score, 65);
+  } else if (inputHasFull && givenHasFull && !fullTokenMatchExists) {
+    score = Math.min(score, 65);
+  }
+
+  let remark: string;
+  if (score === 100) remark = "Exact Match";
+  else if (score >= 90) remark = "High Similarity";
+  else if (score >= 70) remark = "Possible Match";
+  else remark = "Low Match";
+
+  return {
+    inputName: originalInput,
+    givenName: originalGiven,
+    percentage: score,
+    remark,
+  };
+}

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+    "compilerOptions": {
+      "target": "ES2022",
+      "module": "CommonJS",
+      "declaration": true,
+      "outDir": "dist",
+      "strict": true,
+      "esModuleInterop": true,
+      "forceConsistentCasingInFileNames": true,
+      "skipLibCheck": true
+    },
+    "include": ["src"]
+  }