Oh also:

• there is no timing issue in HTML, two parallel requests are deduped if they are for "the same module"
• import type text and import "type js" always result in two requests in HTML. It's unambiguous that it happens, and it's also if they happen not in parallel

also, scripts are not "content" in the sense meant by this guideline:

In this specification, the noun "content" is used in three ways:
It is used to mean the document object as a whole or in parts.
It is used to mean the content of an HTML or XML element, in the sense employed by the XML 1.0 specification ([XML], section 3.1): "The text between the start-tag and end-tag is called the element's content." Context should indicate that the term content is being used in this sense.
It is used in the context of the phrases non-text content and text content.

class A {}
class B extends A {}
B instanceof A // false

I sometimes wonder about the potential for something like C#'s approach to implicit vs explicit interface implementation, such that implementing an interface could use an identifier-named member as a shorthand for the more explicit symbol-named member. For example, if you had something like:

protocol Stringable {
  toString;
}

You could potentially implement it in a class like either:

class C1 implements Stringable {
  toString() {} // implicit
}
class C2 implements Stringable {
  [Stringable.toString]() {} // explicit
}

In the first case, implementing the protocol would look first look for the explicit implementation and then for an identifier with the same name. If an explicit member didn't exist, it would be added as an alias to the identifier-named member, i.e.:

class C1 implements Stringable {
  toString() { ... } 
}
// runtime generated
Object.defineProperty(C1.prototype, Stringable.toString, Object.getOwnPropertyDescriptor(C1.prototype, "toString"));

That might make the dichotomy between identifier and symbol a bit less of a problem.