JavaScript Float Parsing Challenge

You'll be tasked with creating a robust JavaScript function to parse strings into floating-point numbers. This is a common operation in web development, especially when dealing with user input or data from APIs, where numbers are often represented as strings. Your solution will need to handle various formats and potential errors gracefully.

Problem Description

Your goal is to implement a function, parseFloatRobust(inputString), that takes a string as input and attempts to convert it into a floating-point number. The function should be "robust" in that it handles common variations in string representations of numbers and also gracefully deals with invalid inputs.

Key Requirements:

1. Basic Parsing: Convert standard string representations of floats (e.g., "3.14", "-0.5", "100") into their corresponding JavaScript Number types.
2. Whitespace Handling: Ignore leading and trailing whitespace in the input string.
3. Scientific Notation: Support scientific notation (e.g., "1.23e-4", "5e6").
4. Hexadecimal Floats (Optional but Recommended): While not strictly required by standard JavaScript parseFloat, consider how you might handle hexadecimal representations if they were to appear (though standard parseFloat does not support this for floats). For this challenge, focus on standard decimal and scientific notation.
5. Invalid Input:
   • If the input string cannot be parsed into a valid number, the function should return NaN (Not a Number).
   • Empty strings or strings containing only whitespace should also result in NaN.
   • Strings that start with non-numeric characters (after whitespace trimming) should result in NaN.
6. "Hexadecimal Floats": This is a bit of a trick. Standard JavaScript parseFloat does not support hexadecimal floats directly. It will parse leading hex digits as integers and stop. For this challenge, you should mimic the behavior of the native parseFloat regarding non-decimal characters – it stops parsing when it encounters a character that is not part of a valid number representation.

Expected Behavior:

The function should return a Number type if successful, and NaN if parsing fails.

Examples

Example 1:

Input: "  123.456  "
Output: 123.456
Explanation: Leading and trailing whitespace is ignored, and the string is parsed into a float.

Example 2:

Input: "-9.87e-2"
Output: -0.0987
Explanation: Scientific notation is correctly parsed.

Example 3:

Input: "hello 123.45"
Output: NaN
Explanation: The string does not start with a valid number (after potential whitespace trimming).

Example 4:

Input: ""
Output: NaN
Explanation: An empty string cannot be parsed as a number.

Example 5:

Input: "   "
Output: NaN
Explanation: A string containing only whitespace cannot be parsed as a number.

Example 6:

Input: "100 apples"
Output: 100
Explanation: The function should parse as much of the string as possible until an invalid character is encountered. "100" is a valid float.

Constraints

• The input will always be a string.
• The input string may contain characters beyond digits and decimal points, including spaces, signs, 'e'/'E', and potentially other non-numeric characters.
• Performance is not a primary concern for this challenge, but your solution should be reasonably efficient.

Notes

Consider using built-in JavaScript methods. Think about how parseFloat itself behaves with different inputs, and aim to replicate that behavior, especially regarding the stopping condition for parsing. For invalid inputs, returning NaN is crucial.