DevTools: use semicolons after each statement.

third_party/WebKit/Source/devtools/front_end/source_frame/SourcesTextEditor.js

 // Copyright (c) 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 /**
  * @constructor
  * @extends {WebInspector.CodeMirrorTextEditor}
  * @param {!WebInspector.SourcesTextEditorDelegate} delegate
  */
 WebInspector.SourcesTextEditor = function(delegate)
@@ skipping 39 matching lines @@
     }
 
     this.element.addEventListener("mousedown", updateAnticipateJumpFlag.bind(this, true), true);
     this.element.addEventListener("mousedown", updateAnticipateJumpFlag.bind(this, false), false);
     WebInspector.moduleSetting("textEditorIndent").addChangeListener(this._onUpdateEditorIndentation, this);
     WebInspector.moduleSetting("textEditorAutoDetectIndent").addChangeListener(this._onUpdateEditorIndentation, this);
     WebInspector.moduleSetting("showWhitespacesInEditor").addChangeListener(this._updateWhitespace, this);
 
     this._onUpdateEditorIndentation();
     this._setupWhitespaceHighlight();
-}
+};
 WebInspector.SourcesTextEditor.prototype = {
     /**
      * @return {boolean}
      */
     _isSearchActive: function()
     {
         return !!this._tokenHighlighter.highlightedRegex();
     },
 
     /**
@@ skipping 122 matching lines @@
         this.refresh();
     },
 
     /**
      * @param {number} lineNumber
      * @param {string} type
      * @param {?Element} element
      */
     setGutterDecoration: function(lineNumber, type, element)
     {
-        console.assert(this._gutters.indexOf(type) !== -1, "Cannot decorate unexisting gutter.")
+        console.assert(this._gutters.indexOf(type) !== -1, "Cannot decorate unexisting gutter.");
         this.codeMirror().setGutterMarker(lineNumber, type, element);
     },
 
     /**
      * @param {number} lineNumber
      * @param {number} columnNumber
      */
     setExecutionLocation: function(lineNumber, columnNumber)
     {
         this.clearPositionHighlight();
@@ skipping 122 matching lines @@
             this.codeMirror().setOption("indentUnit", 4);
         } else {
             this.codeMirror().setOption("indentWithTabs", false);
             this.codeMirror().setOption("indentUnit", indent.length);
             extraKeys.Tab = function(codeMirror)
             {
                 if (codeMirror.somethingSelected())
                     return CodeMirror.Pass;
                 var pos = codeMirror.getCursor("head");
                 codeMirror.replaceRange(indent.substring(pos.ch % indent.length), codeMirror.getCursor());
-            }
+            };
         }
 
         this.codeMirror().setOption("extraKeys", extraKeys);
         this._indentationLevel = indent;
     },
 
     /**
      * @return {string}
      */
     indent: function()
@@ skipping 241 matching lines @@
             spaceChars += spaceChar;
             var rule = classBase + i + "::before { content: '" + spaceChars + "';}\n";
             rules += rule;
         }
         var style = doc.createElement("style");
         style.textContent = rules;
         doc.head.appendChild(style);
     },
 
     __proto__: WebInspector.CodeMirrorTextEditor.prototype
-}
+};
 
 /** @typedef {{lineNumber: number, event: !Event}} */
 WebInspector.SourcesTextEditor.GutterClickEventData;
 
 /** @enum {symbol} */
 WebInspector.SourcesTextEditor.Events = {
     GutterClick: Symbol("GutterClick"),
     TextChanged: Symbol("TextChanged"),
     SelectionChanged: Symbol("SelectionChanged"),
     ScrollChanged: Symbol("ScrollChanged"),
     EditorFocused: Symbol("EditorFocused"),
     EditorBlurred: Symbol("EditorBlurred"),
     JumpHappened: Symbol("JumpHappened")
-}
+};
 
 /**
  * @interface
  */
