add optional chaining and nullish coalescing support

lib/ConstPlugin.js

@@ -314,6 +314,45 @@ class ConstPlugin {
 										dep.loc = expression.loc;
 										parser.state.module.addPresentationalDependency(dep);
 									}
+									return keepRight;
+								}
+							} else if (expression.operator === "??") {
+								const param = parser.evaluateExpression(expression.left);
+								const keepRight = param && param.asNullish();
+								if (typeof keepRight === "boolean") {
+									// ------------------------------------------
+									//
+									// Given the following code:
+									//
+									//   (falsy || truthy) ?? someExpression();
+									//
+									// the generated code is:
+									//
+									//   (falsy || truthy) ?? false;
+									//
+									// ------------------------------------------
+									//
+									// Given the following code:
+									//
+									//   nullable ?? someExpression();
+									//
+									// the generated code is:
+									//
+									//   null ?? someExpression();
+									//
+									if (keepRight) {
+										const dep = new ConstDependency("null", param.range);
+										dep.loc = expression.loc;
+										parser.state.module.addPresentationalDependency(dep);
+									} else {
+										const dep = new ConstDependency(
+											"false",
+											expression.right.range
+										);
+										dep.loc = expression.loc;
+										parser.state.module.addPresentationalDependency(dep);
+									}
+
 									return keepRight;
 								}
 							}

lib/dependencies/CommonJsPlugin.js

@@ -199,7 +199,7 @@ class CommonJsPlugin {
 
 					parser.hooks.evaluateIdentifier.for("module.hot").tap(
 						"CommonJsPlugin",
-						evaluateToIdentifier("module.hot", "module", () => ["hot"], false)
+						evaluateToIdentifier("module.hot", "module", () => ["hot"], null)
 					);
 
 					new CommonJsImportsParserPlugin(options).apply(parser);

lib/javascript/BasicEvaluatedExpression.js

@@ -26,6 +26,7 @@ class BasicEvaluatedExpression {
 		this.range = undefined;
 		this.falsy = false;
 		this.truthy = false;
+		this.nullish = undefined;
 		this.bool = undefined;
 		this.number = undefined;
 		this.bigint = undefined;
@@ -97,6 +98,37 @@ class BasicEvaluatedExpression {
 		return this.type === TypeTemplateString;
 	}
 
+	/**
+	 * check for "simple" types (inlined) only
+	 * @returns {boolean} is simple type
+	 */
+	isSimpleType() {
+		switch (this.type) {
+			case TypeIdentifier:
+			case TypeConditional:
+			case TypeWrapped:
+			case TypeUnknown:
+				return false;
+			default:
+				return true;
+		}
+	}
+
+	/**
+	 * @param {BasicEvaluatedExpression} basicEvaluatedExpression basicEvaluatedExpression
+	 * @returns {boolean|undefined} is same type
+	 */
+	isSameType(basicEvaluatedExpression) {
+		if (
+			this.type === TypeUnknown ||
+			basicEvaluatedExpression.type === TypeUnknown
+		) {
+			return undefined;
+		}
+
+		return this.type === basicEvaluatedExpression.type;
+	}
+
 	isTruthy() {
 		return this.truthy;
 	}
@@ -105,9 +137,13 @@ class BasicEvaluatedExpression {
 		return this.falsy;
 	}
 
+	isNullish() {
+		return this.nullish;
+	}
+
 	asBool() {
 		if (this.truthy) return true;
-		if (this.falsy) return false;
+		if (this.falsy || this.nullish) return false;
 		if (this.isBoolean()) return this.bool;
 		if (this.isNull()) return false;
 		if (this.isUndefined()) return false;
@@ -130,6 +166,26 @@ class BasicEvaluatedExpression {
 		return undefined;
 	}
 
+	asNullish() {
+		const nullish = this.isNullish();
+
+		if (nullish === true || this.isNull() || this.isUndefined()) return true;
+
+		if (nullish === false) return false;
+		if (this.isTruthy()) return false;
+		if (this.isBoolean()) return false;
+		if (this.isString()) return false;
+		if (this.isNumber()) return false;
+		if (this.isBigInt()) return false;
+		if (this.isRegExp()) return false;
+		if (this.isArray()) return false;
+		if (this.isConstArray()) return false;
+		if (this.isTemplateString()) return false;
+		if (this.isRegExp()) return false;
+
+		return undefined;
+	}
+
 	asString() {
 		if (this.isBoolean()) return `${this.bool}`;
 		if (this.isNull()) return "null";
@@ -265,6 +321,11 @@ class BasicEvaluatedExpression {
 		return this;
 	}
 
+	setNullish(value) {
+		this.nullish = value;
+		return this;
+	}
+
 	setRange(range) {
 		this.range = range;
 		return this;