refactor: Event and EventTarget implementations (#4707)

Refactors Event and EventTarget so that they better encapsulate their
non-public data as well as are more forward compatible with things like
DOM Nodes.

Moves `dom_types.ts` -> `dom_types.d.ts` which was always the intention,
it was a legacy of when we used to build the types from the code and the
limitations of the compiler.  There was a lot of cruft in `dom_types`
which shouldn't have been there, and mis-alignment to the DOM standards.
This generally has been eliminated, though we still have some minor
differences from the DOM (like the removal of some deprecated
methods/properties).

Adds `DOMException`.  Strictly it shouldn't inherit from `Error`, but
most browsers provide a stack trace when one is thrown, so the behaviour
in Deno actually better matches the browser.

`Event` still doesn't log to console like it does in the browser.  I
 wanted to get this raised and that could be an enhancement later on (it
 currently doesn't either).

1 files changed, 19 insertions, 13 deletions

diff --git a/cli/js/web/util.ts b/cli/js/web/util.ts
index 2d63b4d60..32e73c443 100644
--- a/cli/js/web/util.ts
+++ b/cli/js/web/util.ts
@@ -11,6 +11,7 @@ export type TypedArray =
   | Float32Array
   | Float64Array;
 
+// @internal
 export function isTypedArray(x: unknown): x is TypedArray {
   return (
     x instanceof Int8Array ||
@@ -54,19 +55,8 @@ export function immutableDefine(
   });
 }
 
-// Returns values from a WeakMap to emulate private properties in JavaScript
-export function getPrivateValue<
-  K extends object,
-  V extends object,
-  W extends keyof V
->(instance: K, weakMap: WeakMap<K, V>, key: W): V[W] {
-  if (weakMap.has(instance)) {
-    return weakMap.get(instance)![key];
-  }
-  throw new TypeError("Illegal invocation");
-}
-
-export function hasOwnProperty<T>(obj: T, v: PropertyKey): boolean {
+// @internal
+export function hasOwnProperty(obj: unknown, v: PropertyKey): boolean {
   if (obj == null) {
     return false;
   }
@@ -87,3 +77,19 @@ export function isIterable<T, P extends keyof T, K extends T[P]>(
     typeof ((o as unknown) as Iterable<[P, K]>)[Symbol.iterator] === "function"
   );
 }
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+interface GenericConstructor<T = any> {
+  prototype: T;
+}
+
+/** A helper function which ensures accessors are enumerable, as they normally
+ * are not. */
+export function defineEnumerableProps(
+  Ctor: GenericConstructor,
+  props: string[]
+): void {
+  for (const prop of props) {
+    Reflect.defineProperty(Ctor.prototype, prop, { enumerable: true });
+  }
+}