@@ -0,0 +1,8 @@
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+charset = utf-8
+trim_trailing_whitespace = false
+insert_final_newline = false

@@ -1,7 +1,7 @@
 {
 "parser": "@typescript-eslint/parser",
-"extends": ["alloy", "alloy/typescript", "plugin:prettier/recommended"],
-"plugins": ["@typescript-eslint", "prettier"],
+"extends": ["alloy", "alloy/typescript"],
+"plugins": ["@typescript-eslint"],
 "env": {
 "browser": true,
 "node": true,
@@ -32,6 +32,7 @@
 "checkLoops": false
 }
 ],
+"semi": [2, "never"],
 "no-control-regex": "error",
 "no-debugger": "error",
 "no-dupe-args": "error",

@@ -7,3 +7,5 @@ pnpm-lock.yaml
 lib
 
 dist
+*.log
+.cache

@@ -0,0 +1,4 @@
+{
+"singleQuote": true,
+"semi": false
+}

@@ -3,5 +3,4 @@
 "editor.formatOnSave": true
 },
 "typescript.tsdk": "node_modules/typescript/lib",
-"editor.defaultFormatter": "esbenp.prettier-vscode"
-}
+}

@@ -1,5 +1,10 @@
 ## Release Notes
 
+### 1.2.0
+* Feature: longestCommonSubsequence = lcs
+* Feature: metricLcs = mlcs
+
+
 ### 1.1.0
 * Feature: Support import&require
 * Optimize: JS to Ts

