I come from strongly typed languages, so I might be biased. I think, that checking the type is actually very useful and can help prevent bugs, which might otherwise be security risks, like code execution, personal data leaks, buffer overflow; or lead to fatal program exits.
Instead of using exceptions, though, I strongly recommend self-healing code / defensive programming principles. Functional programming offers us many nice ideas, like monadic results and options. For example, instead of having the application crash or return an error, which would probably lead to an application crash, too, return a Result object, which has to be handled gracefully and can be chained and propagated to a layer of the application, which can handle the problem (in the worst case, the user). I built my own library for that purpose, which uses Rust's rewritten APIs, for example result-js and roption-js. Both can be browserified :)
Using JS extensions and other languages, like TypeScript and Flow, might seem nice at first, but they won't help you the least when they are not used by every part of the application. For example, you write a library in TS, but your users just use the generated JS - all of TS's type-checks will be for naught; useless in the face of what your users do with the transpiled code.