chrome-devtools-frontend 1.0.950971 → 1.0.952403

package/front_end/entrypoints/formatter_worker/HTMLFormatter.ts

@@ -10,107 +10,107 @@ import {AbortTokenization, createTokenizer} from './FormatterWorker.js';
 import {JavaScriptFormatter} from './JavaScriptFormatter.js';
 
 export class HTMLFormatter {
-  private readonly builder: FormattedContentBuilder;
-  private readonly jsFormatter: JavaScriptFormatter;
-  private readonly cssFormatter: CSSFormatter;
-  private text?: string;
-  private lineEndings?: number[];
-  private model?: HTMLModel;
+  readonly #builder: FormattedContentBuilder;
+  readonly #jsFormatter: JavaScriptFormatter;
+  readonly #cssFormatter: CSSFormatter;
+  #text?: string;
+  #lineEndings?: number[];
+  #model?: HTMLModel;
 
   constructor(builder: FormattedContentBuilder) {
-    this.builder = builder;
-    this.jsFormatter = new JavaScriptFormatter(builder);
-    this.cssFormatter = new CSSFormatter(builder);
+    this.#builder = builder;
+    this.#jsFormatter = new JavaScriptFormatter(builder);
+    this.#cssFormatter = new CSSFormatter(builder);
   }
 
   format(text: string, lineEndings: number[]): void {
-    this.text = text;
-    this.lineEndings = lineEndings;
-    this.model = new HTMLModel(text);
-    this.walk(this.model.document());
+    this.#text = text;
+    this.#lineEndings = lineEndings;
+    this.#model = new HTMLModel(text);
+    this.#walk(this.#model.document());
   }
 
-  private formatTokensTill(element: FormatterElement, offset: number): void {
-    if (!this.model) {
+  #formatTokensTill(element: FormatterElement, offset: number): void {
+    if (!this.#model) {
       return;
     }
 
-    let nextToken = this.model.peekToken();
+    let nextToken = this.#model.peekToken();
     while (nextToken && nextToken.startOffset < offset) {
-      const token = (this.model.nextToken() as Token);
-      this.formatToken(element, token);
-      nextToken = this.model.peekToken();
+      const token = (this.#model.nextToken() as Token);
+      this.#formatToken(element, token);
+      nextToken = this.#model.peekToken();
     }
   }
 
-  private walk(element: FormatterElement): void {
+  #walk(element: FormatterElement): void {
     if (!element.openTag || !element.closeTag) {
       throw new Error('Element is missing open or close tag');
     }
 
     if (element.parent) {
-      this.formatTokensTill(element.parent, element.openTag.startOffset);
+      this.#formatTokensTill(element.parent, element.openTag.startOffset);
     }
-    this.beforeOpenTag(element);
-    this.formatTokensTill(element, element.openTag.endOffset);
-    this.afterOpenTag(element);
+    this.#beforeOpenTag(element);
+    this.#formatTokensTill(element, element.openTag.endOffset);
+    this.#afterOpenTag(element);
     for (let i = 0; i < element.children.length; ++i) {
-      this.walk(element.children[i]);
+      this.#walk(element.children[i]);
     }
 
-    this.formatTokensTill(element, element.closeTag.startOffset);
-    this.beforeCloseTag(element);
-    this.formatTokensTill(element, element.closeTag.endOffset);
-    this.afterCloseTag(element);
+    this.#formatTokensTill(element, element.closeTag.startOffset);
+    this.#beforeCloseTag(element);
+    this.#formatTokensTill(element, element.closeTag.endOffset);
+    this.#afterCloseTag(element);
   }
 
-  private beforeOpenTag(element: FormatterElement): void {
-    if (!this.model) {
+  #beforeOpenTag(element: FormatterElement): void {
+    if (!this.#model) {
       return;
     }
 
-    if (!element.children.length || element === this.model.document()) {
+    if (!element.children.length || element === this.#model.document()) {
       return;
     }
-    this.builder.addNewLine();
+    this.#builder.addNewLine();
   }
 
-  private afterOpenTag(element: FormatterElement): void {
-    if (!this.model) {
+  #afterOpenTag(element: FormatterElement): void {
+    if (!this.#model) {
       return;
     }
 
-    if (!element.children.length || element === this.model.document()) {
+    if (!element.children.length || element === this.#model.document()) {
       return;
     }
-    this.builder.increaseNestingLevel();
-    this.builder.addNewLine();
+    this.#builder.increaseNestingLevel();
+    this.#builder.addNewLine();
   }
 
-  private beforeCloseTag(element: FormatterElement): void {
-    if (!this.model) {
+  #beforeCloseTag(element: FormatterElement): void {
+    if (!this.#model) {
       return;
     }
 
-    if (!element.children.length || element === this.model.document()) {
+    if (!element.children.length || element === this.#model.document()) {
       return;
     }
-    this.builder.decreaseNestingLevel();
-    this.builder.addNewLine();
+    this.#builder.decreaseNestingLevel();
+    this.#builder.addNewLine();
   }
 
-  private afterCloseTag(_element: FormatterElement): void {
-    this.builder.addNewLine();
+  #afterCloseTag(_element: FormatterElement): void {
+    this.#builder.addNewLine();
   }
 
-  private formatToken(element: FormatterElement, token: Token): void {
+  #formatToken(element: FormatterElement, token: Token): void {
     if (Platform.StringUtilities.isWhitespace(token.value)) {
       return;
     }
     if (hasTokenInSet(token.type, 'comment') || hasTokenInSet(token.type, 'meta')) {
-      this.builder.addNewLine();
-      this.builder.addToken(token.value.trim(), token.startOffset);
-      this.builder.addNewLine();
+      this.#builder.addNewLine();
+      this.#builder.addToken(token.value.trim(), token.startOffset);
+      this.#builder.addNewLine();
       return;
     }
 
@@ -121,33 +121,33 @@ export class HTMLFormatter {
     const isBodyToken =
         element.openTag.endOffset <= token.startOffset && token.startOffset < element.closeTag.startOffset;
     if (isBodyToken && element.name === 'style') {
-      this.builder.addNewLine();
-      this.builder.increaseNestingLevel();
-      this.cssFormatter.format(this.text || '', this.lineEndings || [], token.startOffset, token.endOffset);
-      this.builder.decreaseNestingLevel();
+      this.#builder.addNewLine();
+      this.#builder.increaseNestingLevel();
+      this.#cssFormatter.format(this.#text || '', this.#lineEndings || [], token.startOffset, token.endOffset);
+      this.#builder.decreaseNestingLevel();
       return;
     }
     if (isBodyToken && element.name === 'script') {
-      this.builder.addNewLine();
-      this.builder.increaseNestingLevel();
-      if (this.scriptTagIsJavaScript(element)) {
-        this.jsFormatter.format(this.text || '', this.lineEndings || [], token.startOffset, token.endOffset);
+      this.#builder.addNewLine();
+      this.#builder.increaseNestingLevel();
+      if (this.#scriptTagIsJavaScript(element)) {
+        this.#jsFormatter.format(this.#text || '', this.#lineEndings || [], token.startOffset, token.endOffset);
       } else {
-        this.builder.addToken(token.value, token.startOffset);
-        this.builder.addNewLine();
+        this.#builder.addToken(token.value, token.startOffset);
+        this.#builder.addNewLine();
       }
-      this.builder.decreaseNestingLevel();
+      this.#builder.decreaseNestingLevel();
       return;
     }
 
     if (!isBodyToken && hasTokenInSet(token.type, 'attribute')) {
-      this.builder.addSoftSpace();
+      this.#builder.addSoftSpace();
     }
 
-    this.builder.addToken(token.value, token.startOffset);
+    this.#builder.addToken(token.value, token.startOffset);
   }
 
-  private scriptTagIsJavaScript(element: FormatterElement): boolean {
+  #scriptTagIsJavaScript(element: FormatterElement): boolean {
     if (!element.openTag) {
       return true;
     }
@@ -200,37 +200,37 @@ function hasTokenInSet(tokenTypes: Set<string>, type: string): boolean {
 }
 
 export class HTMLModel {
-  private state: ParseState;
-  private readonly documentInternal: FormatterElement;
-  private stack: FormatterElement[];
-  private readonly tokens: Token[];
-  private tokenIndex: number;
-  private attributes: Map<string, string>;
-  private attributeName: string;
-  private tagName: string;
-  private isOpenTag: boolean;
-  private tagStartOffset?: number|null;
-  private tagEndOffset?: number|null;
+  #state: ParseState;
+  readonly #documentInternal: FormatterElement;
+  #stack: FormatterElement[];
+  readonly #tokens: Token[];
+  #tokenIndex: number;
+  #attributes: Map<string, string>;
+  #attributeName: string;
+  #tagName: string;
+  #isOpenTag: boolean;
+  #tagStartOffset?: number|null;
+  #tagEndOffset?: number|null;
 
   constructor(text: string) {
-    this.state = ParseState.Initial;
-    this.documentInternal = new FormatterElement('document');
-    this.documentInternal.openTag = new Tag('document', 0, 0, new Map(), true, false);
-    this.documentInternal.closeTag = new Tag('document', text.length, text.length, new Map(), false, false);
+    this.#state = ParseState.Initial;
+    this.#documentInternal = new FormatterElement('document');
+    this.#documentInternal.openTag = new Tag('document', 0, 0, new Map(), true, false);
+    this.#documentInternal.closeTag = new Tag('document', text.length, text.length, new Map(), false, false);
 
-    this.stack = [this.documentInternal];
+    this.#stack = [this.#documentInternal];
 
-    this.tokens = [];
-    this.tokenIndex = 0;
-    this.build(text);
+    this.#tokens = [];
+    this.#tokenIndex = 0;
+    this.#build(text);
 
-    this.attributes = new Map();
-    this.attributeName = '';
-    this.tagName = '';
-    this.isOpenTag = false;
+    this.#attributes = new Map();
+    this.#attributeName = '';
+    this.#tagName = '';
+    this.#isOpenTag = false;
   }
 
-  private build(text: string): void {
+  #build(text: string): void {
     const tokenizer = createTokenizer('text/html');
     let lastOffset = 0;
     const lowerCaseText = text.toLowerCase();
@@ -240,7 +240,7 @@ export class HTMLModel {
       if (lastOffset >= text.length) {
         break;
       }
-      const element = this.stack[this.stack.length - 1];
+      const element = this.#stack[this.#stack.length - 1];
       if (!element) {
         break;
       }
@@ -257,16 +257,16 @@ export class HTMLModel {
       const tokenStart = element.openTag.endOffset;
       const tokenEnd = lastOffset;
       const tokenValue = text.substring(tokenStart, tokenEnd);
-      this.tokens.push(new Token(tokenValue, new Set(), tokenStart, tokenEnd));
+      this.#tokens.push(new Token(tokenValue, new Set(), tokenStart, tokenEnd));
     }
 
-    while (this.stack.length > 1) {
-      const element = this.stack[this.stack.length - 1];
+    while (this.#stack.length > 1) {
+      const element = this.#stack[this.#stack.length - 1];
       if (!element) {
         break;
       }
 
-      this.popElement(new Tag(element.name, text.length, text.length, new Map(), false, false));
+      this.#popElement(new Tag(element.name, text.length, text.length, new Map(), false, false));
     }
 
     function processToken(
@@ -278,10 +278,10 @@ export class HTMLModel {
 
       const tokenType = type ? new Set<string>(type.split(' ')) : new Set<string>();
       const token = new Token(tokenValue, tokenType, tokenStart, tokenEnd);
-      this.tokens.push(token);
-      this.updateDOM(token);
+      this.#tokens.push(token);
+      this.#updateDOM(token);
 
-      const element = this.stack[this.stack.length - 1];
+      const element = this.#stack[this.#stack.length - 1];
       if (element && (element.name === 'script' || element.name === 'style') && element.openTag &&
           element.openTag.endOffset === lastOffset) {
         return AbortTokenization;
@@ -291,124 +291,125 @@ export class HTMLModel {
     }
   }
 
-  private updateDOM(token: Token): void {
+  #updateDOM(token: Token): void {
     const value = token.value;
     const type = token.type;
-    switch (this.state) {
+    switch (this.#state) {
       case ParseState.Initial:
         if (hasTokenInSet(type, 'bracket') && (value === '<' || value === '</')) {
-          this.onStartTag(token);
-          this.state = ParseState.Tag;
+          this.#onStartTag(token);
+          this.#state = ParseState.Tag;
         }
         return;
       case ParseState.Tag:
         if (hasTokenInSet(type, 'tag') && !hasTokenInSet(type, 'bracket')) {
-          this.tagName = value.trim().toLowerCase();
+          this.#tagName = value.trim().toLowerCase();
         } else if (hasTokenInSet(type, 'attribute')) {
-          this.attributeName = value.trim().toLowerCase();
-          this.attributes.set(this.attributeName, '');
-          this.state = ParseState.AttributeName;
+          this.#attributeName = value.trim().toLowerCase();
+          this.#attributes.set(this.#attributeName, '');
+          this.#state = ParseState.AttributeName;
         } else if (hasTokenInSet(type, 'bracket') && (value === '>' || value === '/>')) {
-          this.onEndTag(token);
-          this.state = ParseState.Initial;
+          this.#onEndTag(token);
+          this.#state = ParseState.Initial;
         }
         return;
       case ParseState.AttributeName:
         if (!type.size && value === '=') {
-          this.state = ParseState.AttributeValue;
+          this.#state = ParseState.AttributeValue;
         } else if (hasTokenInSet(type, 'bracket') && (value === '>' || value === '/>')) {
-          this.onEndTag(token);
-          this.state = ParseState.Initial;
+          this.#onEndTag(token);
+          this.#state = ParseState.Initial;
         }
         return;
       case ParseState.AttributeValue:
         if (hasTokenInSet(type, 'string')) {
-          this.attributes.set(this.attributeName, value);
-          this.state = ParseState.Tag;
+          this.#attributes.set(this.#attributeName, value);
+          this.#state = ParseState.Tag;
         } else if (hasTokenInSet(type, 'bracket') && (value === '>' || value === '/>')) {
-          this.onEndTag(token);
-          this.state = ParseState.Initial;
+          this.#onEndTag(token);
+          this.#state = ParseState.Initial;
         }
         return;
     }
   }
 
-  private onStartTag(token: Token): void {
-    this.tagName = '';
-    this.tagStartOffset = token.startOffset;
-    this.tagEndOffset = null;
-    this.attributes = new Map();
-    this.attributeName = '';
-    this.isOpenTag = token.value === '<';
+  #onStartTag(token: Token): void {
+    this.#tagName = '';
+    this.#tagStartOffset = token.startOffset;
+    this.#tagEndOffset = null;
+    this.#attributes = new Map();
+    this.#attributeName = '';
+    this.#isOpenTag = token.value === '<';
   }
 
-  private onEndTag(token: Token): void {
-    this.tagEndOffset = token.endOffset;
-    const selfClosingTag = token.value === '/>' || SelfClosingTags.has(this.tagName);
+  #onEndTag(token: Token): void {
+    this.#tagEndOffset = token.endOffset;
+    const selfClosingTag = token.value === '/>' || SelfClosingTags.has(this.#tagName);
     const tag = new Tag(
-        this.tagName, this.tagStartOffset || 0, this.tagEndOffset, this.attributes, this.isOpenTag, selfClosingTag);
-    this.onTagComplete(tag);
+        this.#tagName, this.#tagStartOffset || 0, this.#tagEndOffset, this.#attributes, this.#isOpenTag,
+        selfClosingTag);
+    this.#onTagComplete(tag);
   }
 
-  private onTagComplete(tag: Tag): void {
+  #onTagComplete(tag: Tag): void {
     if (tag.isOpenTag) {
-      const topElement = this.stack[this.stack.length - 1];
+      const topElement = this.#stack[this.#stack.length - 1];
       if (topElement) {
         const tagSet = AutoClosingTags.get(topElement.name);
-        if (topElement !== this.documentInternal && topElement.openTag && topElement.openTag.selfClosingTag) {
-          this.popElement(autocloseTag(topElement, topElement.openTag.endOffset));
+        if (topElement !== this.#documentInternal && topElement.openTag && topElement.openTag.selfClosingTag) {
+          this.#popElement(autocloseTag(topElement, topElement.openTag.endOffset));
         } else if (tagSet && tagSet.has(tag.name)) {
-          this.popElement(autocloseTag(topElement, tag.startOffset));
+          this.#popElement(autocloseTag(topElement, tag.startOffset));
         }
-        this.pushElement(tag);
+        this.#pushElement(tag);
       }
       return;
     }
 
-    let lastTag = this.stack[this.stack.length - 1];
-    while (this.stack.length > 1 && lastTag && lastTag.name !== tag.name) {
-      this.popElement(autocloseTag(lastTag, tag.startOffset));
-      lastTag = this.stack[this.stack.length - 1];
+    let lastTag = this.#stack[this.#stack.length - 1];
+    while (this.#stack.length > 1 && lastTag && lastTag.name !== tag.name) {
+      this.#popElement(autocloseTag(lastTag, tag.startOffset));
+      lastTag = this.#stack[this.#stack.length - 1];
     }
-    if (this.stack.length === 1) {
+    if (this.#stack.length === 1) {
       return;
     }
-    this.popElement(tag);
+    this.#popElement(tag);
 
     function autocloseTag(element: FormatterElement, offset: number): Tag {
       return new Tag(element.name, offset, offset, new Map(), false, false);
     }
   }
 
-  private popElement(closeTag: Tag): void {
-    const element = this.stack.pop();
+  #popElement(closeTag: Tag): void {
+    const element = this.#stack.pop();
     if (!element) {
       return;
     }
     element.closeTag = closeTag;
   }
 
-  private pushElement(openTag: Tag): void {
-    const topElement = this.stack[this.stack.length - 1];
+  #pushElement(openTag: Tag): void {
+    const topElement = this.#stack[this.#stack.length - 1];
     const newElement = new FormatterElement(openTag.name);
     if (topElement) {
       newElement.parent = topElement;
       topElement.children.push(newElement);
     }
     newElement.openTag = openTag;
-    this.stack.push(newElement);
+    this.#stack.push(newElement);
   }
 
   peekToken(): Token|null {
-    return this.tokenIndex < this.tokens.length ? this.tokens[this.tokenIndex] : null;
+    return this.#tokenIndex < this.#tokens.length ? this.#tokens[this.#tokenIndex] : null;
   }
 
   nextToken(): Token|null {
-    return this.tokens[this.tokenIndex++];
+    return this.#tokens[this.#tokenIndex++];
   }
 
   document(): FormatterElement {
-    return this.documentInternal;
+    return this.#documentInternal;
   }
 }
 

package/front_end/entrypoints/formatter_worker/JavaScriptFormatter.ts

@@ -36,30 +36,30 @@ import {ESTreeWalker} from './ESTreeWalker.js';
 import type {FormattedContentBuilder} from './FormattedContentBuilder.js';
 
 export class JavaScriptFormatter {
-  private readonly builder: FormattedContentBuilder;
-  private tokenizer!: AcornTokenizer;
-  private content!: string;
-  private fromOffset!: number;
-  private lastLineNumber!: number;
-  private toOffset?: number;
+  readonly #builder: FormattedContentBuilder;
+  #tokenizer!: AcornTokenizer;
+  #content!: string;
+  #fromOffset!: number;
+  #lastLineNumber!: number;
+  #toOffset?: number;
   constructor(builder: FormattedContentBuilder) {
-    this.builder = builder;
+    this.#builder = builder;
   }
 
   format(text: string, lineEndings: number[], fromOffset: number, toOffset: number): void {
-    this.fromOffset = fromOffset;
-    this.toOffset = toOffset;
-    this.content = text.substring(this.fromOffset, this.toOffset);
-    this.lastLineNumber = 0;
-    this.tokenizer = new AcornTokenizer(this.content);
-    const ast = Acorn.parse(this.content, {
+    this.#fromOffset = fromOffset;
+    this.#toOffset = toOffset;
+    this.#content = text.substring(this.#fromOffset, this.#toOffset);
+    this.#lastLineNumber = 0;
+    this.#tokenizer = new AcornTokenizer(this.#content);
+    const ast = Acorn.parse(this.#content, {
       ranges: false,
       preserveParens: true,
       allowImportExportEverywhere: true,
       ecmaVersion: ECMA_VERSION,
       allowHashBang: true,
     });
-    const walker = new ESTreeWalker(this.beforeVisit.bind(this), this.afterVisit.bind(this));
+    const walker = new ESTreeWalker(this.#beforeVisit.bind(this), this.#afterVisit.bind(this));
     // @ts-ignore Technically, the acorn Node type is a subclass of Acorn.ESTree.Node.
     // However, the acorn package currently exports its type without specifying
     // this relationship. So while this is allowed on runtime, we can't properly
@@ -67,55 +67,55 @@ export class JavaScriptFormatter {
     walker.walk(ast);
   }
 
-  private push(token: Acorn.Token|Acorn.Comment|null, format: string): void {
+  #push(token: Acorn.Token|Acorn.Comment|null, format: string): void {
     for (let i = 0; i < format.length; ++i) {
       if (format[i] === 's') {
-        this.builder.addSoftSpace();
+        this.#builder.addSoftSpace();
       } else if (format[i] === 'S') {
-        this.builder.addHardSpace();
+        this.#builder.addHardSpace();
       } else if (format[i] === 'n') {
-        this.builder.addNewLine();
+        this.#builder.addNewLine();
       } else if (format[i] === '>') {
-        this.builder.increaseNestingLevel();
+        this.#builder.increaseNestingLevel();
       } else if (format[i] === '<') {
-        this.builder.decreaseNestingLevel();
+        this.#builder.decreaseNestingLevel();
       } else if (format[i] === 't') {
-        if (this.tokenizer.tokenLineStart() - this.lastLineNumber > 1) {
-          this.builder.addNewLine(true);
+        if (this.#tokenizer.tokenLineStart() - this.#lastLineNumber > 1) {
+          this.#builder.addNewLine(true);
         }
-        this.lastLineNumber = this.tokenizer.tokenLineEnd();
+        this.#lastLineNumber = this.#tokenizer.tokenLineEnd();
         if (token) {
-          this.builder.addToken(this.content.substring(token.start, token.end), this.fromOffset + token.start);
+          this.#builder.addToken(this.#content.substring(token.start, token.end), this.#fromOffset + token.start);
         }
       }
     }
   }
 
-  private beforeVisit(node: Acorn.ESTree.Node): undefined {
+  #beforeVisit(node: Acorn.ESTree.Node): undefined {
     if (!node.parent) {
       return;
     }
     let token;
-    while ((token = this.tokenizer.peekToken()) && token.start < node.start) {
-      const token = (this.tokenizer.nextToken() as TokenOrComment);
+    while ((token = this.#tokenizer.peekToken()) && token.start < node.start) {
+      const token = (this.#tokenizer.nextToken() as TokenOrComment);
       // @ts-ignore Same reason as above about Acorn types and ESTree types
-      const format = this.formatToken(node.parent, token);
-      this.push(token, format);
+      const format = this.#formatToken(node.parent, token);
+      this.#push(token, format);
     }
     return;
   }
 
-  private afterVisit(node: Acorn.ESTree.Node): void {
+  #afterVisit(node: Acorn.ESTree.Node): void {
     let token;
-    while ((token = this.tokenizer.peekToken()) && token.start < node.end) {
-      const token = (this.tokenizer.nextToken() as TokenOrComment);
-      const format = this.formatToken(node, token);
-      this.push(token, format);
+    while ((token = this.#tokenizer.peekToken()) && token.start < node.end) {
+      const token = (this.#tokenizer.nextToken() as TokenOrComment);
+      const format = this.#formatToken(node, token);
+      this.#push(token, format);
     }
-    this.push(null, this.finishNode(node));
+    this.#push(null, this.#finishNode(node));
   }
 
-  private inForLoopHeader(node: Acorn.ESTree.Node): boolean {
+  #inForLoopHeader(node: Acorn.ESTree.Node): boolean {
     const parent = node.parent;
     if (!parent) {
       return false;
@@ -131,7 +131,7 @@ export class JavaScriptFormatter {
     return false;
   }
 
-  private formatToken(node: Acorn.ESTree.Node, tokenOrComment: TokenOrComment): string {
+  #formatToken(node: Acorn.ESTree.Node, tokenOrComment: TokenOrComment): string {
     const AT = AcornTokenizer;
     if (AT.lineComment(tokenOrComment)) {
       return 'tn';
@@ -241,7 +241,7 @@ export class JavaScriptFormatter {
           // it exists. We can't fix that, unless we use proper typechecking
           allVariablesInitialized = allVariablesInitialized && Boolean(declarations[i].init);
         }
-        return !this.inForLoopHeader(node) && allVariablesInitialized ? 'nSSts' : 'ts';
+        return !this.#inForLoopHeader(node) && allVariablesInitialized ? 'nSSts' : 'ts';
       }
     } else if (node.type === 'PropertyDefinition') {
       if (AT.punctuator(token, '=')) {
@@ -356,13 +356,13 @@ export class JavaScriptFormatter {
     return AT.keyword(token) && !AT.keyword(token, 'this') ? 'ts' : 't';
   }
 
-  private finishNode(node: Acorn.ESTree.Node): string {
+  #finishNode(node: Acorn.ESTree.Node): string {
     if (node.type === 'WithStatement') {
       if (node.body && node.body.type !== 'BlockStatement') {
         return 'n<';
       }
     } else if (node.type === 'VariableDeclaration') {
-      if (!this.inForLoopHeader(node)) {
+      if (!this.#inForLoopHeader(node)) {
         return 'n';
       }
     } else if (node.type === 'ForStatement' || node.type === 'ForOfStatement' || node.type === 'ForInStatement') {