### Install and Run TextDistance WASM

Source: https://github.com/demomacro/textdistance/blob/main/README.md

Commands for cloning the repository, installing dependencies using pnpm, and starting the development server. This is a common setup for Node.js projects using pnpm.

```bash
git clone https://github.com/YOUR_USERNAME/textdistance.git
cd textdistance

pnpm install

pnpm dev
```

--------------------------------

### Install TextDistance using npm, yarn, or pnpm

Source: https://github.com/demomacro/textdistance/blob/main/packages/textdistance/README.md

Demonstrates how to install the textdistance library using common package managers like npm, yarn, and pnpm. This is the first step before using the library in your project.

```bash
# Install with npm
$ npm install textdistance

# Install with yarn
$ yarn add textdistance

# Install with pnpm
$ pnpm add textdistance
```

--------------------------------

### TextDistance Edit Distance Algorithms Examples

Source: https://github.com/demomacro/textdistance/blob/main/packages/textdistance/README.md

Provides examples of using various edit distance algorithms like Levenshtein, Damerau-Levenshtein, Jaro, Jaro-Winkler, Hamming, and Sift4 Simple from the textdistance library.

```typescript
// Classic string edit distance
textdistance.levenshtein("saturday", "sunday"); // 3
textdistance.damerau_levenshtein("ca", "abc"); // 2

// Phonetic and similarity algorithms
textdistance.jaro("martha", "marhta"); // 0.9611111111111111
textdistance.jarowinkler("martha", "marhta"); // 0.9611111111111111
textdistance.hamming("karolin", "kathrin"); // 3
textdistance.sift4_simple("abc", "axc"); // 1
```

--------------------------------

### TextDistance Naive Algorithms Examples

Source: https://github.com/demomacro/textdistance/blob/main/packages/textdistance/README.md

Demonstrates the usage of simple, naive comparison algorithms in textdistance, such as prefix, suffix, and length comparisons.

```typescript
// Simple comparison methods
textdistance.prefix("hello", "help"); // 0.6
textdistance.suffix("hello", "ello"); // 0.8
textdistance.length("hello", "hallo"); // 0
```

--------------------------------

### Contributing to TextDistance WASM

Source: https://github.com/demomacro/textdistance/blob/main/README.md

Steps for setting up a local development environment for contributing to the TextDistance WASM project. Includes forking, cloning, adding remotes, installing dependencies, and running in development mode.

```bash
git clone https://github.com/YOUR_USERNAME/textdistance.git
cd textdistance

git remote add upstream https://github.com/DemoMacro/textdistance.git

pnpm install

pnpm dev
```

--------------------------------

### Basic TextDistance Usage in TypeScript

Source: https://github.com/demomacro/textdistance/blob/main/packages/textdistance/README.md

Shows how to import and use basic string distance and similarity algorithms from the textdistance library. It includes examples for Levenshtein, Jaro, and Cosine similarity.

```typescript
import * as textdistance from "textdistance";

// All algorithms are available as named functions
console.log(textdistance.levenshtein("kitten", "sitting")); // 3
console.log(textdistance.jaro("hello", "hallo")); // 0.8666666666666667
console.log(textdistance.cosine("abc", "bcd")); // 0.6666666666666666
```

--------------------------------

### TextDistance Bigram Algorithms Examples

Source: https://github.com/demomacro/textdistance/blob/main/packages/textdistance/README.md

Illustrates the use of bigram-based similarity algorithms in textdistance, including Jaccard and Cosine similarity calculated on character pairs (bigrams).

```typescript
// Character pair based similarity
textdistance.jaccard_bigram("night", "nacht"); // 0.14285714285714285
textdistance.cosine_bigram("night", "nacht"); // 0.25
```

--------------------------------

### Calculate Jaro Similarity for Strings (JavaScript)

Source: https://context7.com/demomacro/textdistance/llms.txt

Demonstrates the usage of the Jaro similarity algorithm, which is effective for short strings and names. The code includes examples for name matching and comparing name variations.

```javascript
import * as textdistance from "textdistance";

// Name matching
const similarity = textdistance.jaro("MARTHA", "MARHTA");
console.log(similarity); // Output: 0.944

// Compare different name variations
const name1 = "DWAYNE";
const name2 = "DUANE";
console.log(textdistance.jaro(name1, name2)); // Output: 0.822

// Practical name matching system
const recordName = "Jon Smith";
const inputName = "John Smyth";
const jaro = textdistance.jaro(recordName.toLowerCase(), inputName.toLowerCase());
if (jaro > 0.85) {
  console.log("Possible match found");
}
// Output: Possible match found (jaro ≈ 0.89)
```

--------------------------------

### TextDistance Sequence-based Algorithms Examples

Source: https://github.com/demomacro/textdistance/blob/main/packages/textdistance/README.md

Demonstrates the usage of sequence-based algorithms in textdistance, including Longest Common Subsequence (LCS), Gestalt Pattern Matching (Ratcliff-Obershelp), and Smith-Waterman local sequence alignment.

```typescript
// Longest common subsequence/substring
textdistance.lcs_seq("ABCD", "ACBAD"); // 3
textdistance.lcs_str("ABCD", "ACBAD"); // 1

// Gestalt pattern matching
textdistance.ratcliff_obershelp("hello", "hallo"); // 0.8

// Local sequence alignment
textdistance.smith_waterman("ACGT", "ACGT"); // 4
```

