From 54bcbdca96a654f29e6ac6b1435fa775e942fec6 Mon Sep 17 00:00:00 2001
From: Kagami Sascha Rosylight <saschanaz@outlook.com>
Date: Sun, 24 Nov 2019 01:22:02 +0900
Subject: [PATCH 1/3] Add HTML Media types

---
 baselines/dom.generated.d.ts                | 261 +++++++++++---------
 inputfiles/addedTypes.json                  |  67 +++++
 inputfiles/comments.json                    |  33 ---
 inputfiles/idl/HTML - Media.commentmap.json |  71 ++++++
 inputfiles/idl/HTML - Media.widl            | 221 +++++++++++++++++
 inputfiles/idl/Media Playback Quality.widl  |  10 +
 inputfiles/idlSources.json                  |   8 +
 inputfiles/overridingTypes.json             |  21 --
 inputfiles/removedTypes.json                |  14 ++
 package.json                                |   6 +-
 10 files changed, 534 insertions(+), 178 deletions(-)
 create mode 100644 inputfiles/idl/HTML - Media.commentmap.json
 create mode 100644 inputfiles/idl/HTML - Media.widl
 create mode 100644 inputfiles/idl/Media Playback Quality.widl

diff --git a/baselines/dom.generated.d.ts b/baselines/dom.generated.d.ts
index cc5537b24..80029b6a2 100644
--- a/baselines/dom.generated.d.ts
+++ b/baselines/dom.generated.d.ts
@@ -2312,11 +2312,28 @@ declare var AudioScheduledSourceNode: {
 
 /** A single audio track from one of the HTML media elements, <audio> or <video>.  */
 interface AudioTrack {
+    /**
+     * Returns true if the given track is active, and false otherwise.
+     * 
+     * Can be set, to change whether the track is enabled or not. If multiple audio tracks are enabled simultaneously, they are mixed.
+     */
     enabled: boolean;
+    /**
+     * Returns the ID of the given track. This is the ID that can be used with a fragment if the format supports media fragment syntax, and that can be used with the getTrackById() method.
+     */
     readonly id: string;
-    kind: string;
+    /**
+     * Returns the category the given track falls into. The possible track categories are given below.
+     */
+    readonly kind: string;
+    /**
+     * Returns the label of the given track, if known, or the empty string otherwise.
+     */
     readonly label: string;
-    language: string;
+    /**
+     * Returns the language of the given track, if known, or the empty string otherwise.
+     */
+    readonly language: string;
     readonly sourceBuffer: SourceBuffer | null;
 }
 
@@ -2338,7 +2355,6 @@ interface AudioTrackList extends EventTarget {
     onchange: ((this: AudioTrackList, ev: Event) => any) | null;
     onremovetrack: ((this: AudioTrackList, ev: TrackEvent) => any) | null;
     getTrackById(id: string): AudioTrack | null;
-    item(index: number): AudioTrack;
     addEventListener<K extends keyof AudioTrackListEventMap>(type: K, listener: (this: AudioTrackList, ev: AudioTrackListEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
     removeEventListener<K extends keyof AudioTrackListEventMap>(type: K, listener: (this: AudioTrackList, ev: AudioTrackListEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
@@ -7650,7 +7666,6 @@ declare var HTMLMarqueeElement: {
 
 interface HTMLMediaElementEventMap extends HTMLElementEventMap {
     "encrypted": MediaEncryptedEvent;
-    "msneedkey": Event;
     "waitingforkey": Event;
 }
 
@@ -7703,40 +7718,6 @@ interface HTMLMediaElement extends HTMLElement {
      */
     loop: boolean;
     readonly mediaKeys: MediaKeys | null;
-    /**
-     * Specifies the purpose of the audio or video media, such as background audio or alerts.
-     */
-    msAudioCategory: string;
-    /**
-     * Specifies the output device id that the audio will be sent to.
-     */
-    msAudioDeviceType: string;
-    readonly msGraphicsTrustStatus: MSGraphicsTrust;
-    /**
-     * Gets the MSMediaKeys object, which is used for decrypting media data, that is associated with this media element.
-     */
-    /** @deprecated */
-    readonly msKeys: MSMediaKeys;
-    /**
-     * Gets or sets whether the DLNA PlayTo device is available.
-     */
-    msPlayToDisabled: boolean;
-    /**
-     * Gets or sets the path to the preferred media source. This enables the Play To target device to stream the media content, which can be DRM protected, from a different location, such as a cloud media server.
-     */
-    msPlayToPreferredSourceUri: string;
-    /**
-     * Gets or sets the primary DLNA PlayTo device.
-     */
-    msPlayToPrimary: boolean;
-    /**
-     * Gets the source associated with the media element for use by the PlayToManager.
-     */
-    readonly msPlayToSource: any;
-    /**
-     * Specifies whether or not to enable low-latency playback on the media element.
-     */
-    msRealTime: boolean;
     /**
      * Gets or sets a flag that indicates whether the audio (either audio or the audio track on video media) is muted.
      */
@@ -7746,8 +7727,6 @@ interface HTMLMediaElement extends HTMLElement {
      */
     readonly networkState: number;
     onencrypted: ((this: HTMLMediaElement, ev: MediaEncryptedEvent) => any) | null;
-    /** @deprecated */
-    onmsneedkey: ((this: HTMLMediaElement, ev: Event) => any) | null;
     onwaitingforkey: ((this: HTMLMediaElement, ev: Event) => any) | null;
     /**
      * Gets a flag that specifies whether playback is paused.
@@ -7778,7 +7757,7 @@ interface HTMLMediaElement extends HTMLElement {
      * The address or URL of the a media resource that is to be considered.
      */
     src: string;
-    srcObject: MediaStream | MediaSource | Blob | null;
+    srcObject: MediaProvider | null;
     readonly textTracks: TextTrackList;
     readonly videoTracks: VideoTrackList;
     /**
@@ -7790,25 +7769,11 @@ interface HTMLMediaElement extends HTMLElement {
      * Returns a string that specifies whether the client can play a given media resource type.
      */
     canPlayType(type: string): CanPlayTypeResult;
+    fastSeek(time: number): void;
     /**
      * Resets the audio or video object and loads a new media resource.
      */
     load(): void;
-    /**
-     * Clears all effects from the media pipeline.
-     */
-    msClearEffects(): void;
-    msGetAsCastingSource(): any;
-    /**
-     * Inserts the specified audio effect into media pipeline.
-     */
-    msInsertAudioEffect(activatableClassId: string, effectRequired: boolean, config?: any): void;
-    /** @deprecated */
-    msSetMediaKeys(mediaKeys: MSMediaKeys): void;
-    /**
-     * Specifies the media protection manager for a given media pipeline.
-     */
-    msSetMediaProtectionManager(mediaProtectionManager?: any): void;
     /**
      * Pauses the current playback and sets paused to TRUE. This can be used to test whether the media is playing or paused. You can also use the pause or play events to tell whether the media is playing or not.
      */
@@ -9108,27 +9073,12 @@ declare var HTMLUnknownElement: {
     new(): HTMLUnknownElement;
 };
 
-interface HTMLVideoElementEventMap extends HTMLMediaElementEventMap {
-    "MSVideoFormatChanged": Event;
-    "MSVideoFrameStepCompleted": Event;
-    "MSVideoOptimalLayoutChanged": Event;
-}
-
 /** Provides special properties and methods for manipulating video objects. It also inherits properties and methods of HTMLMediaElement and HTMLElement. */
 interface HTMLVideoElement extends HTMLMediaElement {
     /**
      * Gets or sets the height of the video element.
      */
     height: number;
-    msHorizontalMirror: boolean;
-    readonly msIsLayoutOptimalForPlayback: boolean;
-    readonly msIsStereo3D: boolean;
-    msStereo3DPackingMode: string;
-    msStereo3DRenderMode: string;
-    msZoom: boolean;
-    onMSVideoFormatChanged: ((this: HTMLVideoElement, ev: Event) => any) | null;
-    onMSVideoFrameStepCompleted: ((this: HTMLVideoElement, ev: Event) => any) | null;
-    onMSVideoOptimalLayoutChanged: ((this: HTMLVideoElement, ev: Event) => any) | null;
     /**
      * Gets or sets a URL of an image to display, for example, like a movie poster. This can be a still frame from the video, or another image if no video data is available.
      */
@@ -9141,23 +9091,14 @@ interface HTMLVideoElement extends HTMLMediaElement {
      * Gets the intrinsic width of a video in CSS pixels, or zero if the dimensions are not known.
      */
     readonly videoWidth: number;
-    readonly webkitDisplayingFullscreen: boolean;
-    readonly webkitSupportsFullscreen: boolean;
     /**
      * Gets or sets the width of the video element.
      */
     width: number;
     getVideoPlaybackQuality(): VideoPlaybackQuality;
-    msFrameStep(forward: boolean): void;
-    msInsertVideoEffect(activatableClassId: string, effectRequired: boolean, config?: any): void;
-    msSetVideoRectangle(left: number, top: number, right: number, bottom: number): void;
-    webkitEnterFullScreen(): void;
-    webkitEnterFullscreen(): void;
-    webkitExitFullScreen(): void;
-    webkitExitFullscreen(): void;
-    addEventListener<K extends keyof HTMLVideoElementEventMap>(type: K, listener: (this: HTMLVideoElement, ev: HTMLVideoElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener<K extends keyof HTMLMediaElementEventMap>(type: K, listener: (this: HTMLVideoElement, ev: HTMLMediaElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
-    removeEventListener<K extends keyof HTMLVideoElementEventMap>(type: K, listener: (this: HTMLVideoElement, ev: HTMLVideoElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLMediaElementEventMap>(type: K, listener: (this: HTMLVideoElement, ev: HTMLMediaElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
 }
 
@@ -10290,12 +10231,10 @@ declare var MediaEncryptedEvent: {
 interface MediaError {
     readonly code: number;
     readonly message: string;
-    readonly msExtendedCode: number;
     readonly MEDIA_ERR_ABORTED: number;
     readonly MEDIA_ERR_DECODE: number;
     readonly MEDIA_ERR_NETWORK: number;
     readonly MEDIA_ERR_SRC_NOT_SUPPORTED: number;
-    readonly MS_MEDIA_ERR_ENCRYPTED: number;
 }
 
 declare var MediaError: {
@@ -10305,7 +10244,6 @@ declare var MediaError: {
     readonly MEDIA_ERR_DECODE: number;
     readonly MEDIA_ERR_NETWORK: number;
     readonly MEDIA_ERR_SRC_NOT_SUPPORTED: number;
-    readonly MS_MEDIA_ERR_ENCRYPTED: number;
 };
 
 /** This EncryptedMediaExtensions API interface contains the content and related data when the content decryption module generates a message for the session. */
@@ -15809,33 +15747,58 @@ declare var TextMetrics: {
 
 interface TextTrackEventMap {
     "cuechange": Event;
-    "error": Event;
-    "load": Event;
 }
 
 /** This interface also inherits properties from EventTarget. */
 interface TextTrack extends EventTarget {
-    readonly activeCues: TextTrackCueList;
-    readonly cues: TextTrackCueList;
+    /**
+     * Returns the text track cues from the text track list of cues that are currently active (i.e. that start before the current playback position and end after it), as a TextTrackCueList object.
+     */
+    readonly activeCues: TextTrackCueList | null;
+    /**
+     * Returns the text track list of cues, as a TextTrackCueList object.
+     */
+    readonly cues: TextTrackCueList | null;
+    /**
+     * Returns the ID of the given track.
+     * 
+     * For in-band tracks, this is the ID that can be used with a fragment if the format supports media fragment syntax, and that can be used with the getTrackById() method.
+     * 
+     * For TextTrack objects corresponding to track elements, this is the ID of the track element.
+     */
+    readonly id: string;
+    /**
+     * Returns the text track in-band metadata track dispatch type string.
+     */
     readonly inBandMetadataTrackDispatchType: string;
-    readonly kind: string;
+    /**
+     * Returns the text track kind string.
+     */
+    readonly kind: TextTrackKind;
+    /**
+     * Returns the text track label, if there is one, or the empty string otherwise (indicating that a custom label probably needs to be generated from the other attributes of the object if the object is exposed to the user).
+     */
     readonly label: string;
+    /**
+     * Returns the text track language string.
+     */
     readonly language: string;
-    mode: TextTrackMode | number;
+    /**
+     * Returns the text track mode, represented by a string from the following list:
+     * 
+     * Can be set, to change the mode.
+     */
+    mode: TextTrackMode;
     oncuechange: ((this: TextTrack, ev: Event) => any) | null;
-    onerror: ((this: TextTrack, ev: Event) => any) | null;
-    onload: ((this: TextTrack, ev: Event) => any) | null;
-    readonly readyState: number;
     readonly sourceBuffer: SourceBuffer | null;
+    /**
+     * Adds the given cue to textTrack's text track list of cues.
+     */
     addCue(cue: TextTrackCue): void;
+    /**
+     * Removes the given cue from textTrack's text track list of cues.
+     */
     removeCue(cue: TextTrackCue): void;
-    readonly DISABLED: number;
-    readonly ERROR: number;
-    readonly HIDDEN: number;
-    readonly LOADED: number;
-    readonly LOADING: number;
-    readonly NONE: number;
-    readonly SHOWING: number;
     addEventListener<K extends keyof TextTrackEventMap>(type: K, listener: (this: TextTrack, ev: TextTrackEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
     removeEventListener<K extends keyof TextTrackEventMap>(type: K, listener: (this: TextTrack, ev: TextTrackEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
@@ -15845,13 +15808,6 @@ interface TextTrack extends EventTarget {
 declare var TextTrack: {
     prototype: TextTrack;
     new(): TextTrack;
-    readonly DISABLED: number;
-    readonly ERROR: number;
-    readonly HIDDEN: number;
-    readonly LOADED: number;
-    readonly LOADING: number;
-    readonly NONE: number;
-    readonly SHOWING: number;
 };
 
 interface TextTrackCueEventMap {
@@ -15861,15 +15817,36 @@ interface TextTrackCueEventMap {
 
 /** TextTrackCues represent a string of text that will be displayed for some duration of time on a TextTrack. This includes the start and end times that the cue will be displayed. A TextTrackCue cannot be used directly, instead one of the derived types (e.g. VTTCue) must be used. */
 interface TextTrackCue extends EventTarget {
+    /**
+     * Returns the text track cue end time, in seconds.
+     * 
+     * Can be set.
+     */
     endTime: number;
+    /**
+     * Returns the text track cue identifier.
+     * 
+     * Can be set.
+     */
     id: string;
     onenter: ((this: TextTrackCue, ev: Event) => any) | null;
     onexit: ((this: TextTrackCue, ev: Event) => any) | null;
+    /**
+     * Returns true if the text track cue pause-on-exit flag is set, false otherwise.
+     * 
+     * Can be set.
+     */
     pauseOnExit: boolean;
+    /**
+     * Returns the text track cue start time, in seconds.
+     * 
+     * Can be set.
+     */
     startTime: number;
-    text: string;
-    readonly track: TextTrack;
-    getCueAsHTML(): DocumentFragment;
+    /**
+     * Returns the TextTrack object to which this text track cue belongs, if any, or null otherwise.
+     */
+    readonly track: TextTrack | null;
     addEventListener<K extends keyof TextTrackCueEventMap>(type: K, listener: (this: TextTrackCue, ev: TextTrackCueEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
     removeEventListener<K extends keyof TextTrackCueEventMap>(type: K, listener: (this: TextTrackCue, ev: TextTrackCueEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
@@ -15878,13 +15855,20 @@ interface TextTrackCue extends EventTarget {
 
 declare var TextTrackCue: {
     prototype: TextTrackCue;
-    new(startTime: number, endTime: number, text: string): TextTrackCue;
+    new(): TextTrackCue;
 };
 
 interface TextTrackCueList {
+    /**
+     * Returns the number of cues in the list.
+     */
     readonly length: number;
-    getCueById(id: string): TextTrackCue;
-    item(index: number): TextTrackCue;
+    /**
+     * Returns the first text track cue (in text track cue order) with text track cue identifier id.
+     * 
+     * Returns null if none of the cues have the given identifier or if the argument is the empty string.
+     */
+    getCueById(id: string): TextTrackCue | null;
     [index: number]: TextTrackCue;
 }
 
@@ -15895,12 +15879,16 @@ declare var TextTrackCueList: {
 
 interface TextTrackListEventMap {
     "addtrack": TrackEvent;
+    "change": Event;
+    "removetrack": TrackEvent;
 }
 
 interface TextTrackList extends EventTarget {
     readonly length: number;
     onaddtrack: ((this: TextTrackList, ev: TrackEvent) => any) | null;
-    item(index: number): TextTrack;
+    onchange: ((this: TextTrackList, ev: Event) => any) | null;
+    onremovetrack: ((this: TextTrackList, ev: TrackEvent) => any) | null;
+    getTrackById(id: string): TextTrack | null;
     addEventListener<K extends keyof TextTrackListEventMap>(type: K, listener: (this: TextTrackList, ev: TextTrackListEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
     removeEventListener<K extends keyof TextTrackListEventMap>(type: K, listener: (this: TextTrackList, ev: TextTrackListEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
@@ -15915,8 +15903,21 @@ declare var TextTrackList: {
 
 /** Used to represent a set of time ranges, primarily for the purpose of tracking which portions of media have been buffered when loading it for use by the <audio> and <video> elements. */
 interface TimeRanges {
+    /**
+     * Returns the number of ranges in the object.
+     */
     readonly length: number;
+    /**
+     * Returns the time for the end of the range with the given index.
+     * 
+     * Throws an "IndexSizeError" DOMException if the index is out of range.
+     */
     end(index: number): number;
+    /**
+     * Returns the time for the start of the range with the given index.
+     * 
+     * Throws an "IndexSizeError" DOMException if the index is out of range.
+     */
     start(index: number): number;
 }
 
@@ -15979,12 +15980,15 @@ declare var TouchList: {
 
 /** The TrackEvent interface, part of the HTML DOM specification, is used for events which represent changes to the set of available tracks on an HTML media element; these events are addtrack and removetrack. */
 interface TrackEvent extends Event {
+    /**
+     * Returns the track object (TextTrack, AudioTrack, or VideoTrack) to which the event relates.
+     */
     readonly track: VideoTrack | AudioTrack | TextTrack | null;
 }
 
 declare var TrackEvent: {
     prototype: TrackEvent;
-    new(typeArg: string, eventInitDict?: TrackEventInit): TrackEvent;
+    new(type: string, eventInitDict?: TrackEventInit): TrackEvent;
 };
 
 interface TransformStream<I = any, O = any> {
@@ -16285,10 +16289,8 @@ declare var ValidityState: {
 
 /** Returned by the HTMLVideoElement.getVideoPlaybackQuality() method and contains metrics that can be used to determine the playback quality of a video. */
 interface VideoPlaybackQuality {
-    readonly corruptedVideoFrames: number;
     readonly creationTime: number;
     readonly droppedVideoFrames: number;
-    readonly totalFrameDelay: number;
     readonly totalVideoFrames: number;
 }
 
@@ -16299,10 +16301,27 @@ declare var VideoPlaybackQuality: {
 
 /** A single video track from a <video> element. */
 interface VideoTrack {
+    /**
+     * Returns the ID of the given track. This is the ID that can be used with a fragment if the format supports media fragment syntax, and that can be used with the getTrackById() method.
+     */
     readonly id: string;
-    kind: string;
+    /**
+     * Returns the category the given track falls into. The possible track categories are given below.
+     */
+    readonly kind: string;
+    /**
+     * Returns the label of the given track, if known, or the empty string otherwise.
+     */
     readonly label: string;
-    language: string;
+    /**
+     * Returns the language of the given track, if known, or the empty string otherwise.
+     */
+    readonly language: string;
+    /**
+     * Returns true if the given track is active, and false otherwise.
+     * 
+     * Can be set, to change whether the track is selected or not. Either zero or one video track is selected; selecting a new track while a previous one is selected will unselect the previous one.
+     */
     selected: boolean;
     readonly sourceBuffer: SourceBuffer | null;
 }
@@ -16326,7 +16345,6 @@ interface VideoTrackList extends EventTarget {
     onremovetrack: ((this: VideoTrackList, ev: TrackEvent) => any) | null;
     readonly selectedIndex: number;
     getTrackById(id: string): VideoTrack | null;
-    item(index: number): VideoTrack;
     addEventListener<K extends keyof VideoTrackListEventMap>(type: K, listener: (this: VideoTrackList, ev: VideoTrackListEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
     removeEventListener<K extends keyof VideoTrackListEventMap>(type: K, listener: (this: VideoTrackList, ev: VideoTrackListEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
@@ -19983,6 +20001,7 @@ type OffscreenRenderingContext = OffscreenCanvasRenderingContext2D | ImageBitmap
 type MessageEventSource = WindowProxy | MessagePort | ServiceWorker;
 type HTMLOrSVGScriptElement = HTMLScriptElement | SVGScriptElement;
 type ImageBitmapSource = CanvasImageSource | Blob | ImageData;
+type MediaProvider = MediaStream | MediaSource | Blob;
 type OnErrorEventHandler = OnErrorEventHandlerNonNull | null;
 type OnBeforeUnloadEventHandler = OnBeforeUnloadEventHandlerNonNull | null;
 type TimerHandler = string | Function;
diff --git a/inputfiles/addedTypes.json b/inputfiles/addedTypes.json
index a6ce1c001..3dbc60596 100644
--- a/inputfiles/addedTypes.json
+++ b/inputfiles/addedTypes.json
@@ -162,6 +162,10 @@
                             "name": "mouseup",
                             "type": "MouseEvent"
                         },
+                        {
+                            "name": "pause",
+                            "type": "Event"
+                        },
                         {
                             "name": "scroll",
                             "type": "Event"
@@ -349,6 +353,24 @@
                     ]
                 }
             },
+            "AudioTrackList": {
+                "events": {
+                    "event": [
+                        {
+                            "name": "addtrack",
+                            "type": "TrackEvent"
+                        },
+                        {
+                            "name": "change",
+                            "type": "Event"
+                        },
+                        {
+                            "name": "removetrack",
+                            "type": "TrackEvent"
+                        }
+                    ]
+                }
+            },
             "DeviceMotionEventAcceleration": {
                 "no-interface-object": 1
             },
@@ -479,6 +501,16 @@
                     }
                 ]
             },
+            "HTMLMediaElement": {
+                "events": {
+                    "event": [
+                        {
+                            "name": "encrypted",
+                            "type": "MediaEncryptedEvent"
+                        }
+                    ]
+                }
+            },
             "CSSStyleDeclaration": {
                 "name": "CSSStyleDeclaration",
                 "properties": {
@@ -1184,6 +1216,20 @@
                     }
                 }
             },
+            "TextTrackList": {
+                "events": {
+                    "event": [
+                        {
+                            "name": "addtrack",
+                            "type": "TrackEvent"
+                        },
+                        {
+                            "name": "removetrack",
+                            "type": "TrackEvent"
+                        }
+                    ]
+                }
+            },
             "DOMMatrixReadOnly": {
                 "methods": {
                     "method": {
@@ -1231,6 +1277,13 @@
                     }
                 ]
             },
+            "HTMLAudioElement": {
+                "element": [
+                    {
+                        "name": "audio"
+                    }
+                ]
+            },
             "HTMLBaseElement": {
                 "element": [
                     {
@@ -1710,6 +1763,13 @@
                     }
                 ]
             },
+            "HTMLTrackElement": {
+                "element": [
+                    {
+                        "name": "track"
+                    }
+                ]
+            },
             "HTMLUListElement": {
                 "element": [
                     {
@@ -1717,6 +1777,13 @@
                     }
                 ]
             },
+            "HTMLVideoElement": {
+                "element": [
+                    {
+                        "name": "video"
+                    }
+                ]
+            },
             "HTMLDialogElement": {
                 "element": [
                     {
diff --git a/inputfiles/comments.json b/inputfiles/comments.json
index d4c94897c..8b1bc4333 100644
--- a/inputfiles/comments.json
+++ b/inputfiles/comments.json
@@ -1607,32 +1607,8 @@
                         "networkState": {
                             "comment": "/**\n * Gets the current network activity for the element.\n */"
                         },
-                        "msAudioCategory": {
-                            "comment": "/**\n * Specifies the purpose of the audio or video media, such as background audio or alerts.\n */"
-                        },
-                        "msRealTime": {
-                            "comment": "/**\n * Specifies whether or not to enable low-latency playback on the media element.\n */"
-                        },
-                        "msPlayToPrimary": {
-                            "comment": "/**\n * Gets or sets the primary DLNA PlayTo device.\n */"
-                        },
-                        "msPlayToDisabled": {
-                            "comment": "/**\n * Gets or sets whether the DLNA PlayTo device is available.\n */"
-                        },
                         "audioTracks": {
                             "comment": "/**\n * Returns an AudioTrackList object with the audio tracks for a given video element.\n */"
-                        },
-                        "msPlayToSource": {
-                            "comment": "/**\n * Gets the source associated with the media element for use by the PlayToManager.\n */"
-                        },
-                        "msAudioDeviceType": {
-                            "comment": "/**\n * Specifies the output device id that the audio will be sent to.\n */"
-                        },
-                        "msPlayToPreferredSourceUri": {
-                            "comment": "/**\n * Gets or sets the path to the preferred media source. This enables the Play To target device to stream the media content, which can be DRM protected, from a different location, such as a cloud media server.\n */"
-                        },
-                        "msKeys": {
-                            "comment": "/**\n * Gets the MSMediaKeys object, which is used for decrypting media data, that is associated with this media element.\n */"
                         }
                     }
                 },
@@ -1649,15 +1625,6 @@
                         },
                         "canPlayType": {
                             "comment": "/**\n * Returns a string that specifies whether the client can play a given media resource type.\n */"
-                        },
-                        "msClearEffects": {
-                            "comment": "/**\n * Clears all effects from the media pipeline.\n */"
-                        },
-                        "msSetMediaProtectionManager": {
-                            "comment": "/**\n * Specifies the media protection manager for a given media pipeline.\n */"
-                        },
-                        "msInsertAudioEffect": {
-                            "comment": "/**\n * Inserts the specified audio effect into media pipeline.\n */"
                         }
                     }
                 }
diff --git a/inputfiles/idl/HTML - Media.commentmap.json b/inputfiles/idl/HTML - Media.commentmap.json
new file mode 100644
index 000000000..7058bf8d2
--- /dev/null
+++ b/inputfiles/idl/HTML - Media.commentmap.json	
@@ -0,0 +1,71 @@
+{
+    "video-videowidth": "These attributes return the intrinsic dimensions of the video, or zero if the dimensions are not known.",
+    "video-videoheight": "These attributes return the intrinsic dimensions of the video, or zero if the dimensions are not known.",
+    "audio": "Returns a new audio element, with the src attribute set to the value passed in the argument, if applicable.",
+    "track-readystate": "Returns the text track readiness state, represented by a number from the following list:",
+    "track-track": "Returns the TextTrack object corresponding to the text track of the track element.",
+    "media-error": "Returns a MediaError object representing the current error state of the element.\n\nReturns null if there is no error.",
+    "media-srcobject": "Allows the media element to be assigned a media provider object.",
+    "media-currentsrc": "Returns the URL of the current media resource, if any.\n\nReturns the empty string when there is no media resource, or it doesn't have a URL.",
+    "navigator-canplaytype": "Returns the empty string (a negative response), \"maybe\", or \"probably\" based on how confident the user agent is that it can play media resources of the given type.",
+    "media-networkstate": "Returns the current state of network activity for the element, from the codes in the list below.",
+    "media-load": "Causes the element to reset and start selecting and loading a new media resource from scratch.",
+    "media-buffered": "Returns a TimeRanges object that represents the ranges of the media resource that the user agent has buffered.",
+    "media-duration": "Returns the length of the media resource, in seconds, assuming that the start of the media resource is at time zero.\n\nReturns NaN if the duration isn't available.\n\nReturns Infinity for unbounded streams.",
+    "media-currenttime": "Returns the official playback position, in seconds.\n\nCan be set, to seek to the given time.",
+    "media-readystate": "Returns a value that expresses the current state of the element with respect to rendering the current playback position, from the codes in the list below.",
+    "media-paused": "Returns true if playback is paused; false otherwise.",
+    "media-ended": "Returns true if playback has reached the end of the media resource.",
+    "media-defaultplaybackrate": "Returns the default rate of playback, for when the user is not fast-forwarding or reversing through the media resource.\n\nCan be set, to change the default rate of playback.\n\nThe default rate has no direct effect on playback, but if the user switches to a fast-forward mode, when they return to the normal playback mode, it is expected that the rate of playback will be returned to the default rate of playback.",
+    "media-playbackrate": "Returns the current rate playback, where 1.0 is normal speed.\n\nCan be set, to change the rate of playback.",
+    "media-played": "Returns a TimeRanges object that represents the ranges of the media resource that the user agent has played.",
+    "media-play": "Sets the paused attribute to false, loading the media resource and beginning playback if necessary. If the playback had ended, will restart it from the start.",
+    "media-pause": "Sets the paused attribute to true, loading the media resource if necessary.",
+    "media-seeking": "Returns true if the user agent is currently seeking.",
+    "media-seekable": "Returns a TimeRanges object that represents the ranges of the media resource to which it is possible for the user agent to seek.",
+    "media-fastseek": "Seeks to near the given time as fast as possible, trading precision for speed. (To seek to a precise time, use the currentTime attribute.)\n\nThis does nothing if the media resource has not been loaded.",
+    "media-audiotracks": "Returns an AudioTrackList object representing the audio tracks available in the media resource.",
+    "media-videotracks": "Returns a VideoTrackList object representing the video tracks available in the media resource.",
+    "audiotrack-id": "Returns the ID of the given track. This is the ID that can be used with a fragment if the format supports media fragment syntax, and that can be used with the getTrackById() method.",
+    "videotrack-id": "Returns the ID of the given track. This is the ID that can be used with a fragment if the format supports media fragment syntax, and that can be used with the getTrackById() method.",
+    "audiotrack-kind": "Returns the category the given track falls into. The possible track categories are given below.",
+    "videotrack-kind": "Returns the category the given track falls into. The possible track categories are given below.",
+    "audiotrack-label": "Returns the label of the given track, if known, or the empty string otherwise.",
+    "videotrack-label": "Returns the label of the given track, if known, or the empty string otherwise.",
+    "audiotrack-language": "Returns the language of the given track, if known, or the empty string otherwise.",
+    "videotrack-language": "Returns the language of the given track, if known, or the empty string otherwise.",
+    "audiotrack-enabled": "Returns true if the given track is active, and false otherwise.\n\nCan be set, to change whether the track is enabled or not. If multiple audio tracks are enabled simultaneously, they are mixed.",
+    "videotrack-selected": "Returns true if the given track is active, and false otherwise.\n\nCan be set, to change whether the track is selected or not. Either zero or one video track is selected; selecting a new track while a previous one is selected will unselect the previous one.",
+    "media-texttracks": "Returns the number of text tracks associated with the media element (e.g. from track elements). This is the number of text tracks in the media element's list of text tracks.",
+    "media-addtexttrack": "Creates and returns a new TextTrack object, which is also added to the media element's list of text tracks.",
+    "texttrack-kind": "Returns the text track kind string.",
+    "texttrack-label": "Returns the text track label, if there is one, or the empty string otherwise (indicating that a custom label probably needs to be generated from the other attributes of the object if the object is exposed to the user).",
+    "texttrack-language": "Returns the text track language string.",
+    "texttrack-id": "Returns the ID of the given track.\n\nFor in-band tracks, this is the ID that can be used with a fragment if the format supports media fragment syntax, and that can be used with the getTrackById() method.\n\nFor TextTrack objects corresponding to track elements, this is the ID of the track element.",
+    "texttrack-inbandmetadatatrackdispatchtype": "Returns the text track in-band metadata track dispatch type string.",
+    "texttrack-mode": "Returns the text track mode, represented by a string from the following list:\n\nCan be set, to change the mode.",
+    "texttrack-cues": "Returns the text track list of cues, as a TextTrackCueList object.",
+    "texttrack-activecues": "Returns the text track cues from the text track list of cues that are currently active (i.e. that start before the current playback position and end after it), as a TextTrackCueList object.",
+    "texttrack-addcue": "Adds the given cue to textTrack's text track list of cues.",
+    "texttrack-removecue": "Removes the given cue from textTrack's text track list of cues.",
+    "texttrackcuelist-length": "Returns the number of cues in the list.",
+    "texttrackcuelist-getcuebyid": "Returns the first text track cue (in text track cue order) with text track cue identifier id.\n\nReturns null if none of the cues have the given identifier or if the argument is the empty string.",
+    "texttrackcue-track": "Returns the TextTrack object to which this text track cue belongs, if any, or null otherwise.",
+    "texttrackcue-id": "Returns the text track cue identifier.\n\nCan be set.",
+    "texttrackcue-starttime": "Returns the text track cue start time, in seconds.\n\nCan be set.",
+    "texttrackcue-endtime": "Returns the text track cue end time, in seconds.\n\nCan be set.",
+    "texttrackcue-pauseonexit": "Returns true if the text track cue pause-on-exit flag is set, false otherwise.\n\nCan be set.",
+    "media-volume": "Returns the current playback volume, as a number in the range 0.0 to 1.0, where 0.0 is the quietest and 1.0 the loudest.\n\nCan be set, to change the volume.\n\nThrows an \"IndexSizeError\" DOMException if the new value is not in the range 0.0 .. 1.0.",
+    "media-muted": "Returns true if audio is muted, overriding the volume attribute, and false if the volume attribute is being honored.\n\nCan be set, to change whether the audio is muted or not.",
+    "timeranges-length": "Returns the number of ranges in the object.",
+    "timeranges-start": "Returns the time for the start of the range with the given index.\n\nThrows an \"IndexSizeError\" DOMException if the index is out of range.",
+    "timeranges-end": "Returns the time for the end of the range with the given index.\n\nThrows an \"IndexSizeError\" DOMException if the index is out of range.",
+    "trackevent-track": "Returns the track object (TextTrack, AudioTrack, or VideoTrack) to which the event relates.",
+    "track-none": "The text track not loaded state.",
+    "track-loading": "The text track loading state.",
+    "track-loaded": "The text track loaded state.",
+    "track-error": "The text track failed to load state.",
+    "texttrack-disabled": "The text track disabled mode.",
+    "texttrack-hidden": "The text track hidden mode.",
+    "texttrack-showing": "The text track showing mode."
+}
diff --git a/inputfiles/idl/HTML - Media.widl b/inputfiles/idl/HTML - Media.widl
new file mode 100644
index 000000000..f6adfaf3b
--- /dev/null
+++ b/inputfiles/idl/HTML - Media.widl	
@@ -0,0 +1,221 @@
+[Exposed=Window]
+interface HTMLVideoElement : HTMLMediaElement {
+  [HTMLConstructor] constructor();
+
+  [CEReactions] attribute unsigned long width;
+  [CEReactions] attribute unsigned long height;
+  readonly attribute unsigned long videoWidth;
+  readonly attribute unsigned long videoHeight;
+  [CEReactions] attribute USVString poster;
+  [CEReactions] attribute boolean playsInline;
+};
+
+[Exposed=Window,
+ NamedConstructor=Audio(optional DOMString src)]
+interface HTMLAudioElement : HTMLMediaElement {
+  [HTMLConstructor] constructor();
+};
+
+[Exposed=Window]
+interface HTMLTrackElement : HTMLElement {
+  [HTMLConstructor] constructor();
+
+  [CEReactions] attribute DOMString kind;
+  [CEReactions] attribute USVString src;
+  [CEReactions] attribute DOMString srclang;
+  [CEReactions] attribute DOMString label;
+  [CEReactions] attribute boolean default;
+
+  const unsigned short NONE = 0;
+  const unsigned short LOADING = 1;
+  const unsigned short LOADED = 2;
+  const unsigned short ERROR = 3;
+  readonly attribute unsigned short readyState;
+
+  readonly attribute TextTrack track;
+};
+
+enum CanPlayTypeResult { "" /* empty string */, "maybe", "probably" };
+typedef (MediaStream or MediaSource or Blob) MediaProvider;
+
+[Exposed=Window]
+interface HTMLMediaElement : HTMLElement {
+
+  // error state
+  readonly attribute MediaError? error;
+
+  // network state
+  [CEReactions] attribute USVString src;
+  attribute MediaProvider? srcObject;
+  readonly attribute USVString currentSrc;
+  [CEReactions] attribute DOMString? crossOrigin;
+  const unsigned short NETWORK_EMPTY = 0;
+  const unsigned short NETWORK_IDLE = 1;
+  const unsigned short NETWORK_LOADING = 2;
+  const unsigned short NETWORK_NO_SOURCE = 3;
+  readonly attribute unsigned short networkState;
+  [CEReactions] attribute DOMString preload;
+  readonly attribute TimeRanges buffered;
+  void load();
+  CanPlayTypeResult canPlayType(DOMString type);
+
+  // ready state
+  const unsigned short HAVE_NOTHING = 0;
+  const unsigned short HAVE_METADATA = 1;
+  const unsigned short HAVE_CURRENT_DATA = 2;
+  const unsigned short HAVE_FUTURE_DATA = 3;
+  const unsigned short HAVE_ENOUGH_DATA = 4;
+  readonly attribute unsigned short readyState;
+  readonly attribute boolean seeking;
+
+  // playback state
+  attribute double currentTime;
+  void fastSeek(double time);
+  readonly attribute unrestricted double duration;
+  object getStartDate();
+  readonly attribute boolean paused;
+  attribute double defaultPlaybackRate;
+  attribute double playbackRate;
+  readonly attribute TimeRanges played;
+  readonly attribute TimeRanges seekable;
+  readonly attribute boolean ended;
+  [CEReactions] attribute boolean autoplay;
+  [CEReactions] attribute boolean loop;
+  Promise<void> play();
+  void pause();
+
+  // controls
+  [CEReactions] attribute boolean controls;
+  attribute double volume;
+  attribute boolean muted;
+  [CEReactions] attribute boolean defaultMuted;
+
+  // tracks
+  [SameObject] readonly attribute AudioTrackList audioTracks;
+  [SameObject] readonly attribute VideoTrackList videoTracks;
+  [SameObject] readonly attribute TextTrackList textTracks;
+  TextTrack addTextTrack(TextTrackKind kind, optional DOMString label = "", optional DOMString language = "");
+};
+
+[Exposed=Window]
+interface MediaError {
+  const unsigned short MEDIA_ERR_ABORTED = 1;
+  const unsigned short MEDIA_ERR_NETWORK = 2;
+  const unsigned short MEDIA_ERR_DECODE = 3;
+  const unsigned short MEDIA_ERR_SRC_NOT_SUPPORTED = 4;
+
+  readonly attribute unsigned short code;
+  readonly attribute DOMString message;
+};
+
+[Exposed=Window]
+interface AudioTrackList : EventTarget {
+  readonly attribute unsigned long length;
+  getter AudioTrack (unsigned long index);
+  AudioTrack? getTrackById(DOMString id);
+
+  attribute EventHandler onchange;
+  attribute EventHandler onaddtrack;
+  attribute EventHandler onremovetrack;
+};
+
+[Exposed=Window]
+interface AudioTrack {
+  readonly attribute DOMString id;
+  readonly attribute DOMString kind;
+  readonly attribute DOMString label;
+  readonly attribute DOMString language;
+  attribute boolean enabled;
+};
+
+[Exposed=Window]
+interface VideoTrackList : EventTarget {
+  readonly attribute unsigned long length;
+  getter VideoTrack (unsigned long index);
+  VideoTrack? getTrackById(DOMString id);
+  readonly attribute long selectedIndex;
+
+  attribute EventHandler onchange;
+  attribute EventHandler onaddtrack;
+  attribute EventHandler onremovetrack;
+};
+
+[Exposed=Window]
+interface VideoTrack {
+  readonly attribute DOMString id;
+  readonly attribute DOMString kind;
+  readonly attribute DOMString label;
+  readonly attribute DOMString language;
+  attribute boolean selected;
+};
+
+[Exposed=Window]
+interface TextTrackList : EventTarget {
+  readonly attribute unsigned long length;
+  getter TextTrack (unsigned long index);
+  TextTrack? getTrackById(DOMString id);
+
+  attribute EventHandler onchange;
+  attribute EventHandler onaddtrack;
+  attribute EventHandler onremovetrack;
+};
+
+enum TextTrackMode { "disabled",  "hidden",  "showing" };
+enum TextTrackKind { "subtitles",  "captions",  "descriptions",  "chapters",  "metadata" };
+
+[Exposed=Window]
+interface TextTrack : EventTarget {
+  readonly attribute TextTrackKind kind;
+  readonly attribute DOMString label;
+  readonly attribute DOMString language;
+
+  readonly attribute DOMString id;
+  readonly attribute DOMString inBandMetadataTrackDispatchType;
+
+  attribute TextTrackMode mode;
+
+  readonly attribute TextTrackCueList? cues;
+  readonly attribute TextTrackCueList? activeCues;
+
+  void addCue(TextTrackCue cue);
+  void removeCue(TextTrackCue cue);
+
+  attribute EventHandler oncuechange;
+};
+
+[Exposed=Window]
+interface TextTrackCueList {
+  readonly attribute unsigned long length;
+  getter TextTrackCue (unsigned long index);
+  TextTrackCue? getCueById(DOMString id);
+};
+
+[Exposed=Window]
+interface TextTrackCue : EventTarget {
+  readonly attribute TextTrack? track;
+
+  attribute DOMString id;
+  attribute double startTime;
+  attribute double endTime;
+  attribute boolean pauseOnExit;
+
+  attribute EventHandler onenter;
+  attribute EventHandler onexit;
+};
+
+[Exposed=Window]
+interface TimeRanges {
+  readonly attribute unsigned long length;
+  double start(unsigned long index);
+  double end(unsigned long index);
+};
+
+[Exposed=Window,
+ Constructor(DOMString type, optional TrackEventInit eventInitDict = {})]
+interface TrackEvent : Event {
+  readonly attribute (VideoTrack or AudioTrack or TextTrack)? track;
+};
+
+dictionary TrackEventInit : EventInit {
+  (VideoTrack or AudioTrack or TextTrack)? track = null;
+};
diff --git a/inputfiles/idl/Media Playback Quality.widl b/inputfiles/idl/Media Playback Quality.widl
new file mode 100644
index 000000000..529883cd9
--- /dev/null
+++ b/inputfiles/idl/Media Playback Quality.widl	
@@ -0,0 +1,10 @@
+partial interface HTMLVideoElement {
+  VideoPlaybackQuality getVideoPlaybackQuality();
+};
+
+[Exposed=Window]
+interface VideoPlaybackQuality {
+  readonly attribute DOMHighResTimeStamp creationTime;
+  readonly attribute unsigned long droppedVideoFrames;
+  readonly attribute unsigned long totalVideoFrames;
+};
diff --git a/inputfiles/idlSources.json b/inputfiles/idlSources.json
index 3eee3c5fe..1563f3191 100644
--- a/inputfiles/idlSources.json
+++ b/inputfiles/idlSources.json
@@ -276,6 +276,10 @@
         "url": "https://html.spec.whatwg.org/multipage/links.html",
         "title": "HTML - Links"
     },
+    {
+        "url": "https://html.spec.whatwg.org/multipage/media.html",
+        "title": "HTML - Media"
+    },
     {
         "url": "https://html.spec.whatwg.org/multipage/obsolete.html",
         "title": "HTML - Obsolete features",
@@ -350,6 +354,10 @@
         "url": "https://w3c.github.io/mediacapture-main/",
         "title": "Media Capture and Streams"
     },
+    {
+        "url": "https://w3c.github.io/media-playback-quality/",
+        "title": "Media Playback Quality"
+    },
     {
         "url": "https://www.w3.org/TR/media-source/",
         "title": "Media Source Extensions"
diff --git a/inputfiles/overridingTypes.json b/inputfiles/overridingTypes.json
index c9ff3e691..9cf43cd8b 100644
--- a/inputfiles/overridingTypes.json
+++ b/inputfiles/overridingTypes.json
@@ -1233,27 +1233,6 @@
                     }
                 }
             },
-            "HTMLMediaElement": {
-                "name": "HTMLMediaElement",
-                "properties": {
-                    "property": {
-                        "readyState": {
-                            "name": "readyState",
-                            "override-type": "number"
-                        }
-                    }
-                },
-                "methods": {
-                    "method": {
-                        "play": {
-                            "name": "play",
-                            "override-signatures": [
-                                "play(): Promise<void>"
-                            ]
-                        }
-                    }
-                }
-            },
             "DataTransferItemList": {
                 "name": "DataTransferItemList",
                 "methods": {
diff --git a/inputfiles/removedTypes.json b/inputfiles/removedTypes.json
index 03dfd953b..68c0a08ce 100644
--- a/inputfiles/removedTypes.json
+++ b/inputfiles/removedTypes.json
@@ -165,6 +165,20 @@
                     }
                 }
             },
+            "HTMLMediaElement": {
+                "methods": {
+                    "method": {
+                        "getStartDate": null
+                    }
+                }
+            },
+            "HTMLVideoElement": {
+                "properties": {
+                    "property": {
+                        "playsInline": null
+                    }
+                }
+            },
             "MessageEvent": {
                 "methods": {
                     "method": {
diff --git a/package.json b/package.json
index 91644cd0d..909af7e14 100644
--- a/package.json
+++ b/package.json
@@ -2,12 +2,12 @@
   "name": "tsjs-lib-generator",
   "private": true,
   "scripts": {
-    "build": "tsc --p ./tsconfig.json && node ./lib/index.js",
-    "fetch-idl": "tsc --p ./tsconfig.json && node ./lib/idlfetcher.js",
+    "build": "tsc -p ./tsconfig.json && node ./lib/index.js",
+    "fetch-idl": "tsc -p ./tsconfig.json && node ./lib/idlfetcher.js",
     "fetch-mdn": "npm run build && node ./lib/mdnfetcher.js",
     "fetch": "echo This could take a few minutes... && npm run fetch-idl && npm run fetch-mdn",
     "baseline-accept": "cpx \"generated\\*\" baselines\\",
-    "test": "tsc --p ./tsconfig.json && node ./lib/index.js && node ./lib/test.js"
+    "test": "tsc -p ./tsconfig.json && node ./lib/index.js && node ./lib/test.js"
   },
   "dependencies": {
     "@types/jsdom": "^11.12.0",

From 23e2ab4c70a3a2b400ba6a6543570ae859d57db4 Mon Sep 17 00:00:00 2001
From: Kagami Sascha Rosylight <saschanaz@outlook.com>
Date: Wed, 1 Jan 2020 18:25:45 +0900
Subject: [PATCH 2/3] fix addtrack event interface

---
 baselines/dom.generated.d.ts |  8 ++++----
 inputfiles/addedTypes.json   | 22 +++++-----------------
 2 files changed, 9 insertions(+), 21 deletions(-)

diff --git a/baselines/dom.generated.d.ts b/baselines/dom.generated.d.ts
index 36b830444..32a4c8a50 100644
--- a/baselines/dom.generated.d.ts
+++ b/baselines/dom.generated.d.ts
@@ -15867,14 +15867,14 @@ declare var TextTrackCueList: {
 };
 
 interface TextTrackListEventMap {
-    "addtrack": MediaStreamTrackEvent;
+    "addtrack": TrackEvent;
     "change": Event;
     "removetrack": TrackEvent;
 }
 
 interface TextTrackList extends EventTarget {
     readonly length: number;
-    onaddtrack: ((this: TextTrackList, ev: MediaStreamTrackEvent) => any) | null;
+    onaddtrack: ((this: TextTrackList, ev: TrackEvent) => any) | null;
     onchange: ((this: TextTrackList, ev: Event) => any) | null;
     onremovetrack: ((this: TextTrackList, ev: TrackEvent) => any) | null;
     getTrackById(id: string): TextTrack | null;
@@ -16324,7 +16324,7 @@ declare var VideoTrack: {
 };
 
 interface VideoTrackListEventMap {
-    "addtrack": MediaStreamTrackEvent;
+    "addtrack": TrackEvent;
     "change": Event;
     "removetrack": TrackEvent;
 }
@@ -16332,7 +16332,7 @@ interface VideoTrackListEventMap {
 /** Used to represent a list of the video tracks contained within a <video> element, with each track represented by a separate VideoTrack object in the list. */
 interface VideoTrackList extends EventTarget {
     readonly length: number;
-    onaddtrack: ((this: VideoTrackList, ev: MediaStreamTrackEvent) => any) | null;
+    onaddtrack: ((this: VideoTrackList, ev: TrackEvent) => any) | null;
     onchange: ((this: VideoTrackList, ev: Event) => any) | null;
     onremovetrack: ((this: VideoTrackList, ev: TrackEvent) => any) | null;
     readonly selectedIndex: number;
diff --git a/inputfiles/addedTypes.json b/inputfiles/addedTypes.json
index 5ae02d4fc..b22ad9016 100644
--- a/inputfiles/addedTypes.json
+++ b/inputfiles/addedTypes.json
@@ -2241,25 +2241,13 @@
                     }
                 }
             },
-            "TextTrackList": {
-                "properties": {
-                    "property": {
-                        "onchange": {
-                            "name": "onchange",
-                            "type": "EventHandler",
-                            "event-handler": "change",
-                            "nullable": 1
-                        },
-                        "onremovetrack": {
-                            "name": "onremovetrack",
-                            "type": "EventHandler",
-                            "event-handler": "removetrack",
-                            "nullable": 1
-                        }
-                    }
-                },
+            "VideoTrackList": {
                 "events": {
                     "event": [
+                        {
+                            "name": "addtrack",
+                            "type": "TrackEvent"
+                        },
                         {
                             "name": "change",
                             "type": "Event"

From efd135be6067023eed13fa5f416d654f4c259af2 Mon Sep 17 00:00:00 2001
From: Kagami Sascha Rosylight <saschanaz@outlook.com>
Date: Wed, 4 Mar 2020 20:03:32 +0100
Subject: [PATCH 3/3] remove *Track[List]

---
 baselines/dom.generated.d.ts          | 127 +-------------------------
 baselines/dom.iterable.generated.d.ts |   8 --
 inputfiles/addedTypes.json            |  44 ++-------
 inputfiles/comments.json              |   3 -
 inputfiles/removedTypes.json          |  17 ++++
 5 files changed, 28 insertions(+), 171 deletions(-)

diff --git a/baselines/dom.generated.d.ts b/baselines/dom.generated.d.ts
index 2bd9da245..9ad6a483c 100644
--- a/baselines/dom.generated.d.ts
+++ b/baselines/dom.generated.d.ts
@@ -1773,7 +1773,7 @@ interface TouchInit {
 }
 
 interface TrackEventInit extends EventInit {
-    track?: VideoTrack | AudioTrack | TextTrack | null;
+    track?: TextTrack | null;
 }
 
 interface Transformer<I = any, O = any> {
@@ -2343,63 +2343,6 @@ declare var AudioScheduledSourceNode: {
     new(): AudioScheduledSourceNode;
 };
 
-/** A single audio track from one of the HTML media elements, <audio> or <video>.  */
-interface AudioTrack {
-    /**
-     * Returns true if the given track is active, and false otherwise.
-     * 
-     * Can be set, to change whether the track is enabled or not. If multiple audio tracks are enabled simultaneously, they are mixed.
-     */
-    enabled: boolean;
-    /**
-     * Returns the ID of the given track. This is the ID that can be used with a fragment if the format supports media fragment syntax, and that can be used with the getTrackById() method.
-     */
-    readonly id: string;
-    /**
-     * Returns the category the given track falls into. The possible track categories are given below.
-     */
-    readonly kind: string;
-    /**
-     * Returns the label of the given track, if known, or the empty string otherwise.
-     */
-    readonly label: string;
-    /**
-     * Returns the language of the given track, if known, or the empty string otherwise.
-     */
-    readonly language: string;
-    readonly sourceBuffer: SourceBuffer | null;
-}
-
-declare var AudioTrack: {
-    prototype: AudioTrack;
-    new(): AudioTrack;
-};
-
-interface AudioTrackListEventMap {
-    "addtrack": TrackEvent;
-    "change": Event;
-    "removetrack": TrackEvent;
-}
-
-/** Used to represent a list of the audio tracks contained within a given HTML media element, with each track represented by a separate AudioTrack object in the list. */
-interface AudioTrackList extends EventTarget {
-    readonly length: number;
-    onaddtrack: ((this: AudioTrackList, ev: TrackEvent) => any) | null;
-    onchange: ((this: AudioTrackList, ev: Event) => any) | null;
-    onremovetrack: ((this: AudioTrackList, ev: TrackEvent) => any) | null;
-    getTrackById(id: string): AudioTrack | null;
-    addEventListener<K extends keyof AudioTrackListEventMap>(type: K, listener: (this: AudioTrackList, ev: AudioTrackListEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
-    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
-    removeEventListener<K extends keyof AudioTrackListEventMap>(type: K, listener: (this: AudioTrackList, ev: AudioTrackListEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
-    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
-    [index: number]: AudioTrack;
-}
-
-declare var AudioTrackList: {
-    prototype: AudioTrackList;
-    new(): AudioTrackList;
-};
-
 interface AudioWorklet extends Worklet {
 }
 
@@ -7696,10 +7639,6 @@ interface HTMLMediaElementEventMap extends HTMLElementEventMap {
 
 /** Adds to HTMLElement the properties and methods needed to support basic media-related capabilities that are common to audio and video. */
 interface HTMLMediaElement extends HTMLElement {
-    /**
-     * Returns an AudioTrackList object with the audio tracks for a given video element.
-     */
-    readonly audioTracks: AudioTrackList;
     /**
      * Gets or sets a value that indicates whether to start playing the media automatically.
      */
@@ -7784,7 +7723,6 @@ interface HTMLMediaElement extends HTMLElement {
     src: string;
     srcObject: MediaProvider | null;
     readonly textTracks: TextTrackList;
-    readonly videoTracks: VideoTrackList;
     /**
      * Gets or sets the volume level for audio portions of the media element.
      */
@@ -15149,7 +15087,6 @@ interface SourceBufferEventMap {
 interface SourceBuffer extends EventTarget {
     appendWindowEnd: number;
     appendWindowStart: number;
-    readonly audioTracks: AudioTrackList;
     readonly buffered: TimeRanges;
     mode: AppendMode;
     onabort: ((this: SourceBuffer, ev: Event) => any) | null;
@@ -15157,10 +15094,8 @@ interface SourceBuffer extends EventTarget {
     onupdate: ((this: SourceBuffer, ev: Event) => any) | null;
     onupdateend: ((this: SourceBuffer, ev: Event) => any) | null;
     onupdatestart: ((this: SourceBuffer, ev: Event) => any) | null;
-    readonly textTracks: TextTrackList;
     timestampOffset: number;
     readonly updating: boolean;
-    readonly videoTracks: VideoTrackList;
     abort(): void;
     appendBuffer(data: BufferSource): void;
     remove(start: number, end: number): void;
@@ -16002,7 +15937,7 @@ interface TrackEvent extends Event {
     /**
      * Returns the track object (TextTrack, AudioTrack, or VideoTrack) to which the event relates.
      */
-    readonly track: VideoTrack | AudioTrack | TextTrack | null;
+    readonly track: TextTrack | null;
 }
 
 declare var TrackEvent: {
@@ -16321,64 +16256,6 @@ declare var VideoPlaybackQuality: {
     new(): VideoPlaybackQuality;
 };
 
-/** A single video track from a <video> element. */
-interface VideoTrack {
-    /**
-     * Returns the ID of the given track. This is the ID that can be used with a fragment if the format supports media fragment syntax, and that can be used with the getTrackById() method.
-     */
-    readonly id: string;
-    /**
-     * Returns the category the given track falls into. The possible track categories are given below.
-     */
-    readonly kind: string;
-    /**
-     * Returns the label of the given track, if known, or the empty string otherwise.
-     */
-    readonly label: string;
-    /**
-     * Returns the language of the given track, if known, or the empty string otherwise.
-     */
-    readonly language: string;
-    /**
-     * Returns true if the given track is active, and false otherwise.
-     * 
-     * Can be set, to change whether the track is selected or not. Either zero or one video track is selected; selecting a new track while a previous one is selected will unselect the previous one.
-     */
-    selected: boolean;
-    readonly sourceBuffer: SourceBuffer | null;
-}
-
-declare var VideoTrack: {
-    prototype: VideoTrack;
-    new(): VideoTrack;
-};
-
-interface VideoTrackListEventMap {
-    "addtrack": TrackEvent;
-    "change": Event;
-    "removetrack": TrackEvent;
-}
-
-/** Used to represent a list of the video tracks contained within a <video> element, with each track represented by a separate VideoTrack object in the list. */
-interface VideoTrackList extends EventTarget {
-    readonly length: number;
-    onaddtrack: ((this: VideoTrackList, ev: TrackEvent) => any) | null;
-    onchange: ((this: VideoTrackList, ev: Event) => any) | null;
-    onremovetrack: ((this: VideoTrackList, ev: TrackEvent) => any) | null;
-    readonly selectedIndex: number;
-    getTrackById(id: string): VideoTrack | null;
-    addEventListener<K extends keyof VideoTrackListEventMap>(type: K, listener: (this: VideoTrackList, ev: VideoTrackListEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
-    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
-    removeEventListener<K extends keyof VideoTrackListEventMap>(type: K, listener: (this: VideoTrackList, ev: VideoTrackListEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
-    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
-    [index: number]: VideoTrack;
-}
-
-declare var VideoTrackList: {
-    prototype: VideoTrackList;
-    new(): VideoTrackList;
-};
-
 interface WEBGL_color_buffer_float {
     readonly FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE_EXT: GLenum;
     readonly RGBA32F_EXT: GLenum;
diff --git a/baselines/dom.iterable.generated.d.ts b/baselines/dom.iterable.generated.d.ts
index 13a22e5aa..13e5c6462 100644
--- a/baselines/dom.iterable.generated.d.ts
+++ b/baselines/dom.iterable.generated.d.ts
@@ -9,10 +9,6 @@ interface AudioParam {
 interface AudioParamMap extends ReadonlyMap<string, AudioParam> {
 }
 
-interface AudioTrackList {
-    [Symbol.iterator](): IterableIterator<AudioTrack>;
-}
-
 interface BaseAudioContext {
     createIIRFilter(feedforward: Iterable<number>, feedback: Iterable<number>): IIRFilterNode;
     createPeriodicWave(real: Iterable<number>, imag: Iterable<number>, constraints?: PeriodicWaveConstraints): PeriodicWave;
@@ -260,10 +256,6 @@ interface VRDisplay {
     requestPresent(layers: Iterable<VRLayer>): Promise<void>;
 }
 
-interface VideoTrackList {
-    [Symbol.iterator](): IterableIterator<VideoTrack>;
-}
-
 interface WEBGL_draw_buffers {
     drawBuffersWEBGL(buffers: Iterable<GLenum>): void;
 }
diff --git a/inputfiles/addedTypes.json b/inputfiles/addedTypes.json
index 2dd0b2c4f..4f660b131 100644
--- a/inputfiles/addedTypes.json
+++ b/inputfiles/addedTypes.json
@@ -94,6 +94,10 @@
                             "name": "cancel",
                             "type": "Event"
                         },
+                        {
+                            "name": "change",
+                            "type": "Event"
+                        },
                         {
                             "name": "drag",
                             "type": "DragEvent"
@@ -245,6 +249,9 @@
     },
     "interfaces": {
         "interface": {
+            "AudioTrack": {
+                "exposed": ""
+            },
             "SVGSVGElement": {
                 "name": "SVGSVGElement",
                 "methods": {
@@ -350,24 +357,6 @@
                     ]
                 }
             },
-            "AudioTrackList": {
-                "events": {
-                    "event": [
-                        {
-                            "name": "addtrack",
-                            "type": "TrackEvent"
-                        },
-                        {
-                            "name": "change",
-                            "type": "Event"
-                        },
-                        {
-                            "name": "removetrack",
-                            "type": "TrackEvent"
-                        }
-                    ]
-                }
-            },
             "DeviceMotionEventAcceleration": {
                 "no-interface-object": 1
             },
@@ -2270,23 +2259,8 @@
                     }
                 }
             },
-            "VideoTrackList": {
-                "events": {
-                    "event": [
-                        {
-                            "name": "addtrack",
-                            "type": "TrackEvent"
-                        },
-                        {
-                            "name": "change",
-                            "type": "Event"
-                        },
-                        {
-                            "name": "removetrack",
-                            "type": "TrackEvent"
-                        }
-                    ]
-                }
+            "VideoTrack": {
+                "exposed": ""
             },
             "WebSocket": {
                 "events": {
diff --git a/inputfiles/comments.json b/inputfiles/comments.json
index cc12bf850..13389b749 100644
--- a/inputfiles/comments.json
+++ b/inputfiles/comments.json
@@ -1591,9 +1591,6 @@
                         },
                         "networkState": {
                             "comment": "/**\n * Gets the current network activity for the element.\n */"
-                        },
-                        "audioTracks": {
-                            "comment": "/**\n * Returns an AudioTrackList object with the audio tracks for a given video element.\n */"
                         }
                     }
                 },
diff --git a/inputfiles/removedTypes.json b/inputfiles/removedTypes.json
index 946133173..e21098030 100644
--- a/inputfiles/removedTypes.json
+++ b/inputfiles/removedTypes.json
@@ -52,6 +52,7 @@
     },
     "interfaces": {
         "interface": {
+            "AudioTrackList": null,
             "CanvasRenderingContext2D": {
                 "methods": {
                     "method": {
@@ -167,6 +168,12 @@
             "FormDataEvent": null,
             "HTMLAreasCollection": null,
             "HTMLMediaElement": {
+                "properties": {
+                    "property": {
+                        "audioTracks": null,
+                        "videoTracks": null
+                    }
+                },
                 "methods": {
                     "method": {
                         "getStartDate": null
@@ -240,6 +247,15 @@
                     }
                 }
             },
+            "SourceBuffer": {
+                "properties": {
+                    "property": {
+                        "audioTracks": null,
+                        "textTracks": null,
+                        "videoTracks": null
+                    }
+                }
+            },
             "SpeechRecognitionEvent": {
                 "constructor": null
             },
@@ -305,6 +321,7 @@
                     }
                 }
             },
+            "VideoTrackList": null,
             "WebKitCSSMatrix": null,
             "WebKitDirectoryEntry": null,
             "WebKitDirectoryReader": null,