chrome-devtools-frontend 1.0.922782 → 1.0.923788

package/front_end/core/common/Console.ts

@@ -7,7 +7,7 @@ import {reveal} from './Revealer.js';
 
 let consoleInstance: Console;
 
-export class Console extends ObjectWrapper {
+export class Console extends ObjectWrapper<EventTypes> {
   private readonly messagesInternal: Message[];
   /**
    * Instantiable via the instance() factory below.
@@ -64,6 +64,10 @@ export enum Events {
   MessageAdded = 'messageAdded',
 }
 
+export type EventTypes = {
+  [Events.MessageAdded]: Message,
+};
+
 // TODO(crbug.com/1167717): Make this a const enum again
 // eslint-disable-next-line rulesdir/const_enum
 export enum MessageLevel {

package/front_end/core/common/EventTarget.ts

@@ -11,7 +11,7 @@ export interface EventDescriptor<Events = any, T extends EventType<Events> = any
   eventTarget: EventTarget<Events>;
   eventType: T;
   thisObject?: Object;
-  listener: (arg0: EventTargetEvent<EventPayload<Events, T>>) => void;
+  listener: EventListener<Events, T>;
 }
 
 export function removeEventListeners(eventList: EventDescriptor[]): void {
@@ -22,24 +22,18 @@ export function removeEventListeners(eventList: EventDescriptor[]): void {
   eventList.splice(0);
 }
 
-// TODO(crbug.com/1228674): Once all event emitters and sinks have been migrated
-// we can use:
-//    export type EventType<Events> = keyof Events;
-//    export type EventPayload<Events, T> = Events[T];
 export type EventType<Events> = Events extends Object ? keyof Events : Events extends void ? never : string|symbol;
 export type EventPayload<Events, T> = T extends keyof Events ? Events[T] : unknown;
 export type EventPayloadToRestParameters<T> = T extends void ? [] : [T];
 
-// TODO(crbug.com/1228674) Remove defaults for generic type parameters once
-//                         all event emitters and sinks have been migrated.
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export interface EventTarget<Events = any> {
-  addEventListener<T extends EventType<Events>>(
-      eventType: T, listener: (arg0: EventTargetEvent<EventPayload<Events, T>>) => void,
-      thisObject?: Object): EventDescriptor<Events, T>;
+export type EventListener<Events, T> = (arg0: EventTargetEvent<EventPayload<Events, T>>) => void;
+
+export interface EventTarget<Events> {
+  addEventListener<T extends EventType<Events>>(eventType: T, listener: EventListener<Events, T>, thisObject?: Object):
+      EventDescriptor<Events, T>;
   once<T extends EventType<Events>>(eventType: T): Promise<EventPayload<Events, T>>;
   removeEventListener<T extends EventType<Events>>(
-      eventType: T, listener: (arg0: EventTargetEvent<EventPayload<Events, T>>) => void, thisObject?: Object): void;
+      eventType: T, listener: EventListener<Events, T>, thisObject?: Object): void;
   hasEventListeners(eventType: EventType<Events>): boolean;
   dispatchEventToListeners<T extends EventType<Events>>(
       eventType: Platform.TypeScriptUtilities.NoUnion<T>,

package/front_end/core/common/Object.ts

@@ -28,7 +28,7 @@
  */
 
 import type * as Platform from '../platform/platform.js';
-import type {EventDescriptor, EventTarget, EventTargetEvent, EventType, EventPayload, EventPayloadToRestParameters} from './EventTarget.js';
+import type {EventDescriptor, EventListener, EventTarget, EventTargetEvent, EventType, EventPayload, EventPayloadToRestParameters} from './EventTarget.js';
 
 export interface ListenerCallbackTuple {
   thisObject?: Object;
@@ -36,15 +36,11 @@ export interface ListenerCallbackTuple {
   disposed?: boolean;
 }
 
-// TODO(crbug.com/1228674) Remove defaults for generic type parameters once
-//                         all event emitters and sinks have been migrated.
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export class ObjectWrapper<Events = any> implements EventTarget<Events> {
+export class ObjectWrapper<Events> implements EventTarget<Events> {
   listeners?: Map<EventType<Events>, Set<ListenerCallbackTuple>>;
 
-  addEventListener<T extends EventType<Events>>(
-      eventType: T, listener: (arg0: EventTargetEvent<EventPayload<Events, T>>) => void,
-      thisObject?: Object): EventDescriptor<Events, T> {
+  addEventListener<T extends EventType<Events>>(eventType: T, listener: EventListener<Events, T>, thisObject?: Object):
+      EventDescriptor<Events, T> {
     if (!this.listeners) {
       this.listeners = new Map();
     }
@@ -68,7 +64,7 @@ export class ObjectWrapper<Events = any> implements EventTarget<Events> {
   }
 
   removeEventListener<T extends EventType<Events>>(
-      eventType: T, listener: (arg0: EventTargetEvent<EventPayload<Events, T>>) => void, thisObject?: Object): void {
+      eventType: T, listener: EventListener<Events, T>, thisObject?: Object): void {
     const listeners = this.listeners?.get(eventType);
     if (!listeners) {
       return;

package/front_end/core/common/Settings.ts

@@ -46,7 +46,7 @@ export class Settings {
   private readonly sessionStorage: SettingsStorage;
   settingNameSet: Set<string>;
   orderValuesBySettingCategory: Map<SettingCategory, Set<number>>;
-  private eventSupport: ObjectWrapper;
+  private eventSupport: ObjectWrapper<unknown>;
   private registry: Map<string, Setting<unknown>>;
   readonly moduleSettings: Map<string, Setting<unknown>>;
 
@@ -59,7 +59,7 @@ export class Settings {
 
     this.orderValuesBySettingCategory = new Map();
 
-    this.eventSupport = new ObjectWrapper();
+    this.eventSupport = new ObjectWrapper<unknown>();
     this.registry = new Map();
     this.moduleSettings = new Map();
 
@@ -276,7 +276,7 @@ function removeSetting(setting: Setting<unknown>): void {
 export class Setting<V> {
   private nameInternal: string;
   private defaultValueInternal: V;
-  private readonly eventSupport: ObjectWrapper;
+  private readonly eventSupport: ObjectWrapper<unknown>;
   private storage: SettingsStorage;
   private titleFunction!: () => Platform.UIString.LocalizedString;
   private titleInternal!: string;
@@ -287,7 +287,7 @@ export class Setting<V> {
   private serializer: Serializer<unknown, V> = JSON;
   private hadUserAction?: boolean;
 
-  constructor(name: string, defaultValue: V, eventSupport: ObjectWrapper, storage: SettingsStorage) {
+  constructor(name: string, defaultValue: V, eventSupport: ObjectWrapper<unknown>, storage: SettingsStorage) {
     this.nameInternal = name;
     this.defaultValueInternal = defaultValue;
     this.eventSupport = eventSupport;
@@ -299,12 +299,14 @@ export class Setting<V> {
     this.serializer = serializer;
   }
 
-  addChangeListener(listener: (arg0: EventTargetEvent) => void, thisObject?: Object): EventDescriptor {
-    return this.eventSupport.addEventListener(this.nameInternal, listener, thisObject);
+  addChangeListener(listener: (arg0: EventTargetEvent<V>) => void, thisObject?: Object): EventDescriptor {
+    return this.eventSupport.addEventListener(
+        this.nameInternal, listener as (arg0: EventTargetEvent<unknown>) => void, thisObject);
   }
 
-  removeChangeListener(listener: (arg0: EventTargetEvent) => void, thisObject?: Object): void {
-    this.eventSupport.removeEventListener(this.nameInternal, listener, thisObject);
+  removeChangeListener(listener: (arg0: EventTargetEvent<V>) => void, thisObject?: Object): void {
+    this.eventSupport.removeEventListener(
+        this.nameInternal, listener as (arg0: EventTargetEvent<unknown>) => void, thisObject);
   }
 
   get name(): string {
@@ -449,7 +451,8 @@ export class RegExpSetting extends Setting<any> {
   private regex?: RegExp|null;
 
   constructor(
-      name: string, defaultValue: string, eventSupport: ObjectWrapper, storage: SettingsStorage, regexFlags?: string) {
+      name: string, defaultValue: string, eventSupport: ObjectWrapper<unknown>, storage: SettingsStorage,
+      regexFlags?: string) {
     super(name, defaultValue ? [{pattern: defaultValue}] : [], eventSupport, storage);
     this.regexFlags = regexFlags;
   }

package/front_end/core/host/InspectorFrontendHost.ts

@@ -36,7 +36,7 @@ import * as i18n from '../i18n/i18n.js';
 import * as Platform from '../platform/platform.js';
 import * as Root from '../root/root.js';
 
-import type {CanShowSurveyResult, ContextMenuDescriptor, EnumeratedHistogram, ExtensionDescriptor, InspectorFrontendHostAPI, LoadNetworkResourceResult, ShowSurveyResult} from './InspectorFrontendHostAPI.js';
+import type {CanShowSurveyResult, ContextMenuDescriptor, EnumeratedHistogram, EventTypes, ExtensionDescriptor, InspectorFrontendHostAPI, LoadNetworkResourceResult, ShowSurveyResult} from './InspectorFrontendHostAPI.js';
 import {EventDescriptors, Events} from './InspectorFrontendHostAPI.js';
 import {streamWrite as resourceLoaderStreamWrite} from './ResourceLoader.js';
 
@@ -54,8 +54,7 @@ const MAX_RECORDED_HISTOGRAMS_SIZE = 100;
 
 export class InspectorFrontendHostStub implements InspectorFrontendHostAPI {
   private readonly urlsBeingSaved: Map<string, string[]>;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  events!: Common.EventTarget.EventTarget<any>;
+  events!: Common.EventTarget.EventTarget<EventTypes>;
   private windowVisible?: boolean;
 
   recordedEnumeratedHistograms: {actionName: EnumeratedHistogram, actionCode: number}[] = [];
@@ -379,7 +378,8 @@ class InspectorFrontendAPIImpl {
       // Single argument methods get dispatched with the param.
       if (signature.length < 2) {
         try {
-          InspectorFrontendHostInstance.events.dispatchEventToListeners(name, params[0]);
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          InspectorFrontendHostInstance.events.dispatchEventToListeners<any>(name, params[0]);
         } catch (error) {
           console.error(error + ' ' + error.stack);
         }
@@ -392,7 +392,8 @@ class InspectorFrontendAPIImpl {
         data[signature[i]] = params[i];
       }
       try {
-        InspectorFrontendHostInstance.events.dispatchEventToListeners(name, data);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        InspectorFrontendHostInstance.events.dispatchEventToListeners<any>(name, data);
       } catch (error) {
         console.error(error + ' ' + error.stack);
       }

package/front_end/core/host/InspectorFrontendHostAPI.ts

@@ -68,6 +68,108 @@ export const EventDescriptors = [
   [Events.ShowPanel, 'showPanel', ['panelName']],
 ];
 
+export interface DispatchMessageChunkEvent {
+  messageChunk: string;
+  messageSize: number;
+}
+
+export interface EyeDropperPickedColorEvent {
+  r: number;
+  g: number;
+  b: number;
+  a: number;
+}
+
+export interface DevToolsFileSystem {
+  type: string;
+  fileSystemName: string;
+  rootURL: string;
+  fileSystemPath: string;
+}
+
+export interface FileSystemAddedEvent {
+  errorMessage?: string;
+  fileSystem: DevToolsFileSystem|null;
+}
+
+export interface FilesChangedEvent {
+  changed: string[];
+  added: string[];
+  removed: string[];
+}
+
+export interface IndexingEvent {
+  requestId: number;
+  fileSystemPath: string;
+}
+
+export interface IndexingTotalWorkCalculatedEvent extends IndexingEvent {
+  totalWork: number;
+}
+
+export interface IndexingWorkedEvent extends IndexingEvent {
+  worked: number;
+}
+
+export interface KeyEventUnhandledEvent {
+  type: string;
+  key: string;
+  keyCode: number;
+  modifiers: number;
+}
+
+export interface RevealSourceLineEvent {
+  url: string;
+  lineNumber: number;
+  columnNumber: number;
+}
+
+export interface SavedURLEvent {
+  url: string;
+  fileSystemPath: string;
+}
+
+export interface SearchCompletedEvent {
+  requestId: number;
+  files: string[];
+}
+
+// While `EventDescriptors` are used to dynamically dispatch host binding events,
+// the `EventTypes` "type map" is used for type-checking said events by TypeScript.
+// `EventTypes` is not used at runtime.
+// Please note that the "dispatch" side can't be type-checked as the dispatch is
+// done dynamically.
+export type EventTypes = {
+  [Events.AppendedToURL]: string,
+  [Events.CanceledSaveURL]: string,
+  [Events.ContextMenuCleared]: void,
+  [Events.ContextMenuItemSelected]: number,
+  [Events.DeviceCountUpdated]: number,
+  [Events.DevicesDiscoveryConfigChanged]: Adb.Config,
+  [Events.DevicesPortForwardingStatusChanged]: void,
+  [Events.DevicesUpdated]: void,
+  [Events.DispatchMessage]: string,
+  [Events.DispatchMessageChunk]: DispatchMessageChunkEvent,
+  [Events.EnterInspectElementMode]: void,
+  [Events.EyeDropperPickedColor]: EyeDropperPickedColorEvent,
+  [Events.FileSystemsLoaded]: DevToolsFileSystem[],
+  [Events.FileSystemRemoved]: string,
+  [Events.FileSystemAdded]: FileSystemAddedEvent,
+  [Events.FileSystemFilesChangedAddedRemoved]: FilesChangedEvent,
+  [Events.IndexingTotalWorkCalculated]: IndexingTotalWorkCalculatedEvent,
+  [Events.IndexingWorked]: IndexingWorkedEvent,
+  [Events.IndexingDone]: IndexingEvent,
+  [Events.KeyEventUnhandled]: KeyEventUnhandledEvent,
+  [Events.ReattachMainTarget]: void,
+  [Events.ReloadInspectedPage]: boolean,
+  [Events.RevealSourceLine]: RevealSourceLineEvent,
+  [Events.SavedURL]: SavedURLEvent,
+  [Events.SearchCompleted]: SearchCompletedEvent,
+  [Events.SetInspectedTabId]: string,
+  [Events.SetUseSoftMenu]: boolean,
+  [Events.ShowPanel]: string,
+};
+
 export interface InspectorFrontendHostAPI {
   addFileSystem(type?: string): void;
 

package/front_end/core/sdk/CSSModel.ts

@@ -707,9 +707,9 @@ export class CSSModel extends SDKModel<EventTypes> {
       }
 
       if (this.cssPropertyTracker) {
-        this.cssPropertyTracker.dispatchEventToListeners(CSSPropertyTrackerEvents.TrackedCSSPropertiesUpdated, {
-          domNodes: result.nodeIds.map(nodeId => this.domModelInternal.nodeForId(nodeId)),
-        });
+        this.cssPropertyTracker.dispatchEventToListeners(
+            CSSPropertyTrackerEvents.TrackedCSSPropertiesUpdated,
+            result.nodeIds.map(nodeId => this.domModelInternal.nodeForId(nodeId)));
       }
     }
 
@@ -867,7 +867,7 @@ export class InlineStyleResult {
   }
 }
 
-export class CSSPropertyTracker extends Common.ObjectWrapper.ObjectWrapper {
+export class CSSPropertyTracker extends Common.ObjectWrapper.ObjectWrapper<CSSPropertyTrackerEventTypes> {
   private readonly cssModel: CSSModel;
   private readonly properties: Protocol.CSS.CSSComputedStyleProperty[];
   constructor(cssModel: CSSModel, propertiesToTrack: Protocol.CSS.CSSComputedStyleProperty[]) {
@@ -897,6 +897,10 @@ export enum CSSPropertyTrackerEvents {
   TrackedCSSPropertiesUpdated = 'TrackedCSSPropertiesUpdated',
 }
 
+export type CSSPropertyTrackerEventTypes = {
+  [CSSPropertyTrackerEvents.TrackedCSSPropertiesUpdated]: (DOMNode|null)[],
+};
+
 SDKModel.register(CSSModel, {capabilities: Capability.DOM, autostart: true});
 export interface ContrastInfo {
   backgroundColors: string[]|null;

package/front_end/core/sdk/Connections.ts

@@ -42,15 +42,15 @@ export class MainConnection implements ProtocolClient.InspectorBackend.Connectio
     }
   }
 
-  private dispatchMessage(event: Common.EventTarget.EventTargetEvent): void {
+  private dispatchMessage(event: Common.EventTarget.EventTargetEvent<string>): void {
     if (this.onMessage) {
-      this.onMessage.call(null, (event.data as string));
+      this.onMessage.call(null, event.data);
     }
   }
 
-  private dispatchMessageChunk(event: Common.EventTarget.EventTargetEvent): void {
-    const messageChunk = (event.data['messageChunk'] as string);
-    const messageSize = (event.data['messageSize'] as number);
+  private dispatchMessageChunk(
+      event: Common.EventTarget.EventTargetEvent<Host.InspectorFrontendHostAPI.DispatchMessageChunkEvent>): void {
+    const {messageChunk, messageSize} = event.data;
     if (messageSize) {
       this.messageBuffer = '';
       this.messageSize = messageSize;

package/front_end/core/sdk/DebuggerModel.ts

@@ -135,7 +135,10 @@ export class DebuggerModel extends SDKModel<EventTypes> {
                                           }>>)|null;
   private expandCallFramesCallback: ((arg0: Array<CallFrame>) => Promise<Array<CallFrame>>)|null;
   evaluateOnCallFrameCallback: ((arg0: CallFrame, arg1: EvaluationOptions) => Promise<EvaluationResult|null>)|null;
-  private readonly breakpointResolvedEventTarget: Common.ObjectWrapper.ObjectWrapper;
+  // We need to be able to register listeners for individual breakpoints. As such, we dispatch
+  // on breakpoint ids, which are not statically known. The event payload will always be a `Location`.
+  private readonly breakpointResolvedEventTarget =
+      new Common.ObjectWrapper.ObjectWrapper<{[breakpointId: string]: Location}>();
   private autoStepOver: boolean;
   private isPausingInternal: boolean;
 
@@ -163,8 +166,6 @@ export class DebuggerModel extends SDKModel<EventTypes> {
     this.expandCallFramesCallback = null;
     this.evaluateOnCallFrameCallback = null;
 
-    this.breakpointResolvedEventTarget = new Common.ObjectWrapper.ObjectWrapper();
-
     this.autoStepOver = false;
 
     this.isPausingInternal = false;
@@ -901,12 +902,14 @@ export class DebuggerModel extends SDKModel<EventTypes> {
   }
 
   addBreakpointListener(
-      breakpointId: string, listener: (arg0: Common.EventTarget.EventTargetEvent) => void, thisObject?: Object): void {
+      breakpointId: string, listener: (arg0: Common.EventTarget.EventTargetEvent<Location>) => void,
+      thisObject?: Object): void {
     this.breakpointResolvedEventTarget.addEventListener(breakpointId, listener, thisObject);
   }
 
   removeBreakpointListener(
-      breakpointId: string, listener: (arg0: Common.EventTarget.EventTargetEvent) => void, thisObject?: Object): void {
+      breakpointId: string, listener: (arg0: Common.EventTarget.EventTargetEvent<Location>) => void,
+      thisObject?: Object): void {
     this.breakpointResolvedEventTarget.removeEventListener(breakpointId, listener, thisObject);
   }
 

package/front_end/core/sdk/RuntimeModel.ts

@@ -487,7 +487,7 @@ export interface QueryObjectRequestedEvent {
 
 export type EventTypes = {
   [Events.BindingCalled]: Protocol.Runtime.BindingCalledEvent,
-  [Events.ExecutionContextCreated]: Protocol.Runtime.ExecutionContextDescription,
+  [Events.ExecutionContextCreated]: ExecutionContext,
   [Events.ExecutionContextDestroyed]: ExecutionContext,
   [Events.ExecutionContextChanged]: ExecutionContext,
   [Events.ExecutionContextOrderChanged]: RuntimeModel,

package/front_end/core/sdk/SourceMap.ts

@@ -62,6 +62,7 @@ export interface SourceMap {
       TextUtils.ContentProvider.ContentProvider;
   embeddedContentByURL(sourceURL: string): string|null;
   findEntry(lineNumber: number, columnNumber: number): SourceMapEntry|null;
+  findReverseRanges(sourceURL: string, lineNumber: number, columnNumber: number): TextUtils.TextRange.TextRange[];
   sourceLineMapping(sourceURL: string, lineNumber: number, columnNumber: number): SourceMapEntry|null;
   mappings(): SourceMapEntry[];
   mapsOrigin(): boolean;
@@ -225,37 +226,71 @@ export class TextSourceMap implements SourceMap {
   }
 
   sourceLineMapping(sourceURL: string, lineNumber: number, columnNumber: number): SourceMapEntry|null {
-    const mappings = this.reversedMappings(sourceURL);
-    const first = Platform.ArrayUtilities.lowerBound(mappings, lineNumber, lineComparator);
-    const last = Platform.ArrayUtilities.upperBound(mappings, lineNumber, lineComparator);
-    if (first >= mappings.length || mappings[first].sourceLineNumber !== lineNumber) {
+    const mappings = this.mappings();
+    const reverseMappings = this.reversedMappings(sourceURL);
+    const first = Platform.ArrayUtilities.lowerBound(reverseMappings, lineNumber, lineComparator);
+    const last = Platform.ArrayUtilities.upperBound(reverseMappings, lineNumber, lineComparator);
+    if (first >= reverseMappings.length || mappings[reverseMappings[first]].sourceLineNumber !== lineNumber) {
       return null;
     }
-    const columnMappings = mappings.slice(first, last);
+    const columnMappings = reverseMappings.slice(first, last);
     if (!columnMappings.length) {
       return null;
     }
     const index = Platform.ArrayUtilities.lowerBound(
-        columnMappings, columnNumber, (columnNumber, mapping) => columnNumber - mapping.sourceColumnNumber);
-    return index >= columnMappings.length ? columnMappings[columnMappings.length - 1] : columnMappings[index];
+        columnMappings, columnNumber, (columnNumber, i) => columnNumber - mappings[i].sourceColumnNumber);
+    return index >= columnMappings.length ? mappings[columnMappings[columnMappings.length - 1]] :
+                                            mappings[columnMappings[index]];
 
-    function lineComparator(lineNumber: number, mapping: SourceMapEntry): number {
-      return lineNumber - mapping.sourceLineNumber;
+    function lineComparator(lineNumber: number, i: number): number {
+      return lineNumber - mappings[i].sourceLineNumber;
     }
   }
 
-  findReverseEntries(sourceURL: string, lineNumber: number, columnNumber: number): SourceMapEntry[] {
-    const mappings = this.reversedMappings(sourceURL);
+  private findReverseIndices(sourceURL: string, lineNumber: number, columnNumber: number): number[] {
+    const mappings = this.mappings();
+    const reverseMappings = this.reversedMappings(sourceURL);
     const endIndex = Platform.ArrayUtilities.upperBound(
-        mappings, undefined,
-        (unused, entry) => lineNumber - entry.sourceLineNumber || columnNumber - entry.sourceColumnNumber);
+        reverseMappings, undefined,
+        (unused, i) => lineNumber - mappings[i].sourceLineNumber || columnNumber - mappings[i].sourceColumnNumber);
     let startIndex = endIndex;
-    while (startIndex > 0 && mappings[startIndex - 1].sourceLineNumber === mappings[endIndex - 1].sourceLineNumber &&
-           mappings[startIndex - 1].sourceColumnNumber === mappings[endIndex - 1].sourceColumnNumber) {
+    while (startIndex > 0 &&
+           mappings[reverseMappings[startIndex - 1]].sourceLineNumber ===
+               mappings[reverseMappings[endIndex - 1]].sourceLineNumber &&
+           mappings[reverseMappings[startIndex - 1]].sourceColumnNumber ===
+               mappings[reverseMappings[endIndex - 1]].sourceColumnNumber) {
       --startIndex;
     }
 
-    return mappings.slice(startIndex, endIndex);
+    return reverseMappings.slice(startIndex, endIndex);
+  }
+
+  findReverseEntries(sourceURL: string, lineNumber: number, columnNumber: number): SourceMapEntry[] {
+    const mappings = this.mappings();
+    return this.findReverseIndices(sourceURL, lineNumber, columnNumber).map(i => mappings[i]);
+  }
+
+  findReverseRanges(sourceURL: string, lineNumber: number, columnNumber: number): TextUtils.TextRange.TextRange[] {
+    const mappings = this.mappings();
+    const indices = this.findReverseIndices(sourceURL, lineNumber, columnNumber);
+    const ranges: TextUtils.TextRange.TextRange[] = [];
+
+    for (let i = 0; i < indices.length; ++i) {
+      const startIndex = indices[i];
+
+      // Merge adjacent ranges.
+      let endIndex = startIndex + 1;
+      while (i + 1 < indices.length && endIndex === indices[i + 1]) {
+        ++endIndex;
+        ++i;
+      }
+      const endLine = endIndex < mappings.length ? mappings[endIndex].lineNumber : Infinity;
+      const endColumn = endIndex < mappings.length ? mappings[endIndex].columnNumber : 0;
+      ranges.push(new TextUtils.TextRange.TextRange(
+          mappings[startIndex].lineNumber, mappings[startIndex].columnNumber, endLine, endColumn));
+    }
+
+    return ranges;
   }
 
   mappings(): SourceMapEntry[] {
@@ -267,19 +302,22 @@ export class TextSourceMap implements SourceMap {
     return /** @type {!Array<!SourceMapEntry>} */ this.mappingsInternal as SourceMapEntry[];
   }
 
-  private reversedMappings(sourceURL: string): SourceMapEntry[] {
+  private reversedMappings(sourceURL: string): number[] {
     const info = this.sourceInfos.get(sourceURL);
     if (!info) {
       return [];
     }
     const mappings = this.mappings();
     if (info.reverseMappings === null) {
-      info.reverseMappings = mappings.filter(mapping => mapping.sourceURL === sourceURL).sort(sourceMappingComparator);
+      const indexes = Array(mappings.length).fill(0).map((_, i) => i);
+      info.reverseMappings = indexes.filter(i => mappings[i].sourceURL === sourceURL).sort(sourceMappingComparator);
     }
 
     return info.reverseMappings;
 
-    function sourceMappingComparator(a: SourceMapEntry, b: SourceMapEntry): number {
+    function sourceMappingComparator(indexA: number, indexB: number): number {
+      const a = mappings[indexA];
+      const b = mappings[indexB];
       if (a.sourceLineNumber !== b.sourceLineNumber) {
         return a.sourceLineNumber - b.sourceLineNumber;
       }
@@ -415,25 +453,30 @@ export class TextSourceMap implements SourceMap {
           lineNumber: number,
           columnNumber: number,
         },
-        mapping: SourceMapEntry): number {
-      if (position.lineNumber !== mapping.sourceLineNumber) {
-        return position.lineNumber - mapping.sourceLineNumber;
+        mappingIndex: number): number {
+      if (position.lineNumber !== mappings[mappingIndex].sourceLineNumber) {
+        return position.lineNumber - mappings[mappingIndex].sourceLineNumber;
       }
 
-      return position.columnNumber - mapping.sourceColumnNumber;
+      return position.columnNumber - mappings[mappingIndex].sourceColumnNumber;
     }
 
-    const mappings = this.reversedMappings(url);
-    if (!mappings.length) {
+    const reverseMappings = this.reversedMappings(url);
+    const mappings = this.mappings();
+    if (!reverseMappings.length) {
       return null;
     }
     const startIndex = Platform.ArrayUtilities.lowerBound(
-        mappings, {lineNumber: textRange.startLine, columnNumber: textRange.startColumn}, comparator);
+        reverseMappings, {lineNumber: textRange.startLine, columnNumber: textRange.startColumn}, comparator);
     const endIndex = Platform.ArrayUtilities.upperBound(
-        mappings, {lineNumber: textRange.endLine, columnNumber: textRange.endColumn}, comparator);
+        reverseMappings, {lineNumber: textRange.endLine, columnNumber: textRange.endColumn}, comparator);
+
+    if (endIndex >= reverseMappings.length) {
+      return null;
+    }
 
-    const startMapping = mappings[startIndex];
-    const endMapping = mappings[endIndex];
+    const startMapping = mappings[reverseMappings[startIndex]];
+    const endMapping = mappings[reverseMappings[endIndex]];
     return new TextUtils.TextRange.TextRange(
         startMapping.lineNumber, startMapping.columnNumber, endMapping.lineNumber, endMapping.columnNumber);
   }
@@ -483,9 +526,9 @@ export namespace TextSourceMap {
 
   export class SourceInfo {
     content: string|null;
-    reverseMappings: SourceMapEntry[]|null;
+    reverseMappings: number[]|null;
 
-    constructor(content: string|null, reverseMappings: SourceMapEntry[]|null) {
+    constructor(content: string|null, reverseMappings: number[]|null) {
       this.content = content;
       this.reverseMappings = reverseMappings;
     }

package/front_end/core/sdk/TargetManager.ts

@@ -17,7 +17,7 @@ let targetManagerInstance: TargetManager|undefined;
 export class TargetManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes> {
   private targetsInternal: Set<Target>;
   private readonly observers: Set<Observer>;
-  private modelListeners: Platform.MapUtilities.Multimap<string|symbol, {
+  private modelListeners: Platform.MapUtilities.Multimap<string|symbol|number, {
     modelClass: new(arg1: Target) => SDKModel,
     thisObject: (Object|undefined),
     listener: (arg0: Common.EventTarget.EventTargetEvent) => void,
@@ -124,18 +124,18 @@ export class TargetManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes
     }
   }
 
-  addModelListener(
-      modelClass: new(arg1: Target) => SDKModel, eventType: string|symbol,
-      listener: (arg0: Common.EventTarget.EventTargetEvent) => void, thisObject?: Object): void {
+  addModelListener<Events, T extends Common.EventTarget.EventType<Events>>(
+      modelClass: new(arg1: Target) => SDKModel<Events>, eventType: T,
+      listener: Common.EventTarget.EventListener<Events, T>, thisObject?: Object): void {
     for (const model of this.models(modelClass)) {
       model.addEventListener(eventType, listener, thisObject);
     }
     this.modelListeners.set(eventType, {modelClass: modelClass, thisObject: thisObject, listener: listener});
   }
 
-  removeModelListener(
-      modelClass: new(arg1: Target) => SDKModel, eventType: string|symbol,
-      listener: (arg0: Common.EventTarget.EventTargetEvent) => void, thisObject?: Object): void {
+  removeModelListener<Events, T extends Common.EventTarget.EventType<Events>>(
+      modelClass: new(arg1: Target) => SDKModel<Events>, eventType: T,
+      listener: Common.EventTarget.EventListener<Events, T>, thisObject?: Object): void {
     if (!this.modelListeners.has(eventType)) {
       return;
     }

package/front_end/entrypoints/inspector_main/InspectorMain.ts

@@ -84,8 +84,7 @@ export class InspectorMainImpl implements Common.Runnable.Runnable {
     new MobileThrottling.NetworkPanelIndicator.NetworkPanelIndicator();
 
     Host.InspectorFrontendHost.InspectorFrontendHostInstance.events.addEventListener(
-        Host.InspectorFrontendHostAPI.Events.ReloadInspectedPage, event => {
-          const hard = (event.data as boolean);
+        Host.InspectorFrontendHostAPI.Events.ReloadInspectedPage, ({data: hard}) => {
           SDK.ResourceTreeModel.ResourceTreeModel.reloadAllPages(hard);
         });
   }

package/front_end/entrypoints/main/ExecutionContextSelector.ts

@@ -55,8 +55,9 @@ export class ExecutionContextSelector implements SDK.TargetManager.SDKModelObser
     }
   }
 
-  private executionContextChanged(event: Common.EventTarget.EventTargetEvent): void {
-    const newContext = (event.data as SDK.RuntimeModel.ExecutionContext | null);
+  private executionContextChanged({
+    data: newContext,
+  }: Common.EventTarget.EventTargetEvent<SDK.RuntimeModel.ExecutionContext|null>): void {
     if (newContext) {
       this.context.setFlavor(SDK.Target.Target, newContext.target());
       if (!this.ignoreContextChanged) {
@@ -69,8 +70,7 @@ export class ExecutionContextSelector implements SDK.TargetManager.SDKModelObser
     return executionContext.isDefault ? executionContext.target().name() + ':' + executionContext.frameId : '';
   }
 
-  private targetChanged(event: Common.EventTarget.EventTargetEvent): void {
-    const newTarget = (event.data as SDK.Target.Target | null);
+  private targetChanged({data: newTarget}: Common.EventTarget.EventTargetEvent<SDK.Target.Target|null>): void {
     const currentContext = this.context.flavor(SDK.RuntimeModel.ExecutionContext);
 
     if (!newTarget || (currentContext && currentContext.target() === newTarget)) {