--------------------------------

### TextDistance Token-based Algorithms Examples

Source: https://github.com/demomacro/textdistance/blob/main/packages/textdistance/README.md

Shows how to use token-based similarity measures from textdistance, such as Jaccard, Cosine, Sorensen, Overlap, and Tversky indices for comparing sets of tokens.

```typescript
// Set-based similarity measures
textdistance.jaccard("hello world", "world hello"); // 1
textdistance.cosine("hello world", "world hello"); // 1
textdistance.sorensen("hello world", "world hello"); // 1
textdistance.overlap("hello", "hello world"); // 1
textdistance.tversky("abc", "bcd"); // 0.5
```

--------------------------------

### Basic TextDistance WASM Usage in TypeScript

Source: https://github.com/demomacro/textdistance/blob/main/README.md

Demonstrates how to import and use the textdistance library in a TypeScript project. It shows calculating Levenshtein distance, Jaro similarity, and using a universal compare function. Assumes the 'textdistance' package is installed.

```typescript
import * as textdistance from "textdistance";

// Calculate Levenshtein distance
const distance = textdistance.levenshtein("kitten", "sitting");
console.log(`Distance: ${distance}`); // Output: 3

// Calculate normalized similarity (0-1)
const similarity = textdistance.jaro("hello", "hallo");
console.log(`Similarity: ${similarity}`); // Output: 0.8666666666666667

// Use the universal compare function
const result = textdistance.compare("apple", "apply", "levenshtein");
console.log(`Result: ${result}`); // Output: 0.2
```

--------------------------------

### Calculate Damerau-Levenshtein Distance and Similarity (JavaScript)

Source: https://context7.com/demomacro/textdistance/llms.txt

Shows how to compute Damerau-Levenshtein distance, which accounts for transpositions, and its normalized similarity score. Practical examples for typo detection are provided.

```javascript
import * as textdistance from "textdistance";

// Compare with standard Levenshtein
const s1 = "ca", s2 = "abc";
console.log(textdistance.levenshtein(s1, s2)); // Output: 3
console.log(textdistance.damerau_levenshtein(s1, s2)); // Output: 2 (considers transposition)

// Normalized version
const similarity = textdistance.damerau_levenshtein_normalized("teh", "the");
console.log(similarity); // Output: 0.667 (detects transposition typo)

// Typo detection in user input
const correctWord = "database";
const userInput = "databsae"; // transposed 's' and 'a'
const distance = textdistance.damerau_levenshtein(userInput, correctWord);
if (distance <= 2) {
  console.log(`Did you mean "${correctWord}"?`);
}
// Output: Did you mean "database"?
```

--------------------------------

### Discovering Textdistance Algorithms by Category (JavaScript)

Source: https://context7.com/demomacro/textdistance/llms.txt

Illustrates how to use the textdistance library's utility functions in JavaScript to discover available algorithms categorized by their type. This includes functions to get all algorithms, edit distance algorithms, sequence-based algorithms, token-based algorithms, bigram algorithms, and naive algorithms. It also shows how to build a dynamic algorithm menu and a basic recommendation system.

```javascript
import * as textdistance from "textdistance";

// Get all available algorithms
const allAlgorithms = textdistance.get_algorithms();
console.log(allAlgorithms);
// Output: ["levenshtein", "damerau_levenshtein", "jaro", ...]

// Get edit distance algorithms
const editAlgos = textdistance.get_edit_algorithms();
console.log(editAlgos);
// Output: ["levenshtein", "damerau_levenshtein", "hamming", "jaro", "jarowinkler", "sift4_simple"]

// Get sequence-based algorithms
const seqAlgos = textdistance.get_sequence_algorithms();
console.log(seqAlgos);
// Output: ["lcs_seq", "lcs_str", "ratcliff_obershelp", "smith_waterman"]

// Get token-based algorithms
const tokenAlgos = textdistance.get_token_algorithms();
console.log(tokenAlgos);
// Output: ["jaccard", "sorensen", "tversky", "overlap", "cosine"]

// Get bigram algorithms
const bigramAlgos = textdistance.get_bigram_algorithms();
console.log(bigramAlgos);
// Output: ["jaccard_bigram", "cosine_bigram"]

// Get naive algorithms
const naiveAlgos = textdistance.get_naive_algorithms();
console.log(naiveAlgos);
// Output: ["prefix", "suffix", "length"]

// Build dynamic algorithm selector
function buildAlgorithmMenu() {
  return {
    "Edit Distance": textdistance.get_edit_algorithms(),
    "Sequence-Based": textdistance.get_sequence_algorithms(),
    "Token-Based": textdistance.get_token_algorithms(),
    "Bigram": textdistance.get_bigram_algorithms(),
    "Naive": textdistance.get_naive_algorithms()
  };
}

const menu = buildAlgorithmMenu();
console.log(JSON.stringify(menu, null, 2));

// Algorithm recommendation system
function recommendAlgorithm(useCase) {
  const recommendations = {
    "name-matching": textdistance.get_edit_algorithms().filter(a =>
      a.includes("jaro")
    ),
    "fuzzy-search": ["levenshtein_normalized", "jaro", "cosine"],
    "dna-sequence": ["smith_waterman", "lcs_seq", "hamming"],
    "document-similarity": textdistance.get_token_algorithms(),
    "typo-detection": ["damerau_levenshtein", "levenshtein"]
  };
  return recommendations[useCase] || textdistance.get_algorithms();
}

console.log(recommendAlgorithm("name-matching"));
// Output: ["jaro", "jarowinkler"]

// Performance testing across algorithms
function benchmarkAlgorithms(s1, s2) {
  const algorithms = textdistance.get_algorithms();
  return algorithms.map(algo => {
    const start = performance.now();
    const result = textdistance.compare(s1, s2, algo);
    const time = performance.now() - start;
    return { algorithm: algo, result, time };
  }).sort((a, b) => a.time - b.time);
}

```

