webpack 5.59.0 → 5.94.0

package/lib/util/cleverMerge.js

@@ -23,26 +23,28 @@ const DYNAMIC_INFO = Symbol("cleverMerge dynamic info");
  *  // when same arguments passed, gets the result from WeakMap and returns it.
  * cachedCleverMerge({a: 1}, {a: 2})
  * {a: 2}
- * @param {T} first first object
- * @param {O} second second object
+ * @param {T | null | undefined} first first object
+ * @param {O | null | undefined} second second object
  * @returns {T & O | T | O} merged object of first and second object
  */
 const cachedCleverMerge = (first, second) => {
-	if (second === undefined) return first;
-	if (first === undefined) return second;
-	if (typeof second !== "object" || second === null) return second;
-	if (typeof first !== "object" || first === null) return first;
+	if (second === undefined) return /** @type {T} */ (first);
+	if (first === undefined) return /** @type {O} */ (second);
+	if (typeof second !== "object" || second === null)
+		return /** @type {O} */ (second);
+	if (typeof first !== "object" || first === null)
+		return /** @type {T} */ (first);
 
 	let innerCache = mergeCache.get(first);
 	if (innerCache === undefined) {
 		innerCache = new WeakMap();
 		mergeCache.set(first, innerCache);
 	}
-	const prevMerge = innerCache.get(second);
+	const prevMerge = /** @type {T & O} */ (innerCache.get(second));
 	if (prevMerge !== undefined) return prevMerge;
 	const newMerge = _cleverMerge(first, second, true);
 	innerCache.set(second, newMerge);
-	return newMerge;
+	return /** @type {T & O} */ (newMerge);
 };
 
 /**
@@ -69,7 +71,7 @@ const cachedSetProperty = (obj, property, value) => {
 
 	let result = mapByValue.get(value);
 
-	if (result) return result;
+	if (result) return /** @type {T} */ (result);
 
 	result = {
 		...obj,
@@ -77,18 +79,18 @@ const cachedSetProperty = (obj, property, value) => {
 	};
 	mapByValue.set(value, result);
 
-	return result;
+	return /** @type {T} */ (result);
 };
 
 /**
- * @typedef {Object} ObjectParsedPropertyEntry
+ * @typedef {object} ObjectParsedPropertyEntry
  * @property {any | undefined} base base value
  * @property {string | undefined} byProperty the name of the selector property
  * @property {Map<string, any>} byValues value depending on selector property, merged with base
  */
 
 /**
- * @typedef {Object} ParsedObject
+ * @typedef {object} ParsedObject
  * @property {Map<string, ObjectParsedPropertyEntry>} static static properties (key is property name)
  * @property {{ byProperty: string, fn: Function } | undefined} dynamic dynamic part
  */
