How to use leven - 10 common examples

compare(expectedDom, sourceDom) {
        // Currently, this is just a surrounding-whitespace-
        // insensitive comparison of the text content.
        const expectedText = collapseNewlines(trimLines(textContent(expectedDom)));
        const gotText = collapseNewlines(trimLines(this.contentFnodes(sourceDom).map(fnode => fnode.element.textContent).join('\n')));
        this.lengthOfExpectedTexts += expectedText.length;
        this.lengthOfDiffs += leven(expectedText, gotText);

        // Uncomment for debugging:
        // console.log('Got:\n' + gotText);
        // console.log('\nExpected:\n' + expectedText);
    }

}

    const symbolLower = symbolName.toLocaleLowerCase();
    const typedLower = typedValue.toLocaleLowerCase();

    if (symbolLower.startsWith(typedLower)) {
        return 0.75;
    }

    // How far apart are the two strings? Find the smallest edit
    // distance for each of the substrings taken from the start of
    // symbolName.
    let symbolSubstrLength = symbolLower.length;
    let smallestEditDistance = Number.MAX_VALUE;
    while (symbolSubstrLength > 0) {
        const editDistance = leven(symbolLower.substr(0, symbolSubstrLength), typedLower);
        if (editDistance < smallestEditDistance) {
            smallestEditDistance = editDistance;
        }
        symbolSubstrLength--;
    }

    // We'll take into account the length of the typed value. If the user
    // has typed more characters, and they largely match the symbol name,
    // it is considered more similar. If the the edit distance is similar
    // to the number of characters the user has typed, then there's almost
    // no similarity.
    if (smallestEditDistance >= typedValue.length) {
        return 0;
    }

    const similarity = (typedValue.length - smallestEditDistance) / typedValue.length;

if (binding && binding.kind === "type" && !this.parentPath.isFlow()) {
      throw this.errorWithNode(messages.get("undeclaredVariableType", node.name), ReferenceError);
    }

    if (scope.hasBinding(node.name)) return;

    // get the closest declaration to offer as a suggestion
    // the variable name may have just been mistyped

    var bindings = scope.getAllBindings();

    var closest;
    var shortest = -1;

    for (var name in bindings) {
      var distance = levenshtein(node.name, name);
      if (distance <= 0 || distance > 3) continue;
      if (distance <= shortest) continue;

      closest = name;
      shortest = distance;
    }

    var msg;
    if (closest) {
      msg = messages.get("undeclaredVariableSuggestion", node.name, closest);
    } else {
      msg = messages.get("undeclaredVariable", node.name);
    }

    //

const suggestion = allowedOptions.find(option => {
    const steps: number = leven(option, unrecognized);
    return steps < 3;
  });

getWeight(programNameWithExtension, userInput) {
        let results = []
        let stringToSearchWords = this.splitStringToArray(programNameWithExtension)
        let valueWords = this.splitStringToArray(userInput)

        for (let word of stringToSearchWords)
            for (let value of valueWords) {
                if (value.length === 0 || word.length === 0)
                    continue

                word = word.toLowerCase()
                value = value.toLowerCase()
                let levenshteinDistance = leven(word, value)
                let result = word.startsWith(value)
                    ? (levenshteinDistance / 4)
                    : levenshteinDistance

                results.push(result)
            }

        return this.getAvg(results)
    }

scoreProcessor = (matchItem: T) =>
        leven(
          normalizedInput,
          matchItemProcessor(matchItem, optionsWithDefaults),
        )
      break

    .map(command => leven(command.name, cmdName))
    .reduce(

.map(value => ({
        value,
        weight: leven(value, currentValue.toString()),
      }))
      .sort((x, y) =>

    const moves = sortBy([...game.moves()], move => leven(input, move))
      .slice(0, 5)

(acc, current) => {
          const distance = leven(current, key)
          return distance < 3 && distance < acc.distance ? {closest: current, distance} : acc
        },
        {closest: null, distance: +Infinity}