--------------------------------

### Universal String Comparison with Textdistance (JavaScript)

Source: https://context7.com/demomacro/textdistance/llms.txt

Demonstrates how to use the textdistance library's universal compare function in JavaScript. It supports accessing any algorithm by name, handling multiple naming conventions (underscores, hyphens, or no separators), dynamic algorithm selection via function parameters, and configurable similarity engines. It also includes examples for batch comparisons with multiple algorithms.

```javascript
import * as textdistance from "textdistance";

// Access any algorithm by name
const result1 = textdistance.compare("hello", "hallo", "jaro");
console.log(result1); // Output: 0.867

// Multiple naming conventions supported
const result2 = textdistance.compare("kitten", "sitting", "levenshtein");
const result3 = textdistance.compare("kitten", "sitting", "levenshtein-normalized");
const result4 = textdistance.compare("kitten", "sitting", "levenshtein_normalized");
console.log(result2, result3, result4); // All valid

// Dynamic algorithm selection
function compareStrings(s1, s2, algorithm = "levenshtein") {
  try {
    return textdistance.compare(s1, s2, algorithm);
  } catch (e) {
    console.error(`Algorithm ${algorithm} not found`);
    return null;
  }
}

console.log(compareStrings("test", "text", "hamming")); // Output: 1
console.log(compareStrings("test", "text", "jaro-winkler")); // Output: 0.917

// Configurable similarity engine
class SimilarityEngine {
  constructor(algorithm = "levenshtein_normalized") {
    this.algorithm = algorithm;
  }

  compare(s1, s2) {
    return textdistance.compare(s1, s2, this.algorithm);
  }

  setAlgorithm(algo) {
    this.algorithm = algo;
  }
}

const engine = new SimilarityEngine("jaro");
console.log(engine.compare("hello", "hallo")); // Output: 0.867
engine.setAlgorithm("cosine");
console.log(engine.compare("hello", "hallo")); // Output: 0.894

// Batch comparison with multiple algorithms
function multiAlgorithmCompare(s1, s2, algorithms) {
  return algorithms.map(algo => ({
    algorithm: algo,
    score: textdistance.compare(s1, s2, algo)
  }));
}

const results = multiAlgorithmCompare("test", "text", [
  "levenshtein",
  "jaro",
  "jaccard",
  "cosine"
]);
console.log(results);
// Output: [
//   { algorithm: "levenshtein", score: 1 },
//   { algorithm: "jaro", score: 0.917 },
//   { algorithm: "jaccard", score: 0.75 },
//   { algorithm: "cosine", score: 0.866 }
// ]
```

--------------------------------

### Calculate Levenshtein Distance and Similarity (JavaScript)

Source: https://context7.com/demomacro/textdistance/llms.txt

Demonstrates how to calculate the raw Levenshtein edit distance and normalized similarity score between two strings using the textdistance library. Includes a practical example for fuzzy search.

```javascript
import * as textdistance from "textdistance";

// Calculate raw edit distance
const distance = textdistance.levenshtein("kitten", "sitting");
console.log(distance); // Output: 3 (3 edits needed: k→s, e→i, insert g)

// Calculate normalized similarity (0-1 range, higher = more similar)
const similarity = textdistance.levenshtein_normalized("kitten", "sitting");
console.log(similarity); // Output: 0.571 (1 - 3/7)

// Practical use case: fuzzy search
const searchTerm = "javscript";
const options = ["javascript", "typescript", "python", "java"];
const results = options
  .map(opt => ({
    name: opt,
    similarity: textdistance.levenshtein_normalized(searchTerm, opt)
  }))
  .sort((a, b) => b.similarity - a.similarity);
console.log(results[0]); // Output: { name: "javascript", similarity: 0.9 }
```

--------------------------------

### Calculate Jaro-Winkler Similarity for Names (JavaScript)

Source: https://context7.com/demomacro/textdistance/llms.txt

Illustrates how to use the Jaro-Winkler similarity algorithm, an extension of Jaro that prioritizes common prefixes, making it ideal for name deduplication and record linkage. Includes a practical deduplication example.

```javascript
import * as textdistance from "textdistance";

// Compare Jaro and Jaro-Winkler
const s1 = "DIXON", s2 = "DICKSONX";
console.log(textdistance.jaro(s1, s2)); // Output: 0.767
console.log(textdistance.jarowinkler(s1, s2)); // Output: 0.813 (higher due to prefix)

// Name deduplication in database
const records = [
  { id: 1, name: "William Gates" },
  { id: 2, name: "Bill Gates" },
  { id: 3, name: "William Gate" }
];

const target = "William Gates";
const matches = records
  .map(r => ({
    ...r,
    score: textdistance.jarowinkler(target, r.name)
  }))
  .filter(r => r.score > 0.9)
  .sort((a, b) => b.score - a.score);

console.log(matches);
// Output: [
//   { id: 1, name: "William Gates", score: 1.0 },
//   { id: 3, name: "William Gate", score: 0.979 }
// ]
```

