Tiered Compilation System in JavaScript

This challenge asks you to design and implement a tiered compilation system in JavaScript. Such a system is useful for optimizing code execution based on complexity or resource availability, allowing for faster execution in favorable conditions while maintaining compatibility and robustness in others. You'll be building a system that takes JavaScript code as input and applies different compilation strategies based on a defined tier level.

Problem Description

You are tasked with creating a TieredCompiler class in JavaScript. This class will take a JavaScript code string as input and a tier level (an integer representing the compilation tier). The compiler should then apply a specific compilation strategy based on the tier level. The strategies are as follows:

• Tier 1 (Basic): No compilation. Return the original code string unchanged. This is the fallback tier.
• Tier 2 (Simple Optimization): Perform a simple optimization: replace all occurrences of var with let.
• Tier 3 (Advanced Optimization): Perform the Tier 2 optimization and remove all comments from the code. Comments are defined as anything between // and the end of the line, or between /* and */.

The TieredCompiler class should have a constructor that takes no arguments and a compile method that takes the JavaScript code string and the tier level as arguments and returns the compiled code string.

Key Requirements:

• The TieredCompiler class must be implemented.
• The compile method must correctly apply the appropriate compilation strategy based on the tier level.
• The comment removal in Tier 3 must be accurate and handle both single-line (//) and multi-line (/* ... */) comments.
• The code should be well-structured and readable.

Expected Behavior:

The compile method should return a string representing the compiled code. The returned string should be the original code, the code with var replaced by let, or the code with var replaced by let and all comments removed, depending on the tier level.

Edge Cases to Consider:

• Empty input code string.
• Tier levels outside the range of 1-3. In this case, default to Tier 1 (no compilation).
• Nested comments (e.g., /* /* comment */ */). These should be treated as a single comment block.
• Comments containing /* or */ that are not the start or end of a comment block.
• Code with no comments.
• Code with only comments.

Examples

Example 1:

Input: code = "var x = 10; // This is a comment\nvar y = 20;", tier = 1
Output: "var x = 10; // This is a comment\nvar y = 20;"
Explanation: Tier 1 does no compilation.

Example 2:

Input: code = "var x = 10; // This is a comment\nvar y = 20;", tier = 2
Output: "let x = 10; // This is a comment\nlet y = 20;"
Explanation: Tier 2 replaces 'var' with 'let'.

Example 3:

Input: code = "var x = 10; /* This is a\nmulti-line comment */ var y = 20;", tier = 3
Output: "let x = 10; let y = 20;"
Explanation: Tier 3 replaces 'var' with 'let' and removes all comments.

Example 4:

Input: code = "// Only a comment", tier = 3
Output: ""
Explanation: Tier 3 removes the comment, resulting in an empty string.

Constraints

• The input code string will be a valid JavaScript code snippet.
• The tier level will be an integer between 1 and 3 (inclusive). Values outside this range should default to tier 1.
• The comment removal in Tier 3 must be accurate and not remove parts of the code that are within strings or other valid code contexts.
• Performance is not a primary concern for this challenge, but strive for reasonably efficient code.

Notes

• Consider using regular expressions for comment removal in Tier 3. However, be mindful of the potential complexities of regular expressions when dealing with nested structures.
• Think about how to handle different types of comments (single-line vs. multi-line) effectively.
• Break down the problem into smaller, manageable functions to improve code readability and maintainability. For example, a separate function for replacing var with let and another for removing comments.
• Test your code thoroughly with various inputs, including edge cases, to ensure it behaves as expected.