webpack 5.99.9 → 5.100.0

package/lib/util/cleverMerge.js

@@ -30,10 +30,12 @@ const DYNAMIC_INFO = Symbol("cleverMerge dynamic info");
 const cachedCleverMerge = (first, second) => {
 	if (second === undefined) return /** @type {T} */ (first);
 	if (first === undefined) return /** @type {O} */ (second);
-	if (typeof second !== "object" || second === null)
+	if (typeof second !== "object" || second === null) {
 		return /** @type {O} */ (second);
-	if (typeof first !== "object" || first === null)
+	}
+	if (typeof first !== "object" || first === null) {
 		return /** @type {T} */ (first);
+	}
 
 	let innerCache = mergeCache.get(first);
 	if (innerCache === undefined) {
@@ -171,9 +173,10 @@ const parseObject = obj => {
 										/** @type {ByValues<V>} */
 										(entry.byValues).has(otherByValue)
 									)
-								)
+								) {
 									/** @type {ByValues<V>} */
 									(entry.byValues).set(otherByValue, undefined);
+								}
 							}
 						}
 					}
@@ -424,7 +427,7 @@ const mergeEntries = (firstEntry, secondEntry, internalCaching) => {
 				);
 			}
 			if (
-				Array.from(firstEntry.byValues.values()).every(value => {
+				[...firstEntry.byValues.values()].every(value => {
 					const type = getValueType(value);
 					return type === VALUE_TYPE_ATOM || type === VALUE_TYPE_DELETE;
 				})
@@ -438,8 +441,9 @@ const mergeEntries = (firstEntry, secondEntry, internalCaching) => {
 			} else {
 				// = first.base + ((first.byProperty (+default) + second.base) + second.byProperty)
 				newBase = firstEntry.base;
-				if (!intermediateByValues.has("default"))
+				if (!intermediateByValues.has("default")) {
 					intermediateByValues.set("default", secondEntry.base);
+				}
 			}
 			if (!secondEntry.byProperty) {
 				// = first.base + (first.byProperty + second.base)
@@ -629,9 +633,9 @@ const resolveByProperty = (obj, byProperty, ...values) => {
 	return obj;
 };
 
-module.exports.cachedSetProperty = cachedSetProperty;
+module.exports.DELETE = DELETE;
 module.exports.cachedCleverMerge = cachedCleverMerge;
+module.exports.cachedSetProperty = cachedSetProperty;
 module.exports.cleverMerge = cleverMerge;
-module.exports.resolveByProperty = resolveByProperty;
 module.exports.removeOperations = removeOperations;
-module.exports.DELETE = DELETE;
+module.exports.resolveByProperty = resolveByProperty;

package/lib/util/comparators.js

@@ -55,20 +55,113 @@ const createCachedParameterizedComparator = fn => {
 };
 
 /**
- * @param {Chunk} a chunk
- * @param {Chunk} b chunk
- * @returns {-1|0|1} compare result
+ * @param {string | number} a first id
+ * @param {string | number} b second id
+ * @returns {-1 | 0 | 1} compare result
  */
-module.exports.compareChunksById = (a, b) =>
-	compareIds(/** @type {ChunkId} */ (a.id), /** @type {ChunkId} */ (b.id));
+const compareIds = (a, b) => {
+	if (typeof a !== typeof b) {
+		return typeof a < typeof b ? -1 : 1;
+	}
+	if (a < b) return -1;
+	if (a > b) return 1;
+	return 0;
+};
 
 /**
- * @param {Module} a module
- * @param {Module} b module
- * @returns {-1|0|1} compare result
+ * @template T
+ * @param {Comparator<T>} elementComparator comparator for elements
+ * @returns {Comparator<Iterable<T>>} comparator for iterables of elements
  */
-module.exports.compareModulesByIdentifier = (a, b) =>
-	compareIds(a.identifier(), b.identifier());
+const compareIterables = elementComparator => {
+	const cacheEntry = compareIteratorsCache.get(elementComparator);
+	if (cacheEntry !== undefined) return cacheEntry;
+	/**
+	 * @param {Iterable<T>} a first value
+	 * @param {Iterable<T>} b second value
+	 * @returns {-1|0|1} compare result
+	 */
+	const result = (a, b) => {
+		const aI = a[Symbol.iterator]();
+		const bI = b[Symbol.iterator]();
+		while (true) {
+			const aItem = aI.next();
+			const bItem = bI.next();
+			if (aItem.done) {
+				return bItem.done ? 0 : -1;
+			} else if (bItem.done) {
+				return 1;
+			}
+			const res = elementComparator(aItem.value, bItem.value);
+			if (res !== 0) return res;
+		}
+	};
+	compareIteratorsCache.set(elementComparator, result);
+	return result;
+};
+
+/**
+ * Compare two locations
+ * @param {DependencyLocation} a A location node
+ * @param {DependencyLocation} b A location node
+ * @returns {-1|0|1} sorting comparator value
+ */
+const compareLocations = (a, b) => {
+	const isObjectA = typeof a === "object" && a !== null;
+	const isObjectB = typeof b === "object" && b !== null;
+	if (!isObjectA || !isObjectB) {
+		if (isObjectA) return 1;
+		if (isObjectB) return -1;
+		return 0;
+	}
+	if ("start" in a) {
+		if ("start" in b) {
+			const ap = a.start;
+			const bp = b.start;
+			if (ap.line < bp.line) return -1;
+			if (ap.line > bp.line) return 1;
+			if (
+				/** @type {number} */ (ap.column) < /** @type {number} */ (bp.column)
+			) {
+				return -1;
+			}
+			if (
+				/** @type {number} */ (ap.column) > /** @type {number} */ (bp.column)
+			) {
+				return 1;
+			}
+		} else {
+			return -1;
+		}
+	} else if ("start" in b) {
+		return 1;
+	}
+	if ("name" in a) {
+		if ("name" in b) {
+			if (a.name < b.name) return -1;
+			if (a.name > b.name) return 1;
+		} else {
+			return -1;
+		}
+	} else if ("name" in b) {
+		return 1;
+	}
+	if ("index" in a) {
+		if ("index" in b) {
+			if (/** @type {number} */ (a.index) < /** @type {number} */ (b.index)) {
+				return -1;
+			}
+			if (/** @type {number} */ (a.index) > /** @type {number} */ (b.index)) {
+				return 1;
+			}
+		} else {
+			return -1;
+		}
+	} else if ("index" in b) {
+		return 1;
+	}
+	return 0;
+};
 
 /**
  * @param {ChunkGraph} chunkGraph the chunk graph
@@ -81,9 +174,6 @@ const compareModulesById = (chunkGraph, a, b) =>
 		/** @type {ModuleId} */ (chunkGraph.getModuleId(a)),
 		/** @type {ModuleId} */ (chunkGraph.getModuleId(b))
 	);
-/** @type {ParameterizedComparator<ChunkGraph, Module>} */
-module.exports.compareModulesById =
-	createCachedParameterizedComparator(compareModulesById);
 
 /**
  * @param {number} a number
@@ -98,7 +188,6 @@ const compareNumbers = (a, b) => {
 	if (a > b) return 1;
 	return 0;
 };
-module.exports.compareNumbers = compareNumbers;
 
 /**
  * @param {string} a string
@@ -170,7 +259,6 @@ const compareStringsNumeric = (a, b) => {
 
 	return 0;
 };
-module.exports.compareStringsNumeric = compareStringsNumeric;
 
 /**
  * @param {ModuleGraph} moduleGraph the module graph
@@ -186,11 +274,6 @@ const compareModulesByPostOrderIndexOrIdentifier = (moduleGraph, a, b) => {
 	if (cmp !== 0) return cmp;
 	return compareIds(a.identifier(), b.identifier());
 };
-/** @type {ParameterizedComparator<ModuleGraph, Module>} */
-module.exports.compareModulesByPostOrderIndexOrIdentifier =
-	createCachedParameterizedComparator(
-		compareModulesByPostOrderIndexOrIdentifier
-	);
 
 /**
  * @param {ModuleGraph} moduleGraph the module graph
@@ -206,11 +289,6 @@ const compareModulesByPreOrderIndexOrIdentifier = (moduleGraph, a, b) => {
 	if (cmp !== 0) return cmp;
 	return compareIds(a.identifier(), b.identifier());
 };
-/** @type {ParameterizedComparator<ModuleGraph, Module>} */
-module.exports.compareModulesByPreOrderIndexOrIdentifier =
-	createCachedParameterizedComparator(
-		compareModulesByPreOrderIndexOrIdentifier
-	);
 
 /**
  * @param {ChunkGraph} chunkGraph the chunk graph
@@ -226,9 +304,6 @@ const compareModulesByIdOrIdentifier = (chunkGraph, a, b) => {
 	if (cmp !== 0) return cmp;
 	return compareIds(a.identifier(), b.identifier());
 };
-/** @type {ParameterizedComparator<ChunkGraph, Module>} */
-module.exports.compareModulesByIdOrIdentifier =
-	createCachedParameterizedComparator(compareModulesByIdOrIdentifier);
 
 /**
  * @param {ChunkGraph} chunkGraph the chunk graph
@@ -237,25 +312,6 @@ module.exports.compareModulesByIdOrIdentifier =
  * @returns {-1 | 0 | 1} compare result
  */
 const compareChunks = (chunkGraph, a, b) => chunkGraph.compareChunks(a, b);
-/** @type {ParameterizedComparator<ChunkGraph, Chunk>} */
-module.exports.compareChunks =
-	createCachedParameterizedComparator(compareChunks);
-
-/**
- * @param {string | number} a first id
- * @param {string | number} b second id
- * @returns {-1 | 0 | 1} compare result
- */
-const compareIds = (a, b) => {
-	if (typeof a !== typeof b) {
-		return typeof a < typeof b ? -1 : 1;
-	}
-	if (a < b) return -1;
-	if (a > b) return 1;
-	return 0;
-};
-
-module.exports.compareIds = compareIds;
 
 /**
  * @param {string} a first string
@@ -268,8 +324,6 @@ const compareStrings = (a, b) => {
 	return 0;
 };
 
-module.exports.compareStrings = compareStrings;
-
 /**
  * @param {ChunkGroup} a first chunk group
  * @param {ChunkGroup} b second chunk group
@@ -277,7 +331,6 @@ module.exports.compareStrings = compareStrings;
  */
 const compareChunkGroupsByIndex = (a, b) =>
 	/** @type {number} */ (a.index) < /** @type {number} */ (b.index) ? -1 : 1;
-module.exports.compareChunkGroupsByIndex = compareChunkGroupsByIndex;
 
 /**
  * @template {EXPECTED_OBJECT} K1
@@ -354,7 +407,6 @@ const concatComparators = (c1, c2, ...cRest) => {
 	concatComparatorsCache.set(c1, c2, result);
 	return result;
 };
-module.exports.concatComparators = concatComparators;
 
 /**
  * @template A, B
@@ -396,44 +448,10 @@ const compareSelect = (getter, comparator) => {
 	compareSelectCache.set(getter, comparator, result);
 	return result;
 };
-module.exports.compareSelect = compareSelect;
 
 /** @type {WeakMap<Comparator<EXPECTED_ANY>, Comparator<Iterable<EXPECTED_ANY>>>} */
 const compareIteratorsCache = new WeakMap();
 
-/**
- * @template T
- * @param {Comparator<T>} elementComparator comparator for elements
- * @returns {Comparator<Iterable<T>>} comparator for iterables of elements
- */
-const compareIterables = elementComparator => {
-	const cacheEntry = compareIteratorsCache.get(elementComparator);
-	if (cacheEntry !== undefined) return cacheEntry;
-	/**
-	 * @param {Iterable<T>} a first value
-	 * @param {Iterable<T>} b second value
-	 * @returns {-1|0|1} compare result
-	 */
-	const result = (a, b) => {
-		const aI = a[Symbol.iterator]();
-		const bI = b[Symbol.iterator]();
-		while (true) {
-			const aItem = aI.next();
-			const bItem = bI.next();
-			if (aItem.done) {
-				return bItem.done ? 0 : -1;
-			} else if (bItem.done) {
-				return 1;
-			}
-			const res = elementComparator(aItem.value, bItem.value);
-			if (res !== 0) return res;
-		}
-	};
-	compareIteratorsCache.set(elementComparator, result);
-	return result;
-};
-module.exports.compareIterables = compareIterables;
-
 // TODO this is no longer needed when minimum node.js version is >= 12
 // since these versions ship with a stable sort function
 /**
@@ -441,7 +459,7 @@ module.exports.compareIterables = compareIterables;
  * @param {Iterable<T>} iterable original ordered list
  * @returns {Comparator<T>} comparator
  */
-module.exports.keepOriginalOrder = iterable => {
+const keepOriginalOrder = iterable => {
 	/** @type {Map<T, number>} */
 	const map = new Map();
 	let i = 0;
@@ -459,7 +477,7 @@ module.exports.keepOriginalOrder = iterable => {
  * @param {ChunkGraph} chunkGraph the chunk graph
  * @returns {Comparator<Chunk>} comparator
  */
-module.exports.compareChunksNatural = chunkGraph => {
+const compareChunksNatural = chunkGraph => {
 	const cmpFn = module.exports.compareModulesById(chunkGraph);
 	const cmpIterableFn = compareIterables(cmpFn);
 	return concatComparators(
@@ -479,45 +497,54 @@ module.exports.compareChunksNatural = chunkGraph => {
 	);
 };
 
+module.exports.compareChunkGroupsByIndex = compareChunkGroupsByIndex;
+/** @type {ParameterizedComparator<ChunkGraph, Chunk>} */
+module.exports.compareChunks =
+	createCachedParameterizedComparator(compareChunks);
 /**
- * Compare two locations
- * @param {DependencyLocation} a A location node
- * @param {DependencyLocation} b A location node
- * @returns {-1|0|1} sorting comparator value
+ * @param {Chunk} a chunk
+ * @param {Chunk} b chunk
+ * @returns {-1|0|1} compare result
  */
-module.exports.compareLocations = (a, b) => {
-	const isObjectA = typeof a === "object" && a !== null;
-	const isObjectB = typeof b === "object" && b !== null;
-	if (!isObjectA || !isObjectB) {
-		if (isObjectA) return 1;
-		if (isObjectB) return -1;
-		return 0;
-	}
-	if ("start" in a) {
-		if ("start" in b) {
-			const ap = a.start;
-			const bp = b.start;
-			if (ap.line < bp.line) return -1;
-			if (ap.line > bp.line) return 1;
-			if (/** @type {number} */ (ap.column) < /** @type {number} */ (bp.column))
-				return -1;
-			if (/** @type {number} */ (ap.column) > /** @type {number} */ (bp.column))
-				return 1;
-		} else return -1;
-	} else if ("start" in b) return 1;
-	if ("name" in a) {
-		if ("name" in b) {
-			if (a.name < b.name) return -1;
-			if (a.name > b.name) return 1;
-		} else return -1;
-	} else if ("name" in b) return 1;
-	if ("index" in a) {
-		if ("index" in b) {
-			if (/** @type {number} */ (a.index) < /** @type {number} */ (b.index))
-				return -1;
-			if (/** @type {number} */ (a.index) > /** @type {number} */ (b.index))
-				return 1;
-		} else return -1;
-	} else if ("index" in b) return 1;
-	return 0;
-};
+module.exports.compareChunksById = (a, b) =>
+	compareIds(/** @type {ChunkId} */ (a.id), /** @type {ChunkId} */ (b.id));
+module.exports.compareChunksNatural = compareChunksNatural;
+
+module.exports.compareIds = compareIds;
+
+module.exports.compareIterables = compareIterables;
+
+module.exports.compareLocations = compareLocations;
+
+/** @type {ParameterizedComparator<ChunkGraph, Module>} */
+module.exports.compareModulesById =
+	createCachedParameterizedComparator(compareModulesById);
+/** @type {ParameterizedComparator<ChunkGraph, Module>} */
+module.exports.compareModulesByIdOrIdentifier =
+	createCachedParameterizedComparator(compareModulesByIdOrIdentifier);
+/**
+ * @param {Module} a module
+ * @param {Module} b module
+ * @returns {-1|0|1} compare result
+ */
+module.exports.compareModulesByIdentifier = (a, b) =>
+	compareIds(a.identifier(), b.identifier());
+/** @type {ParameterizedComparator<ModuleGraph, Module>} */
+module.exports.compareModulesByPostOrderIndexOrIdentifier =
+	createCachedParameterizedComparator(
+		compareModulesByPostOrderIndexOrIdentifier
+	);
+/** @type {ParameterizedComparator<ModuleGraph, Module>} */
+module.exports.compareModulesByPreOrderIndexOrIdentifier =
+	createCachedParameterizedComparator(
+		compareModulesByPreOrderIndexOrIdentifier
+	);
+
+module.exports.compareNumbers = compareNumbers;
+module.exports.compareSelect = compareSelect;
+module.exports.compareStrings = compareStrings;
+module.exports.compareStringsNumeric = compareStringsNumeric;
+
+module.exports.concatComparators = concatComparators;
+
+module.exports.keepOriginalOrder = keepOriginalOrder;

package/lib/util/compileBooleanMatcher.js

@@ -42,10 +42,12 @@ const compileBooleanMatcher = map => {
 const compileBooleanMatcherFromLists = (positiveItems, negativeItems) => {
 	if (positiveItems.length === 0) return () => "false";
 	if (negativeItems.length === 0) return () => "true";
-	if (positiveItems.length === 1)
+	if (positiveItems.length === 1) {
 		return value => `${toSimpleString(positiveItems[0])} == ${value}`;
-	if (negativeItems.length === 1)
+	}
+	if (negativeItems.length === 1) {
 		return value => `${toSimpleString(negativeItems[0])} != ${value}`;
+	}
 	const positiveRegexp = itemsToRegexp(positiveItems);
 	const negativeRegexp = itemsToRegexp(negativeItems);
 	if (positiveRegexp.length <= negativeRegexp.length) {
@@ -146,6 +148,7 @@ const itemsToRegexp = itemsArr => {
 	if (countOfSingleCharItems === itemsArr.length) {
 		return `[${quoteMeta(itemsArr.sort().join(""))}]`;
 	}
+	/** @type {Set<string>} */
 	const items = new Set(itemsArr.sort());
 	if (countOfSingleCharItems > 2) {
 		let singleCharItems = "";
@@ -224,11 +227,13 @@ const itemsToRegexp = itemsArr => {
 
 	// TODO further optimize regexp, i. e.
 	// use ranges: (1|2|3|4|a) => [1-4a]
-	const conditional = finishedItems.concat(Array.from(items, quoteMeta));
+	/** @type {string[]} */
+	const conditional = [...finishedItems, ...Array.from(items, quoteMeta)];
 	if (conditional.length === 1) return conditional[0];
 	return `(${conditional.join("|")})`;
 };
 
 compileBooleanMatcher.fromLists = compileBooleanMatcherFromLists;
 compileBooleanMatcher.itemsToRegexp = itemsToRegexp;
+
 module.exports = compileBooleanMatcher;

package/lib/util/concatenate.js

@@ -29,7 +29,7 @@ const getAllReferences = variable => {
 	for (const scope of variable.scope.childScopes) {
 		for (const innerVar of scope.variables) {
 			if (innerVar.identifiers.some(id => identifiers.has(id))) {
-				set = set.concat(innerVar.references);
+				set = [...set, ...innerVar.references];
 				break;
 			}
 		}
@@ -122,8 +122,9 @@ function findNewName(oldName, usedNamed1, usedNamed2, extraInfo) {
 		if (
 			!usedNamed1.has(nameIdent) &&
 			(!usedNamed2 || !usedNamed2.has(nameIdent))
-		)
+		) {
 			return nameIdent;
+		}
 	}
 
 	let i = 0;
@@ -220,12 +221,12 @@ const getUsedNamesInScopeInfo = (usedNamesInScopeInfo, module, id) => {
 };
 
 module.exports = {
-	getUsedNamesInScopeInfo,
+	DEFAULT_EXPORT,
+	NAMESPACE_OBJECT_EXPORT,
+	RESERVED_NAMES,
+	addScopeSymbols,
 	findNewName,
 	getAllReferences,
 	getPathInAst,
-	NAMESPACE_OBJECT_EXPORT,
-	DEFAULT_EXPORT,
-	RESERVED_NAMES,
-	addScopeSymbols
+	getUsedNamesInScopeInfo
 };

package/lib/util/conventions.js

@@ -6,6 +6,77 @@
 "use strict";
 
 /** @typedef {import("../../declarations/WebpackOptions").CssGeneratorExportsConvention} CssGeneratorExportsConvention */
+// Copy from css-loader
+/**
+ * @param {string} string string
+ * @returns {string} result
+ */
+const preserveCamelCase = string => {
+	let result = string;
+	let isLastCharLower = false;
+	let isLastCharUpper = false;
+	let isLastLastCharUpper = false;
+
+	for (let i = 0; i < result.length; i++) {
+		const character = result[i];
+
+		if (isLastCharLower && /[\p{Lu}]/u.test(character)) {
+			result = `${result.slice(0, i)}-${result.slice(i)}`;
+			isLastCharLower = false;
+			isLastLastCharUpper = isLastCharUpper;
+			isLastCharUpper = true;
+			i += 1;
+		} else if (
+			isLastCharUpper &&
+			isLastLastCharUpper &&
+			/[\p{Ll}]/u.test(character)
+		) {
+			result = `${result.slice(0, i - 1)}-${result.slice(i - 1)}`;
+			isLastLastCharUpper = isLastCharUpper;
+			isLastCharUpper = false;
+			isLastCharLower = true;
+		} else {
+			isLastCharLower =
+				character.toLowerCase() === character &&
+				character.toUpperCase() !== character;
+			isLastLastCharUpper = isLastCharUpper;
+			isLastCharUpper =
+				character.toUpperCase() === character &&
+				character.toLowerCase() !== character;
+		}
+	}
+
+	return result;
+};
+
+// Copy from css-loader
+/**
+ * @param {string} input input
+ * @returns {string} result
+ */
+module.exports.camelCase = input => {
+	let result = input.trim();
+
+	if (result.length === 0) {
+		return "";
+	}
+
+	if (result.length === 1) {
+		return result.toLowerCase();
+	}
+
+	const hasUpperCase = result !== result.toLowerCase();
+
+	if (hasUpperCase) {
+		result = preserveCamelCase(result);
+	}
+
+	return result
+		.replace(/^[_.\- ]+/, "")
+		.toLowerCase()
+		.replace(/[_.\- ]+([\p{Alpha}\p{N}_]|$)/gu, (_, p1) => p1.toUpperCase())
+		.replace(/\d+([\p{Alpha}\p{N}_]|$)/gu, m => m.toUpperCase());
+};
 
 /**
  * @param {string} input input
@@ -42,7 +113,7 @@ module.exports.cssExportConvention = (input, convention) => {
 			}
 		}
 	}
-	return Array.from(set);
+	return [...set];
 };
 
 // Copy from css-loader
@@ -52,75 +123,3 @@ module.exports.cssExportConvention = (input, convention) => {
  */
 module.exports.dashesCamelCase = input =>
 	input.replace(/-+(\w)/g, (match, firstLetter) => firstLetter.toUpperCase());
-
-// Copy from css-loader
-/**
- * @param {string} input input
- * @returns {string} result
- */
-module.exports.camelCase = input => {
-	let result = input.trim();
-
-	if (result.length === 0) {
-		return "";
-	}
-
-	if (result.length === 1) {
-		return result.toLowerCase();
-	}
-
-	const hasUpperCase = result !== result.toLowerCase();
-
-	if (hasUpperCase) {
-		result = preserveCamelCase(result);
-	}
-
-	return result
-		.replace(/^[_.\- ]+/, "")
-		.toLowerCase()
-		.replace(/[_.\- ]+([\p{Alpha}\p{N}_]|$)/gu, (_, p1) => p1.toUpperCase())
-		.replace(/\d+([\p{Alpha}\p{N}_]|$)/gu, m => m.toUpperCase());
-};
-
-// Copy from css-loader
-/**
- * @param {string} string string
- * @returns {string} result
- */
-const preserveCamelCase = string => {
-	let result = string;
-	let isLastCharLower = false;
-	let isLastCharUpper = false;
-	let isLastLastCharUpper = false;
-
-	for (let i = 0; i < result.length; i++) {
-		const character = result[i];
-
-		if (isLastCharLower && /[\p{Lu}]/u.test(character)) {
-			result = `${result.slice(0, i)}-${result.slice(i)}`;
-			isLastCharLower = false;
-			isLastLastCharUpper = isLastCharUpper;
-			isLastCharUpper = true;
-			i += 1;
-		} else if (
-			isLastCharUpper &&
-			isLastLastCharUpper &&
-			/[\p{Ll}]/u.test(character)
-		) {
-			result = `${result.slice(0, i - 1)}-${result.slice(i - 1)}`;
-			isLastLastCharUpper = isLastCharUpper;
-			isLastCharUpper = false;
-			isLastCharLower = true;
-		} else {
-			isLastCharLower =
-				character.toLowerCase() === character &&
-				character.toUpperCase() !== character;
-			isLastLastCharUpper = isLastCharUpper;
-			isLastCharUpper =
-				character.toUpperCase() === character &&
-				character.toLowerCase() !== character;
-		}
-	}
-
-	return result;
-};