--------------------------------

### TextDistance Universal Compare Function and Algorithm Listing

Source: https://github.com/demomacro/textdistance/blob/main/packages/textdistance/README.md

Explains how to use the universal `compare` function to access any algorithm by name and retrieve lists of all available algorithms, categorized algorithms, and specific category algorithm names.

```typescript
const result = textdistance.compare("hello", "hallo", "jaro");
console.log(result); // 0.8666666666666667

// Available algorithm names (returns array)
console.log(textdistance.get_algorithms());
// ["levenshtein", "damerau_levenshtein", "jaro", "jaro_winkler", "hamming", "sift4_simple", "lcs_seq", "lcs_str", "ratcliff_obershelp", "jaccard", "cosine", "sorensen", "tversky", "overlap", "prefix", "suffix", "length", "jaccard_bigram", "cosine_bigram", "smith_waterman"]

// Get algorithms by category (returns arrays)
console.log(textdistance.get_edit_algorithms());
// ["levenshtein", "damerau_levenshtein", "jaro", "jaro_winkler", "hamming", "sift4_simple"]

console.log(textdistance.get_sequence_algorithms());
// ["lcs_seq", "lcs_str", "ratcliff_obershelp", "smith_waterman"]

console.log(textdistance.get_token_algorithms());
// ["jaccard", "cosine", "sorensen", "tversky", "overlap"]

console.log(textdistance.get_naive_algorithms());
// ["prefix", "suffix", "length"]

console.log(textdistance.get_bigram_algorithms());
// ["jaccard_bigram", "cosine_bigram"]
```

--------------------------------

### Using Normalized vs. Raw Distance in TextDistance

Source: https://github.com/demomacro/textdistance/blob/main/packages/textdistance/README.md

Illustrates the difference between raw distance algorithms (lower is more similar) and normalized similarity algorithms (higher is more similar, 0-1 range) provided by textdistance.

```typescript
// Distance algorithms (lower is more similar)
const distance = textdistance.levenshtein("cat", "bat"); // 1

// Similarity algorithms (higher is more similar, 0-1 range)
const similarity = textdistance.levenshtein_normalized("cat", "bat"); // 0.6666666666666666
```

--------------------------------

### Ratcliff-Obershelp Similarity Calculation

Source: https://context7.com/demomacro/textdistance/llms.txt

Demonstrates the Ratcliff-Obershelp algorithm for measuring string similarity. It recursively finds matching sequences and computes a similarity score. Useful for general pattern matching, document comparison, and fuzzy name matching.

```javascript
import * as textdistance from "textdistance";

// Pattern matching
const similarity = textdistance.ratcliff_obershelp("ALEXANDRE", "ALEKSANDER");
console.log(similarity); // Output: 0.737

// Document comparison
const doc1 = "The quick brown fox jumps over the lazy dog";
const doc2 = "A quick brown dog jumps over the lazy fox";
const docSim = textdistance.ratcliff_obershelp(doc1, doc2);
console.log(`Document similarity: ${(docSim * 100).toFixed(1)}%`);
// Output: Document similarity: 81.4%

// Fuzzy matching for product names
const products = [
  "iPhone 13 Pro Max",
  "iPhone 13 Pro",
  "iPhone 12 Pro Max",
  "Samsung Galaxy S21"
];
const search = "iPhone 13 Pro Max";
const ranked = products
  .map(p => ({ name: p, score: textdistance.ratcliff_obershelp(search, p) }))
  .sort((a, b) => b.score - a.score);
console.log(ranked[0]);
// Output: { name: "iPhone 13 Pro Max", score: 1.0 }
```

--------------------------------

### SIFT4 Simple String Matching in JavaScript

Source: https://context7.com/demomacro/textdistance/llms.txt

Implements the SIFT4 algorithm for fast approximate string matching, optimized for performance when exact results are not critical. It includes basic distance calculation and a normalized version for similarity. Useful for real-time search and filtering large datasets.

```javascript
import * as textdistance from "textdistance";

// Fast approximate matching
const distance = textdistance.sift4_simple("hello", "hallo");
console.log(distance); // Output: 1

// Normalized version
const similarity = textdistance.sift4_simple_normalized("javascript", "javscript");
console.log(similarity); // Output: 0.9

// High-performance real-time search
const query = "pythn";
const items = ["python", "perl", "php", "ruby", "python3", "cython"];

// Fast filtering for large datasets
const quickMatches = items.filter(item =>
  textdistance.sift4_simple_normalized(query, item) > 0.7
);
console.log(quickMatches); // Output: ["python", "python3", "cython"]

// Benchmark comparison
console.time("sift4_simple");
for (let i = 0; i < 10000; i++) {
  textdistance.sift4_simple("example", "exampl");
}
console.timeEnd("sift4_simple"); // Significantly faster than other algorithms
```

--------------------------------

### Smith-Waterman Algorithm for Local Alignment

Source: https://context7.com/demomacro/textdistance/llms.txt

Implements the Smith-Waterman algorithm for local sequence alignment. It's effective for finding similar regions within strings, especially useful in bioinformatics for protein and DNA sequence analysis. Provides both raw alignment scores and normalized similarity.

