@powerlines/plugin-automd 0.1.341 → 0.1.342

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

@@ -1,204 +0,0 @@
-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

@@ -1,203 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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":";;;;;;;AAGA,IAAI,kBAA+B,yBAAU,mBAAiB;AAC5D,mBAAgB,yBAAyB;AACzC,mBAAgB,iBAAiB;AACjC,mBAAgB,wBAAwB;AACxC,mBAAgB,yBAAyB;AACzC,mBAAgB,iBAAiB;AACjC,QAAOA;EACP,EAAE,CAAC;AAEL,IAAI,qBAAkC,yBAAU,sBAAoB;AAClE,sBAAmB,mBAAmB;AACtC,sBAAmB,gBAAgB;AACnC,QAAOC;EACP,EAAE,CAAC;AAEL,MAAM,sBAAqB,YAAW;CACpC,MAAM,2BAA2B;EAC/B,eAAe;EACf,QAAQ;EACR,WAAW,EAAE;EACb,YAAY,gBAAgB;EAC5B,eAAe,mBAAmB;EAClC,YAAY;EACZ,GAAG;EACJ;AACD,KAAI,CAAC,OAAO,OAAO,gBAAgB,CAAC,SAAS,yBAAyB,WAAW,CAC/E,OAAM,IAAI,UAAU,qBAAqB;AAE3C,KAAI,CAAC,OAAO,OAAO,mBAAmB,CAAC,SAAS,yBAAyB,cAAc,CACrF,OAAM,IAAI,UAAU,wBAAwB;AAE9C,SAAQ,yBAAyB,eAAjC;EACE,KAAK,mBAAmB,cACtB,QAAO;GACL,WAAW;GACX,GAAG;GACJ;EACH,KAAK,mBAAmB,WACtB,QAAO;GACL,WAAW;GACX,GAAG;GACJ;;;;;;;;;;AAWP,MAAM,iBAAiB,GAAG,MAAM;AAC9B,KAAI,CAAC,KAAK,CAAC,EAAG,QAAO;AACrB,KAAI,MAAM,EAAG,QAAO;CACpB,MAAM,wDAAwB,GAAG,EAAE;CACnC,MAAM,gBAAgB,KAAK,IAAI,EAAE,QAAQ,EAAE,OAAO;AAClD,SAAQ,gBAAgB,gBAAgB;;;;;;;;;AAU1C,MAAM,mBAAmB,KAAK,YAAY;CACxC,IAAI,IAAI;AACR,KAAI,QAAQ,WACV,KAAI,EAAE,MAAM,CAAC,WAAW,SAAS,IAAI;AAEvC,KAAI,QAAQ,OACV,gCAAW,EAAE;AAEf,KAAI,CAAC,QAAQ,cACX,KAAI,EAAE,aAAa;AAErB,QAAO;;AAGT,MAAM,mBAAmB,WAAW,cAAc;CAChD,MAAM,eAAe,UAAU,SAAS,IAAI,UAAU,QAAQ,KAAK,SAAS;AAE1E,SAAO,MAAM;IACZ,UAAU,GAAG;AAChB,KAAI,OAAO,iBAAiB,SAAU,QAAO;AAC7C,QAAO;;;;;;;;;AAUT,MAAM,sBAAsB,WAAW,YAAY;CACjD,MAAM,EACJ,cACE;AAEJ,QAAO,gBADc,gBAAgB,WAAW,UAAU,EACrB,QAAQ;;;;;;;;;;AAW/C,MAAM,mBAAmB,WAAW,gBAAgB,eAE/C;AACH,SAAQ,YAAR;EACE,KAAK,gBAAgB;EACrB,KAAK,gBAAgB;EACrB,KAAK,gBAAgB,mBACnB,QAAO,eAAe,KAAI,iBAAgB,UAAU,cAAc;EACpE,KAAK,gBAAgB;EACrB,KAAK,gBAAgB,aACnB;GACE,MAAM,eAAe,eAAe;AACpC,OAAI,iBAAiB,OAAW,QAAO;AACvC,UAAO,UAAU;;;;;;;;;;;;AAazB,SAAS,WAAW,OAAO,WAAW,SAEpC;CAKA,MAAM,sBAAsB,mBAAmB,QAAQ;CACvD,MAAM,EACJ,YACA,WACA,kBACE;CAMJ,MAAM,kBAAkB,gBAAgB,OAAO,oBAAoB;CACnE,IAAI;CACJ,IAAI;AACJ,SAAQ,eAAR;EACE,KAAK,mBAAmB;AACtB,qBAAiB,UAAS,SAAS;AACnC,qBAAiB,uDAAsB,iBAAiB,mBAAmB,WAAW,oBAAoB,CAAC;AAC3G;EACF,KAAK,mBAAmB;AACtB,qBAAiB,UAAS,SAAS;AACnC,qBAAiB,cAAa,cAAc,iBAAiB,mBAAmB,WAAW,oBAAoB,CAAC;AAChH;;CAQJ,MAAM,iBAAiB,EAAE;AACzB,SAAQ,YAAR;EACE,KAAK,gBAAgB;EACrB,KAAK,gBAAgB,qBACnB;GAEE,MAAM,SAAS,EAAE;GACjB,IAAI;AACJ,WAAQ,eAAR;IACE,KAAK,mBAAmB;AAEtB,mBAAc,OAAO;AACrB,UAAK,MAAM,aAAa,WAAW;MACjC,MAAM,QAAQ,eAAe,UAAU;AACvC,UAAI,cAAc,MAAO,eAAc;AACvC,aAAO,KAAK,MAAM;;AAEpB;IACF,KAAK,mBAAmB;AAEtB,mBAAc;AACd,UAAK,MAAM,aAAa,WAAW;MACjC,MAAM,QAAQ,eAAe,UAAU;AACvC,UAAI,cAAc,MAAO,eAAc;AACvC,aAAO,KAAK,MAAM;;AAEpB;;AAEJ,QAAK,MAAM,CAAC,GAAG,UAAU,OAAO,SAAS,CACvC,KAAI,eAAe,MAAM,IAAI,UAAU,YACrC,gBAAe,KAAK,EAAE;AAG1B;;EAEJ,KAAK,gBAAgB;AACnB,QAAK,MAAM,CAAC,GAAG,cAAc,UAAU,SAAS,EAAE;IAChD,MAAM,QAAQ,eAAe,UAAU;AAGvC,QAAI,eAAe,MAAM,CACvB,gBAAe,KAAK,EAAE;;AAG1B;EACF,KAAK,gBAAgB,oBACnB;GAEE,MAAM,kBAAkB,EAAE;AAC1B,QAAK,MAAM,CAAC,GAAG,cAAc,UAAU,SAAS,EAAE;IAChD,MAAM,QAAQ,eAAe,UAAU;AAGvC,QAAI,eAAe,MAAM,CACvB,iBAAgB,KAAK;KACnB;KACA,OAAO;KACR,CAAC;;AAGN,WAAQ,eAAR;IACE,KAAK,mBAAmB;AACtB,qBAAgB,MAAM,GAAG,MAAM,EAAE,QAAQ,EAAE,MAAM;AACjD;IACF,KAAK,mBAAmB;AACtB,qBAAgB,MAAM,GAAG,MAAM,EAAE,QAAQ,EAAE,MAAM;AACjD;;AAEJ,QAAK,MAAM,kBAAkB,gBAC3B,gBAAe,KAAK,eAAe,MAAM;AAE3C;;EAEJ,KAAK,gBAAgB;AACnB,QAAK,MAAM,CAAC,GAAG,cAAc,UAAU,SAAS,EAAE;IAChD,MAAM,QAAQ,eAAe,UAAU;AAGvC,QAAI,eAAe,MAAM,EAAE;AACzB,oBAAe,KAAK,EAAE;AACtB;;;AAGJ;;AAOJ,QAAO,gBAAgB,WAAW,gBAAgB,WAAW"}