@@ -20,6 +20,7 @@ A library implementing different string similarity, distance and sortMatch measu
 - [Cosine similarity](#cosine-similarity)
 - [Sorensen-Dice coefficient](#sorensen-dice-coefficient)
 - [API](#api)
+- [Methods](#methods)
 - [similarity](#similarity)
 - [params](#params)
 - [return](#return)
@@ -91,15 +92,16 @@ The Levenshtein distance between two words is the minimum number of single-chara
 It is a metric string distance. This implementation uses dynamic programming (Wagner–Fischer algorithm), with only 2 rows of data. The space requirement is thus O(m) and the algorithm runs in O(m.n).
 
 ```js
-import { Levenshtein } from "string-comparison"
+import { levenshtein } from "string-comparison"
+import type {SortMatchResultType} from "string-comparison"
 
 const Thanos = 'healed'
 const Rival = 'sealed'
 const Avengers = ['edward', 'sealed', 'theatre']
 
-console.log(Levenshtein.similarity(Thanos, Rival))
-console.log(Levenshtein.distance(Thanos, Rival))
-console.log(Levenshtein.sortMatch(Thanos, Avengers))
+console.log(levenshtein.similarity(Thanos, Rival))
+console.log(levenshtein.distance(Thanos, Rival))
+console.log(levenshtein.sortMatch(Thanos, Avengers) as SortMatchResultType)
 
 // output
 0.8333333333333334
@@ -129,15 +131,18 @@ This class implements the dynamic programming approach, which has a space requir
 In "Length of Maximal Common Subsequences", K.S. Larsen proposed an algorithm that computes the length of LCS in time O(log(m).log(n)). But the algorithm has a memory requirement O(m.n²) and was thus not implemented here.
 
 ```js
-import { LongestCommonSubsequence } from "string-comparison"
+import { longestCommonSubsequence } from "string-comparison"
+or
+import { lcs } from "string-comparison"
+
 
 const Thanos = 'healed'
 const Rival = 'sealed'
 const Avengers = ['edward', 'sealed', 'theatre']
 
-console.log(LongestCommonSubsequence.similarity(Thanos, Rival))
-console.log(LongestCommonSubsequence.distance(Thanos, Rival))
-console.log(LongestCommonSubsequence.sortMatch(Thanos, Avengers))
+console.log(lcs.similarity(Thanos, Rival))
+console.log(lcs.distance(Thanos, Rival))
+console.log(lcs.sortMatch(Thanos, Avengers))
 
 // output
 0.8333333333333334
@@ -157,15 +162,17 @@ http://heim.ifi.uio.no/~danielry/StringMetric.pdf
 The distance is computed as 1 - |LCS(s1, s2)| / max(|s1|, |s2|)
 
 ```js
-import { MetricLCS } from "string-comparison"
+import { metricLcs } from "string-comparison"
+or
+import { mlcs } from "string-comparison"
 
 const Thanos = 'healed'
 const Rival = 'sealed'
 const Avengers = ['edward', 'sealed', 'theatre']
 
-console.log(MetricLCS.similarity(Thanos, Rival))
-console.log(MetricLCS.distance(Thanos, Rival))
-console.log(MetricLCS.sortMatch(Thanos, Avengers))
+console.log(metricLcs.similarity(Thanos, Rival))
+console.log(metricLcs.distance(Thanos, Rival))
+console.log(metricLcs.sortMatch(Thanos, Avengers))
 
 // output
 0.8333333333333334
@@ -185,7 +192,7 @@ Distance is computed as 1 - similarity.
 Jaccard index is a metric distance.
 
 ```js
-import { Cosine } from "string-comparison"
+import { cosine } from "string-comparison"
 ```
 
 ## Sorensen-Dice coefficient
@@ -195,10 +202,18 @@ Similar to Jaccard index, but this time the similarity is computed as 2 * |V1 in
 Distance is computed as 1 - similarity.
 
 ```js
-import { DiceCoefficient } from "string-comparison"
+import { diceCoefficient } from "string-comparison"
 ```
 
 ## API
+* `cosine`
+* `diceCoefficient`
+* `jaccardIndex`
+* `levenshtein`
+* `lcs` = `longestCommonSubsequence`
+* `mlcs` = `metricLcs`
+
+## Methods
 * `similarity`.
 * `distance`.
 * `sortMatch`
@@ -222,8 +237,8 @@ Implementing algorithms define a distance between strings (0 means strings are i
 
 #### params
 
-1. thanos [String]
-2. rival [String]
+1. `thanos` [String]
+2. `rival` [String]
 
 #### return
 
@@ -238,7 +253,7 @@ Return a number
 
 #### return
 
-Return an array of objects. ex:
+Return an array of objects - `SortMatchResultType` ex:
 ```js
 [
 { member: 'edward', rating: 0.16666666666666663 },

@@ -1,10 +1,13 @@
 {
 "name": "string-comparison",
-"version": "1.1.0",
+"version": "1.2.0",
 "description": "A library implementing different string similarity",
 "main": "dist/index.js",
 "module": "dist/index.mjs",
 "types": "dist/index.d.ts",
+"engines": {
+"node": "^16.0.0 || >=18.0.0"
+},
 "exports": {
 ".": {
 "import": "./dist/index.mjs",

@@ -1,36 +1,57 @@
-import SimilarityResult from "./SimilarityResult";
+export interface SortMatchResultType {
+member: string
+index: number
+rating: number
+}
 
 export default abstract class Similarity {
-/**
-* @description 比较两个字符串
-*/
-protected static similarity: (thanos: string, rival: string) => number;
+public static initParams(thanos: string, rival: string) {
+return [
+thanos.replace(/\s+/g, '').toLowerCase(),
+rival.replace(/\s+/g, '').toLowerCase(),
+]
+}
 
-// distance
-protected static distance: (thanos: string, rival: string) => number;
+protected static checkThanosType(thanos: string) {
+if (typeof thanos !== 'string')
+throw new Error('first argument should be a string')
+}
+
+protected static checkRivalType(rival: string) {
+if (typeof rival !== 'string')
+throw new Error('second argument should be a string')
+}
+
+protected static checkAvengersType(avengers: string[]) {
+if (!Array.isArray(avengers))
+throw new Error('second argument should be an array of strings')
+if (avengers.find((s) => typeof s !== 'string'))
+throw new Error('second argument should be an array of strings')
+}
 
 /**
 * @description 寻找最佳匹配结果
 */
-public static sortMatch(
-thanos: string,
-avengers: string[],
-): SimilarityResult[] {
+public sortMatch(thanos: string, avengers: string[]): SortMatchResultType[] {
+Similarity.checkThanosType(thanos)
+Similarity.checkAvengersType(avengers)
+
 return avengers
 .map((str, index) => {
 return {
 member: str,
 index,
-rating: Similarity.similarity(thanos, str),
-};
+rating: this.similarity(thanos, str),
+}
 })
-.sort((a, b) => a.rating - b.rating);
+.sort((a, b) => a.rating - b.rating)
 }
 
-protected static initParams(thanos: string, rival: string): string[] {
-return [
-thanos.replace(/\s+/g, "").toLowerCase(),
-rival.replace(/\s+/g, "").toLowerCase(),
-];
-}
+/**
+* @description 比较两个字符串
+*/
+public abstract similarity(thanos: string, rival: string): number
+
+// distance
+public abstract distance(thanos: string, rival: string): number
 }

@@ -1,36 +1,40 @@
-import Similarity from "../interface/Similarity";
+import Similarity from '../interface/Similarity'
 
 export default class Cosine extends Similarity {
-public static similarity(pThanos: string, pRival: string): number {
+public similarity(pThanos: string, pRival: string) {
+Similarity.checkThanosType(pThanos)
+Similarity.checkRivalType(pRival)
+
 // clear white space characters & to low
-const [thanos, rival] = Similarity.initParams(pThanos, pRival);
+const [thanos, rival] = Similarity.initParams(pThanos, pRival)
 
-if (!thanos.length && !rival.length) return 1;
-if (!thanos.length || !rival.length) return 0;
-if (thanos === rival) return 1;
+if (!thanos.length && !rival.length) return 1
+if (!thanos.length || !rival.length) return 0
+if (thanos === rival) return 1
 
-let common = Array.from(new Set(thanos.split("").concat(rival.split(""))));
+// string vectorization
+let common = Array.from(new Set(thanos.split('').concat(rival.split(''))))
 
-let vectorThanos = this.stringVectorization(thanos.split(""), common);
-let vectorRival = Cosine.stringVectorization(rival.split(""), common);
-let [dotproduct, mThanos, mRival] = [0, 0, 0];
+let vectorThanos = this.stringVectorization(thanos.split(''), common)
+let vectorRival = this.stringVectorization(rival.split(''), common)
+let [dotproduct, mThanos, mRival] = [0, 0, 0]
 
 for (let i = 0; i < vectorThanos.length; ++i) {
-dotproduct += vectorThanos[i] * vectorRival[i];
-mThanos += vectorThanos[i] * vectorThanos[i];
-mRival += vectorRival[i] * vectorRival[i];
+dotproduct += vectorThanos[i] * vectorRival[i]
+mThanos += vectorThanos[i] * vectorThanos[i]
+mRival += vectorRival[i] * vectorRival[i]
 }
-mThanos = Math.sqrt(mThanos);
-mRival = Math.sqrt(mRival);
-return Number(dotproduct) / (mThanos * mRival);
+mThanos = Math.sqrt(mThanos)
+mRival = Math.sqrt(mRival)
+return Number(dotproduct) / (mThanos * mRival)
 }
 
-public static distance(thanos: string, rival: string): number {
-return 1.0 - Cosine.similarity(thanos, rival);
+public distance(thanos: string, rival: string) {
+return 1.0 - this.similarity(thanos, rival)
 }
 
 // string vectorization
-private static stringVectorization(strArr: string[], common: string[]) {
-return common.map((v) => (strArr.includes(v) ? 1 : 0));
+private stringVectorization(strArr: string | any[], common: any[]) {
+return common.map((v: any) => (strArr.includes(v) ? 1 : 0))
 }
 }