```javascript
import * as textdistance from "textdistance";

// Local alignment scoring
const score = textdistance.smith_waterman("GGTTGACTA", "TGTTACGG");
console.log(score); // Output: alignment score

// Normalized version for comparison
const similarity = textdistance.smith_waterman_normalized("ACACACTA", "AGCACACA");
console.log(similarity); // Output: 0.875

// Protein sequence alignment
const protein1 = "HEAGAWGHEE";
const protein2 = "PAWHEAE";
const alignScore = textdistance.smith_waterman(protein1, protein2);
console.log(`Alignment score: ${alignScore}`);

// Finding similar regions in text
const text1 = "The quick brown fox jumps";
const text2 = "A brown fox runs quickly";
const localSim = textdistance.smith_waterman_normalized(text1, text2);
console.log(`Local similarity: ${(localSim * 100).toFixed(1)}%`);
// Output: Local similarity: 68.0%

// Substring matching in DNA
const genome = "ATCGATCGATCGATCG";
const query = "GATCGAT";
const matchScore = textdistance.smith_waterman_normalized(genome, query);
console.log(`Match quality: ${matchScore}`);
```

--------------------------------

### Tversky Index for Asymmetric Similarity using textdistance

Source: https://context7.com/demomacro/textdistance/llms.txt

Calculates the Tversky Index, an asymmetric similarity measure that allows different weights for prototype and variant. This is useful for non-symmetric matching scenarios, such as query-document matching or spell correction with asymmetric weighting. It requires alpha and beta parameters for weighting, influencing the output.

```javascript
import * as textdistance from "textdistance";

// Asymmetric similarity
const similarity = textdistance.tversky("abcde", "abc");
console.log(similarity); // Output: varies based on alpha/beta parameters

// Query-document matching (query is prototype)
const query = "machine learning";
const documents = [
  "introduction to machine learning algorithms",
  "deep learning and neural networks",
  "machine learning in practice"
];

const matches = documents.map(doc => ({
  doc,
  score: textdistance.tversky(query, doc)
}));

console.log(matches);
// Documents containing query terms score higher

// Spell correction with asymmetric weighting
const userInput = "databse";
const dictionary = ["database", "data", "base"];
const corrections = dictionary
  .map(word => ({
    word,
    score: textdistance.tversky(word, userInput)
  }))
  .sort((a, b) => b.score - a.score);

console.log(`Suggested correction: ${corrections[0].word}`);
// Output: Suggested correction: database

```

--------------------------------

### Prefix Similarity Calculation with JavaScript

Source: https://context7.com/demomacro/textdistance/llms.txt

Measures string similarity based on the length of the common prefix. This is ideal for use cases such as autocomplete suggestions and path matching. The function takes two strings and returns a score proportional to the length of their shared prefix relative to the maximum length of the two strings.

```javascript
import * as textdistance from "textdistance";

// Prefix matching
const similarity = textdistance.prefix("hello", "help");
console.log(similarity); // Output: 0.6 (3 common chars / 5 max length)

// Autocomplete suggestions
function autocomplete(input, options) {
  return options
    .map(opt => ({ text: opt, score: textdistance.prefix(input, opt) }))
    .filter(r => r.score > 0.5)
    .sort((a, b) => b.score - a.score);
}

const suggestions = autocomplete("jav", ["java", "javascript", "python", "javac"]);
console.log(suggestions);
// Output: [
//   { text: "java", score: 0.75 },
//   { text: "javac", score: 0.6 },
//   { text: "javascript", score: 0.6 }
// ]

// Path matching
const paths = [
  "/api/users/list",
  "/api/users/create",
  "/api/posts/list",
  "/admin/users"
];
const searchPath = "/api/users";
const matches = paths
  .filter(p => textdistance.prefix(searchPath, p) > 0.8)
  .sort();
console.log(matches);
// Output: ["/api/users/create", "/api/users/list"]

// Version comparison
const versions = ["1.2.3", "1.2.4", "1.3.0", "2.0.0"];
const current = "1.2";
const compatible = versions.filter(v =>
  textdistance.prefix(current, v) > 0.8
);
console.log(compatible);
// Output: ["1.2.3", "1.2.4"]
```

--------------------------------

### Suffix Similarity in JavaScript

Source: https://context7.com/demomacro/textdistance/llms.txt

Calculates string similarity based on the length of the common suffix. Useful for tasks like file extension grouping, rhyme detection, domain matching, and identifying word endings (e.g., gerunds). It takes two strings as input and returns a similarity score.

```javascript
import * as textdistance from "textdistance";

// Suffix matching
const similarity = textdistance.suffix("hello", "jello");
console.log(similarity); // Output: 0.8 (4 common chars / 5 max length)

// File extension grouping
function groupByExtension(filename, patterns) {
  return patterns.find(p => textdistance.suffix(filename, p) > 0.9);
}

const files = ["document.pdf", "image.jpg", "script.js", "data.json"];
files.forEach(f => {
  const match = groupByExtension(f, [".pdf", ".jpg", ".js", ".json"]);
  console.log(`${f} matches ${match}`);
});

// Rhyme detection
function findRhymes(word, wordList) {
  return wordList.filter(w =>
    textdistance.suffix(word, w) > 0.6 && w !== word
  );
}

const rhymes = findRhymes("cat", ["bat", "rat", "dog", "hat", "car"]);
console.log(rhymes); // Output: ["bat", "rat", "hat"]

// Domain similarity
const domains = [
  "example.com",
  "test.com",
  "demo.com",
  "example.org"
];
const target = ".com";
const comDomains = domains.filter(d =>
  textdistance.suffix(d, target) === 1.0
);
console.log(comDomains);
// Output: ["example.com", "test.com", "demo.com"]

// Word ending analysis
const words = ["running", "jumping", "walking", "run", "jump"];
const gerunds = words.filter(w => textdistance.suffix(w, "ing") > 0.4);
console.log(gerunds);
// Output: ["running", "jumping", "walking"]

```

