@powerlines/plugin-automd 0.1.237 → 0.1.239

package/dist/dist-BavrV299.cjs

@@ -0,0 +1,682 @@
+const require_chunk = require('./chunk-BrXtsOCC.cjs');
+
+//#region ../../node_modules/.pnpm/fastest-levenshtein@1.0.16/node_modules/fastest-levenshtein/mod.js
+var require_fastest_levenshtein = /* @__PURE__ */ require_chunk.__commonJSMin(((exports) => {
+	exports.__esModule = true;
+	exports.distance = exports.closest = void 0;
+	var peq = new Uint32Array(65536);
+	var myers_32 = function(a, b) {
+		var n = a.length;
+		var m = b.length;
+		var lst = 1 << n - 1;
+		var pv = -1;
+		var mv = 0;
+		var sc = n;
+		var i = n;
+		while (i--) peq[a.charCodeAt(i)] |= 1 << i;
+		for (i = 0; i < m; i++) {
+			var eq = peq[b.charCodeAt(i)];
+			var xv = eq | mv;
+			eq |= (eq & pv) + pv ^ pv;
+			mv |= ~(eq | pv);
+			pv &= eq;
+			if (mv & lst) sc++;
+			if (pv & lst) sc--;
+			mv = mv << 1 | 1;
+			pv = pv << 1 | ~(xv | mv);
+			mv &= xv;
+		}
+		i = n;
+		while (i--) peq[a.charCodeAt(i)] = 0;
+		return sc;
+	};
+	var myers_x = function(b, a) {
+		var n = a.length;
+		var m = b.length;
+		var mhc = [];
+		var phc = [];
+		var hsize = Math.ceil(n / 32);
+		var vsize = Math.ceil(m / 32);
+		for (var i = 0; i < hsize; i++) {
+			phc[i] = -1;
+			mhc[i] = 0;
+		}
+		var j = 0;
+		for (; j < vsize - 1; j++) {
+			var mv_1 = 0;
+			var pv_1 = -1;
+			var start_1 = j * 32;
+			var vlen_1 = Math.min(32, m) + start_1;
+			for (var k = start_1; k < vlen_1; k++) peq[b.charCodeAt(k)] |= 1 << k;
+			for (var i = 0; i < n; i++) {
+				var eq = peq[a.charCodeAt(i)];
+				var pb = phc[i / 32 | 0] >>> i & 1;
+				var mb = mhc[i / 32 | 0] >>> i & 1;
+				var xv = eq | mv_1;
+				var xh = ((eq | mb) & pv_1) + pv_1 ^ pv_1 | eq | mb;
+				var ph = mv_1 | ~(xh | pv_1);
+				var mh = pv_1 & xh;
+				if (ph >>> 31 ^ pb) phc[i / 32 | 0] ^= 1 << i;
+				if (mh >>> 31 ^ mb) mhc[i / 32 | 0] ^= 1 << i;
+				ph = ph << 1 | pb;
+				mh = mh << 1 | mb;
+				pv_1 = mh | ~(xv | ph);
+				mv_1 = ph & xv;
+			}
+			for (var k = start_1; k < vlen_1; k++) peq[b.charCodeAt(k)] = 0;
+		}
+		var mv = 0;
+		var pv = -1;
+		var start = j * 32;
+		var vlen = Math.min(32, m - start) + start;
+		for (var k = start; k < vlen; k++) peq[b.charCodeAt(k)] |= 1 << k;
+		var score = m;
+		for (var i = 0; i < n; i++) {
+			var eq = peq[a.charCodeAt(i)];
+			var pb = phc[i / 32 | 0] >>> i & 1;
+			var mb = mhc[i / 32 | 0] >>> i & 1;
+			var xv = eq | mv;
+			var xh = ((eq | mb) & pv) + pv ^ pv | eq | mb;
+			var ph = mv | ~(xh | pv);
+			var mh = pv & xh;
+			score += ph >>> m - 1 & 1;
+			score -= mh >>> m - 1 & 1;
+			if (ph >>> 31 ^ pb) phc[i / 32 | 0] ^= 1 << i;
+			if (mh >>> 31 ^ mb) mhc[i / 32 | 0] ^= 1 << i;
+			ph = ph << 1 | pb;
+			mh = mh << 1 | mb;
+			pv = mh | ~(xv | ph);
+			mv = ph & xv;
+		}
+		for (var k = start; k < vlen; k++) peq[b.charCodeAt(k)] = 0;
+		return score;
+	};
+	var distance$1 = function(a, b) {
+		if (a.length < b.length) {
+			var tmp = b;
+			b = a;
+			a = tmp;
+		}
+		if (b.length === 0) return a.length;
+		if (a.length <= 32) return myers_32(a, b);
+		return myers_x(a, b);
+	};
+	exports.distance = distance$1;
+	var closest = function(str, arr) {
+		var min_distance = Infinity;
+		var min_index = 0;
+		for (var i = 0; i < arr.length; i++) {
+			var dist = distance$1(str, arr[i]);
+			if (dist < min_distance) {
+				min_distance = dist;
+				min_index = i;
+			}
+		}
+		return arr[min_index];
+	};
+	exports.closest = closest;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash.deburr@4.1.0/node_modules/lodash.deburr/index.js
+var require_lodash = /* @__PURE__ */ require_chunk.__commonJSMin(((exports, module) => {
+	/**
+	* lodash (Custom Build) <https://lodash.com/>
+	* Build: `lodash modularize exports="npm" -o ./`
+	* Copyright jQuery Foundation and other contributors <https://jquery.org/>
+	* Released under MIT license <https://lodash.com/license>
+	* Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
+	* Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+	*/
+	/** Used as references for various `Number` constants. */
+	var INFINITY = Infinity;
+	/** `Object#toString` result references. */
+	var symbolTag = "[object Symbol]";
+	/** Used to match Latin Unicode letters (excluding mathematical operators). */
+	var reLatin = /[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g;
+	/**
+	* Used to match [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks) and
+	* [combining diacritical marks for symbols](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks_for_Symbols).
+	*/
+	var reComboMark = RegExp("[\\u0300-\\u036f\\ufe20-\\ufe23\\u20d0-\\u20f0]", "g");
+	/** Used to map Latin Unicode letters to basic Latin letters. */
+	var deburredLetters = {
+		"À": "A",
+		"Á": "A",
+		"Â": "A",
+		"Ã": "A",
+		"Ä": "A",
+		"Å": "A",
+		"à": "a",
+		"á": "a",
+		"â": "a",
+		"ã": "a",
+		"ä": "a",
+		"å": "a",
+		"Ç": "C",
+		"ç": "c",
+		"Ð": "D",
+		"ð": "d",
+		"È": "E",
+		"É": "E",
+		"Ê": "E",
+		"Ë": "E",
+		"è": "e",
+		"é": "e",
+		"ê": "e",
+		"ë": "e",
+		"Ì": "I",
+		"Í": "I",
+		"Î": "I",
+		"Ï": "I",
+		"ì": "i",
+		"í": "i",
+		"î": "i",
+		"ï": "i",
+		"Ñ": "N",
+		"ñ": "n",
+		"Ò": "O",
+		"Ó": "O",
+		"Ô": "O",
+		"Õ": "O",
+		"Ö": "O",
+		"Ø": "O",
+		"ò": "o",
+		"ó": "o",
+		"ô": "o",
+		"õ": "o",
+		"ö": "o",
+		"ø": "o",
+		"Ù": "U",
+		"Ú": "U",
+		"Û": "U",
+		"Ü": "U",
+		"ù": "u",
+		"ú": "u",
+		"û": "u",
+		"ü": "u",
+		"Ý": "Y",
+		"ý": "y",
+		"ÿ": "y",
+		"Æ": "Ae",
+		"æ": "ae",
+		"Þ": "Th",
+		"þ": "th",
+		"ß": "ss",
+		"Ā": "A",
+		"Ă": "A",
+		"Ą": "A",
+		"ā": "a",
+		"ă": "a",
+		"ą": "a",
+		"Ć": "C",
+		"Ĉ": "C",
+		"Ċ": "C",
+		"Č": "C",
+		"ć": "c",
+		"ĉ": "c",
+		"ċ": "c",
+		"č": "c",
+		"Ď": "D",
+		"Đ": "D",
+		"ď": "d",
+		"đ": "d",
+		"Ē": "E",
+		"Ĕ": "E",
+		"Ė": "E",
+		"Ę": "E",
+		"Ě": "E",
+		"ē": "e",
+		"ĕ": "e",
+		"ė": "e",
+		"ę": "e",
+		"ě": "e",
+		"Ĝ": "G",
+		"Ğ": "G",
+		"Ġ": "G",
+		"Ģ": "G",
+		"ĝ": "g",
+		"ğ": "g",
+		"ġ": "g",
+		"ģ": "g",
+		"Ĥ": "H",
+		"Ħ": "H",
+		"ĥ": "h",
+		"ħ": "h",
+		"Ĩ": "I",
+		"Ī": "I",
+		"Ĭ": "I",
+		"Į": "I",
+		"İ": "I",
+		"ĩ": "i",
+		"ī": "i",
+		"ĭ": "i",
+		"į": "i",
+		"ı": "i",
+		"Ĵ": "J",
+		"ĵ": "j",
+		"Ķ": "K",
+		"ķ": "k",
+		"ĸ": "k",
+		"Ĺ": "L",
+		"Ļ": "L",
+		"Ľ": "L",
+		"Ŀ": "L",
+		"Ł": "L",
+		"ĺ": "l",
+		"ļ": "l",
+		"ľ": "l",
+		"ŀ": "l",
+		"ł": "l",
+		"Ń": "N",
+		"Ņ": "N",
+		"Ň": "N",
+		"Ŋ": "N",
+		"ń": "n",
+		"ņ": "n",
+		"ň": "n",
+		"ŋ": "n",
+		"Ō": "O",
+		"Ŏ": "O",
+		"Ő": "O",
+		"ō": "o",
+		"ŏ": "o",
+		"ő": "o",
+		"Ŕ": "R",
+		"Ŗ": "R",
+		"Ř": "R",
+		"ŕ": "r",
+		"ŗ": "r",
+		"ř": "r",
+		"Ś": "S",
+		"Ŝ": "S",
+		"Ş": "S",
+		"Š": "S",
+		"ś": "s",
+		"ŝ": "s",
+		"ş": "s",
+		"š": "s",
+		"Ţ": "T",
+		"Ť": "T",
+		"Ŧ": "T",
+		"ţ": "t",
+		"ť": "t",
+		"ŧ": "t",
+		"Ũ": "U",
+		"Ū": "U",
+		"Ŭ": "U",
+		"Ů": "U",
+		"Ű": "U",
+		"Ų": "U",
+		"ũ": "u",
+		"ū": "u",
+		"ŭ": "u",
+		"ů": "u",
+		"ű": "u",
+		"ų": "u",
+		"Ŵ": "W",
+		"ŵ": "w",
+		"Ŷ": "Y",
+		"ŷ": "y",
+		"Ÿ": "Y",
+		"Ź": "Z",
+		"Ż": "Z",
+		"Ž": "Z",
+		"ź": "z",
+		"ż": "z",
+		"ž": "z",
+		"IJ": "IJ",
+		"ij": "ij",
+		"Œ": "Oe",
+		"œ": "oe",
+		"ʼn": "'n",
+		"ſ": "ss"
+	};
+	/** Detect free variable `global` from Node.js. */
+	var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
+	/** Detect free variable `self`. */
+	var freeSelf = typeof self == "object" && self && self.Object === Object && self;
+	/** Used as a reference to the global object. */
+	var root = freeGlobal || freeSelf || Function("return this")();
+	/**
+	* The base implementation of `_.propertyOf` without support for deep paths.
+	*
+	* @private
+	* @param {Object} object The object to query.
+	* @returns {Function} Returns the new accessor function.
+	*/
+	function basePropertyOf(object) {
+		return function(key) {
+			return object == null ? void 0 : object[key];
+		};
+	}
+	/**
+	* Used by `_.deburr` to convert Latin-1 Supplement and Latin Extended-A
+	* letters to basic Latin letters.
+	*
+	* @private
+	* @param {string} letter The matched letter to deburr.
+	* @returns {string} Returns the deburred letter.
+	*/
+	var deburrLetter = basePropertyOf(deburredLetters);
+	/**
+	* Used to resolve the
+	* [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+	* of values.
+	*/
+	var objectToString = Object.prototype.toString;
+	/** Built-in value references. */
+	var Symbol = root.Symbol;
+	/** Used to convert symbols to primitives and strings. */
+	var symbolProto = Symbol ? Symbol.prototype : void 0, symbolToString = symbolProto ? symbolProto.toString : void 0;
+	/**
+	* The base implementation of `_.toString` which doesn't convert nullish
+	* values to empty strings.
+	*
+	* @private
+	* @param {*} value The value to process.
+	* @returns {string} Returns the string.
+	*/
+	function baseToString(value) {
+		if (typeof value == "string") return value;
+		if (isSymbol(value)) return symbolToString ? symbolToString.call(value) : "";
+		var result = value + "";
+		return result == "0" && 1 / value == -INFINITY ? "-0" : result;
+	}
+	/**
+	* Checks if `value` is object-like. A value is object-like if it's not `null`
+	* and has a `typeof` result of "object".
+	*
+	* @static
+	* @memberOf _
+	* @since 4.0.0
+	* @category Lang
+	* @param {*} value The value to check.
+	* @returns {boolean} Returns `true` if `value` is object-like, else `false`.
+	* @example
+	*
+	* _.isObjectLike({});
+	* // => true
+	*
+	* _.isObjectLike([1, 2, 3]);
+	* // => true
+	*
+	* _.isObjectLike(_.noop);
+	* // => false
+	*
+	* _.isObjectLike(null);
+	* // => false
+	*/
+	function isObjectLike(value) {
+		return !!value && typeof value == "object";
+	}
+	/**
+	* Checks if `value` is classified as a `Symbol` primitive or object.
+	*
+	* @static
+	* @memberOf _
+	* @since 4.0.0
+	* @category Lang
+	* @param {*} value The value to check.
+	* @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
+	* @example
+	*
+	* _.isSymbol(Symbol.iterator);
+	* // => true
+	*
+	* _.isSymbol('abc');
+	* // => false
+	*/
+	function isSymbol(value) {
+		return typeof value == "symbol" || isObjectLike(value) && objectToString.call(value) == symbolTag;
+	}
+	/**
+	* Converts `value` to a string. An empty string is returned for `null`
+	* and `undefined` values. The sign of `-0` is preserved.
+	*
+	* @static
+	* @memberOf _
+	* @since 4.0.0
+	* @category Lang
+	* @param {*} value The value to process.
+	* @returns {string} Returns the string.
+	* @example
+	*
+	* _.toString(null);
+	* // => ''
+	*
+	* _.toString(-0);
+	* // => '-0'
+	*
+	* _.toString([1, 2, 3]);
+	* // => '1,2,3'
+	*/
+	function toString(value) {
+		return value == null ? "" : baseToString(value);
+	}
+	/**
+	* Deburrs `string` by converting
+	* [Latin-1 Supplement](https://en.wikipedia.org/wiki/Latin-1_Supplement_(Unicode_block)#Character_table)
+	* and [Latin Extended-A](https://en.wikipedia.org/wiki/Latin_Extended-A)
+	* letters to basic Latin letters and removing
+	* [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks).
+	*
+	* @static
+	* @memberOf _
+	* @since 3.0.0
+	* @category String
+	* @param {string} [string=''] The string to deburr.
+	* @returns {string} Returns the deburred string.
+	* @example
+	*
+	* _.deburr('déjà vu');
+	* // => 'deja vu'
+	*/
+	function deburr$1(string) {
+		string = toString(string);
+		return string && string.replace(reLatin, deburrLetter).replace(reComboMark, "");
+	}
+	module.exports = deburr$1;
+}));
+
+//#endregion
+//#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__ */ require_chunk.__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
+exports.ReturnTypeEnums = ReturnTypeEnums;
+exports.ThresholdTypeEnums = ThresholdTypeEnums;
+exports.default = didYouMean;