@@ -229,7 +231,7 @@ const getValueType = value => {
 	} else if (value === DELETE) {
 		return VALUE_TYPE_DELETE;
 	} else if (Array.isArray(value)) {
-		if (value.lastIndexOf("...") !== -1) return VALUE_TYPE_ARRAY_EXTEND;
+		if (value.includes("...")) return VALUE_TYPE_ARRAY_EXTEND;
 		return VALUE_TYPE_ATOM;
 	} else if (
 		typeof value === "object" &&
@@ -257,7 +259,7 @@ const cleverMerge = (first, second) => {
 	if (typeof second !== "object" || second === null) return second;
 	if (typeof first !== "object" || first === null) return first;
 
-	return _cleverMerge(first, second, false);
+	return /** @type {T & O} */ (_cleverMerge(first, second, false));
 };
 
 /**
@@ -457,8 +459,8 @@ const mergeSingleValue = (a, b, internalCaching) => {
 			return aType !== VALUE_TYPE_OBJECT
 				? b
 				: internalCaching
-				? cachedCleverMerge(a, b)
-				: cleverMerge(a, b);
+					? cachedCleverMerge(a, b)
+					: cleverMerge(a, b);
 		}
 		case VALUE_TYPE_UNDEFINED:
 			return a;
@@ -467,8 +469,8 @@ const mergeSingleValue = (a, b, internalCaching) => {
 				aType !== VALUE_TYPE_ATOM
 					? aType
 					: Array.isArray(a)
-					? VALUE_TYPE_ARRAY_EXTEND
-					: VALUE_TYPE_OBJECT
+						? VALUE_TYPE_ARRAY_EXTEND
+						: VALUE_TYPE_OBJECT
 			) {
 				case VALUE_TYPE_UNDEFINED:
 					return b;
@@ -498,27 +500,40 @@ const mergeSingleValue = (a, b, internalCaching) => {
 };
 
 /**
- * @template T
+ * @template {object} T
  * @param {T} obj the object
+ * @param {(keyof T)[]=} keysToKeepOriginalValue keys to keep original value
  * @returns {T} the object without operations like "..." or DELETE
  */
-const removeOperations = obj => {
+const removeOperations = (obj, keysToKeepOriginalValue = []) => {
 	const newObj = /** @type {T} */ ({});
 	for (const key of Object.keys(obj)) {
-		const value = obj[key];
+		const value = obj[/** @type {keyof T} */ (key)];
 		const type = getValueType(value);
+		if (
+			type === VALUE_TYPE_OBJECT &&
+			keysToKeepOriginalValue.includes(/** @type {keyof T} */ (key))
+		) {
+			newObj[/** @type {keyof T} */ (key)] = value;
+			continue;
+		}
 		switch (type) {
 			case VALUE_TYPE_UNDEFINED:
 			case VALUE_TYPE_DELETE:
 				break;
 			case VALUE_TYPE_OBJECT:
-				newObj[key] = removeOperations(value);
+				newObj[key] = removeOperations(
+					/** @type {TODO} */ (value),
+					keysToKeepOriginalValue
+				);
 				break;
 			case VALUE_TYPE_ARRAY_EXTEND:
-				newObj[key] = value.filter(i => i !== "...");
+				newObj[key] =
+					/** @type {any[]} */
+					(value).filter(i => i !== "...");
 				break;
 			default:
-				newObj[key] = value;
+				newObj[/** @type {keyof T} */ (key)] = value;
 				break;
 		}
 	}
@@ -537,21 +552,21 @@ const resolveByProperty = (obj, byProperty, ...values) => {
 	if (typeof obj !== "object" || obj === null || !(byProperty in obj)) {
 		return obj;
 	}
-	const { [byProperty]: _byValue, ..._remaining } = /** @type {object} */ (obj);
+	const { [byProperty]: _byValue, ..._remaining } = obj;
 	const remaining = /** @type {T} */ (_remaining);
-	const byValue = /** @type {Record<string, T> | function(...any[]): T} */ (
-		_byValue
-	);
+	const byValue =
+		/** @type {Record<string, T> | function(...any[]): T} */
+		(_byValue);
 	if (typeof byValue === "object") {
 		const key = values[0];
 		if (key in byValue) {
 			return cachedCleverMerge(remaining, byValue[key]);
 		} else if ("default" in byValue) {
 			return cachedCleverMerge(remaining, byValue.default);
-		} else {
-			return /** @type {T} */ (remaining);
 		}
+		return remaining;
 	} else if (typeof byValue === "function") {
+		// eslint-disable-next-line prefer-spread
 		const result = byValue.apply(null, values);
 		return cachedCleverMerge(
 			remaining,
@@ -560,9 +575,9 @@ const resolveByProperty = (obj, byProperty, ...values) => {
 	}
 };
 
-exports.cachedSetProperty = cachedSetProperty;
-exports.cachedCleverMerge = cachedCleverMerge;
-exports.cleverMerge = cleverMerge;
-exports.resolveByProperty = resolveByProperty;
-exports.removeOperations = removeOperations;
-exports.DELETE = DELETE;
+module.exports.cachedSetProperty = cachedSetProperty;
+module.exports.cachedCleverMerge = cachedCleverMerge;
+module.exports.cleverMerge = cleverMerge;
+module.exports.resolveByProperty = resolveByProperty;
+module.exports.removeOperations = removeOperations;
+module.exports.DELETE = DELETE;

package/lib/util/comparators.js

@@ -8,15 +8,28 @@
 const { compareRuntime } = require("./runtime");
 
 /** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Chunk").ChunkId} ChunkId */
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../ChunkGraph").ModuleId} ModuleId */
 /** @typedef {import("../ChunkGroup")} ChunkGroup */
 /** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 
-/** @template T @typedef {function(T, T): -1|0|1} Comparator */
-/** @template TArg @template T @typedef {function(TArg, T, T): -1|0|1} RawParameterizedComparator */
-/** @template TArg @template T @typedef {function(TArg): Comparator<T>} ParameterizedComparator */
+/**
+ * @template T
+ * @typedef {function(T, T): -1|0|1} Comparator
+ */
+/**
+ * @template TArg
+ * @template T
+ * @typedef {function(TArg, T, T): -1|0|1} RawParameterizedComparator
+ */
+/**
+ * @template TArg
+ * @template T
+ * @typedef {function(TArg): Comparator<T>} ParameterizedComparator
+ */
 
 /**
  * @template T
@@ -45,18 +58,16 @@ const createCachedParameterizedComparator = fn => {
  * @param {Chunk} b chunk
  * @returns {-1|0|1} compare result
  */
-exports.compareChunksById = (a, b) => {
-	return compareIds(a.id, b.id);
-};
+module.exports.compareChunksById = (a, b) =>
+	compareIds(/** @type {ChunkId} */ (a.id), /** @type {ChunkId} */ (b.id));
 
 /**
  * @param {Module} a module
  * @param {Module} b module
  * @returns {-1|0|1} compare result
  */
-exports.compareModulesByIdentifier = (a, b) => {
-	return compareIds(a.identifier(), b.identifier());
-};
+module.exports.compareModulesByIdentifier = (a, b) =>
+	compareIds(a.identifier(), b.identifier());
 
 /**
  * @param {ChunkGraph} chunkGraph the chunk graph
@@ -64,11 +75,13 @@ exports.compareModulesByIdentifier = (a, b) => {
  * @param {Module} b module
  * @returns {-1|0|1} compare result
  */
-const compareModulesById = (chunkGraph, a, b) => {
-	return compareIds(chunkGraph.getModuleId(a), chunkGraph.getModuleId(b));
-};
+const compareModulesById = (chunkGraph, a, b) =>
+	compareIds(
+		/** @type {ModuleId} */ (chunkGraph.getModuleId(a)),
+		/** @type {ModuleId} */ (chunkGraph.getModuleId(b))
+	);
 /** @type {ParameterizedComparator<ChunkGraph, Module>} */
-exports.compareModulesById =
+module.exports.compareModulesById =
 	createCachedParameterizedComparator(compareModulesById);
 
 /**
@@ -84,7 +97,7 @@ const compareNumbers = (a, b) => {
 	if (a > b) return 1;
 	return 0;
 };
-exports.compareNumbers = compareNumbers;
+module.exports.compareNumbers = compareNumbers;
 
 /**
  * @param {string} a string
@@ -92,35 +105,71 @@ exports.compareNumbers = compareNumbers;
  * @returns {-1|0|1} compare result
  */
 const compareStringsNumeric = (a, b) => {
-	const partsA = a.split(/(\d+)/);
-	const partsB = b.split(/(\d+)/);
-	const len = Math.min(partsA.length, partsB.length);
-	for (let i = 0; i < len; i++) {
-		const pA = partsA[i];
-		const pB = partsB[i];
-		if (i % 2 === 0) {
-			if (pA.length > pB.length) {
-				if (pA.slice(0, pB.length) > pB) return 1;
-				return -1;
-			} else if (pB.length > pA.length) {
-				if (pB.slice(0, pA.length) > pA) return -1;
-				return 1;
-			} else {
-				if (pA < pB) return -1;
-				if (pA > pB) return 1;
-			}
+	const aLength = a.length;
+	const bLength = b.length;
+
+	let aChar = 0;
+	let bChar = 0;
+
+	let aIsDigit = false;
+	let bIsDigit = false;
+	let i = 0;
+	let j = 0;
+	while (i < aLength && j < bLength) {
+		aChar = a.charCodeAt(i);
+		bChar = b.charCodeAt(j);
+
+		aIsDigit = aChar >= 48 && aChar <= 57;
+		bIsDigit = bChar >= 48 && bChar <= 57;
+
+		if (!aIsDigit && !bIsDigit) {
+			if (aChar < bChar) return -1;
+			if (aChar > bChar) return 1;
+			i++;
+			j++;
+		} else if (aIsDigit && !bIsDigit) {
+			// This segment of a is shorter than in b
+			return 1;
+		} else if (!aIsDigit && bIsDigit) {
+			// This segment of b is shorter than in a
+			return -1;
 		} else {
-			const nA = +pA;
-			const nB = +pB;
-			if (nA < nB) return -1;
-			if (nA > nB) return 1;
+			let aNumber = aChar - 48;
+			let bNumber = bChar - 48;
+
+			while (++i < aLength) {
+				aChar = a.charCodeAt(i);
+				if (aChar < 48 || aChar > 57) break;
+				aNumber = aNumber * 10 + aChar - 48;
+			}
+
+			while (++j < bLength) {
+				bChar = b.charCodeAt(j);
+				if (bChar < 48 || bChar > 57) break;
+				bNumber = bNumber * 10 + bChar - 48;
+			}
+
+			if (aNumber < bNumber) return -1;
+			if (aNumber > bNumber) return 1;
 		}
 	}
-	if (partsB.length < partsA.length) return 1;
-	if (partsB.length > partsA.length) return -1;
+
+	if (j < bLength) {
+		// a is shorter than b
+		bChar = b.charCodeAt(j);
+		bIsDigit = bChar >= 48 && bChar <= 57;
+		return bIsDigit ? -1 : 1;
+	}
+	if (i < aLength) {
+		// b is shorter than a
+		aChar = a.charCodeAt(i);
+		aIsDigit = aChar >= 48 && aChar <= 57;
+		return aIsDigit ? 1 : -1;
+	}
+
 	return 0;
 };
-exports.compareStringsNumeric = compareStringsNumeric;
+module.exports.compareStringsNumeric = compareStringsNumeric;
 
 /**
  * @param {ModuleGraph} moduleGraph the module graph
@@ -130,14 +179,14 @@ exports.compareStringsNumeric = compareStringsNumeric;
  */
 const compareModulesByPostOrderIndexOrIdentifier = (moduleGraph, a, b) => {
 	const cmp = compareNumbers(
-		moduleGraph.getPostOrderIndex(a),
-		moduleGraph.getPostOrderIndex(b)
+		/** @type {number} */ (moduleGraph.getPostOrderIndex(a)),
+		/** @type {number} */ (moduleGraph.getPostOrderIndex(b))
 	);
 	if (cmp !== 0) return cmp;
 	return compareIds(a.identifier(), b.identifier());
 };
 /** @type {ParameterizedComparator<ModuleGraph, Module>} */
-exports.compareModulesByPostOrderIndexOrIdentifier =
+module.exports.compareModulesByPostOrderIndexOrIdentifier =
 	createCachedParameterizedComparator(
 		compareModulesByPostOrderIndexOrIdentifier
 	);
@@ -150,14 +199,14 @@ exports.compareModulesByPostOrderIndexOrIdentifier =
  */
 const compareModulesByPreOrderIndexOrIdentifier = (moduleGraph, a, b) => {
 	const cmp = compareNumbers(
-		moduleGraph.getPreOrderIndex(a),
-		moduleGraph.getPreOrderIndex(b)
+		/** @type {number} */ (moduleGraph.getPreOrderIndex(a)),
+		/** @type {number} */ (moduleGraph.getPreOrderIndex(b))
 	);
 	if (cmp !== 0) return cmp;
 	return compareIds(a.identifier(), b.identifier());
 };
 /** @type {ParameterizedComparator<ModuleGraph, Module>} */
-exports.compareModulesByPreOrderIndexOrIdentifier =
+module.exports.compareModulesByPreOrderIndexOrIdentifier =
 	createCachedParameterizedComparator(
 		compareModulesByPreOrderIndexOrIdentifier
 	);
@@ -169,14 +218,16 @@ exports.compareModulesByPreOrderIndexOrIdentifier =
  * @returns {-1|0|1} compare result
  */
 const compareModulesByIdOrIdentifier = (chunkGraph, a, b) => {
-	const cmp = compareIds(chunkGraph.getModuleId(a), chunkGraph.getModuleId(b));
+	const cmp = compareIds(
+		/** @type {ModuleId} */ (chunkGraph.getModuleId(a)),
+		/** @type {ModuleId} */ (chunkGraph.getModuleId(b))
+	);
 	if (cmp !== 0) return cmp;
 	return compareIds(a.identifier(), b.identifier());
 };
 /** @type {ParameterizedComparator<ChunkGraph, Module>} */
-exports.compareModulesByIdOrIdentifier = createCachedParameterizedComparator(
-	compareModulesByIdOrIdentifier
-);
+module.exports.compareModulesByIdOrIdentifier =
+	createCachedParameterizedComparator(compareModulesByIdOrIdentifier);
 
 /**
  * @param {ChunkGraph} chunkGraph the chunk graph
@@ -184,11 +235,10 @@ exports.compareModulesByIdOrIdentifier = createCachedParameterizedComparator(
  * @param {Chunk} b chunk
  * @returns {-1|0|1} compare result
  */
-const compareChunks = (chunkGraph, a, b) => {
-	return chunkGraph.compareChunks(a, b);
-};
+const compareChunks = (chunkGraph, a, b) => chunkGraph.compareChunks(a, b);
 /** @type {ParameterizedComparator<ChunkGraph, Chunk>} */
-exports.compareChunks = createCachedParameterizedComparator(compareChunks);
+module.exports.compareChunks =
+	createCachedParameterizedComparator(compareChunks);
 
 /**
  * @param {string|number} a first id
@@ -204,7 +254,7 @@ const compareIds = (a, b) => {
 	return 0;
 };
 
-exports.compareIds = compareIds;
+module.exports.compareIds = compareIds;
 
 /**
  * @param {string} a first string
@@ -217,18 +267,16 @@ const compareStrings = (a, b) => {
 	return 0;
 };
 
-exports.compareStrings = compareStrings;
+module.exports.compareStrings = compareStrings;
 
 /**
  * @param {ChunkGroup} a first chunk group
  * @param {ChunkGroup} b second chunk group
  * @returns {-1|0|1} compare result
  */
-const compareChunkGroupsByIndex = (a, b) => {
-	return a.index < b.index ? -1 : 1;
-};
-
-exports.compareChunkGroupsByIndex = compareChunkGroupsByIndex;
+const compareChunkGroupsByIndex = (a, b) =>
+	/** @type {number} */ (a.index) < /** @type {number} */ (b.index) ? -1 : 1;
+module.exports.compareChunkGroupsByIndex = compareChunkGroupsByIndex;
 
 /**
  * @template K1 {Object}
@@ -237,7 +285,10 @@ exports.compareChunkGroupsByIndex = compareChunkGroupsByIndex;
  */
 class TwoKeyWeakMap {
 	constructor() {
-		/** @private @type {WeakMap<any, WeakMap<any, T>>} */
+		/**
+		 * @private
+		 * @type {WeakMap<any, WeakMap<any, T | undefined>>}
+		 */
 		this._map = new WeakMap();
 	}
 
@@ -249,7 +300,7 @@ class TwoKeyWeakMap {
 	get(key1, key2) {
 		const childMap = this._map.get(key1);
 		if (childMap === undefined) {
-			return undefined;
+			return;
 		}
 		return childMap.get(key2);
 	}
@@ -302,9 +353,12 @@ const concatComparators = (c1, c2, ...cRest) => {
 	concatComparatorsCache.set(c1, c2, result);
 	return result;
 };
-exports.concatComparators = concatComparators;
+module.exports.concatComparators = concatComparators;
 
-/** @template A, B @typedef {(input: A) => B} Selector */
+/**
+ * @template A, B
+ * @typedef {(input: A) => B | undefined | null} Selector
+ */
 
 /** @type {TwoKeyWeakMap<Selector<any, any>, Comparator<any>, Comparator<any>>}} */
 const compareSelectCache = new TwoKeyWeakMap();
@@ -332,17 +386,16 @@ const compareSelect = (getter, comparator) => {
 				return comparator(aValue, bValue);
 			}
 			return -1;
-		} else {
-			if (bValue !== undefined && bValue !== null) {
-				return 1;
-			}
-			return 0;
 		}
+		if (bValue !== undefined && bValue !== null) {
+			return 1;
+		}
+		return 0;
 	};
 	compareSelectCache.set(getter, comparator, result);
 	return result;
 };
-exports.compareSelect = compareSelect;
+module.exports.compareSelect = compareSelect;
 
 /** @type {WeakMap<Comparator<any>, Comparator<Iterable<any>>>} */
 const compareIteratorsCache = new WeakMap();
@@ -363,7 +416,6 @@ const compareIterables = elementComparator => {
 	const result = (a, b) => {
 		const aI = a[Symbol.iterator]();
 		const bI = b[Symbol.iterator]();
-		// eslint-disable-next-line no-constant-condition
 		while (true) {
 			const aItem = aI.next();
 			const bItem = bI.next();
@@ -379,7 +431,7 @@ const compareIterables = elementComparator => {
 	compareIteratorsCache.set(elementComparator, result);
 	return result;
 };
-exports.compareIterables = compareIterables;
+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
@@ -388,25 +440,32 @@ exports.compareIterables = compareIterables;
  * @param {Iterable<T>} iterable original ordered list
  * @returns {Comparator<T>} comparator
  */
-exports.keepOriginalOrder = iterable => {
+module.exports.keepOriginalOrder = iterable => {
 	/** @type {Map<T, number>} */
 	const map = new Map();
 	let i = 0;
 	for (const item of iterable) {
 		map.set(item, i++);
 	}
-	return (a, b) => compareNumbers(map.get(a), map.get(b));
+	return (a, b) =>
+		compareNumbers(
+			/** @type {number} */ (map.get(a)),
+			/** @type {number} */ (map.get(b))
+		);
 };
 
 /**
  * @param {ChunkGraph} chunkGraph the chunk graph
  * @returns {Comparator<Chunk>} comparator
  */
-exports.compareChunksNatural = chunkGraph => {
-	const cmpFn = exports.compareModulesById(chunkGraph);
+module.exports.compareChunksNatural = chunkGraph => {
+	const cmpFn = module.exports.compareModulesById(chunkGraph);
 	const cmpIterableFn = compareIterables(cmpFn);
 	return concatComparators(
-		compareSelect(chunk => chunk.name, compareIds),
+		compareSelect(
+			chunk => /** @type {string|number} */ (chunk.name),
+			compareIds
+		),
 		compareSelect(chunk => chunk.runtime, compareRuntime),
 		compareSelect(
 			/**
@@ -425,9 +484,9 @@ exports.compareChunksNatural = chunkGraph => {
  * @param {DependencyLocation} b A location node
  * @returns {-1|0|1} sorting comparator value
  */
-exports.compareLocations = (a, b) => {
-	let isObjectA = typeof a === "object" && a !== null;
-	let isObjectB = typeof b === "object" && b !== null;
+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;
@@ -439,8 +498,10 @@ exports.compareLocations = (a, b) => {
 			const bp = b.start;
 			if (ap.line < bp.line) return -1;
 			if (ap.line > bp.line) return 1;
-			if (ap.column < bp.column) return -1;
-			if (ap.column > bp.column) 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) {
@@ -451,8 +512,10 @@ exports.compareLocations = (a, b) => {
 	} else if ("name" in b) return 1;
 	if ("index" in a) {
 		if ("index" in b) {
-			if (a.index < b.index) return -1;
-			if (a.index > b.index) return 1;
+			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;