If you could rewrite HTML/CSS/Javascript or other basic web languages from scratch, what changes would you make?

It’s a short list:
Static type checking.
HTML, CSS, XML and JSON have many problems, most notably:
They are all overly-complicated ways to express untyped trees.
They were supposed to be human readable.
A better direct replacement for all of these would be the most straightforward tree: a Lisp-style list of lists where the leaves are strings although I’d probably use m-express and square brackets rather than s-exprs because I find them easier to understand. However, significant picture none of this stuff needs to be human readable. We have computers, people. Let’s use them. So I’d go with a binary format but more on that later.
Javascript is a poorly designed programming language when what we needed was a common language runtime. If I were to reinvent this today, I would use Microsoft’s .NET. If I were reinventing it back when Javascript came out I would look for a lean binary replacement like OCaml’s bytecode but, retrospectively, I’d be sad to have missed out on reified generics and value types.
The core issue is this: HTML, CSS, XML and JSON are just ways for programs to exchange information. A better alternative would be to use statically type checked code and verify the data going over the wire using that same type system. The interface between your web browser and the remote web server should be type checked. No need for “schemas”. Serialization should be an implementation detail.
Interesting question though. After programming for almost 40 years, professionally for over 24, I have given up because I cannot stand the fact that web technologies have dragged computer programming backwards ~20 years. I think the state of web tech is shameful.
PS: I should probably give more detail about my proposed type of system. I’d aim for core ML:
Ints, floats, chars and strings.
Mutable arrays.
Tuples
Unions (where each constructor has precisely one argument).
Functions (that accept one value and return one value).
Parametric polymorphism (aka “generics”).
Zeroth-order modules.
I believe that is the most straightforward type of system that would be practically useful. You don’t even need a built-in bool type because it is just the union of true and false.
I’d expect the first language to provide ML-style pattern matching with exhaustiveness and redundancy checking and the ability to serialize any value to and from the wire format (whatever it is: an implementation detail) with a single function call.

I would first plan my work using a pencil and paper. The best architecture would involve DRY (Don't repeat yourself) techniques, resulting in modularised code.
I would remove the dependency of one module over another. Coding standards and documentation would be the utmost priority, as it helps in the maintenance of the code over the long run once the application starts becoming bigger.