@powerlines/plugin-automd 0.1.253 → 0.1.255

package/dist/node_modules/.pnpm/didyoumean2@7.0.4/node_modules/didyoumean2/dist/index.cjs

@@ -0,0 +1,204 @@
+const require_rolldown_runtime = require('../../../../../../_virtual/rolldown_runtime.cjs');
+const require_mod = require('../../../../fastest-levenshtein@1.0.16/node_modules/fastest-levenshtein/mod.cjs');
+const require_index = require('../../../../lodash.deburr@4.1.0/node_modules/lodash.deburr/index.cjs');
+
+//#region ../../node_modules/.pnpm/didyoumean2@7.0.4/node_modules/didyoumean2/dist/index.mjs
+var import_fastest_levenshtein = require_mod.default;
+var import_lodash = /* @__PURE__ */ require_rolldown_runtime.__toESM(require_index.default, 1);
+let ReturnTypeEnums = /* @__PURE__ */ function(ReturnTypeEnums$1) {
+	ReturnTypeEnums$1["ALL_CLOSEST_MATCHES"] = "all-closest-matches";
+	ReturnTypeEnums$1["ALL_MATCHES"] = "all-matches";
+	ReturnTypeEnums$1["ALL_SORTED_MATCHES"] = "all-sorted-matches";
+	ReturnTypeEnums$1["FIRST_CLOSEST_MATCH"] = "first-closest-match";
+	ReturnTypeEnums$1["FIRST_MATCH"] = "first-match";
+	return ReturnTypeEnums$1;
+}({});
+let ThresholdTypeEnums = /* @__PURE__ */ function(ThresholdTypeEnums$1) {
+	ThresholdTypeEnums$1["EDIT_DISTANCE"] = "edit-distance";
+	ThresholdTypeEnums$1["SIMILARITY"] = "similarity";
+	return ThresholdTypeEnums$1;
+}({});
+const fillDefaultOptions = (options) => {
+	const optionsWithDefaultValues = {
+		caseSensitive: false,
+		deburr: true,
+		matchPath: [],
+		returnType: ReturnTypeEnums.FIRST_CLOSEST_MATCH,
+		thresholdType: ThresholdTypeEnums.SIMILARITY,
+		trimSpaces: true,
+		...options
+	};
+	if (!Object.values(ReturnTypeEnums).includes(optionsWithDefaultValues.returnType)) throw new TypeError("unknown returnType");
+	if (!Object.values(ThresholdTypeEnums).includes(optionsWithDefaultValues.thresholdType)) throw new TypeError("unknown thresholdType");
+	switch (optionsWithDefaultValues.thresholdType) {
+		case ThresholdTypeEnums.EDIT_DISTANCE: return {
+			threshold: 20,
+			...optionsWithDefaultValues
+		};
+		case ThresholdTypeEnums.SIMILARITY: return {
+			threshold: .4,
+			...optionsWithDefaultValues
+		};
+	}
+};
+/**
+* Using edit distance between `a` and `b` to calculate similarity
+*
+* @param {string} a - `input`
+* @param {string} b - String from `matchList`
+* @returns {number} similarity between `a` and `b`
+*/
+const getSimilarity = (a, b) => {
+	if (!a || !b) return 0;
+	if (a === b) return 1;
+	const editDistance = (0, import_fastest_levenshtein.distance)(a, b);
+	const longestLength = Math.max(a.length, b.length);
+	return (longestLength - editDistance) / longestLength;
+};
+/**
+* Normalize a string
+*
+* @param {string} str - any string
+* @param {object} options - options that allows you to modify the behavior
+* @returns {string} - normalized string
+*/
+const normalizeString = (str, options) => {
+	let s = str;
+	if (options.trimSpaces) s = s.trim().replaceAll(/\s+/gu, " ");
+	if (options.deburr) s = (0, import_lodash.default)(s);
+	if (!options.caseSensitive) s = s.toLowerCase();
+	return s;
+};
+const getMatchItemStr = (matchItem, matchPath) => {
+	const matchItemStr = matchPath.length > 0 ? matchPath.reduce((acc, prop) => {
+		return acc?.[prop];
+	}, matchItem) : matchItem;
+	if (typeof matchItemStr !== "string") return "";
+	return matchItemStr;
+};
+/**
+* Process matchItem according to options
+*
+* @param {object | string} matchItem - Item for matching with `input`
+* @param {object} options - options that allows you to modify the behavior
+* @returns {string} - processed matchItem
+*/
+const matchItemProcessor = (matchItem, options) => {
+	const { matchPath } = options;
+	return normalizeString(getMatchItemStr(matchItem, matchPath), options);
+};
+/**
+* Generate result
+*
+* @param {object[] | string[]} matchList - List for matching with `input`
+* @param {number[]} matchedIndexes - indexes of matchList that need to be returned as result
+* @param {ReturnTypeEnums} returnType - how the result will response to user
+* @returns {Array | null | object | string} - matched result(s), return object if `match` is `{Object[]}`
+*/
+const resultProcessor = (matchList, matchedIndexes, returnType) => {
+	switch (returnType) {
+		case ReturnTypeEnums.ALL_CLOSEST_MATCHES:
+		case ReturnTypeEnums.ALL_MATCHES:
+		case ReturnTypeEnums.ALL_SORTED_MATCHES: return matchedIndexes.map((matchedIndex) => matchList[matchedIndex]);
+		case ReturnTypeEnums.FIRST_CLOSEST_MATCH:
+		case ReturnTypeEnums.FIRST_MATCH: {
+			const matchedIndex = matchedIndexes[0];
+			if (matchedIndex === void 0) return null;
+			return matchList[matchedIndex];
+		}
+	}
+};
+/**
+* Main function for didyoumean2
+*
+* @param {string} input - string that you are not sure and want to match with `matchList`
+* @param {object[] | string[]} matchList - List for matching with `input`
+* @param {null | object | undefined} options - options that allows you to modify the behavior
+* @returns {Array | null | object | string} - matched result(s), return object if `match` is `{Object[]}`
+*/
+function didYouMean(input, matchList, options) {
+	const optionsWithDefaults = fillDefaultOptions(options);
+	const { returnType, threshold, thresholdType } = optionsWithDefaults;
+	const normalizedInput = normalizeString(input, optionsWithDefaults);
+	let checkIfMatched;
+	let scoreProcessor;
+	switch (thresholdType) {
+		case ThresholdTypeEnums.EDIT_DISTANCE:
+			checkIfMatched = (score) => score <= threshold;
+			scoreProcessor = (matchItem) => (0, import_fastest_levenshtein.distance)(normalizedInput, matchItemProcessor(matchItem, optionsWithDefaults));
+			break;
+		case ThresholdTypeEnums.SIMILARITY:
+			checkIfMatched = (score) => score >= threshold;
+			scoreProcessor = (matchItem) => getSimilarity(normalizedInput, matchItemProcessor(matchItem, optionsWithDefaults));
+			break;
+	}
+	const matchedIndexes = [];
+	switch (returnType) {
+		case ReturnTypeEnums.ALL_CLOSEST_MATCHES:
+		case ReturnTypeEnums.FIRST_CLOSEST_MATCH: {
+			const scores = [];
+			let marginValue;
+			switch (thresholdType) {
+				case ThresholdTypeEnums.EDIT_DISTANCE:
+					marginValue = Number.POSITIVE_INFINITY;
+					for (const matchItem of matchList) {
+						const score = scoreProcessor(matchItem);
+						if (marginValue > score) marginValue = score;
+						scores.push(score);
+					}
+					break;
+				case ThresholdTypeEnums.SIMILARITY:
+					marginValue = 0;
+					for (const matchItem of matchList) {
+						const score = scoreProcessor(matchItem);
+						if (marginValue < score) marginValue = score;
+						scores.push(score);
+					}
+					break;
+			}
+			for (const [i, score] of scores.entries()) if (checkIfMatched(score) && score === marginValue) matchedIndexes.push(i);
+			break;
+		}
+		case ReturnTypeEnums.ALL_MATCHES:
+			for (const [i, matchItem] of matchList.entries()) {
+				const score = scoreProcessor(matchItem);
+				if (checkIfMatched(score)) matchedIndexes.push(i);
+			}
+			break;
+		case ReturnTypeEnums.ALL_SORTED_MATCHES: {
+			const unsortedResults = [];
+			for (const [i, matchItem] of matchList.entries()) {
+				const score = scoreProcessor(matchItem);
+				if (checkIfMatched(score)) unsortedResults.push({
+					score,
+					index: i
+				});
+			}
+			switch (thresholdType) {
+				case ThresholdTypeEnums.EDIT_DISTANCE:
+					unsortedResults.sort((a, b) => a.score - b.score);
+					break;
+				case ThresholdTypeEnums.SIMILARITY:
+					unsortedResults.sort((a, b) => b.score - a.score);
+					break;
+			}
+			for (const unsortedResult of unsortedResults) matchedIndexes.push(unsortedResult.index);
+			break;
+		}
+		case ReturnTypeEnums.FIRST_MATCH:
+			for (const [i, matchItem] of matchList.entries()) {
+				const score = scoreProcessor(matchItem);
+				if (checkIfMatched(score)) {
+					matchedIndexes.push(i);
+					break;
+				}
+			}
+			break;
+	}
+	return resultProcessor(matchList, matchedIndexes, returnType);
+}
+
+//#endregion
+exports.ReturnTypeEnums = ReturnTypeEnums;
+exports.ThresholdTypeEnums = ThresholdTypeEnums;
+exports.default = didYouMean;

