chrome-devtools-frontend 1.0.929965 → 1.0.930993

package/front_end/models/bindings/FileUtils.ts

@@ -54,74 +54,74 @@ declare const DecompressionStream: {
 };
 
 export class ChunkedFileReader implements ChunkedReader {
-  private file: File|null;
-  private readonly fileSizeInternal: number;
-  private loadedSizeInternal: number;
-  private streamReader: ReadableStreamReader<Uint8Array>|null;
-  private readonly chunkSize: number;
-  private readonly chunkTransferredCallback: ((arg0: ChunkedReader) => void)|undefined;
-  private readonly decoder: TextDecoder;
-  private isCanceled: boolean;
-  private errorInternal: DOMException|null;
-  private transferFinished!: (arg0: boolean) => void;
-  private output?: Common.StringOutputStream.OutputStream;
-  private reader?: FileReader|null;
+  #file: File|null;
+  readonly #fileSizeInternal: number;
+  #loadedSizeInternal: number;
+  #streamReader: ReadableStreamReader<Uint8Array>|null;
+  readonly #chunkSize: number;
+  readonly #chunkTransferredCallback: ((arg0: ChunkedReader) => void)|undefined;
+  readonly #decoder: TextDecoder;
+  #isCanceled: boolean;
+  #errorInternal: DOMException|null;
+  #transferFinished!: (arg0: boolean) => void;
+  #output?: Common.StringOutputStream.OutputStream;
+  #reader?: FileReader|null;
 
   constructor(file: File, chunkSize: number, chunkTransferredCallback?: ((arg0: ChunkedReader) => void)) {
-    this.file = file;
-    this.fileSizeInternal = file.size;
-    this.loadedSizeInternal = 0;
-    this.chunkSize = chunkSize;
-    this.chunkTransferredCallback = chunkTransferredCallback;
-    this.decoder = new TextDecoder();
-    this.isCanceled = false;
-    this.errorInternal = null;
-    this.streamReader = null;
+    this.#file = file;
+    this.#fileSizeInternal = file.size;
+    this.#loadedSizeInternal = 0;
+    this.#chunkSize = chunkSize;
+    this.#chunkTransferredCallback = chunkTransferredCallback;
+    this.#decoder = new TextDecoder();
+    this.#isCanceled = false;
+    this.#errorInternal = null;
+    this.#streamReader = null;
   }
 
   async read(output: Common.StringOutputStream.OutputStream): Promise<boolean> {
-    if (this.chunkTransferredCallback) {
-      this.chunkTransferredCallback(this);
+    if (this.#chunkTransferredCallback) {
+      this.#chunkTransferredCallback(this);
     }
 
-    if (this.file?.type.endsWith('gzip')) {
-      const stream = this.decompressStream(this.file.stream());
-      this.streamReader = stream.getReader();
+    if (this.#file?.type.endsWith('gzip')) {
+      const stream = this.decompressStream(this.#file.stream());
+      this.#streamReader = stream.getReader();
     } else {
-      this.reader = new FileReader();
-      this.reader.onload = this.onChunkLoaded.bind(this);
-      this.reader.onerror = this.onError.bind(this);
+      this.#reader = new FileReader();
+      this.#reader.onload = this.onChunkLoaded.bind(this);
+      this.#reader.onerror = this.onError.bind(this);
     }
 
-    this.output = output;
+    this.#output = output;
     this.loadChunk();
 
     return new Promise(resolve => {
-      this.transferFinished = resolve;
+      this.#transferFinished = resolve;
     });
   }
 
   cancel(): void {
-    this.isCanceled = true;
+    this.#isCanceled = true;
   }
 
   loadedSize(): number {
-    return this.loadedSizeInternal;
+    return this.#loadedSizeInternal;
   }
 
   fileSize(): number {
-    return this.fileSizeInternal;
+    return this.#fileSizeInternal;
   }
 
   fileName(): string {
-    if (!this.file) {
+    if (!this.#file) {
       return '';
     }
-    return this.file.name;
+    return this.#file.name;
   }
 
   error(): DOMException|null {
-    return this.errorInternal;
+    return this.#errorInternal;
   }
 
   // Decompress gzip natively thanks to https://wicg.github.io/compression/
@@ -132,7 +132,7 @@ export class ChunkedFileReader implements ChunkedReader {
   }
 
   private onChunkLoaded(event: Event): void {
-    if (this.isCanceled) {
+    if (this.#isCanceled) {
       return;
     }
 
@@ -141,27 +141,27 @@ export class ChunkedFileReader implements ChunkedReader {
       return;
     }
 
-    if (!this.reader) {
+    if (!this.#reader) {
       return;
     }
 
-    const buffer = (this.reader.result as ArrayBuffer);
-    this.loadedSizeInternal += buffer.byteLength;
-    const endOfFile = this.loadedSizeInternal === this.fileSizeInternal;
+    const buffer = (this.#reader.result as ArrayBuffer);
+    this.#loadedSizeInternal += buffer.byteLength;
+    const endOfFile = this.#loadedSizeInternal === this.#fileSizeInternal;
     this.decodeChunkBuffer(buffer, endOfFile);
   }
 
   private async decodeChunkBuffer(buffer: ArrayBuffer, endOfFile: boolean): Promise<void> {
-    if (!this.output) {
+    if (!this.#output) {
       return;
     }
-    const decodedString = this.decoder.decode(buffer, {stream: !endOfFile});
-    await this.output.write(decodedString);
-    if (this.isCanceled) {
+    const decodedString = this.#decoder.decode(buffer, {stream: !endOfFile});
+    await this.#output.write(decodedString);
+    if (this.#isCanceled) {
       return;
     }
-    if (this.chunkTransferredCallback) {
-      this.chunkTransferredCallback(this);
+    if (this.#chunkTransferredCallback) {
+      this.#chunkTransferredCallback(this);
     }
 
     if (endOfFile) {
@@ -172,55 +172,55 @@ export class ChunkedFileReader implements ChunkedReader {
   }
 
   private finishRead(): void {
-    if (!this.output) {
+    if (!this.#output) {
       return;
     }
-    this.file = null;
-    this.reader = null;
-    this.output.close();
-    this.transferFinished(!this.errorInternal);
+    this.#file = null;
+    this.#reader = null;
+    this.#output.close();
+    this.#transferFinished(!this.#errorInternal);
   }
 
   private async loadChunk(): Promise<void> {
-    if (!this.output || !this.file) {
+    if (!this.#output || !this.#file) {
       return;
     }
-    if (this.streamReader) {
-      const {value, done} = await this.streamReader.read();
+    if (this.#streamReader) {
+      const {value, done} = await this.#streamReader.read();
       if (done || !value) {
         return this.finishRead();
       }
       this.decodeChunkBuffer(value.buffer, false);
     }
-    if (this.reader) {
-      const chunkStart = this.loadedSizeInternal;
-      const chunkEnd = Math.min(this.fileSizeInternal, chunkStart + this.chunkSize);
-      const nextPart = this.file.slice(chunkStart, chunkEnd);
-      this.reader.readAsArrayBuffer(nextPart);
+    if (this.#reader) {
+      const chunkStart = this.#loadedSizeInternal;
+      const chunkEnd = Math.min(this.#fileSizeInternal, chunkStart + this.#chunkSize);
+      const nextPart = this.#file.slice(chunkStart, chunkEnd);
+      this.#reader.readAsArrayBuffer(nextPart);
     }
   }
 
   private onError(event: Event): void {
     const eventTarget = (event.target as FileReader);
-    this.errorInternal = eventTarget.error;
-    this.transferFinished(false);
+    this.#errorInternal = eventTarget.error;
+    this.#transferFinished(false);
   }
 }
 
 export class FileOutputStream implements Common.StringOutputStream.OutputStream {
-  private writeCallbacks: (() => void)[];
-  private fileName!: string;
-  private closed?: boolean;
+  #writeCallbacks: (() => void)[];
+  #fileName!: string;
+  #closed?: boolean;
   constructor() {
-    this.writeCallbacks = [];
+    this.#writeCallbacks = [];
   }
 
   async open(fileName: string): Promise<boolean> {
-    this.closed = false;
+    this.#closed = false;
     /** @type {!Array<function():void>} */
-    this.writeCallbacks = [];
-    this.fileName = fileName;
-    const saveResponse = await Workspace.FileManager.FileManager.instance().save(this.fileName, '', true);
+    this.#writeCallbacks = [];
+    this.#fileName = fileName;
+    const saveResponse = await Workspace.FileManager.FileManager.instance().save(this.#fileName, '', true);
     if (saveResponse) {
       Workspace.FileManager.FileManager.instance().addEventListener(
           Workspace.FileManager.Events.AppendedToURL, this.onAppendDone, this);
@@ -230,37 +230,37 @@ export class FileOutputStream implements Common.StringOutputStream.OutputStream
 
   write(data: string): Promise<void> {
     return new Promise(resolve => {
-      this.writeCallbacks.push(resolve);
-      Workspace.FileManager.FileManager.instance().append(this.fileName, data);
+      this.#writeCallbacks.push(resolve);
+      Workspace.FileManager.FileManager.instance().append(this.#fileName, data);
     });
   }
 
   async close(): Promise<void> {
-    this.closed = true;
-    if (this.writeCallbacks.length) {
+    this.#closed = true;
+    if (this.#writeCallbacks.length) {
       return;
     }
     Workspace.FileManager.FileManager.instance().removeEventListener(
         Workspace.FileManager.Events.AppendedToURL, this.onAppendDone, this);
-    Workspace.FileManager.FileManager.instance().close(this.fileName);
+    Workspace.FileManager.FileManager.instance().close(this.#fileName);
   }
 
   private onAppendDone(event: Common.EventTarget.EventTargetEvent<string>): void {
-    if (event.data !== this.fileName) {
+    if (event.data !== this.#fileName) {
       return;
     }
-    const writeCallback = this.writeCallbacks.shift();
+    const writeCallback = this.#writeCallbacks.shift();
     if (writeCallback) {
       writeCallback();
     }
-    if (this.writeCallbacks.length) {
+    if (this.#writeCallbacks.length) {
       return;
     }
-    if (!this.closed) {
+    if (!this.#closed) {
       return;
     }
     Workspace.FileManager.FileManager.instance().removeEventListener(
         Workspace.FileManager.Events.AppendedToURL, this.onAppendDone, this);
-    Workspace.FileManager.FileManager.instance().close(this.fileName);
+    Workspace.FileManager.FileManager.instance().close(this.#fileName);
   }
 }

package/front_end/models/bindings/IgnoreListManager.ts

@@ -12,12 +12,12 @@ import type {DebuggerWorkspaceBinding} from './DebuggerWorkspaceBinding.js';
 let ignoreListManagerInstance: IgnoreListManager;
 
 export class IgnoreListManager implements SDK.TargetManager.SDKModelObserver<SDK.DebuggerModel.DebuggerModel> {
-  private readonly debuggerWorkspaceBinding: DebuggerWorkspaceBinding;
-  private readonly listeners: Set<() => void>;
-  private readonly isIgnoreListedURLCache: Map<string, boolean>;
+  readonly #debuggerWorkspaceBinding: DebuggerWorkspaceBinding;
+  readonly #listeners: Set<() => void>;
+  readonly #isIgnoreListedURLCache: Map<string, boolean>;
 
   private constructor(debuggerWorkspaceBinding: DebuggerWorkspaceBinding) {
-    this.debuggerWorkspaceBinding = debuggerWorkspaceBinding;
+    this.#debuggerWorkspaceBinding = debuggerWorkspaceBinding;
 
     SDK.TargetManager.TargetManager.instance().addModelListener(
         SDK.DebuggerModel.DebuggerModel, SDK.DebuggerModel.Events.GlobalObjectCleared,
@@ -29,9 +29,9 @@ export class IgnoreListManager implements SDK.TargetManager.SDKModelObserver<SDK
         .moduleSetting('skipContentScripts')
         .addChangeListener(this.patternChanged.bind(this));
 
-    this.listeners = new Set();
+    this.#listeners = new Set();
 
-    this.isIgnoreListedURLCache = new Map();
+    this.#isIgnoreListedURLCache = new Map();
 
     SDK.TargetManager.TargetManager.instance().observeModels(SDK.DebuggerModel.DebuggerModel, this);
   }
@@ -55,11 +55,11 @@ export class IgnoreListManager implements SDK.TargetManager.SDKModelObserver<SDK
   }
 
   addChangeListener(listener: () => void): void {
-    this.listeners.add(listener);
+    this.#listeners.add(listener);
   }
 
   removeChangeListener(listener: () => void): void {
-    this.listeners.delete(listener);
+    this.#listeners.delete(listener);
   }
 
   modelAdded(debuggerModel: SDK.DebuggerModel.DebuggerModel): void {
@@ -77,8 +77,8 @@ export class IgnoreListManager implements SDK.TargetManager.SDKModelObserver<SDK
   }
 
   private clearCacheIfNeeded(): void {
-    if (this.isIgnoreListedURLCache.size > 1024) {
-      this.isIgnoreListedURLCache.clear();
+    if (this.#isIgnoreListedURLCache.size > 1024) {
+      this.#isIgnoreListedURLCache.clear();
     }
   }
 
@@ -109,15 +109,15 @@ export class IgnoreListManager implements SDK.TargetManager.SDKModelObserver<SDK
   }
 
   isIgnoreListedURL(url: string, isContentScript?: boolean): boolean {
-    if (this.isIgnoreListedURLCache.has(url)) {
-      return Boolean(this.isIgnoreListedURLCache.get(url));
+    if (this.#isIgnoreListedURLCache.has(url)) {
+      return Boolean(this.#isIgnoreListedURLCache.get(url));
     }
     if (isContentScript && Common.Settings.Settings.instance().moduleSetting('skipContentScripts').get()) {
       return true;
     }
     const regex = this.getSkipStackFramesPatternSetting().asRegExp();
     const isIgnoreListed = (regex && regex.test(url)) || false;
-    this.isIgnoreListedURLCache.set(url, isIgnoreListed);
+    this.#isIgnoreListedURLCache.set(url, isIgnoreListed);
     return isIgnoreListed;
   }
 
@@ -145,7 +145,7 @@ export class IgnoreListManager implements SDK.TargetManager.SDKModelObserver<SDK
       if (scriptToRange.get(script) && await script.setBlackboxedRanges([])) {
         scriptToRange.delete(script);
       }
-      await this.debuggerWorkspaceBinding.updateLocations(script);
+      await this.#debuggerWorkspaceBinding.updateLocations(script);
       return;
     }
 
@@ -173,7 +173,7 @@ export class IgnoreListManager implements SDK.TargetManager.SDKModelObserver<SDK
     if (!isEqual(oldRanges, newRanges) && await script.setBlackboxedRanges(newRanges)) {
       scriptToRange.set(script, newRanges);
     }
-    this.debuggerWorkspaceBinding.updateLocations(script);
+    this.#debuggerWorkspaceBinding.updateLocations(script);
 
     function isEqual(rangesA: SourceRange[], rangesB: SourceRange[]): boolean {
       if (rangesA.length !== rangesB.length) {
@@ -266,7 +266,7 @@ export class IgnoreListManager implements SDK.TargetManager.SDKModelObserver<SDK
   }
 
   private async patternChanged(): Promise<void> {
-    this.isIgnoreListedURLCache.clear();
+    this.#isIgnoreListedURLCache.clear();
 
     const promises: Promise<unknown>[] = [];
     for (const debuggerModel of SDK.TargetManager.TargetManager.instance().models(SDK.DebuggerModel.DebuggerModel)) {
@@ -277,7 +277,7 @@ export class IgnoreListManager implements SDK.TargetManager.SDKModelObserver<SDK
       }
     }
     await Promise.all(promises);
-    const listeners = Array.from(this.listeners);
+    const listeners = Array.from(this.#listeners);
     for (const listener of listeners) {
       listener();
     }

package/front_end/models/bindings/LiveLocation.ts

@@ -12,31 +12,31 @@ export interface LiveLocation {
 }
 
 export class LiveLocationWithPool implements LiveLocation {
-  private updateDelegate: ((arg0: LiveLocation) => Promise<void>)|null;
-  private readonly locationPool: LiveLocationPool;
-  private updatePromise: Promise<void>|null;
+  #updateDelegate: ((arg0: LiveLocation) => Promise<void>)|null;
+  readonly #locationPool: LiveLocationPool;
+  #updatePromise: Promise<void>|null;
 
   constructor(updateDelegate: (arg0: LiveLocation) => Promise<void>, locationPool: LiveLocationPool) {
-    this.updateDelegate = updateDelegate;
-    this.locationPool = locationPool;
-    this.locationPool.add(this);
+    this.#updateDelegate = updateDelegate;
+    this.#locationPool = locationPool;
+    this.#locationPool.add(this);
 
-    this.updatePromise = null;
+    this.#updatePromise = null;
   }
 
   async update(): Promise<void> {
-    if (!this.updateDelegate) {
+    if (!this.#updateDelegate) {
       return;
     }
     // The following is a basic scheduling algorithm, guaranteeing that
-    // {updateDelegate} is always run atomically. That is, we always
+    // {#updateDelegate} is always run atomically. That is, we always
     // wait for an update to finish before we trigger the next run.
-    if (this.updatePromise) {
-      await this.updatePromise.then(() => this.update());
+    if (this.#updatePromise) {
+      await this.#updatePromise.then(() => this.update());
     } else {
-      this.updatePromise = this.updateDelegate(this);
-      await this.updatePromise;
-      this.updatePromise = null;
+      this.#updatePromise = this.#updateDelegate(this);
+      await this.#updatePromise;
+      this.#updatePromise = null;
     }
   }
 
@@ -45,8 +45,8 @@ export class LiveLocationWithPool implements LiveLocation {
   }
 
   dispose(): void {
-    this.locationPool.delete(this);
-    this.updateDelegate = null;
+    this.#locationPool.delete(this);
+    this.#updateDelegate = null;
   }
 
   async isIgnoreListed(): Promise<boolean> {
@@ -55,22 +55,22 @@ export class LiveLocationWithPool implements LiveLocation {
 }
 
 export class LiveLocationPool {
-  private readonly locations: Set<LiveLocation>;
+  readonly #locations: Set<LiveLocation>;
 
   constructor() {
-    this.locations = new Set();
+    this.#locations = new Set();
   }
 
   add(location: LiveLocation): void {
-    this.locations.add(location);
+    this.#locations.add(location);
   }
 
   delete(location: LiveLocation): void {
-    this.locations.delete(location);
+    this.#locations.delete(location);
   }
 
   disposeAll(): void {
-    for (const location of this.locations) {
+    for (const location of this.#locations) {
       location.dispose();
     }
   }

package/front_end/models/bindings/PresentationConsoleMessageHelper.ts

@@ -87,17 +87,17 @@ export class PresentationConsoleMessageManager implements
 }
 
 export class PresentationConsoleMessageHelper {
-  private readonly debuggerModel: SDK.DebuggerModel.DebuggerModel;
-  private pendingConsoleMessages: Map<string, SDK.ConsoleModel.ConsoleMessage[]>;
-  private presentationConsoleMessages: PresentationConsoleMessage[];
-  private readonly locationPool: LiveLocationPool;
+  readonly #debuggerModel: SDK.DebuggerModel.DebuggerModel;
+  #pendingConsoleMessages: Map<string, SDK.ConsoleModel.ConsoleMessage[]>;
+  #presentationConsoleMessages: PresentationConsoleMessage[];
+  readonly #locationPool: LiveLocationPool;
 
   constructor(debuggerModel: SDK.DebuggerModel.DebuggerModel) {
-    this.debuggerModel = debuggerModel;
+    this.#debuggerModel = debuggerModel;
 
-    this.pendingConsoleMessages = new Map();
+    this.#pendingConsoleMessages = new Map();
 
-    this.presentationConsoleMessages = [];
+    this.#presentationConsoleMessages = [];
 
     // TODO(dgozman): queueMicrotask because we race with DebuggerWorkspaceBinding on ParsedScriptSource event delivery.
     debuggerModel.addEventListener(SDK.DebuggerModel.Events.ParsedScriptSource, event => {
@@ -107,7 +107,7 @@ export class PresentationConsoleMessageHelper {
     });
     debuggerModel.addEventListener(SDK.DebuggerModel.Events.GlobalObjectCleared, this.debuggerReset, this);
 
-    this.locationPool = new LiveLocationPool();
+    this.#locationPool = new LiveLocationPool();
   }
 
   consoleMessageAdded(message: SDK.ConsoleModel.ConsoleMessage): void {
@@ -121,31 +121,31 @@ export class PresentationConsoleMessageHelper {
 
   private rawLocation(message: SDK.ConsoleModel.ConsoleMessage): SDK.DebuggerModel.Location|null {
     if (message.scriptId) {
-      return this.debuggerModel.createRawLocationByScriptId(message.scriptId, message.line, message.column);
+      return this.#debuggerModel.createRawLocationByScriptId(message.scriptId, message.line, message.column);
     }
     const callFrame = message.stackTrace && message.stackTrace.callFrames ? message.stackTrace.callFrames[0] : null;
     if (callFrame) {
-      return this.debuggerModel.createRawLocationByScriptId(
+      return this.#debuggerModel.createRawLocationByScriptId(
           callFrame.scriptId, callFrame.lineNumber, callFrame.columnNumber);
     }
     if (message.url) {
-      return this.debuggerModel.createRawLocationByURL(message.url, message.line, message.column);
+      return this.#debuggerModel.createRawLocationByURL(message.url, message.line, message.column);
     }
     return null;
   }
 
   private addConsoleMessageToScript(message: SDK.ConsoleModel.ConsoleMessage, rawLocation: SDK.DebuggerModel.Location):
       void {
-    this.presentationConsoleMessages.push(new PresentationConsoleMessage(message, rawLocation, this.locationPool));
+    this.#presentationConsoleMessages.push(new PresentationConsoleMessage(message, rawLocation, this.#locationPool));
   }
 
   private addPendingConsoleMessage(message: SDK.ConsoleModel.ConsoleMessage): void {
     if (!message.url) {
       return;
     }
-    const pendingMessages = this.pendingConsoleMessages.get(message.url);
+    const pendingMessages = this.#pendingConsoleMessages.get(message.url);
     if (!pendingMessages) {
-      this.pendingConsoleMessages.set(message.url, [message]);
+      this.#pendingConsoleMessages.set(message.url, [message]);
     } else {
       pendingMessages.push(message);
     }
@@ -154,7 +154,7 @@ export class PresentationConsoleMessageHelper {
   private parsedScriptSource(event: Common.EventTarget.EventTargetEvent<SDK.Script.Script>): void {
     const script = event.data;
 
-    const messages = this.pendingConsoleMessages.get(script.sourceURL);
+    const messages = this.#pendingConsoleMessages.get(script.sourceURL);
     if (!messages) {
       return;
     }
@@ -170,28 +170,28 @@ export class PresentationConsoleMessageHelper {
     }
 
     if (pendingMessages.length) {
-      this.pendingConsoleMessages.set(script.sourceURL, pendingMessages);
+      this.#pendingConsoleMessages.set(script.sourceURL, pendingMessages);
     } else {
-      this.pendingConsoleMessages.delete(script.sourceURL);
+      this.#pendingConsoleMessages.delete(script.sourceURL);
     }
   }
 
   consoleCleared(): void {
-    this.pendingConsoleMessages = new Map();
+    this.#pendingConsoleMessages = new Map();
     this.debuggerReset();
   }
 
   private debuggerReset(): void {
-    for (const message of this.presentationConsoleMessages) {
+    for (const message of this.#presentationConsoleMessages) {
       message.dispose();
     }
-    this.presentationConsoleMessages = [];
-    this.locationPool.disposeAll();
+    this.#presentationConsoleMessages = [];
+    this.#locationPool.disposeAll();
   }
 }
 
 export class PresentationConsoleMessage extends Workspace.UISourceCode.Message {
-  private uiSourceCode?: Workspace.UISourceCode.UISourceCode;
+  #uiSourceCode?: Workspace.UISourceCode.UISourceCode;
 
   constructor(
       message: SDK.ConsoleModel.ConsoleMessage, rawLocation: SDK.DebuggerModel.Location,
@@ -203,21 +203,21 @@ export class PresentationConsoleMessage extends Workspace.UISourceCode.Message {
   }
 
   private async updateLocation(liveLocation: LiveLocation): Promise<void> {
-    if (this.uiSourceCode) {
-      this.uiSourceCode.removeMessage(this);
+    if (this.#uiSourceCode) {
+      this.#uiSourceCode.removeMessage(this);
     }
     const uiLocation = await liveLocation.uiLocation();
     if (!uiLocation) {
       return;
     }
     this.range = TextUtils.TextRange.TextRange.createFromLocation(uiLocation.lineNumber, uiLocation.columnNumber || 0);
-    this.uiSourceCode = uiLocation.uiSourceCode;
-    this.uiSourceCode.addMessage(this);
+    this.#uiSourceCode = uiLocation.uiSourceCode;
+    this.#uiSourceCode.addMessage(this);
   }
 
   dispose(): void {
-    if (this.uiSourceCode) {
-      this.uiSourceCode.removeMessage(this);
+    if (this.#uiSourceCode) {
+      this.#uiSourceCode.removeMessage(this);
     }
   }
 }