chrome-devtools-frontend 1.0.927127 → 1.0.928589

package/front_end/core/sdk/SourceMap.ts

@@ -1,3 +1,7 @@
+// Copyright 2021 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  *
@@ -11,7 +15,7 @@
  * copyright notice, this list of conditions and the following disclaimer
  * in the documentation and/or other materials provided with the
  * distribution.
- *     * Neither the name of Google Inc. nor the names of its
+ *     * Neither the #name of Google Inc. nor the names of its
  * contributors may be used to endorse or promote products derived from
  * this software without specific prior written permission.
  *
@@ -133,13 +137,13 @@ for (let i = 0; i < base64Digits.length; ++i) {
 const sourceMapToSourceList = new WeakMap<SourceMapV3, string[]>();
 
 export class TextSourceMap implements SourceMap {
-  private readonly initiator: PageResourceLoadInitiator;
-  private json: SourceMapV3|null;
-  private readonly compiledURLInternal: string;
-  private readonly sourceMappingURL: string;
-  private readonly baseURL: string;
-  private mappingsInternal: SourceMapEntry[]|null;
-  private readonly sourceInfos: Map<string, TextSourceMap.SourceInfo>;
+  readonly #initiator: PageResourceLoadInitiator;
+  #json: SourceMapV3|null;
+  readonly #compiledURLInternal: string;
+  readonly #sourceMappingURL: string;
+  readonly #baseURL: string;
+  #mappingsInternal: SourceMapEntry[]|null;
+  readonly #sourceInfos: Map<string, TextSourceMap.SourceInfo>;
 
   /**
    * Implements Source Map V3 model. See https://github.com/google/closure-compiler/wiki/Source-Maps
@@ -147,16 +151,16 @@ export class TextSourceMap implements SourceMap {
    */
   constructor(
       compiledURL: string, sourceMappingURL: string, payload: SourceMapV3, initiator: PageResourceLoadInitiator) {
-    this.initiator = initiator;
-    this.json = payload;
-    this.compiledURLInternal = compiledURL;
-    this.sourceMappingURL = sourceMappingURL;
-    this.baseURL = sourceMappingURL.startsWith('data:') ? compiledURL : sourceMappingURL;
-
-    this.mappingsInternal = null;
-    this.sourceInfos = new Map();
-    if (this.json.sections) {
-      const sectionWithURL = Boolean(this.json.sections.find(section => Boolean(section.url)));
+    this.#initiator = initiator;
+    this.#json = payload;
+    this.#compiledURLInternal = compiledURL;
+    this.#sourceMappingURL = sourceMappingURL;
+    this.#baseURL = sourceMappingURL.startsWith('data:') ? compiledURL : sourceMappingURL;
+
+    this.#mappingsInternal = null;
+    this.#sourceInfos = new Map();
+    if (this.#json.sections) {
+      const sectionWithURL = Boolean(this.#json.sections.find(section => Boolean(section.url)));
       if (sectionWithURL) {
         Common.Console.Console.instance().warn(
             `SourceMap "${sourceMappingURL}" contains unsupported "URL" field in one of its sections.`);
@@ -190,28 +194,28 @@ export class TextSourceMap implements SourceMap {
   }
 
   compiledURL(): string {
-    return this.compiledURLInternal;
+    return this.#compiledURLInternal;
   }
 
   url(): string {
-    return this.sourceMappingURL;
+    return this.#sourceMappingURL;
   }
 
   sourceURLs(): string[] {
-    return [...this.sourceInfos.keys()];
+    return [...this.#sourceInfos.keys()];
   }
 
   sourceContentProvider(sourceURL: string, contentType: Common.ResourceType.ResourceType):
       TextUtils.ContentProvider.ContentProvider {
-    const info = this.sourceInfos.get(sourceURL);
+    const info = this.#sourceInfos.get(sourceURL);
     if (info && info.content) {
       return TextUtils.StaticContentProvider.StaticContentProvider.fromString(sourceURL, contentType, info.content);
     }
-    return new CompilerSourceMappingContentProvider(sourceURL, contentType, this.initiator);
+    return new CompilerSourceMappingContentProvider(sourceURL, contentType, this.#initiator);
   }
 
   embeddedContentByURL(sourceURL: string): string|null {
-    const entry = this.sourceInfos.get(sourceURL);
+    const entry = this.#sourceInfos.get(sourceURL);
     if (!entry) {
       return null;
     }
@@ -294,16 +298,16 @@ export class TextSourceMap implements SourceMap {
   }
 
   mappings(): SourceMapEntry[] {
-    if (this.mappingsInternal === null) {
-      this.mappingsInternal = [];
+    if (this.#mappingsInternal === null) {
+      this.#mappingsInternal = [];
       this.eachSection(this.parseMap.bind(this));
-      this.json = null;
+      this.#json = null;
     }
-    return /** @type {!Array<!SourceMapEntry>} */ this.mappingsInternal as SourceMapEntry[];
+    return /** @type {!Array<!SourceMapEntry>} */ this.#mappingsInternal as SourceMapEntry[];
   }
 
   private reversedMappings(sourceURL: string): number[] {
-    const info = this.sourceInfos.get(sourceURL);
+    const info = this.#sourceInfos.get(sourceURL);
     if (!info) {
       return [];
     }
@@ -334,14 +338,14 @@ export class TextSourceMap implements SourceMap {
   }
 
   private eachSection(callback: (arg0: SourceMapV3, arg1: number, arg2: number) => void): void {
-    if (!this.json) {
+    if (!this.#json) {
       return;
     }
-    if (!this.json.sections) {
-      callback(this.json, 0, 0);
+    if (!this.#json.sections) {
+      callback(this.#json, 0, 0);
       return;
     }
-    for (const section of this.json.sections) {
+    for (const section of this.#json.sections) {
       callback(section.map, section.offset.line, section.offset.column);
     }
   }
@@ -354,12 +358,12 @@ export class TextSourceMap implements SourceMap {
     }
     for (let i = 0; i < sourceMap.sources.length; ++i) {
       const href = sourceRoot + sourceMap.sources[i];
-      let url = Common.ParsedURL.ParsedURL.completeURL(this.baseURL, href) || href;
+      let url = Common.ParsedURL.ParsedURL.completeURL(this.#baseURL, href) || href;
       const source = sourceMap.sourcesContent && sourceMap.sourcesContent[i];
-      if (url === this.compiledURLInternal && source) {
+      if (url === this.#compiledURLInternal && source) {
         url += '? [sm]';
       }
-      this.sourceInfos.set(url, new TextSourceMap.SourceInfo(source || null, null));
+      this.#sourceInfos.set(url, new TextSourceMap.SourceInfo(source || null, null));
       sourcesList.push(url);
     }
     sourceMapToSourceList.set(sourceMap, sourcesList);

package/front_end/core/sdk/SourceMapManager.ts

@@ -23,61 +23,61 @@ const str_ = i18n.i18n.registerUIStrings('core/sdk/SourceMapManager.ts', UIStrin
 const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
 
 export class SourceMapManager<T extends FrameAssociated> extends Common.ObjectWrapper.ObjectWrapper<EventTypes<T>> {
-  private readonly target: Target;
-  private isEnabled: boolean;
-  private readonly relativeSourceURL: Map<T, string>;
-  private readonly relativeSourceMapURL: Map<T, string>;
-  private resolvedSourceMapId: Map<T, string>;
-  private readonly sourceMapById: Map<string, SourceMap>;
-  private sourceMapIdToLoadingClients: Platform.MapUtilities.Multimap<string, T>;
-  private sourceMapIdToClients: Platform.MapUtilities.Multimap<string, T>;
+  readonly #target: Target;
+  #isEnabled: boolean;
+  readonly #relativeSourceURL: Map<T, string>;
+  readonly #relativeSourceMapURL: Map<T, string>;
+  #resolvedSourceMapId: Map<T, string>;
+  readonly #sourceMapById: Map<string, SourceMap>;
+  #sourceMapIdToLoadingClients: Platform.MapUtilities.Multimap<string, T>;
+  #sourceMapIdToClients: Platform.MapUtilities.Multimap<string, T>;
 
   constructor(target: Target) {
     super();
 
-    this.target = target;
-    this.isEnabled = true;
+    this.#target = target;
+    this.#isEnabled = true;
 
-    this.relativeSourceURL = new Map();
-    this.relativeSourceMapURL = new Map();
-    this.resolvedSourceMapId = new Map();
+    this.#relativeSourceURL = new Map();
+    this.#relativeSourceMapURL = new Map();
+    this.#resolvedSourceMapId = new Map();
 
-    this.sourceMapById = new Map();
-    this.sourceMapIdToLoadingClients = new Platform.MapUtilities.Multimap();
-    this.sourceMapIdToClients = new Platform.MapUtilities.Multimap();
+    this.#sourceMapById = new Map();
+    this.#sourceMapIdToLoadingClients = new Platform.MapUtilities.Multimap();
+    this.#sourceMapIdToClients = new Platform.MapUtilities.Multimap();
 
     TargetManager.instance().addEventListener(TargetManagerEvents.InspectedURLChanged, this.inspectedURLChanged, this);
   }
 
   setEnabled(isEnabled: boolean): void {
-    if (isEnabled === this.isEnabled) {
+    if (isEnabled === this.#isEnabled) {
       return;
     }
-    this.isEnabled = isEnabled;
-    // We need this copy, because `this.resolvedSourceMapId` is getting modified
+    this.#isEnabled = isEnabled;
+    // We need this copy, because `this.#resolvedSourceMapId` is getting modified
     // in the loop body and trying to iterate over it at the same time leads to
     // an infinite loop.
-    const clients = [...this.resolvedSourceMapId.keys()];
+    const clients = [...this.#resolvedSourceMapId.keys()];
     for (const client of clients) {
-      const relativeSourceURL = this.relativeSourceURL.get(client);
-      const relativeSourceMapURL = this.relativeSourceMapURL.get(client);
+      const relativeSourceURL = this.#relativeSourceURL.get(client);
+      const relativeSourceMapURL = this.#relativeSourceMapURL.get(client);
       this.detachSourceMap(client);
       this.attachSourceMap(client, relativeSourceURL, relativeSourceMapURL);
     }
   }
 
   private inspectedURLChanged(event: Common.EventTarget.EventTargetEvent<Target>): void {
-    if (event.data !== this.target) {
+    if (event.data !== this.#target) {
       return;
     }
 
-    // We need this copy, because `this.resolvedSourceMapId` is getting modified
+    // We need this copy, because `this.#resolvedSourceMapId` is getting modified
     // in the loop body and trying to iterate over it at the same time leads to
     // an infinite loop.
-    const prevSourceMapIds = new Map(this.resolvedSourceMapId);
+    const prevSourceMapIds = new Map(this.#resolvedSourceMapId);
     for (const [client, prevSourceMapId] of prevSourceMapIds) {
-      const relativeSourceURL = this.relativeSourceURL.get(client);
-      const relativeSourceMapURL = this.relativeSourceMapURL.get(client);
+      const relativeSourceURL = this.#relativeSourceURL.get(client);
+      const relativeSourceMapURL = this.#relativeSourceMapURL.get(client);
       if (relativeSourceURL === undefined || relativeSourceMapURL === undefined) {
         continue;
       }
@@ -90,19 +90,19 @@ export class SourceMapManager<T extends FrameAssociated> extends Common.ObjectWr
   }
 
   sourceMapForClient(client: T): SourceMap|null {
-    const sourceMapId = this.resolvedSourceMapId.get(client);
+    const sourceMapId = this.#resolvedSourceMapId.get(client);
     if (!sourceMapId) {
       return null;
     }
-    return this.sourceMapById.get(sourceMapId) || null;
+    return this.#sourceMapById.get(sourceMapId) || null;
   }
 
   clientsForSourceMap(sourceMap: SourceMap): T[] {
     const sourceMapId = this.getSourceMapId(sourceMap.compiledURL(), sourceMap.url());
-    if (this.sourceMapIdToClients.has(sourceMapId)) {
-      return [...this.sourceMapIdToClients.get(sourceMapId)];
+    if (this.#sourceMapIdToClients.has(sourceMapId)) {
+      return [...this.#sourceMapIdToClients.get(sourceMapId)];
     }
-    return [...this.sourceMapIdToLoadingClients.get(sourceMapId)];
+    return [...this.#sourceMapIdToLoadingClients.get(sourceMapId)];
   }
 
   private getSourceMapId(sourceURL: string, sourceMapURL: string): string {
@@ -114,9 +114,9 @@ export class SourceMapManager<T extends FrameAssociated> extends Common.ObjectWr
     sourceMapURL: string,
     sourceMapId: string,
   }|null {
-    // |sourceURL| can be a random string, but is generally an absolute path.
+    // |#sourceURL| can be a random string, but is generally an absolute path.
     // Complete it to inspected page url for relative links.
-    const resolvedSourceURL = Common.ParsedURL.ParsedURL.completeURL(this.target.inspectedURL(), sourceURL);
+    const resolvedSourceURL = Common.ParsedURL.ParsedURL.completeURL(this.#target.inspectedURL(), sourceURL);
     if (!resolvedSourceURL) {
       return null;
     }
@@ -136,28 +136,28 @@ export class SourceMapManager<T extends FrameAssociated> extends Common.ObjectWr
     if (relativeSourceURL === undefined || !relativeSourceMapURL) {
       return;
     }
-    console.assert(!this.resolvedSourceMapId.has(client), 'SourceMap is already attached to client');
+    console.assert(!this.#resolvedSourceMapId.has(client), 'SourceMap is already attached to client');
     const resolvedURLs = this.resolveRelativeURLs(relativeSourceURL, relativeSourceMapURL);
     if (!resolvedURLs) {
       return;
     }
-    this.relativeSourceURL.set(client, relativeSourceURL);
-    this.relativeSourceMapURL.set(client, relativeSourceMapURL);
+    this.#relativeSourceURL.set(client, relativeSourceURL);
+    this.#relativeSourceMapURL.set(client, relativeSourceMapURL);
 
     const {sourceURL, sourceMapURL, sourceMapId} = resolvedURLs;
-    this.resolvedSourceMapId.set(client, sourceMapId);
+    this.#resolvedSourceMapId.set(client, sourceMapId);
 
-    if (!this.isEnabled) {
+    if (!this.#isEnabled) {
       return;
     }
 
     this.dispatchEventToListeners(Events.SourceMapWillAttach, {client});
 
-    if (this.sourceMapById.has(sourceMapId)) {
+    if (this.#sourceMapById.has(sourceMapId)) {
       attach.call(this, sourceMapId, client);
       return;
     }
-    if (!this.sourceMapIdToLoadingClients.has(sourceMapId)) {
+    if (!this.#sourceMapIdToLoadingClients.has(sourceMapId)) {
       TextSourceMap.load(sourceMapURL, sourceURL, client.createPageResourceLoadInitiator())
           .catch(error => {
             Common.Console.Console.instance().warn(
@@ -166,12 +166,12 @@ export class SourceMapManager<T extends FrameAssociated> extends Common.ObjectWr
           })
           .then(onSourceMap.bind(this, sourceMapId));
     }
-    this.sourceMapIdToLoadingClients.set(sourceMapId, client);
+    this.#sourceMapIdToLoadingClients.set(sourceMapId, client);
 
     function onSourceMap(this: SourceMapManager<T>, sourceMapId: string, sourceMap: SourceMap|null): void {
       this.sourceMapLoadedForTest();
-      const clients = this.sourceMapIdToLoadingClients.get(sourceMapId);
-      this.sourceMapIdToLoadingClients.deleteAll(sourceMapId);
+      const clients = this.#sourceMapIdToLoadingClients.get(sourceMapId);
+      this.#sourceMapIdToLoadingClients.deleteAll(sourceMapId);
       if (!clients.size) {
         return;
       }
@@ -181,41 +181,41 @@ export class SourceMapManager<T extends FrameAssociated> extends Common.ObjectWr
         }
         return;
       }
-      this.sourceMapById.set(sourceMapId, sourceMap);
+      this.#sourceMapById.set(sourceMapId, sourceMap);
       for (const client of clients) {
         attach.call(this, sourceMapId, client);
       }
     }
 
     function attach(this: SourceMapManager<T>, sourceMapId: string, client: T): void {
-      this.sourceMapIdToClients.set(sourceMapId, client);
-      const sourceMap = this.sourceMapById.get(sourceMapId) as SourceMap;
+      this.#sourceMapIdToClients.set(sourceMapId, client);
+      const sourceMap = this.#sourceMapById.get(sourceMapId) as SourceMap;
       this.dispatchEventToListeners(Events.SourceMapAttached, {client, sourceMap});
     }
   }
 
   detachSourceMap(client: T): void {
-    const sourceMapId = this.resolvedSourceMapId.get(client);
-    this.relativeSourceURL.delete(client);
-    this.relativeSourceMapURL.delete(client);
-    this.resolvedSourceMapId.delete(client);
+    const sourceMapId = this.#resolvedSourceMapId.get(client);
+    this.#relativeSourceURL.delete(client);
+    this.#relativeSourceMapURL.delete(client);
+    this.#resolvedSourceMapId.delete(client);
 
     if (!sourceMapId) {
       return;
     }
-    if (!this.sourceMapIdToClients.hasValue(sourceMapId, client)) {
-      if (this.sourceMapIdToLoadingClients.delete(sourceMapId, client)) {
+    if (!this.#sourceMapIdToClients.hasValue(sourceMapId, client)) {
+      if (this.#sourceMapIdToLoadingClients.delete(sourceMapId, client)) {
         this.dispatchEventToListeners(Events.SourceMapFailedToAttach, {client});
       }
       return;
     }
-    this.sourceMapIdToClients.delete(sourceMapId, client);
-    const sourceMap = this.sourceMapById.get(sourceMapId);
+    this.#sourceMapIdToClients.delete(sourceMapId, client);
+    const sourceMap = this.#sourceMapById.get(sourceMapId);
     if (!sourceMap) {
       return;
     }
-    if (!this.sourceMapIdToClients.has(sourceMapId)) {
-      this.sourceMapById.delete(sourceMapId);
+    if (!this.#sourceMapIdToClients.has(sourceMapId)) {
+      this.#sourceMapById.delete(sourceMapId);
     }
     this.dispatchEventToListeners(Events.SourceMapDetached, {client, sourceMap});
   }

package/front_end/core/sdk/Target.ts

@@ -10,18 +10,18 @@ import type {TargetManager} from './TargetManager.js';
 import {SDKModel} from './SDKModel.js';
 
 export class Target extends ProtocolClient.InspectorBackend.TargetBase {
-  private readonly targetManagerInternal: TargetManager;
-  private nameInternal: string;
-  private inspectedURLInternal: string;
-  private inspectedURLName: string;
-  private readonly capabilitiesMask: number;
-  private typeInternal: Type;
-  private readonly parentTargetInternal: Target|null;
-  private idInternal: Protocol.Target.TargetID|'main';
-  private modelByConstructor: Map<new(arg1: Target) => SDKModel, SDKModel>;
-  private isSuspended: boolean;
-  private targetInfoInternal: Protocol.Target.TargetInfo|undefined;
-  private creatingModels?: boolean;
+  readonly #targetManagerInternal: TargetManager;
+  #nameInternal: string;
+  #inspectedURLInternal: string;
+  #inspectedURLName: string;
+  readonly #capabilitiesMask: number;
+  #typeInternal: Type;
+  readonly #parentTargetInternal: Target|null;
+  #idInternal: Protocol.Target.TargetID|'main';
+  #modelByConstructor: Map<new(arg1: Target) => SDKModel, SDKModel>;
+  #isSuspended: boolean;
+  #targetInfoInternal: Protocol.Target.TargetInfo|undefined;
+  #creatingModels?: boolean;
 
   constructor(
       targetManager: TargetManager, id: Protocol.Target.TargetID|'main', name: string, type: Type,
@@ -29,58 +29,58 @@ export class Target extends ProtocolClient.InspectorBackend.TargetBase {
       connection: ProtocolClient.InspectorBackend.Connection|null, targetInfo?: Protocol.Target.TargetInfo) {
     const needsNodeJSPatching = type === Type.Node;
     super(needsNodeJSPatching, parentTarget, sessionId, connection);
-    this.targetManagerInternal = targetManager;
-    this.nameInternal = name;
-    this.inspectedURLInternal = '';
-    this.inspectedURLName = '';
-    this.capabilitiesMask = 0;
+    this.#targetManagerInternal = targetManager;
+    this.#nameInternal = name;
+    this.#inspectedURLInternal = '';
+    this.#inspectedURLName = '';
+    this.#capabilitiesMask = 0;
     switch (type) {
       case Type.Frame:
-        this.capabilitiesMask = Capability.Browser | Capability.Storage | Capability.DOM | Capability.JS |
+        this.#capabilitiesMask = Capability.Browser | Capability.Storage | Capability.DOM | Capability.JS |
             Capability.Log | Capability.Network | Capability.Target | Capability.Tracing | Capability.Emulation |
             Capability.Input | Capability.Inspector | Capability.Audits | Capability.WebAuthn | Capability.IO |
             Capability.Media;
         if (!parentTarget) {
           // This matches backend exposing certain capabilities only for the main frame.
-          this.capabilitiesMask |=
+          this.#capabilitiesMask |=
               Capability.DeviceEmulation | Capability.ScreenCapture | Capability.Security | Capability.ServiceWorker;
           // TODO(dgozman): we report service workers for the whole frame tree on the main frame,
           // while we should be able to only cover the subtree corresponding to the target.
         }
         break;
       case Type.ServiceWorker:
-        this.capabilitiesMask = Capability.JS | Capability.Log | Capability.Network | Capability.Target |
+        this.#capabilitiesMask = Capability.JS | Capability.Log | Capability.Network | Capability.Target |
             Capability.Inspector | Capability.IO;
         if (!parentTarget) {
-          this.capabilitiesMask |= Capability.Browser;
+          this.#capabilitiesMask |= Capability.Browser;
         }
         break;
       case Type.SharedWorker:
-        this.capabilitiesMask = Capability.JS | Capability.Log | Capability.Network | Capability.Target |
+        this.#capabilitiesMask = Capability.JS | Capability.Log | Capability.Network | Capability.Target |
             Capability.IO | Capability.Media | Capability.Inspector;
         break;
       case Type.Worker:
-        this.capabilitiesMask =
+        this.#capabilitiesMask =
             Capability.JS | Capability.Log | Capability.Network | Capability.Target | Capability.IO | Capability.Media;
         break;
       case Type.Node:
-        this.capabilitiesMask = Capability.JS;
+        this.#capabilitiesMask = Capability.JS;
         break;
       case Type.Browser:
-        this.capabilitiesMask = Capability.Target | Capability.IO;
+        this.#capabilitiesMask = Capability.Target | Capability.IO;
         break;
     }
-    this.typeInternal = type;
-    this.parentTargetInternal = parentTarget;
-    this.idInternal = id;
+    this.#typeInternal = type;
+    this.#parentTargetInternal = parentTarget;
+    this.#idInternal = id;
     /* } */
-    this.modelByConstructor = new Map();
-    this.isSuspended = suspended;
-    this.targetInfoInternal = targetInfo;
+    this.#modelByConstructor = new Map();
+    this.#isSuspended = suspended;
+    this.#targetInfoInternal = targetInfo;
   }
 
   createModels(required: Set<new(arg1: Target) => SDKModel>): void {
-    this.creatingModels = true;
+    this.#creatingModels = true;
     const registeredModels = Array.from(SDKModel.registeredModels.entries());
     // Create early models.
     for (const [modelClass, info] of registeredModels) {
@@ -94,120 +94,121 @@ export class Target extends ProtocolClient.InspectorBackend.TargetBase {
         this.model(modelClass);
       }
     }
-    this.creatingModels = false;
+    this.#creatingModels = false;
   }
 
   id(): Protocol.Target.TargetID|'main' {
-    return this.idInternal;
+    return this.#idInternal;
   }
 
   name(): string {
-    return this.nameInternal || this.inspectedURLName;
+    return this.#nameInternal || this.#inspectedURLName;
   }
 
   type(): Type {
-    return this.typeInternal;
+    return this.#typeInternal;
   }
 
   markAsNodeJSForTest(): void {
     super.markAsNodeJSForTest();
-    this.typeInternal = Type.Node;
+    this.#typeInternal = Type.Node;
   }
 
   targetManager(): TargetManager {
-    return this.targetManagerInternal;
+    return this.#targetManagerInternal;
   }
 
   hasAllCapabilities(capabilitiesMask: number): boolean {
     // TODO(dgozman): get rid of this method, once we never observe targets with
     // capability mask.
-    return (this.capabilitiesMask & capabilitiesMask) === capabilitiesMask;
+    return (this.#capabilitiesMask & capabilitiesMask) === capabilitiesMask;
   }
 
   decorateLabel(label: string): string {
-    return (this.typeInternal === Type.Worker || this.typeInternal === Type.ServiceWorker) ? '\u2699 ' + label : label;
+    return (this.#typeInternal === Type.Worker || this.#typeInternal === Type.ServiceWorker) ? '\u2699 ' + label :
+                                                                                               label;
   }
 
   parentTarget(): Target|null {
-    return this.parentTargetInternal;
+    return this.#parentTargetInternal;
   }
 
   dispose(reason: string): void {
     super.dispose(reason);
-    this.targetManagerInternal.removeTarget(this);
-    for (const model of this.modelByConstructor.values()) {
+    this.#targetManagerInternal.removeTarget(this);
+    for (const model of this.#modelByConstructor.values()) {
       model.dispose();
     }
   }
 
   model<T extends SDKModel>(modelClass: new(arg1: Target) => T): T|null {
-    if (!this.modelByConstructor.get(modelClass)) {
+    if (!this.#modelByConstructor.get(modelClass)) {
       const info = SDKModel.registeredModels.get(modelClass);
       if (info === undefined) {
         throw 'Model class is not registered @' + new Error().stack;
       }
-      if ((this.capabilitiesMask & info.capabilities) === info.capabilities) {
+      if ((this.#capabilitiesMask & info.capabilities) === info.capabilities) {
         const model = new modelClass(this);
-        this.modelByConstructor.set(modelClass, model);
-        if (!this.creatingModels) {
-          this.targetManagerInternal.modelAdded(this, modelClass, model);
+        this.#modelByConstructor.set(modelClass, model);
+        if (!this.#creatingModels) {
+          this.#targetManagerInternal.modelAdded(this, modelClass, model);
         }
       }
     }
-    return (this.modelByConstructor.get(modelClass) as T) || null;
+    return (this.#modelByConstructor.get(modelClass) as T) || null;
   }
 
   models(): Map<new(arg1: Target) => SDKModel, SDKModel> {
-    return this.modelByConstructor;
+    return this.#modelByConstructor;
   }
 
   inspectedURL(): string {
-    return this.inspectedURLInternal;
+    return this.#inspectedURLInternal;
   }
 
   setInspectedURL(inspectedURL: string): void {
-    this.inspectedURLInternal = inspectedURL;
+    this.#inspectedURLInternal = inspectedURL;
     const parsedURL = Common.ParsedURL.ParsedURL.fromString(inspectedURL);
-    this.inspectedURLName = parsedURL ? parsedURL.lastPathComponentWithFragment() : '#' + this.idInternal;
+    this.#inspectedURLName = parsedURL ? parsedURL.lastPathComponentWithFragment() : '#' + this.#idInternal;
     if (!this.parentTarget()) {
       Host.InspectorFrontendHost.InspectorFrontendHostInstance.inspectedURLChanged(inspectedURL || '');
     }
-    this.targetManagerInternal.onInspectedURLChange(this);
-    if (!this.nameInternal) {
-      this.targetManagerInternal.onNameChange(this);
+    this.#targetManagerInternal.onInspectedURLChange(this);
+    if (!this.#nameInternal) {
+      this.#targetManagerInternal.onNameChange(this);
     }
   }
 
   async suspend(reason?: string): Promise<void> {
-    if (this.isSuspended) {
+    if (this.#isSuspended) {
       return;
     }
-    this.isSuspended = true;
+    this.#isSuspended = true;
 
     await Promise.all(Array.from(this.models().values(), m => m.preSuspendModel(reason)));
     await Promise.all(Array.from(this.models().values(), m => m.suspendModel(reason)));
   }
 
   async resume(): Promise<void> {
-    if (!this.isSuspended) {
+    if (!this.#isSuspended) {
       return;
     }
-    this.isSuspended = false;
+    this.#isSuspended = false;
 
     await Promise.all(Array.from(this.models().values(), m => m.resumeModel()));
     await Promise.all(Array.from(this.models().values(), m => m.postResumeModel()));
   }
 
   suspended(): boolean {
-    return this.isSuspended;
+    return this.#isSuspended;
   }
 
   updateTargetInfo(targetInfo: Protocol.Target.TargetInfo): void {
-    this.targetInfoInternal = targetInfo;
+    this.#targetInfoInternal = targetInfo;
   }
 
   targetInfo(): Protocol.Target.TargetInfo|undefined {
-    return this.targetInfoInternal;
+    return this.#targetInfoInternal;
   }
 }