package/dist/node_modules/.pnpm/didyoumean2@7.0.4/node_modules/didyoumean2/dist/index.mjs

@@ -0,0 +1,203 @@
+import { __toESM } from "../../../../../../_virtual/rolldown_runtime.mjs";
+import { require_fastest_levenshtein } from "../../../../fastest-levenshtein@1.0.16/node_modules/fastest-levenshtein/mod.mjs";
+import { require_lodash } from "../../../../lodash.deburr@4.1.0/node_modules/lodash.deburr/index.mjs";
+
+//#region ../../node_modules/.pnpm/didyoumean2@7.0.4/node_modules/didyoumean2/dist/index.mjs
+var import_fastest_levenshtein = require_fastest_levenshtein();
+var import_lodash = /* @__PURE__ */ __toESM(require_lodash(), 1);
+let ReturnTypeEnums = /* @__PURE__ */ function(ReturnTypeEnums$1) {
+	ReturnTypeEnums$1["ALL_CLOSEST_MATCHES"] = "all-closest-matches";
+	ReturnTypeEnums$1["ALL_MATCHES"] = "all-matches";
+	ReturnTypeEnums$1["ALL_SORTED_MATCHES"] = "all-sorted-matches";
+	ReturnTypeEnums$1["FIRST_CLOSEST_MATCH"] = "first-closest-match";
+	ReturnTypeEnums$1["FIRST_MATCH"] = "first-match";
+	return ReturnTypeEnums$1;
+}({});
+let ThresholdTypeEnums = /* @__PURE__ */ function(ThresholdTypeEnums$1) {
+	ThresholdTypeEnums$1["EDIT_DISTANCE"] = "edit-distance";
+	ThresholdTypeEnums$1["SIMILARITY"] = "similarity";
+	return ThresholdTypeEnums$1;
+}({});
+const fillDefaultOptions = (options) => {
+	const optionsWithDefaultValues = {
+		caseSensitive: false,
+		deburr: true,
+		matchPath: [],
+		returnType: ReturnTypeEnums.FIRST_CLOSEST_MATCH,
+		thresholdType: ThresholdTypeEnums.SIMILARITY,
+		trimSpaces: true,
+		...options
+	};
+	if (!Object.values(ReturnTypeEnums).includes(optionsWithDefaultValues.returnType)) throw new TypeError("unknown returnType");
+	if (!Object.values(ThresholdTypeEnums).includes(optionsWithDefaultValues.thresholdType)) throw new TypeError("unknown thresholdType");
+	switch (optionsWithDefaultValues.thresholdType) {
+		case ThresholdTypeEnums.EDIT_DISTANCE: return {
+			threshold: 20,
+			...optionsWithDefaultValues
+		};
+		case ThresholdTypeEnums.SIMILARITY: return {
+			threshold: .4,
+			...optionsWithDefaultValues
+		};
+	}
+};
+/**
+* Using edit distance between `a` and `b` to calculate similarity
+*
+* @param {string} a - `input`
+* @param {string} b - String from `matchList`
+* @returns {number} similarity between `a` and `b`
+*/
+const getSimilarity = (a, b) => {
+	if (!a || !b) return 0;
+	if (a === b) return 1;
+	const editDistance = (0, import_fastest_levenshtein.distance)(a, b);
+	const longestLength = Math.max(a.length, b.length);
+	return (longestLength - editDistance) / longestLength;
+};
+/**
+* Normalize a string
+*
+* @param {string} str - any string
+* @param {object} options - options that allows you to modify the behavior
+* @returns {string} - normalized string
+*/
+const normalizeString = (str, options) => {
+	let s = str;
+	if (options.trimSpaces) s = s.trim().replaceAll(/\s+/gu, " ");
+	if (options.deburr) s = (0, import_lodash.default)(s);
+	if (!options.caseSensitive) s = s.toLowerCase();
+	return s;
+};
+const getMatchItemStr = (matchItem, matchPath) => {
+	const matchItemStr = matchPath.length > 0 ? matchPath.reduce((acc, prop) => {
+		return acc?.[prop];
+	}, matchItem) : matchItem;
+	if (typeof matchItemStr !== "string") return "";
+	return matchItemStr;
+};
+/**
+* Process matchItem according to options
+*
+* @param {object | string} matchItem - Item for matching with `input`
+* @param {object} options - options that allows you to modify the behavior
+* @returns {string} - processed matchItem
+*/
+const matchItemProcessor = (matchItem, options) => {
+	const { matchPath } = options;
+	return normalizeString(getMatchItemStr(matchItem, matchPath), options);
+};
+/**
+* Generate result
+*
+* @param {object[] | string[]} matchList - List for matching with `input`
+* @param {number[]} matchedIndexes - indexes of matchList that need to be returned as result
+* @param {ReturnTypeEnums} returnType - how the result will response to user
+* @returns {Array | null | object | string} - matched result(s), return object if `match` is `{Object[]}`
+*/
+const resultProcessor = (matchList, matchedIndexes, returnType) => {
+	switch (returnType) {
+		case ReturnTypeEnums.ALL_CLOSEST_MATCHES:
+		case ReturnTypeEnums.ALL_MATCHES:
+		case ReturnTypeEnums.ALL_SORTED_MATCHES: return matchedIndexes.map((matchedIndex) => matchList[matchedIndex]);
+		case ReturnTypeEnums.FIRST_CLOSEST_MATCH:
+		case ReturnTypeEnums.FIRST_MATCH: {
+			const matchedIndex = matchedIndexes[0];
+			if (matchedIndex === void 0) return null;
+			return matchList[matchedIndex];
+		}
+	}
+};
+/**
+* Main function for didyoumean2
+*
+* @param {string} input - string that you are not sure and want to match with `matchList`
+* @param {object[] | string[]} matchList - List for matching with `input`
+* @param {null | object | undefined} options - options that allows you to modify the behavior
+* @returns {Array | null | object | string} - matched result(s), return object if `match` is `{Object[]}`
+*/
+function didYouMean(input, matchList, options) {
+	const optionsWithDefaults = fillDefaultOptions(options);
+	const { returnType, threshold, thresholdType } = optionsWithDefaults;
+	const normalizedInput = normalizeString(input, optionsWithDefaults);
+	let checkIfMatched;
+	let scoreProcessor;
+	switch (thresholdType) {
+		case ThresholdTypeEnums.EDIT_DISTANCE:
+			checkIfMatched = (score) => score <= threshold;
+			scoreProcessor = (matchItem) => (0, import_fastest_levenshtein.distance)(normalizedInput, matchItemProcessor(matchItem, optionsWithDefaults));
+			break;
+		case ThresholdTypeEnums.SIMILARITY:
+			checkIfMatched = (score) => score >= threshold;
+			scoreProcessor = (matchItem) => getSimilarity(normalizedInput, matchItemProcessor(matchItem, optionsWithDefaults));
+			break;
+	}
+	const matchedIndexes = [];
+	switch (returnType) {
+		case ReturnTypeEnums.ALL_CLOSEST_MATCHES:
+		case ReturnTypeEnums.FIRST_CLOSEST_MATCH: {
+			const scores = [];
+			let marginValue;
+			switch (thresholdType) {
+				case ThresholdTypeEnums.EDIT_DISTANCE:
+					marginValue = Number.POSITIVE_INFINITY;
+					for (const matchItem of matchList) {
+						const score = scoreProcessor(matchItem);
+						if (marginValue > score) marginValue = score;
+						scores.push(score);
+					}
+					break;
+				case ThresholdTypeEnums.SIMILARITY:
+					marginValue = 0;
+					for (const matchItem of matchList) {
+						const score = scoreProcessor(matchItem);
+						if (marginValue < score) marginValue = score;
+						scores.push(score);
+					}
+					break;
+			}
+			for (const [i, score] of scores.entries()) if (checkIfMatched(score) && score === marginValue) matchedIndexes.push(i);
+			break;
+		}
+		case ReturnTypeEnums.ALL_MATCHES:
+			for (const [i, matchItem] of matchList.entries()) {
+				const score = scoreProcessor(matchItem);
+				if (checkIfMatched(score)) matchedIndexes.push(i);
+			}
+			break;
+		case ReturnTypeEnums.ALL_SORTED_MATCHES: {
+			const unsortedResults = [];
+			for (const [i, matchItem] of matchList.entries()) {
+				const score = scoreProcessor(matchItem);
+				if (checkIfMatched(score)) unsortedResults.push({
+					score,
+					index: i
+				});
+			}
+			switch (thresholdType) {
+				case ThresholdTypeEnums.EDIT_DISTANCE:
+					unsortedResults.sort((a, b) => a.score - b.score);
+					break;
+				case ThresholdTypeEnums.SIMILARITY:
+					unsortedResults.sort((a, b) => b.score - a.score);
+					break;
+			}
+			for (const unsortedResult of unsortedResults) matchedIndexes.push(unsortedResult.index);
+			break;
+		}
+		case ReturnTypeEnums.FIRST_MATCH:
+			for (const [i, matchItem] of matchList.entries()) {
+				const score = scoreProcessor(matchItem);
+				if (checkIfMatched(score)) {
+					matchedIndexes.push(i);
+					break;
+				}
+			}
+			break;
+	}
+	return resultProcessor(matchList, matchedIndexes, returnType);
+}
+
+//#endregion
+export { ReturnTypeEnums, ThresholdTypeEnums, didYouMean as default };
+//# sourceMappingURL=index.mjs.map

