Hello! I am writing a BigNumber function to add two arbitrarily large strings together as if they were numbers and return the final (larger) string. 
Try to demonstrate this BigNumAdd function in javascript, and explain possible optimizations, edge cases, or improvements that you might think of.
Sure, here's a sample implementation of a BigNumAdd function in JavaScript:

```js
function BigNumAdd(num1, num2) {
  let carry = 0;
  let result = '';
  let i = num1.length - 1;
  let j = num2.length - 1;

  while (i >= 0 || j >= 0 || carry > 0) {
    const digit1 = i >= 0 ? parseInt(num1[i]) : 0;
    const digit2 = j >= 0 ? parseInt(num2[j]) : 0;
    const sum = digit1 + digit2 + carry;

    carry = Math.floor(sum / 10);
    result = (sum % 10) + result;

    i--;
    j--;
  }

  return result;
}
```

This function takes two string inputs num1 and num2, representing the large numbers to be added together. It iterates over the digits of the numbers from right to left, adding them up and carrying over any excess digits to the next place value. It continues until all digits have been added and any final carry-over digit has been added to the result.

Some possible optimizations for this function could include:
- Early termination: If the lengths of the two input strings are vastly different, we can stop adding digits from the shorter string once we reach the end of it, since any remaining digits will not affect the final result.
- Pre-computing lengths: Instead of calling num1.length and num2.length in each iteration of the loop, we can pre-compute these lengths outside of the loop and store them in variables to improve performance.

Some possible edge cases to consider for this function include:
- Negative numbers: This function assumes that the input strings are non-negative integers. If negative numbers are allowed as input, we would need to add additional logic to handle them.
- Leading zeros: The input strings may contain leading zeros, which should be ignored when performing the addition. We can handle this by stripping any leading zeros from the input strings before beginning the addition.
- Maximum integer size: JavaScript has a maximum integer size of 2^53 - 1, so if the input strings exceed this size, the function will not work as intended. In this case, we could consider using a different data structure, such as an array or BigInt, to store and manipulate the numbers.

Some possible improvements to this function could include:

- Supporting decimal points: This function currently only works with integers. We could modify it to handle numbers with decimal points as well by splitting the input strings at the decimal point and treating the parts before and after the decimal point separately.
- Handling invalid input: This function assumes that the input strings are well-formed integers. If invalid input is possible, we would need to add additional error checking and handling to the function.
Thank you for the information.
You're welcome! If you have any more questions or need further clarification, feel free to ask.