--------------------------------

### Jaccard Bigram Similarity Calculation with JavaScript

Source: https://context7.com/demomacro/textdistance/llms.txt

Calculates Jaccard similarity using character bigrams for more sensitive comparisons. Useful for typo detection and brand name similarity, it takes two strings as input and returns a similarity score between 0 and 1.

```javascript
import * as textdistance from "textdistance";

// Bigram-based similarity
const similarity = textdistance.jaccard_bigram("night", "nacht");
console.log(similarity); // Output: 0.143

// More sensitive to character order than regular Jaccard
const s1 = "abc", s2 = "bca";
console.log(textdistance.jaccard(s1, s2)); // Output: 1.0 (same characters)
console.log(textdistance.jaccard_bigram(s1, s2)); // Output: 0.0 (different bigrams)

// Typo detection preserving character order
function detectTypo(correct, input) {
  const bigramSim = textdistance.jaccard_bigram(correct, input);
  return bigramSim > 0.5 ? "similar" : "different";
}

console.log(detectTypo("hello", "helo")); // Output: similar
console.log(detectTypo("hello", "lleho")); // Output: different (anagram)

// Brand name similarity
const brands = ["microsoft", "microsofl", "macrosoft", "maicrosoft"];
const target = "microsoft";
const similar = brands
  .map(b => ({ name: b, score: textdistance.jaccard_bigram(target, b) }))
  .filter(b => b.score > 0.4)
  .sort((a, b) => b.score - a.score);

console.log(similar);
// Output: [
//   { name: "microsoft", score: 1.0 },
//   { name: "microsofl", score: 0.8 }
// ]
```

--------------------------------

### Cosine Bigram Similarity Calculation with JavaScript

Source: https://context7.com/demomacro/textdistance/llms.txt

Calculates cosine similarity using character bigrams, offering improved context awareness over single-character methods. This function is useful for tasks like language detection and phonetic similarity assessment. It accepts two strings and returns a similarity score.

```javascript
import * as textdistance from "textdistance";

// Bigram cosine similarity
const similarity = textdistance.cosine_bigram("night", "nacht");
console.log(similarity); // Output: 0.25

// Language detection helper
function compareLanguageSignatures(text, signature) {
  return textdistance.cosine_bigram(text.toLowerCase(), signature);
}

const signatures = {
  english: "the and for that",
  spanish: "que de la el",
  french: "le de la et"
};

const text = "the quick brown";
const scores = Object.entries(signatures).map(([lang, sig]) => ({
  language: lang,
  score: compareLanguageSignatures(text, sig)
}));
console.log(scores);

// Phonetic similarity
const word1 = "philosophy";
const word2 = "filosophy";
const phonetic = textdistance.cosine_bigram(word1, word2);
console.log(`Phonetic similarity: ${(phonetic * 100).toFixed(1)}%`);
// Output: Phonetic similarity: 82.4%

// Autocomplete ranking
const partial = "pyth";
const completions = ["python", "pythonic", "pytest", "cython"];
const ranked = completions
  .map(c => ({ text: c, score: textdistance.cosine_bigram(partial, c) }))
  .sort((a, b) => b.score - a.score);
console.log(ranked.slice(0, 2));
```

--------------------------------

### Jaccard Similarity for Set Comparison

Source: https://context7.com/demomacro/textdistance/llms.txt

Calculates Jaccard similarity, a set-based measure where similarity is the ratio of intersection size to union size. Applied to character sets, tokenized strings, or tag lists for tasks like content recommendation and duplicate detection.

```javascript
import * as textdistance from "textdistance";

// Character set similarity
const similarity = textdistance.jaccard("night", "nacht");
console.log(similarity); // Output: 0.429

// Token-based comparison (splits on whitespace)
const text1 = "the quick brown fox";
const text2 = "the fast brown dog";
const jaccard = textdistance.jaccard(text1, text2);
console.log(jaccard); // Output: 0.4 (2 common words: "the", "brown")

// Tag similarity for content recommendation
function calculateTagSimilarity(item1Tags, item2Tags) {
  return textdistance.jaccard(item1Tags.join(" "), item2Tags.join(" "));
}
const article1 = ["javascript", "programming", "web"];
const article2 = ["programming", "python", "web"];
const tagSim = calculateTagSimilarity(article1, article2);
console.log(`Tag similarity: ${(tagSim * 100).toFixed(1)}%`);
// Output: Tag similarity: 50.0%

// Duplicate detection
const items = ["abc def ghi", "def ghi jkl", "abc xyz"];
const threshold = 0.3;
items.forEach((item, i) => {
  items.slice(i + 1).forEach((other, j) => {
    const sim = textdistance.jaccard(item, other);
    if (sim > threshold) {
      console.log(`Similar items found: ${i} and ${i + j + 1}, score: ${sim}`);
    }
  });
});
```