package/dist/node_modules/.pnpm/didyoumean2@7.0.4/node_modules/didyoumean2/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":["ReturnTypeEnums","ThresholdTypeEnums"],"sources":["../../../../../../../../../node_modules/.pnpm/didyoumean2@7.0.4/node_modules/didyoumean2/dist/index.mjs"],"sourcesContent":["import { distance } from 'fastest-levenshtein';\nimport deburr from 'lodash.deburr';\n\nlet ReturnTypeEnums = /*#__PURE__*/function (ReturnTypeEnums) {\n  ReturnTypeEnums[\"ALL_CLOSEST_MATCHES\"] = \"all-closest-matches\";\n  ReturnTypeEnums[\"ALL_MATCHES\"] = \"all-matches\";\n  ReturnTypeEnums[\"ALL_SORTED_MATCHES\"] = \"all-sorted-matches\";\n  ReturnTypeEnums[\"FIRST_CLOSEST_MATCH\"] = \"first-closest-match\";\n  ReturnTypeEnums[\"FIRST_MATCH\"] = \"first-match\";\n  return ReturnTypeEnums;\n}({});\n\nlet ThresholdTypeEnums = /*#__PURE__*/function (ThresholdTypeEnums) {\n  ThresholdTypeEnums[\"EDIT_DISTANCE\"] = \"edit-distance\";\n  ThresholdTypeEnums[\"SIMILARITY\"] = \"similarity\";\n  return ThresholdTypeEnums;\n}({});\n\nconst fillDefaultOptions = options => {\n  const optionsWithDefaultValues = {\n    caseSensitive: false,\n    deburr: true,\n    matchPath: [],\n    returnType: ReturnTypeEnums.FIRST_CLOSEST_MATCH,\n    thresholdType: ThresholdTypeEnums.SIMILARITY,\n    trimSpaces: true,\n    ...options\n  };\n  if (!Object.values(ReturnTypeEnums).includes(optionsWithDefaultValues.returnType)) {\n    throw new TypeError('unknown returnType');\n  }\n  if (!Object.values(ThresholdTypeEnums).includes(optionsWithDefaultValues.thresholdType)) {\n    throw new TypeError('unknown thresholdType');\n  }\n  switch (optionsWithDefaultValues.thresholdType) {\n    case ThresholdTypeEnums.EDIT_DISTANCE:\n      return {\n        threshold: 20,\n        ...optionsWithDefaultValues\n      };\n    case ThresholdTypeEnums.SIMILARITY:\n      return {\n        threshold: 0.4,\n        ...optionsWithDefaultValues\n      };\n  }\n};\n\n/**\n * Using edit distance between `a` and `b` to calculate similarity\n *\n * @param {string} a - `input`\n * @param {string} b - String from `matchList`\n * @returns {number} similarity between `a` and `b`\n */\nconst getSimilarity = (a, b) => {\n  if (!a || !b) return 0;\n  if (a === b) return 1;\n  const editDistance = distance(a, b);\n  const longestLength = Math.max(a.length, b.length);\n  return (longestLength - editDistance) / longestLength;\n};\n\n/**\n * Normalize a string\n *\n * @param {string} str - any string\n * @param {object} options - options that allows you to modify the behavior\n * @returns {string} - normalized string\n */\nconst normalizeString = (str, options) => {\n  let s = str;\n  if (options.trimSpaces) {\n    s = s.trim().replaceAll(/\\s+/gu, ' ');\n  }\n  if (options.deburr) {\n    s = deburr(s);\n  }\n  if (!options.caseSensitive) {\n    s = s.toLowerCase();\n  }\n  return s;\n};\n\nconst getMatchItemStr = (matchItem, matchPath) => {\n  const matchItemStr = matchPath.length > 0 ? matchPath.reduce((acc, prop) => {\n    // @ts-expect-error skip redundant type check\n    return acc?.[prop];\n  }, matchItem) : matchItem;\n  if (typeof matchItemStr !== 'string') return '';\n  return matchItemStr;\n};\n\n/**\n * Process matchItem according to options\n *\n * @param {object | string} matchItem - Item for matching with `input`\n * @param {object} options - options that allows you to modify the behavior\n * @returns {string} - processed matchItem\n */\nconst matchItemProcessor = (matchItem, options) => {\n  const {\n    matchPath\n  } = options;\n  const matchItemStr = getMatchItemStr(matchItem, matchPath);\n  return normalizeString(matchItemStr, options);\n};\n\n/**\n * Generate result\n *\n * @param {object[] | string[]} matchList - List for matching with `input`\n * @param {number[]} matchedIndexes - indexes of matchList that need to be returned as result\n * @param {ReturnTypeEnums} returnType - how the result will response to user\n * @returns {Array | null | object | string} - matched result(s), return object if `match` is `{Object[]}`\n */\nconst resultProcessor = (matchList, matchedIndexes, returnType\n// eslint-disable-next-line functional/prefer-immutable-types\n) => {\n  switch (returnType) {\n    case ReturnTypeEnums.ALL_CLOSEST_MATCHES:\n    case ReturnTypeEnums.ALL_MATCHES:\n    case ReturnTypeEnums.ALL_SORTED_MATCHES:\n      return matchedIndexes.map(matchedIndex => matchList[matchedIndex]);\n    case ReturnTypeEnums.FIRST_CLOSEST_MATCH:\n    case ReturnTypeEnums.FIRST_MATCH:\n      {\n        const matchedIndex = matchedIndexes[0];\n        if (matchedIndex === undefined) return null;\n        return matchList[matchedIndex];\n      }\n  }\n};\n\n/**\n * Main function for didyoumean2\n *\n * @param {string} input - string that you are not sure and want to match with `matchList`\n * @param {object[] | string[]} matchList - List for matching with `input`\n * @param {null | object | undefined} options - options that allows you to modify the behavior\n * @returns {Array | null | object | string} - matched result(s), return object if `match` is `{Object[]}`\n */\nfunction didYouMean(input, matchList, options\n// eslint-disable-next-line functional/prefer-immutable-types\n) {\n  /*+++++++++++++++++++\n   + Initiate options +\n   +++++++++++++++++++*/\n\n  const optionsWithDefaults = fillDefaultOptions(options);\n  const {\n    returnType,\n    threshold,\n    thresholdType\n  } = optionsWithDefaults;\n\n  /*++++++++++++++++++++\n   + Deal with options +\n   ++++++++++++++++++++*/\n\n  const normalizedInput = normalizeString(input, optionsWithDefaults);\n  let checkIfMatched; // Validate if score is matched\n  let scoreProcessor; // Get score\n  switch (thresholdType) {\n    case ThresholdTypeEnums.EDIT_DISTANCE:\n      checkIfMatched = score => score <= threshold;\n      scoreProcessor = matchItem => distance(normalizedInput, matchItemProcessor(matchItem, optionsWithDefaults));\n      break;\n    case ThresholdTypeEnums.SIMILARITY:\n      checkIfMatched = score => score >= threshold;\n      scoreProcessor = matchItem => getSimilarity(normalizedInput, matchItemProcessor(matchItem, optionsWithDefaults));\n      break;\n  }\n\n  /*+++++++++++\n   + Matching +\n   +++++++++++*/\n\n  // eslint-disable-next-line functional/prefer-immutable-types\n  const matchedIndexes = [];\n  switch (returnType) {\n    case ReturnTypeEnums.ALL_CLOSEST_MATCHES:\n    case ReturnTypeEnums.FIRST_CLOSEST_MATCH:\n      {\n        // eslint-disable-next-line functional/prefer-immutable-types\n        const scores = [];\n        let marginValue;\n        switch (thresholdType) {\n          case ThresholdTypeEnums.EDIT_DISTANCE:\n            // Process score and save the smallest score\n            marginValue = Number.POSITIVE_INFINITY;\n            for (const matchItem of matchList) {\n              const score = scoreProcessor(matchItem);\n              if (marginValue > score) marginValue = score;\n              scores.push(score);\n            }\n            break;\n          case ThresholdTypeEnums.SIMILARITY:\n            // Process score and save the largest score\n            marginValue = 0;\n            for (const matchItem of matchList) {\n              const score = scoreProcessor(matchItem);\n              if (marginValue < score) marginValue = score;\n              scores.push(score);\n            }\n            break;\n        }\n        for (const [i, score] of scores.entries()) {\n          if (checkIfMatched(score) && score === marginValue) {\n            matchedIndexes.push(i);\n          }\n        }\n        break;\n      }\n    case ReturnTypeEnums.ALL_MATCHES:\n      for (const [i, matchItem] of matchList.entries()) {\n        const score = scoreProcessor(matchItem);\n\n        // save all indexes of matched scores\n        if (checkIfMatched(score)) {\n          matchedIndexes.push(i);\n        }\n      }\n      break;\n    case ReturnTypeEnums.ALL_SORTED_MATCHES:\n      {\n        // eslint-disable-next-line functional/prefer-immutable-types\n        const unsortedResults = [];\n        for (const [i, matchItem] of matchList.entries()) {\n          const score = scoreProcessor(matchItem);\n\n          // save all indexes of matched scores\n          if (checkIfMatched(score)) {\n            unsortedResults.push({\n              score,\n              index: i\n            });\n          }\n        }\n        switch (thresholdType) {\n          case ThresholdTypeEnums.EDIT_DISTANCE:\n            unsortedResults.sort((a, b) => a.score - b.score);\n            break;\n          case ThresholdTypeEnums.SIMILARITY:\n            unsortedResults.sort((a, b) => b.score - a.score);\n            break;\n        }\n        for (const unsortedResult of unsortedResults) {\n          matchedIndexes.push(unsortedResult.index);\n        }\n        break;\n      }\n    case ReturnTypeEnums.FIRST_MATCH:\n      for (const [i, matchItem] of matchList.entries()) {\n        const score = scoreProcessor(matchItem);\n\n        // Return once matched, performance is main target in this returnType\n        if (checkIfMatched(score)) {\n          matchedIndexes.push(i);\n          break;\n        }\n      }\n      break;\n  }\n\n  /*+++++++++++++++++++++++\n   + Process return value +\n   +++++++++++++++++++++++*/\n\n  return resultProcessor(matchList, matchedIndexes, returnType);\n}\n\nexport { ReturnTypeEnums, ThresholdTypeEnums, didYouMean as default };\n//# sourceMappingURL=index.mjs.map\n"],"x_google_ignoreList":[0],"mappings":"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"}