anchor.diff:    /// Use `createSyntheticUIEvent` instead.
     external factory SyntheticUIEvent._();
   
  +  /// Details about the event, depending on the event type.
  +  ///
  +  /// See <https://developer.mozilla.org/en-US/docs/Web/API/UIEvent/detail>
     external num get detail;
  +
  +  /// A `WindowProxy` that contains the view that generated the event.
     external get view;
   }
   
  +/// A [SyntheticEvent] wrapper that is specifically backed by a [SyntheticWheelEvent].
  +///
  +/// See <https://developer.mozilla.org/en-US/docs/Web/API/WheelEvent>
   @JS()
   class SyntheticWheelEvent extends SyntheticEvent {
     /// [SyntheticWheelEvent]s cannot be manually instantiated.
  
positive.code:   external List<String> get types;
  }
  
  @JS()
  class SyntheticMouseEvent extends SyntheticEvent {
    /// [SyntheticMouseEvent]s cannot be manually instantiated.
  
negative.code:   /// Use `createSyntheticEvent` instead.
    external factory SyntheticEvent._();
  
    /// Indicates whether the [Event] bubbles up through the DOM or not.
    ///
    /// See: <https://developer.mozilla.org/en-US/docs/Web/API/Event/bubbles>
    external bool get bubbles;
  
    /// Indicates whether the [Event] is cancelable or not.
    ///
    /// See: <https://developer.mozilla.org/en-US/docs/Web/API/Event/cancelable>
    external bool get cancelable;
  
    /// Identifies the current target for the event, as the [Event] traverses the DOM.
    ///
    /// It always refers to the [Element] the [Event] handler has been attached to as opposed to [target] which identifies
    /// the [Element] on which the [Event] occurred.
    ///
    /// See: <https://developer.mozilla.org/en-US/docs/Web/API/Event/currentTarget>
    external get currentTarget;
  
    /// Indicates whether or not [preventDefault] was called on the event.
    ///
    /// See: <https://developer.mozilla.org/en-US/docs/Web/API/Event/defaultPrevented>
    external bool get defaultPrevented;
  
    /// Indicates which phase of the [Event] flow is currently being evaluated.
    ///
    /// Possible values:
    ///
    /// > [Event.CAPTURING_PHASE] (1) - The [Event] is being propagated through the [target]'s ancestor objects. This
    /// process starts with the Window, then [HtmlDocument], then the [HtmlHtmlElement], and so on through the [Element]s
    /// until the [target]'s parent is reached. Event listeners registered for capture mode when
    /// [EventTarget.addEventListener] was called are triggered during this phase.
    ///
    /// > [Event.AT_TARGET] (2) - The [Event] has arrived at the [target]. Event listeners registered for this phase are
    /// called at this time. If [bubbles] is `false`, processing the [Event] is finished after this phase is complete.
    ///
    /// > [Event.BUBBLING_PHASE] (3) - The [Event] is propagating back up through the [target]'s ancestors in reverse
    /// order, starting with the parent, and eventually reaching the containing Window. This is known as bubbling, and
    /// occurs only if [bubbles] is `true`. [Event] listeners registered for this phase are triggered during this process.
    ///
    /// See: <https://developer.mozilla.org/en-US/docs/Web/API/Event/eventPhase>
    external num get eventPhase;
  
    /// Is `true` when the [Event] was generated by a user action, and `false` when the [Event] was created or modified
    /// by a script or dispatched via [Event.dispatchEvent].
    ///
    /// __Read Only__
    ///
    /// See: <https://developer.mozilla.org/en-US/docs/Web/API/Event/isTrusted>
    external bool get isTrusted;
  
    /// Native browser event that [SyntheticEvent] wraps around.
    external /*DOMEvent*/ get nativeEvent;
  
    /// A reference to the object that dispatched the event. It is different from [currentTarget] when the [Event]
    /// handler is called when [eventPhase] is [Event.BUBBLING_PHASE] or [Event.CAPTURING_PHASE].
    ///
    /// See: <https://developer.mozilla.org/en-US/docs/Web/API/Event/target>
    external /*DOMEventTarget*/ get target;
  
    /// Returns the [Time] (in milliseconds) at which the [Event] was created.
    ///
    /// _Starting with Chrome 49, returns a high-resolution monotonic time instead of epoch time._
    ///
    /// See: <https://developer.mozilla.org/en-US/docs/Web/API/Event/timeStamp>
    external num get timeStamp;
  
    /// Returns a string containing the type of event. It is set when the [Event] is constructed and is the name commonly
    /// used to refer to the specific event.
    ///
    /// See: <https://developer.mozilla.org/en-US/docs/Web/API/Event/type>
    external String get type;
  
    /// Prevents further propagation of the current event.
    ///
    /// See: <https://developer.mozilla.org/en-US/docs/Web/API/Event/stopPropagation>
    external void stopPropagation();
  
    /// Cancels the [Event] if it is [cancelable], without stopping further propagation of the event.
    ///
    /// See: <https://developer.mozilla.org/en-US/docs/Web/API/Event/preventDefault>
    external void preventDefault();
  
    /// Call this method on the current event instance if you want to access the event properties in an asynchronous way.
    ///
    /// This will remove the synthetic event from the event pool and allow references
    /// to the event to be retained by user code.
    ///
    /// For example, `setState` callbacks are fired after a component updates as a result of the
    /// new state being passed in - and since component updates are not guaranteed to by synchronous, any
    /// reference to a `SyntheticEvent` within that callback could have been recycled by ReactJS internals.
    ///
    /// You can use `persist()` to ensure access to the event properties within the callback as shown in
    /// the second example below.
    ///
    /// __Without persist()__
    /// ```dart
    /// void handleClick(SyntheticMouseEvent event) {
    ///   print(event.type); // => "click"
    ///
    ///   setState({}, () {
    ///     print(event.type); // => null
    ///     print(event.isPersistent); => false
    ///   });
    /// }
    /// ```
    ///
    /// __With persist()__
    /// ```dart
    /// void handleClick(SyntheticMouseEvent event) {
    ///   print(event.type); // => "click"
    ///   event.persist();
    ///
    ///   setState({}, () {
    ///     print(event.type); // => "click"
    ///     print(event.isPersistent); => true
    ///   });
    /// }
    /// ```
    ///
    /// See: <https://reactjs.org/docs/events.html#event-pooling>
    external void persist();
  
    /// Whether the event instance has been removed from the ReactJS event pool.
    ///
    /// > See: [persist]
    external bool isPersistent();
  }
  
  /// A [SyntheticEvent] wrapper that is specifically backed by a [ClipboardEvent].
  ///
  /// See <https://developer.mozilla.org/en-US/docs/Web/API/ClipboardEvent/clipboardData>
  @JS()
  class SyntheticClipboardEvent extends SyntheticEvent {
    /// [SyntheticClipboardEvent]s cannot be manually instantiated.
  