-WebInspector.SourcesTextEditorDelegate = function() { }
+WebInspector.SourcesTextEditorDelegate = function() { };
 WebInspector.SourcesTextEditorDelegate.prototype = {
     /**
      * @param {!WebInspector.ContextMenu} contextMenu
      * @param {number} lineNumber
      * @return {!Promise}
      */
     populateLineGutterContextMenu: function(contextMenu, lineNumber) { },
 
     /**
      * @param {!WebInspector.ContextMenu} contextMenu
      * @param {number} lineNumber
      * @param {number} columnNumber
      * @return {!Promise}
      */
     populateTextAreaContextMenu: function(contextMenu, lineNumber, columnNumber) { },
-}
+};
 
 /**
  * @param {!CodeMirror} codeMirror
  */
 CodeMirror.commands.smartNewlineAndIndent = function(codeMirror)
 {
     codeMirror.operation(innerSmartNewlineAndIndent.bind(null, codeMirror));
     function innerSmartNewlineAndIndent(codeMirror)
     {
         var selections = codeMirror.listSelections();
         var replacements = [];
         for (var i = 0; i < selections.length; ++i) {
             var selection = selections[i];
             var cur = CodeMirror.cmpPos(selection.head, selection.anchor) < 0 ? selection.head : selection.anchor;
             var line = codeMirror.getLine(cur.line);
             var indent = WebInspector.TextUtils.lineIndent(line);
             replacements.push("\n" + indent.substring(0, Math.min(cur.ch, indent.length)));
         }
         codeMirror.replaceSelections(replacements);
         codeMirror._codeMirrorTextEditor._onAutoAppendedSpaces();
     }
-}
+};
 
 /**
  * @return {!Object|undefined}
  */
 CodeMirror.commands.sourcesDismiss = function(codemirror)
 {
     if (codemirror.listSelections().length === 1 && codemirror._codeMirrorTextEditor._isSearchActive())
         return CodeMirror.Pass;
     return CodeMirror.commands.dismiss(codemirror);
-}
+};
 
 /**
  * @constructor
  * @param {!CodeMirror} codeMirror
  */
 WebInspector.SourcesTextEditor.BlockIndentController = function(codeMirror)
 {
     codeMirror.addKeyMap(this);
-}
+};
 
 WebInspector.SourcesTextEditor.BlockIndentController.prototype = {
     name: "blockIndentKeymap",
 
     /**
      * @return {*}
      */
     Enter: function(codeMirror)
     {
         var selections = codeMirror.listSelections();
@@ skipping 68 matching lines @@
                 head: selection.head,
                 anchor: new CodeMirror.Pos(selection.head.line, 0)
             });
             var line = codeMirror.getLine(matchingBracket.to.line);
             var indent = WebInspector.TextUtils.lineIndent(line);
             replacements.push(indent + "}");
         }
         codeMirror.setSelections(updatedSelections);
         codeMirror.replaceSelections(replacements);
     }
-}
+};
 
 /**
  * @param {!Array.<string>} lines
  * @return {string}
  */
 WebInspector.SourcesTextEditor._guessIndentationLevel = function(lines)
 {
     var tabRegex = /^\t+/;
     var tabLines = 0;
     var indents = {};
@@ skipping 19 matching lines @@
     for (var i in indents) {
         if (indents[i] < linesCountPerIndentThreshold)
             continue;
         var indent = parseInt(i, 10);
         if (minimumIndent > indent)
             minimumIndent = indent;
     }
     if (minimumIndent === Infinity)
         return WebInspector.moduleSetting("textEditorIndent").get();
     return " ".repeat(minimumIndent);
-}
+};
 
 /**
  * @constructor
  * @param {!WebInspector.SourcesTextEditor} textEditor
  * @param {!CodeMirror} codeMirror
  */
 WebInspector.SourcesTextEditor.TokenHighlighter = function(textEditor, codeMirror)
 {
     this._textEditor = textEditor;
     this._codeMirror = codeMirror;
-}
+};
 
 WebInspector.SourcesTextEditor.TokenHighlighter.prototype = {
     /**
      * @param {!RegExp} regex
      * @param {?WebInspector.TextRange} range
      */
     highlightSearchResults: function(regex, range)
     {
         var oldRegex = this._highlightRegex;
         this._highlightRegex = regex;
@@ skipping 131 matching lines @@
     {
         var overlayMode = {
             token: highlighter
         };
         this._codeMirror.addOverlay(overlayMode);
         this._highlightDescriptor = {
             overlay: overlayMode,
             selectionStart: selectionStart
         };
     }
-}
+};
 
 WebInspector.SourcesTextEditor.LinesToScanForIndentationGuessing = 1000;
 WebInspector.SourcesTextEditor.MaximumNumberOfWhitespacesPerSingleSpan = 16;