Being both a TypeScript and Google Dart developer for a few years now (and a former Flash/Flex developer, and still missing lots of aspects of it), I can say:

- On browsers: it is what it is. Neither React nor Angular will fix this for you. You're going to have to work with all existing browsers and their issues (which are quite a lot, especially when you want to go little 'deeper down').
- On styling CSS: Either use a framework like Bootstrap or Material Design Lite, or try to use a pre-processor like SASS. LESS and Stylus, also 2 pre-processors, are losing a bit on popularity, or so it seems. SASS is a good 'safe bet'. There's lots of documentation and fairly decent frameworks were made around it.

- React and Angular are both really good, have amazing documentation and tutorials. But for me personally, React translates really well my experience from Flash/Flex. Angular is also a very nice framework of course, but it feels to me like it is still more something I would use to make webSITES in, instead of webAPPS (although I'm building a huge app in it right now), since it is not as 'fast' and 'snappy' to create components and an architecture as it is with React. (I'm talking development wise, not performance)

- On dependencies: I really dislike the entire dependency hell I always end up in when starting a JavaScript project. Since both JavaScript and TypeScript use NPM (at least, that's the current de-facto standard), TypeScript does not solve this for you.
For instance: how do you manage your dependencies? NPM, Nuget or Yarn? What's the difference, and do you have a day to look it all up?
How are you building your project and your .sass files? Gulp, Grunt, Webpack, NPM scripts, or just vanilla commandline?
If you're creating a new class, how are you going import it in your consumer class? Declare all external JS files in your index.html? Or maybe you prefer CommonJS, RequireJS, UMD, SystemJS or ES2015(=ES6) native modules? And what if one dependency uses another system than you do?

- On languages:

TYPESCRIPT: it's a very nice and powerful language, but like I said, it hooks into the standard JavaScript ecosystem. On top of the dependency hell, you'll have to use a lot of JS interops (to be able to use existing JS libraries), which aren't always that well maintained.

ES6: You could use the ES6 version of JavaScript. You'll need Babel to transpile to ES5 JavaScript, so your code will run in all browsers. No problems with JS interops here, but dependency hell and ecosystem problems will stay.

GOOGLE DART: Also an amazing language, written by Google. You can discuss on what's the better language (TypeScript or Dart), but the advantage here is the ecosystem. You build with Pub, you manage your dependencies with Pub, and there's only one way of importing external classes. A lot of modern API's you'll need, like Futures (kind of like Promises), and Streams (like Observables) are built in the language itself, meaning they are maintained and tested by Google. I've been using AngularDart (a Dart-based Angular) for over 6 months now, and it's going really well.

So for me, this results in:

- JavaScript ES6:
+ Simple and fun language
+ Close to old-skool JavaScript
- Too limited in OOP features
- Inconsistent and way too fast changing JavaScript ecosystem (dependency management, build tools, importing external libraries, ..)

- TypeScript:
+ Very nice language
+ Projects like Angular and React are written in it, so it's easy to find tutorials in TypeScript
+ Popular, and well documented
- Inconsistent and way too fast changing JavaScript ecosystem (dependency management, build tools, importing external libraries, ..)
- Had a lot of bullshit with JS interops (Both with finding good interops for JS libraries, as with creating interops myself)

- Google Dart:
+ Very nice language (very close to Java and C#)
+ AngularDart is fun to work with
+ Very consistent eco-system
+ Really well documented
+ Good support from Google and community members on Gitter chat
+ The most common API's you'll need are either included in the SDK, or written and maintained by Google themselves.
- Third-party libraries are not always that well documented
- The community is not (yet?) as big as the TS or JS community, so obviously it's a little bit harder to find code examples etc

Conclusion:

- React is awesome, but being dependent on TypeScript (or ES6), you'll spend lots and lots of time on managing your dependencies when your project grows even the slightest bit

- Google Dart is awesome, but AngularDart, although it's a lovely piece of software, is still no React.

But for now I choose AngularDart. Perhaps in the future I'll choose for React+TS again. But I'll continue hoping for a real ReactDart. :)