--------------------------------

### Overlap Coefficient for Subset Similarity using textdistance

Source: https://context7.com/demomacro/textdistance/llms.txt

Calculates the Overlap Coefficient, which measures similarity as the size of the intersection divided by the size of the smaller set. This metric is particularly useful for detecting substrings or when one string is expected to be a subset of another, such as in hashtag or skill matching. It returns a float between 0 and 1.

```javascript
import * as textdistance from "textdistance";

// Overlap similarity
const similarity = textdistance.overlap("hello", "hello world");
console.log(similarity); // Output: 1.0 (smaller set fully contained)

// Substring detection
const text = "javascript";
const substr = "java";
const overlap = textdistance.overlap(substr, text);
console.log(`Substring overlap: ${overlap}`);
// Output: Substring overlap: 1.0

// Hashtag matching
function matchHashtags(postTags, searchTags) {
  return textdistance.overlap(
    searchTags.join(" "),
    postTags.join(" ")
  );
}

const post = ["javascript", "webdev", "programming", "tutorial"];
const search = ["javascript", "webdev"];
const match = matchHashtags(post, search);
console.log(`Tag match: ${(match * 100).toFixed(0)}%`);
// Output: Tag match: 100%

// Skill matching for job search
const required = "python sql";
const candidate = "python sql javascript react";
const skillMatch = textdistance.overlap(required, candidate);
if (skillMatch === 1.0) {
  console.log("Candidate has all required skills");
}
// Output: Candidate has all required skills

```

--------------------------------

### Cosine Similarity for Vector Representation

Source: https://context7.com/demomacro/textdistance/llms.txt

Calculates Cosine similarity based on character frequency vectors. This method measures the angle between two vectors in a multi-dimensional space and is suitable for document similarity and content-based filtering tasks.

```javascript
import * as textdistance from "textdistance";

// Character frequency based similarity
const similarity = textdistance.cosine("hello", "hallo");
console.log(similarity); // Output: 0.894

// Document similarity
const doc1 = "machine learning is great";
const doc2 = "deep learning is amazing";
const docSim = textdistance.cosine(doc1, doc2);
console.log(`Document similarity: ${(docSim * 100).toFixed(1)}%`);
// Output: Document similarity: 54.8%

// Content-based filtering
const userProfile = "javascript typescript react vue";
const articles = [
  { id: 1, keywords: "javascript react hooks" },
  { id: 2, keywords: "python django flask" },
  { id: 3, keywords: "typescript angular rxjs" }
];

const recommendations = articles
  .map(a => ({
    ...a,
    relevance: textdistance.cosine(userProfile, a.keywords)
  }))
  .filter(a => a.relevance > 0.5)
  .sort((a, b) => b.relevance - a.relevance);

console.log(recommendations);
// Output: [
//   { id: 1, keywords: "javascript react hooks", relevance: 0.816 },
//   { id: 3, keywords: "typescript angular rxjs", relevance: 0.577 }
// ]
```

--------------------------------

### Hamming Distance Calculation and Normalization in JavaScript

Source: https://context7.com/demomacro/textdistance/llms.txt

Calculates the Hamming distance between two strings of equal length, representing the number of differing characters. It also provides a normalized version for similarity measurement. This is useful for error detection in fixed-length codes and DNA sequence comparison.

```javascript
import * as textdistance from "textdistance";

// Basic usage
const distance = textdistance.hamming("karolin", "kathrin");
console.log(distance); // Output: 3 (positions 2, 4, 5 differ)

// Normalized version
const similarity = textdistance.hamming_normalized("1011101", "1001001");
console.log(similarity); // Output: 0.714 (5 matches out of 7)

// DNA sequence comparison
const dna1 = "AGCTTAGC";
const dna2 = "AGCTTGGC";
const mutations = textdistance.hamming(dna1, dna2);
console.log(`Number of point mutations: ${mutations}`);
// Output: Number of point mutations: 1

// Error detection in fixed-length codes
function checkTransmission(sent, received) {
  const errors = textdistance.hamming(sent, received);
  return errors === 0 ? "OK" : `${errors} bit error(s) detected`;
}
console.log(checkTransmission("10110", "10010"));
// Output: 1 bit error(s) detected
```

--------------------------------

### Length Similarity in JavaScript

Source: https://context7.com/demomacro/textdistance/llms.txt

Measures string similarity based on the normalized difference in string lengths. It's useful for quick filtering of potential matches, password strength checks (based on length), and detecting text truncation. The function takes two strings and returns a similarity score between 0 and 1.

