chrome-devtools-frontend 1.0.951410 → 1.0.952713

package/front_end/entrypoints/formatter_worker/FormattedContentBuilder.ts

@@ -3,16 +3,16 @@
 // found in the LICENSE file.
 
 export class FormattedContentBuilder {
-  private lastOriginalPosition = 0;
-  private formattedContent: string[] = [];
-  private formattedContentLength = 0;
-  private lastFormattedPosition = 0;
-  private nestingLevel = 0;
-  private newLines = 0;
-  private enforceSpaceBetweenWords = true;
-  private softSpace = false;
-  private hardSpaces = 0;
-  private cachedIndents = new Map<number, string>();
+  #lastOriginalPosition = 0;
+  #formattedContent: string[] = [];
+  #formattedContentLength = 0;
+  #lastFormattedPosition = 0;
+  #nestingLevel = 0;
+  #newLines = 0;
+  #enforceSpaceBetweenWords = true;
+  #softSpace = false;
+  #hardSpaces = 0;
+  #cachedIndents = new Map<number, string>();
 
   mapping = {original: [0], formatted: [0]};
 
@@ -20,110 +20,110 @@ export class FormattedContentBuilder {
   }
 
   setEnforceSpaceBetweenWords(value: boolean): boolean {
-    const oldValue = this.enforceSpaceBetweenWords;
-    this.enforceSpaceBetweenWords = value;
+    const oldValue = this.#enforceSpaceBetweenWords;
+    this.#enforceSpaceBetweenWords = value;
     return oldValue;
   }
 
   addToken(token: string, offset: number): void {
-    const last = this.formattedContent[this.formattedContent.length - 1];
-    if (this.enforceSpaceBetweenWords && last && /\w/.test(last[last.length - 1]) && /\w/.test(token)) {
+    const last = this.#formattedContent[this.#formattedContent.length - 1];
+    if (this.#enforceSpaceBetweenWords && last && /\w/.test(last[last.length - 1]) && /\w/.test(token)) {
       this.addSoftSpace();
     }
 
-    this.appendFormatting();
+    this.#appendFormatting();
 
     // Insert token.
-    this.addMappingIfNeeded(offset);
-    this.addText(token);
+    this.#addMappingIfNeeded(offset);
+    this.#addText(token);
   }
 
   addSoftSpace(): void {
-    if (!this.hardSpaces) {
-      this.softSpace = true;
+    if (!this.#hardSpaces) {
+      this.#softSpace = true;
     }
   }
 
   addHardSpace(): void {
-    this.softSpace = false;
-    ++this.hardSpaces;
+    this.#softSpace = false;
+    ++this.#hardSpaces;
   }
 
   addNewLine(noSquash?: boolean): void {
     // Avoid leading newlines.
-    if (!this.formattedContentLength) {
+    if (!this.#formattedContentLength) {
       return;
     }
     if (noSquash) {
-      ++this.newLines;
+      ++this.#newLines;
     } else {
-      this.newLines = this.newLines || 1;
+      this.#newLines = this.#newLines || 1;
     }
   }
 
   increaseNestingLevel(): void {
-    this.nestingLevel += 1;
+    this.#nestingLevel += 1;
   }
 
   decreaseNestingLevel(): void {
-    if (this.nestingLevel > 0) {
-      this.nestingLevel -= 1;
+    if (this.#nestingLevel > 0) {
+      this.#nestingLevel -= 1;
     }
   }
 
   content(): string {
-    return this.formattedContent.join('') + (this.newLines ? '\n' : '');
+    return this.#formattedContent.join('') + (this.#newLines ? '\n' : '');
   }
 
-  private appendFormatting(): void {
-    if (this.newLines) {
-      for (let i = 0; i < this.newLines; ++i) {
-        this.addText('\n');
+  #appendFormatting(): void {
+    if (this.#newLines) {
+      for (let i = 0; i < this.#newLines; ++i) {
+        this.#addText('\n');
       }
-      this.addText(this.indent());
-    } else if (this.softSpace) {
-      this.addText(' ');
+      this.#addText(this.#indent());
+    } else if (this.#softSpace) {
+      this.#addText(' ');
     }
-    if (this.hardSpaces) {
-      for (let i = 0; i < this.hardSpaces; ++i) {
-        this.addText(' ');
+    if (this.#hardSpaces) {
+      for (let i = 0; i < this.#hardSpaces; ++i) {
+        this.#addText(' ');
       }
     }
-    this.newLines = 0;
-    this.softSpace = false;
-    this.hardSpaces = 0;
+    this.#newLines = 0;
+    this.#softSpace = false;
+    this.#hardSpaces = 0;
   }
 
-  private indent(): string {
-    const cachedValue = this.cachedIndents.get(this.nestingLevel);
+  #indent(): string {
+    const cachedValue = this.#cachedIndents.get(this.#nestingLevel);
     if (cachedValue) {
       return cachedValue;
     }
 
     let fullIndent = '';
-    for (let i = 0; i < this.nestingLevel; ++i) {
+    for (let i = 0; i < this.#nestingLevel; ++i) {
       fullIndent += this.indentString;
     }
 
     // Cache a maximum of 20 nesting level indents.
-    if (this.nestingLevel <= 20) {
-      this.cachedIndents.set(this.nestingLevel, fullIndent);
+    if (this.#nestingLevel <= 20) {
+      this.#cachedIndents.set(this.#nestingLevel, fullIndent);
     }
     return fullIndent;
   }
 
-  private addText(text: string): void {
-    this.formattedContent.push(text);
-    this.formattedContentLength += text.length;
+  #addText(text: string): void {
+    this.#formattedContent.push(text);
+    this.#formattedContentLength += text.length;
   }
 
-  private addMappingIfNeeded(originalPosition: number): void {
-    if (originalPosition - this.lastOriginalPosition === this.formattedContentLength - this.lastFormattedPosition) {
+  #addMappingIfNeeded(originalPosition: number): void {
+    if (originalPosition - this.#lastOriginalPosition === this.#formattedContentLength - this.#lastFormattedPosition) {
       return;
     }
     this.mapping.original.push(originalPosition);
-    this.lastOriginalPosition = originalPosition;
-    this.mapping.formatted.push(this.formattedContentLength);
-    this.lastFormattedPosition = this.formattedContentLength;
+    this.#lastOriginalPosition = originalPosition;
+    this.mapping.formatted.push(this.#formattedContentLength);
+    this.#lastFormattedPosition = this.#formattedContentLength;
   }
 }

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;
   }
 }