chrome-devtools-frontend 1.0.929965 → 1.0.930993

package/front_end/models/bindings/ResourceMapping.ts

@@ -20,11 +20,11 @@ const scriptOffsetMap = new WeakMap<SDK.Script.Script, TextUtils.TextRange.TextR
 const boundUISourceCodes = new WeakSet<Workspace.UISourceCode.UISourceCode>();
 
 export class ResourceMapping implements SDK.TargetManager.SDKModelObserver<SDK.ResourceTreeModel.ResourceTreeModel> {
-  private readonly workspace: Workspace.Workspace.WorkspaceImpl;
-  private readonly modelToInfo: Map<SDK.ResourceTreeModel.ResourceTreeModel, ModelInfo>;
+  readonly #workspace: Workspace.Workspace.WorkspaceImpl;
+  readonly #modelToInfo: Map<SDK.ResourceTreeModel.ResourceTreeModel, ModelInfo>;
   private constructor(targetManager: SDK.TargetManager.TargetManager, workspace: Workspace.Workspace.WorkspaceImpl) {
-    this.workspace = workspace;
-    this.modelToInfo = new Map();
+    this.#workspace = workspace;
+    this.#modelToInfo = new Map();
     targetManager.observeModels(SDK.ResourceTreeModel.ResourceTreeModel, this);
   }
 
@@ -47,21 +47,21 @@ export class ResourceMapping implements SDK.TargetManager.SDKModelObserver<SDK.R
   }
 
   modelAdded(resourceTreeModel: SDK.ResourceTreeModel.ResourceTreeModel): void {
-    const info = new ModelInfo(this.workspace, resourceTreeModel);
-    this.modelToInfo.set(resourceTreeModel, info);
+    const info = new ModelInfo(this.#workspace, resourceTreeModel);
+    this.#modelToInfo.set(resourceTreeModel, info);
   }
 
   modelRemoved(resourceTreeModel: SDK.ResourceTreeModel.ResourceTreeModel): void {
-    const info = this.modelToInfo.get(resourceTreeModel);
+    const info = this.#modelToInfo.get(resourceTreeModel);
     if (info) {
       info.dispose();
-      this.modelToInfo.delete(resourceTreeModel);
+      this.#modelToInfo.delete(resourceTreeModel);
     }
   }
 
   private infoForTarget(target: SDK.Target.Target): ModelInfo|null {
     const resourceTreeModel = target.model(SDK.ResourceTreeModel.ResourceTreeModel);
-    return resourceTreeModel ? this.modelToInfo.get(resourceTreeModel) || null : null;
+    return resourceTreeModel ? this.#modelToInfo.get(resourceTreeModel) || null : null;
   }
 
   cssLocationToUILocation(cssLocation: SDK.CSSModel.CSSLocation): Workspace.UISourceCode.UILocation|null {
@@ -151,7 +151,7 @@ export class ResourceMapping implements SDK.TargetManager.SDKModelObserver<SDK.R
 
   private resetForTest(target: SDK.Target.Target): void {
     const resourceTreeModel = target.model(SDK.ResourceTreeModel.ResourceTreeModel);
-    const info = resourceTreeModel ? this.modelToInfo.get(resourceTreeModel) : null;
+    const info = resourceTreeModel ? this.#modelToInfo.get(resourceTreeModel) : null;
     if (info) {
       info.resetForTest();
     }
@@ -160,9 +160,9 @@ export class ResourceMapping implements SDK.TargetManager.SDKModelObserver<SDK.R
 
 class ModelInfo {
   project: ContentProviderBasedProject;
-  private readonly bindings: Map<string, Binding>;
-  private readonly cssModel: SDK.CSSModel.CSSModel;
-  private readonly eventListeners: Common.EventTarget.EventDescriptor[];
+  readonly #bindings: Map<string, Binding>;
+  readonly #cssModel: SDK.CSSModel.CSSModel;
+  readonly #eventListeners: Common.EventTarget.EventDescriptor[];
   constructor(
       workspace: Workspace.Workspace.WorkspaceImpl, resourceTreeModel: SDK.ResourceTreeModel.ResourceTreeModel) {
     const target = resourceTreeModel.target();
@@ -171,16 +171,16 @@ class ModelInfo {
         false /* isServiceProject */);
     NetworkProject.setTargetForProject(this.project, target);
 
-    this.bindings = new Map();
+    this.#bindings = new Map();
 
     const cssModel = target.model(SDK.CSSModel.CSSModel);
     console.assert(Boolean(cssModel));
-    this.cssModel = (cssModel as SDK.CSSModel.CSSModel);
-    this.eventListeners = [
+    this.#cssModel = (cssModel as SDK.CSSModel.CSSModel);
+    this.#eventListeners = [
       resourceTreeModel.addEventListener(SDK.ResourceTreeModel.Events.ResourceAdded, this.resourceAdded, this),
       resourceTreeModel.addEventListener(SDK.ResourceTreeModel.Events.FrameWillNavigate, this.frameWillNavigate, this),
       resourceTreeModel.addEventListener(SDK.ResourceTreeModel.Events.FrameDetached, this.frameDetached, this),
-      this.cssModel.addEventListener(
+      this.#cssModel.addEventListener(
           SDK.CSSModel.Events.StyleSheetChanged,
           event => {
             this.styleSheetChanged(event);
@@ -191,11 +191,11 @@ class ModelInfo {
 
   private async styleSheetChanged(event: Common.EventTarget.EventTargetEvent<SDK.CSSModel.StyleSheetChangedEvent>):
       Promise<void> {
-    const header = this.cssModel.styleSheetHeaderForId(event.data.styleSheetId);
+    const header = this.#cssModel.styleSheetHeaderForId(event.data.styleSheetId);
     if (!header || !header.isInline || (header.isInline && header.isMutable)) {
       return;
     }
-    const binding = this.bindings.get(header.resourceURL());
+    const binding = this.#bindings.get(header.resourceURL());
     if (!binding) {
       return;
     }
@@ -235,10 +235,10 @@ class ModelInfo {
       return;
     }
 
-    let binding = this.bindings.get(resource.url);
+    let binding = this.#bindings.get(resource.url);
     if (!binding) {
       binding = new Binding(this.project, resource);
-      this.bindings.set(resource.url, binding);
+      this.#bindings.set(resource.url, binding);
     } else {
       binding.addResource(resource);
     }
@@ -249,13 +249,13 @@ class ModelInfo {
       if (!this.acceptsResource(resource)) {
         continue;
       }
-      const binding = this.bindings.get(resource.url);
+      const binding = this.#bindings.get(resource.url);
       if (!binding) {
         continue;
       }
       if (binding.resources.size === 1) {
         binding.dispose();
-        this.bindings.delete(resource.url);
+        this.#bindings.delete(resource.url);
       } else {
         binding.removeResource(resource);
       }
@@ -273,18 +273,18 @@ class ModelInfo {
   }
 
   resetForTest(): void {
-    for (const binding of this.bindings.values()) {
+    for (const binding of this.#bindings.values()) {
       binding.dispose();
     }
-    this.bindings.clear();
+    this.#bindings.clear();
   }
 
   dispose(): void {
-    Common.EventTarget.removeEventListeners(this.eventListeners);
-    for (const binding of this.bindings.values()) {
+    Common.EventTarget.removeEventListeners(this.#eventListeners);
+    for (const binding of this.#bindings.values()) {
       binding.dispose();
     }
-    this.bindings.clear();
+    this.#bindings.clear();
     this.project.removeProject();
   }
 
@@ -295,33 +295,33 @@ class ModelInfo {
 
 class Binding implements TextUtils.ContentProvider.ContentProvider {
   readonly resources: Set<SDK.Resource.Resource>;
-  private readonly project: ContentProviderBasedProject;
-  private readonly uiSourceCode: Workspace.UISourceCode.UISourceCode;
-  private edits: {
+  readonly #project: ContentProviderBasedProject;
+  readonly #uiSourceCode: Workspace.UISourceCode.UISourceCode;
+  #edits: {
     stylesheet: SDK.CSSStyleSheetHeader.CSSStyleSheetHeader,
     edit: SDK.CSSModel.Edit|null,
   }[];
   constructor(project: ContentProviderBasedProject, resource: SDK.Resource.Resource) {
     this.resources = new Set([resource]);
-    this.project = project;
-    this.uiSourceCode = this.project.createUISourceCode(resource.url, resource.contentType());
-    boundUISourceCodes.add(this.uiSourceCode);
+    this.#project = project;
+    this.#uiSourceCode = this.#project.createUISourceCode(resource.url, resource.contentType());
+    boundUISourceCodes.add(this.#uiSourceCode);
     if (resource.frameId) {
-      NetworkProject.setInitialFrameAttribution(this.uiSourceCode, resource.frameId);
+      NetworkProject.setInitialFrameAttribution(this.#uiSourceCode, resource.frameId);
     }
-    this.project.addUISourceCodeWithProvider(this.uiSourceCode, this, resourceMetadata(resource), resource.mimeType);
-    this.edits = [];
+    this.#project.addUISourceCodeWithProvider(this.#uiSourceCode, this, resourceMetadata(resource), resource.mimeType);
+    this.#edits = [];
   }
 
   private inlineStyles(): SDK.CSSStyleSheetHeader.CSSStyleSheetHeader[] {
-    const target = NetworkProject.targetForUISourceCode(this.uiSourceCode);
+    const target = NetworkProject.targetForUISourceCode(this.#uiSourceCode);
     const stylesheets: SDK.CSSStyleSheetHeader.CSSStyleSheetHeader[] = [];
     if (!target) {
       return stylesheets;
     }
     const cssModel = target.model(SDK.CSSModel.CSSModel);
     if (cssModel) {
-      for (const headerId of cssModel.getStyleSheetIdsForURL(this.uiSourceCode.url())) {
+      for (const headerId of cssModel.getStyleSheetIdsForURL(this.#uiSourceCode.url())) {
         const header = cssModel.styleSheetHeaderForId(headerId);
         if (header) {
           stylesheets.push(header);
@@ -332,7 +332,7 @@ class Binding implements TextUtils.ContentProvider.ContentProvider {
   }
 
   private inlineScripts(): SDK.Script.Script[] {
-    const target = NetworkProject.targetForUISourceCode(this.uiSourceCode);
+    const target = NetworkProject.targetForUISourceCode(this.#uiSourceCode);
     if (!target) {
       return [];
     }
@@ -340,28 +340,28 @@ class Binding implements TextUtils.ContentProvider.ContentProvider {
     if (!debuggerModel) {
       return [];
     }
-    return debuggerModel.scriptsForSourceURL(this.uiSourceCode.url());
+    return debuggerModel.scriptsForSourceURL(this.#uiSourceCode.url());
   }
 
   async styleSheetChanged(stylesheet: SDK.CSSStyleSheetHeader.CSSStyleSheetHeader, edit: SDK.CSSModel.Edit|null):
       Promise<void> {
-    this.edits.push({stylesheet, edit});
-    if (this.edits.length > 1) {
+    this.#edits.push({stylesheet, edit});
+    if (this.#edits.length > 1) {
       return;
     }  // There is already a styleSheetChanged loop running
 
-    const {content} = await this.uiSourceCode.requestContent();
+    const {content} = await this.#uiSourceCode.requestContent();
     if (content !== null) {
       await this.innerStyleSheetChanged(content);
     }
-    this.edits = [];
+    this.#edits = [];
   }
 
   private async innerStyleSheetChanged(content: string): Promise<void> {
     const scripts = this.inlineScripts();
     const styles = this.inlineStyles();
     let text: TextUtils.Text.Text = new TextUtils.Text.Text(content);
-    for (const data of this.edits) {
+    for (const data of this.#edits) {
       const edit = data.edit;
       if (!edit) {
         continue;
@@ -394,25 +394,25 @@ class Binding implements TextUtils.ContentProvider.ContentProvider {
       }
       await Promise.all(updatePromises);
     }
-    this.uiSourceCode.addRevision(text.value());
+    this.#uiSourceCode.addRevision(text.value());
   }
 
   addResource(resource: SDK.Resource.Resource): void {
     this.resources.add(resource);
     if (resource.frameId) {
-      NetworkProject.addFrameAttribution(this.uiSourceCode, resource.frameId);
+      NetworkProject.addFrameAttribution(this.#uiSourceCode, resource.frameId);
     }
   }
 
   removeResource(resource: SDK.Resource.Resource): void {
     this.resources.delete(resource);
     if (resource.frameId) {
-      NetworkProject.removeFrameAttribution(this.uiSourceCode, resource.frameId);
+      NetworkProject.removeFrameAttribution(this.#uiSourceCode, resource.frameId);
     }
   }
 
   dispose(): void {
-    this.project.removeFile(this.uiSourceCode.url());
+    this.#project.removeFile(this.#uiSourceCode.url());
   }
 
   private firstResource(): SDK.Resource.Resource {

package/front_end/models/bindings/ResourceScriptMapping.ts

@@ -60,26 +60,26 @@ const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
 
 export class ResourceScriptMapping implements DebuggerSourceMapping {
   readonly debuggerModel: SDK.DebuggerModel.DebuggerModel;
-  private workspace: Workspace.Workspace.WorkspaceImpl;
+  #workspace: Workspace.Workspace.WorkspaceImpl;
   readonly debuggerWorkspaceBinding: DebuggerWorkspaceBinding;
-  private readonly uiSourceCodeToScriptFile: Map<Workspace.UISourceCode.UISourceCode, ResourceScriptFile>;
-  private readonly projects: Map<string, ContentProviderBasedProject>;
-  private acceptedScripts: Set<SDK.Script.Script>;
-  private readonly eventListeners: Common.EventTarget.EventDescriptor[];
+  readonly #uiSourceCodeToScriptFile: Map<Workspace.UISourceCode.UISourceCode, ResourceScriptFile>;
+  readonly #projects: Map<string, ContentProviderBasedProject>;
+  #acceptedScripts: Set<SDK.Script.Script>;
+  readonly #eventListeners: Common.EventTarget.EventDescriptor[];
 
   constructor(
       debuggerModel: SDK.DebuggerModel.DebuggerModel, workspace: Workspace.Workspace.WorkspaceImpl,
       debuggerWorkspaceBinding: DebuggerWorkspaceBinding) {
     this.debuggerModel = debuggerModel;
-    this.workspace = workspace;
+    this.#workspace = workspace;
     this.debuggerWorkspaceBinding = debuggerWorkspaceBinding;
-    this.uiSourceCodeToScriptFile = new Map();
+    this.#uiSourceCodeToScriptFile = new Map();
 
-    this.projects = new Map();
+    this.#projects = new Map();
 
-    this.acceptedScripts = new Set();
+    this.#acceptedScripts = new Set();
     const runtimeModel = debuggerModel.runtimeModel();
-    this.eventListeners = [
+    this.#eventListeners = [
       this.debuggerModel.addEventListener(
           SDK.DebuggerModel.Events.ParsedScriptSource,
           event => {
@@ -95,14 +95,14 @@ export class ResourceScriptMapping implements DebuggerSourceMapping {
   private project(script: SDK.Script.Script): ContentProviderBasedProject {
     const prefix = script.isContentScript() ? 'js:extensions:' : 'js::';
     const projectId = prefix + this.debuggerModel.target().id() + ':' + script.frameId;
-    let project = this.projects.get(projectId);
+    let project = this.#projects.get(projectId);
     if (!project) {
       const projectType = script.isContentScript() ? Workspace.Workspace.projectTypes.ContentScripts :
                                                      Workspace.Workspace.projectTypes.Network;
       project = new ContentProviderBasedProject(
-          this.workspace, projectId, projectType, '' /* displayName */, false /* isServiceProject */);
+          this.#workspace, projectId, projectType, '' /* displayName */, false /* isServiceProject */);
       NetworkProject.setTargetForProject(project, this.debuggerModel.target());
-      this.projects.set(projectId, project);
+      this.#projects.set(projectId, project);
     }
     return project;
   }
@@ -117,7 +117,7 @@ export class ResourceScriptMapping implements DebuggerSourceMapping {
     if (!uiSourceCode) {
       return null;
     }
-    const scriptFile = this.uiSourceCodeToScriptFile.get(uiSourceCode);
+    const scriptFile = this.#uiSourceCodeToScriptFile.get(uiSourceCode);
     if (!scriptFile) {
       return null;
     }
@@ -137,7 +137,7 @@ export class ResourceScriptMapping implements DebuggerSourceMapping {
 
   uiLocationToRawLocations(uiSourceCode: Workspace.UISourceCode.UISourceCode, lineNumber: number, columnNumber: number):
       SDK.DebuggerModel.Location[] {
-    const scriptFile = this.uiSourceCodeToScriptFile.get(uiSourceCode);
+    const scriptFile = this.#uiSourceCodeToScriptFile.get(uiSourceCode);
     if (!scriptFile || typeof scriptFile.script === 'undefined') {
       return [];
     }
@@ -173,7 +173,7 @@ export class ResourceScriptMapping implements DebuggerSourceMapping {
     if (!this.acceptsScript(script)) {
       return;
     }
-    this.acceptedScripts.add(script);
+    this.#acceptedScripts.add(script);
     const originalContentProvider = script.originalContentProvider();
 
     const url = script.sourceURL;
@@ -182,7 +182,7 @@ export class ResourceScriptMapping implements DebuggerSourceMapping {
     // Remove previous UISourceCode, if any
     const oldUISourceCode = project.uiSourceCodeForURL(url);
     if (oldUISourceCode) {
-      const scriptFile = this.uiSourceCodeToScriptFile.get(oldUISourceCode);
+      const scriptFile = this.#uiSourceCodeToScriptFile.get(oldUISourceCode);
       if (scriptFile && scriptFile.script) {
         await this.removeScript(scriptFile.script);
       }
@@ -195,7 +195,7 @@ export class ResourceScriptMapping implements DebuggerSourceMapping {
 
     // Bind UISourceCode to scripts.
     const scriptFile = new ResourceScriptFile(this, uiSourceCode, [script]);
-    this.uiSourceCodeToScriptFile.set(uiSourceCode, scriptFile);
+    this.#uiSourceCodeToScriptFile.set(uiSourceCode, scriptFile);
 
     const mimeType = script.isWasm() ? 'application/wasm' : 'text/javascript';
     project.addUISourceCodeWithProvider(uiSourceCode, originalContentProvider, metadata, mimeType);
@@ -203,21 +203,21 @@ export class ResourceScriptMapping implements DebuggerSourceMapping {
   }
 
   scriptFile(uiSourceCode: Workspace.UISourceCode.UISourceCode): ResourceScriptFile|null {
-    return this.uiSourceCodeToScriptFile.get(uiSourceCode) || null;
+    return this.#uiSourceCodeToScriptFile.get(uiSourceCode) || null;
   }
 
   private async removeScript(script: SDK.Script.Script): Promise<void> {
-    if (!this.acceptedScripts.has(script)) {
+    if (!this.#acceptedScripts.has(script)) {
       return;
     }
-    this.acceptedScripts.delete(script);
+    this.#acceptedScripts.delete(script);
     const project = this.project(script);
     const uiSourceCode = (project.uiSourceCodeForURL(script.sourceURL) as Workspace.UISourceCode.UISourceCode);
-    const scriptFile = this.uiSourceCodeToScriptFile.get(uiSourceCode);
+    const scriptFile = this.#uiSourceCodeToScriptFile.get(uiSourceCode);
     if (scriptFile) {
       scriptFile.dispose();
     }
-    this.uiSourceCodeToScriptFile.delete(uiSourceCode);
+    this.#uiSourceCodeToScriptFile.delete(uiSourceCode);
     project.removeFile(script.sourceURL);
     await this.debuggerWorkspaceBinding.updateLocations(script);
   }
@@ -232,56 +232,56 @@ export class ResourceScriptMapping implements DebuggerSourceMapping {
   }
 
   private globalObjectCleared(): void {
-    const scripts = Array.from(this.acceptedScripts);
+    const scripts = Array.from(this.#acceptedScripts);
     for (const script of scripts) {
       this.removeScript(script);
     }
   }
 
   resetForTest(): void {
-    const scripts = Array.from(this.acceptedScripts);
+    const scripts = Array.from(this.#acceptedScripts);
     for (const script of scripts) {
       this.removeScript(script);
     }
   }
 
   dispose(): void {
-    Common.EventTarget.removeEventListeners(this.eventListeners);
-    const scripts = Array.from(this.acceptedScripts);
+    Common.EventTarget.removeEventListeners(this.#eventListeners);
+    const scripts = Array.from(this.#acceptedScripts);
     for (const script of scripts) {
       this.removeScript(script);
     }
-    for (const project of this.projects.values()) {
+    for (const project of this.#projects.values()) {
       project.removeProject();
     }
-    this.projects.clear();
+    this.#projects.clear();
   }
 }
 
 export class ResourceScriptFile extends Common.ObjectWrapper.ObjectWrapper<ResourceScriptFile.EventTypes> {
-  private readonly resourceScriptMapping: ResourceScriptMapping;
-  private readonly uiSourceCodeInternal: Workspace.UISourceCode.UISourceCode;
+  readonly #resourceScriptMapping: ResourceScriptMapping;
+  readonly #uiSourceCodeInternal: Workspace.UISourceCode.UISourceCode;
   scriptInternal: SDK.Script.Script|undefined;
-  private scriptSource?: string|null;
-  private isDivergingFromVMInternal?: boolean;
-  private hasDivergedFromVMInternal?: boolean;
-  private isMergingToVMInternal?: boolean;
+  #scriptSource?: string|null;
+  #isDivergingFromVMInternal?: boolean;
+  #hasDivergedFromVMInternal?: boolean;
+  #isMergingToVMInternal?: boolean;
   constructor(
       resourceScriptMapping: ResourceScriptMapping, uiSourceCode: Workspace.UISourceCode.UISourceCode,
       scripts: SDK.Script.Script[]) {
     super();
     console.assert(scripts.length > 0);
 
-    this.resourceScriptMapping = resourceScriptMapping;
-    this.uiSourceCodeInternal = uiSourceCode;
+    this.#resourceScriptMapping = resourceScriptMapping;
+    this.#uiSourceCodeInternal = uiSourceCode;
 
-    if (this.uiSourceCodeInternal.contentType().isScript()) {
+    if (this.#uiSourceCodeInternal.contentType().isScript()) {
       this.scriptInternal = scripts[scripts.length - 1];
     }
 
-    this.uiSourceCodeInternal.addEventListener(
+    this.#uiSourceCodeInternal.addEventListener(
         Workspace.UISourceCode.Events.WorkingCopyChanged, this.workingCopyChanged, this);
-    this.uiSourceCodeInternal.addEventListener(
+    this.#uiSourceCodeInternal.addEventListener(
         Workspace.UISourceCode.Events.WorkingCopyCommitted, this.workingCopyCommitted, this);
   }
 
@@ -290,25 +290,25 @@ export class ResourceScriptFile extends Common.ObjectWrapper.ObjectWrapper<Resou
   }
 
   private isDiverged(): boolean {
-    if (this.uiSourceCodeInternal.isDirty()) {
+    if (this.#uiSourceCodeInternal.isDirty()) {
       return true;
     }
     if (!this.scriptInternal) {
       return false;
     }
-    if (typeof this.scriptSource === 'undefined' || this.scriptSource === null) {
+    if (typeof this.#scriptSource === 'undefined' || this.#scriptSource === null) {
       return false;
     }
-    const workingCopy = this.uiSourceCodeInternal.workingCopy();
+    const workingCopy = this.#uiSourceCodeInternal.workingCopy();
     if (!workingCopy) {
       return false;
     }
 
     // Match ignoring sourceURL.
-    if (!workingCopy.startsWith(this.scriptSource.trimRight())) {
+    if (!workingCopy.startsWith(this.#scriptSource.trimRight())) {
       return true;
     }
-    const suffix = this.uiSourceCodeInternal.workingCopy().substr(this.scriptSource.length);
+    const suffix = this.#uiSourceCodeInternal.workingCopy().substr(this.#scriptSource.length);
     return Boolean(suffix.length) && !suffix.match(SDK.Script.sourceURLRegex);
   }
 
@@ -317,17 +317,17 @@ export class ResourceScriptFile extends Common.ObjectWrapper.ObjectWrapper<Resou
   }
 
   private workingCopyCommitted(): void {
-    if (this.uiSourceCodeInternal.project().canSetFileContent()) {
+    if (this.#uiSourceCodeInternal.project().canSetFileContent()) {
       return;
     }
     if (!this.scriptInternal) {
       return;
     }
-    const debuggerModel = this.resourceScriptMapping.debuggerModel;
+    const debuggerModel = this.#resourceScriptMapping.debuggerModel;
     const breakpoints = BreakpointManager.instance()
-                            .breakpointLocationsForUISourceCode(this.uiSourceCodeInternal)
+                            .breakpointLocationsForUISourceCode(this.#uiSourceCodeInternal)
                             .map(breakpointLocation => breakpointLocation.breakpoint);
-    const source = this.uiSourceCodeInternal.workingCopy();
+    const source = this.#uiSourceCodeInternal.workingCopy();
     debuggerModel.setScriptSource(this.scriptInternal.scriptId, source, (error, exceptionDetails) => {
       this.scriptSourceWasSet(source, breakpoints, error, exceptionDetails);
     });
@@ -337,13 +337,13 @@ export class ResourceScriptFile extends Common.ObjectWrapper.ObjectWrapper<Resou
       source: string, breakpoints: Breakpoint[], error: string|null,
       exceptionDetails?: Protocol.Runtime.ExceptionDetails): Promise<void> {
     if (!error && !exceptionDetails) {
-      this.scriptSource = source;
+      this.#scriptSource = source;
     }
     await this.update();
 
     if (!error && !exceptionDetails) {
-      // Live edit can cause breakpoints to be in the wrong position, or to be lost altogether.
-      // If any breakpoints were in the pre-live edit script, they need to be re-added.
+      // Live edit can cause #breakpoints to be in the wrong position, or to be lost altogether.
+      // If any #breakpoints were in the pre-live edit script, they need to be re-added.
       await Promise.all(breakpoints.map(breakpoint => breakpoint.refreshInDebugger()));
       return;
     }
@@ -353,58 +353,58 @@ export class ResourceScriptFile extends Common.ObjectWrapper.ObjectWrapper<Resou
       return;
     }
     const messageText = i18nString(UIStrings.liveEditCompileFailed, {PH1: exceptionDetails.text});
-    this.uiSourceCodeInternal.addLineMessage(
+    this.#uiSourceCodeInternal.addLineMessage(
         Workspace.UISourceCode.Message.Level.Error, messageText, exceptionDetails.lineNumber,
         exceptionDetails.columnNumber);
   }
 
   private async update(): Promise<void> {
-    if (this.isDiverged() && !this.hasDivergedFromVMInternal) {
+    if (this.isDiverged() && !this.#hasDivergedFromVMInternal) {
       await this.divergeFromVM();
-    } else if (!this.isDiverged() && this.hasDivergedFromVMInternal) {
+    } else if (!this.isDiverged() && this.#hasDivergedFromVMInternal) {
       await this.mergeToVM();
     }
   }
 
   private async divergeFromVM(): Promise<void> {
     if (this.scriptInternal) {
-      this.isDivergingFromVMInternal = true;
-      await this.resourceScriptMapping.debuggerWorkspaceBinding.updateLocations(this.scriptInternal);
-      delete this.isDivergingFromVMInternal;
-      this.hasDivergedFromVMInternal = true;
+      this.#isDivergingFromVMInternal = true;
+      await this.#resourceScriptMapping.debuggerWorkspaceBinding.updateLocations(this.scriptInternal);
+      this.#isDivergingFromVMInternal = undefined;
+      this.#hasDivergedFromVMInternal = true;
       this.dispatchEventToListeners(ResourceScriptFile.Events.DidDivergeFromVM);
     }
   }
 
   private async mergeToVM(): Promise<void> {
     if (this.scriptInternal) {
-      delete this.hasDivergedFromVMInternal;
-      this.isMergingToVMInternal = true;
-      await this.resourceScriptMapping.debuggerWorkspaceBinding.updateLocations(this.scriptInternal);
-      delete this.isMergingToVMInternal;
+      this.#hasDivergedFromVMInternal = undefined;
+      this.#isMergingToVMInternal = true;
+      await this.#resourceScriptMapping.debuggerWorkspaceBinding.updateLocations(this.scriptInternal);
+      this.#isMergingToVMInternal = undefined;
       this.dispatchEventToListeners(ResourceScriptFile.Events.DidMergeToVM);
     }
   }
 
   hasDivergedFromVM(): boolean {
-    return Boolean(this.hasDivergedFromVMInternal);
+    return Boolean(this.#hasDivergedFromVMInternal);
   }
 
   isDivergingFromVM(): boolean {
-    return Boolean(this.isDivergingFromVMInternal);
+    return Boolean(this.#isDivergingFromVMInternal);
   }
 
   isMergingToVM(): boolean {
-    return Boolean(this.isMergingToVMInternal);
+    return Boolean(this.#isMergingToVMInternal);
   }
 
   checkMapping(): void {
-    if (!this.scriptInternal || typeof this.scriptSource !== 'undefined') {
+    if (!this.scriptInternal || typeof this.#scriptSource !== 'undefined') {
       this.mappingCheckedForTest();
       return;
     }
     this.scriptInternal.requestContent().then(deferredContent => {
-      this.scriptSource = deferredContent.content;
+      this.#scriptSource = deferredContent.content;
       this.update().then(() => this.mappingCheckedForTest());
     });
   }
@@ -413,9 +413,9 @@ export class ResourceScriptFile extends Common.ObjectWrapper.ObjectWrapper<Resou
   }
 
   dispose(): void {
-    this.uiSourceCodeInternal.removeEventListener(
+    this.#uiSourceCodeInternal.removeEventListener(
         Workspace.UISourceCode.Events.WorkingCopyChanged, this.workingCopyChanged, this);
-    this.uiSourceCodeInternal.removeEventListener(
+    this.#uiSourceCodeInternal.removeEventListener(
         Workspace.UISourceCode.Events.WorkingCopyCommitted, this.workingCopyCommitted, this);
   }
 
@@ -435,7 +435,7 @@ export class ResourceScriptFile extends Common.ObjectWrapper.ObjectWrapper<Resou
   }
 
   get uiSourceCode(): Workspace.UISourceCode.UISourceCode {
-    return this.uiSourceCodeInternal;
+    return this.#uiSourceCodeInternal;
   }
 }