```javascript
import * as textdistance from "textdistance";

// Length-based similarity
const similarity = textdistance.length("hello", "hi");
console.log(similarity); // Output: 0.6 (length ratio: 2/5)

// Quick filtering before expensive comparison
function prefilterByLength(query, items, threshold = 0.5) {
  return items.filter(item =>
    textdistance.length(query, item) >= threshold
  );
}

const query = "javascript";
const items = ["js", "javascript", "java", "typescript", "javascripting"];
const candidates = prefilterByLength(query, items);
console.log(candidates);
// Output: ["javascript", "typescript", "javascripting"]

// Password strength: length requirement
function checkPasswordLength(password, minLength = 8) {
  const ref = "x".repeat(minLength);
  const lengthScore = textdistance.length(password, ref);
  return lengthScore >= 1.0 ? "OK" : "Too short";
}

console.log(checkPasswordLength("pass")); // Output: Too short
console.log(checkPasswordLength("password123")); // Output: OK

// Text truncation detection
const original = "The quick brown fox jumps over the lazy dog";
const truncated = "The quick brown fox";
const lengthMatch = textdistance.length(original, truncated);
if (lengthMatch < 0.7) {
  console.log("Text appears to be truncated");
}
// Output: Text appears to be truncated

// Optimization: skip expensive algorithms for vastly different lengths
function smartCompare(s1, s2) {
  const lenSim = textdistance.length(s1, s2);
  if (lenSim < 0.3) {
    return 0; // Too different in length, skip detailed comparison
  }
  return textdistance.levenshtein_normalized(s1, s2);
}

console.log(smartCompare("hi", "hello world example text"));
// Output: 0 (skipped expensive comparison)

```

--------------------------------

### Longest Common Subsequence (LCS) Calculation in JavaScript

Source: https://context7.com/demomacro/textdistance/llms.txt

Calculates the length of the Longest Common Subsequence (LCS) between two strings, where characters do not need to be contiguous. It also offers a normalized similarity score. This is applicable to tasks like code plagiarism detection and document version comparison.

```javascript
import * as textdistance from "textdistance";

// Basic LCS
const length = textdistance.lcs_seq("ABCDGH", "AEDFHR");
console.log(length); // Output: 3 (ADH)

// Normalized similarity
const similarity = textdistance.lcs_seq_normalized("AGGTAB", "GXTXAYB");
console.log(similarity); // Output: 0.571 (LCS="GTAB", length 4)

// Code plagiarism detection
const code1 = "function add(a,b){return a+b;}";
const code2 = "function sum(x,y){return x+y;}";
const lcsScore = textdistance.lcs_seq_normalized(code1, code2);
console.log(`Code similarity: ${(lcsScore * 100).toFixed(1)}%`);
// Output: Code similarity: 65.5%

// Document version comparison
const v1 = "The quick brown fox";
const v2 = "The fast brown dog";
const commonLength = textdistance.lcs_seq(v1, v2);
console.log(`Common characters: ${commonLength}`);
// Output: Common characters: 13
```

--------------------------------

### Longest Common Substring Calculation in JavaScript

Source: https://context7.com/demomacro/textdistance/llms.txt

Finds the length of the longest contiguous substring common to two strings. It also provides a normalized similarity score. This is useful for identifying common patterns in URLs and assessing password strength by detecting common patterns.

```javascript
import * as textdistance from "textdistance";

// Contiguous matching
const length = textdistance.lcs_str("GeeksforGeeks", "GeeksQuiz");
console.log(length); // Output: 5 ("Geeks")

// Normalized similarity
const similarity = textdistance.lcs_str_normalized("abcdef", "zabcxy");
console.log(similarity); // Output: 0.5 (common substring "abc" = 3, max length = 6)

// Finding common patterns in URLs
const url1 = "https://example.com/api/users";
const url2 = "https://example.com/api/posts";
const commonSubstr = textdistance.lcs_str(url1, url2);
console.log(`Common prefix length: ${commonSubstr}`);
// Output: Common prefix length: 24

// Password strength: avoid common patterns
function hasCommonPattern(password, commonPatterns) {
  return commonPatterns.some(pattern => {
    const commonLen = textdistance.lcs_str(password.toLowerCase(), pattern);
    return commonLen >= 4; // 4+ character match is suspicious
  });
}
const result = hasCommonPattern("Pass1234word", ["password", "12345678"]);
console.log(`Contains common pattern: ${result}`);
// Output: Contains common pattern: true
```

--------------------------------

### Sorensen-Dice Similarity Calculation using textdistance

Source: https://context7.com/demomacro/textdistance/llms.txt

Calculates the Sorensen-Dice similarity between two strings, which is a measure of set similarity. It is useful for tasks like medical term matching and fuzzy searching where higher recall than Jaccard similarity is desired. It takes two strings as input and returns a float between 0 and 1.

```javascript
import * as textdistance from "textdistance";

// Sorensen-Dice similarity
const similarity = textdistance.sorensen("night", "nacht");
console.log(similarity); // Output: 0.6

// Compare with Jaccard
const s1 = "abc", s2 = "bcd";
console.log(textdistance.jaccard(s1, s2)); // Output: 0.5
console.log(textdistance.sorensen(s1, s2)); // Output: 0.667 (higher)

// Medical term matching
const diagnosis1 = "type 2 diabetes mellitus";
const diagnosis2 = "diabetes mellitus type 2";
const match = textdistance.sorensen(diagnosis1, diagnosis2);
console.log(`Diagnosis match: ${(match * 100).toFixed(1)}%`);
// Output: Diagnosis match: 100.0%

// Fuzzy search with better recall than Jaccard
function fuzzySearch(query, items) {
  return items
    .map(item => ({
      text: item,
      score: textdistance.sorensen(query.toLowerCase(), item.toLowerCase())
    }))
    .filter(r => r.score > 0.6)
    .sort((a, b) => b.score - a.score);
}

const results = fuzzySearch("nodejs", ["node.js", "node js", "deno", "python"]);
console.log(results);
// Output: [{ text: "node.js", score: 0.923 }, { text: "node js", score: 0.857 }]

```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.