DevTools: use semicolons after each statement.

third_party/WebKit/Source/devtools/front_end/ui/UIUtils.js

 /*
  * Copyright (C) 2011 Google Inc.  All rights reserved.
  * Copyright (C) 2006, 2007, 2008 Apple Inc.  All rights reserved.
  * Copyright (C) 2007 Matt Lilek (pewtermoose@gmail.com).
  * Copyright (C) 2009 Joseph Pecoraro
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
@@ skipping 49 matching lines @@
             clearInterval(startTimer);
         startTimer = null;
     }
 
     var startTimer;
     element.addEventListener("mousedown", onMouseDown, false);
     if (startDelay)
         element.addEventListener("mouseup", onMouseUp, false);
     if (hoverCursor !== null)
         element.style.cursor = hoverCursor || cursor;
-}
+};
 
 /**
  * @param {!Element} targetElement
  * @param {?function(!MouseEvent):boolean} elementDragStart
  * @param {function(!MouseEvent)} elementDrag
  * @param {?function(!MouseEvent)} elementDragEnd
  * @param {string} cursor
  * @param {!Event} event
  */
 WebInspector.elementDragStart = function(targetElement, elementDragStart, elementDrag, elementDragEnd, cursor, event)
@@ skipping 32 matching lines @@
         targetElement.style.cursor = cursor;
         targetDocument.body.style.cursor = cursor;
     }
     function restoreCursor(oldCursor)
     {
         targetDocument.body.style.removeProperty("cursor");
         targetElement.style.cursor = oldCursor;
         WebInspector._restoreCursorAfterDrag = null;
     }
     event.preventDefault();
-}
+};
 
 WebInspector._mouseOutWhileDragging = function()
 {
     var document = WebInspector._mouseOutWhileDraggingTargetDocument;
     WebInspector._unregisterMouseOutWhileDragging();
     WebInspector._elementDraggingGlassPane = new WebInspector.GlassPane(document);
-}
+};
 
 WebInspector._unregisterMouseOutWhileDragging = function()
 {
     if (!WebInspector._mouseOutWhileDraggingTargetDocument)
         return;
     WebInspector._mouseOutWhileDraggingTargetDocument.removeEventListener("mouseout", WebInspector._mouseOutWhileDragging, true);
     delete WebInspector._mouseOutWhileDraggingTargetDocument;
-}
+};
 
 WebInspector._unregisterDragEvents = function()
 {
     if (!WebInspector._dragEventsTargetDocument)
         return;
     WebInspector._dragEventsTargetDocument.removeEventListener("mousemove", WebInspector._elementDragMove, true);
     WebInspector._dragEventsTargetDocument.removeEventListener("mouseup", WebInspector._elementDragEnd, true);
     if (WebInspector._dragEventsTargetDocument !== WebInspector._dragEventsTargetDocumentTop)
         WebInspector._dragEventsTargetDocumentTop.removeEventListener("mouseup", WebInspector._elementDragEnd, true);
     delete WebInspector._dragEventsTargetDocument;
     delete WebInspector._dragEventsTargetDocumentTop;
-}
+};
 
 /**
  * @param {!Event} event
  */
 WebInspector._elementDragMove = function(event)
 {
     if (event.buttons !== 1) {
         WebInspector._elementDragEnd(event);
         return;
     }
 
     if (WebInspector._elementDraggingEventListener(/** @type {!MouseEvent} */ (event)))
         WebInspector._cancelDragEvents(event);
-}
+};
 
 /**
  * @param {!Event} event
  */
 WebInspector._cancelDragEvents = function(event)
 {
     WebInspector._unregisterDragEvents();
     WebInspector._unregisterMouseOutWhileDragging();
 
     if (WebInspector._restoreCursorAfterDrag)
         WebInspector._restoreCursorAfterDrag();
 
     if (WebInspector._elementDraggingGlassPane)
         WebInspector._elementDraggingGlassPane.dispose();
 
     delete WebInspector._elementDraggingGlassPane;
     delete WebInspector._elementDraggingEventListener;
     delete WebInspector._elementEndDraggingEventListener;
-}
+};
 
 /**
  * @param {!Event} event
  */
 WebInspector._elementDragEnd = function(event)
 {
     var elementDragEnd = WebInspector._elementEndDraggingEventListener;
 
     WebInspector._cancelDragEvents(/** @type {!MouseEvent} */ (event));
 
     event.preventDefault();
     if (elementDragEnd)
         elementDragEnd(/** @type {!MouseEvent} */ (event));
-}
+};
 
 /**
  * @param {!Element} element
  * @param {function(number, number, !MouseEvent): boolean} elementDragStart
  * @param {function(number, number)} elementDrag
  * @param {function(number, number)} elementDragEnd
  * @param {string} cursor
  * @param {?string=} hoverCursor
  * @param {number=} startDelay
  * @param {number=} friction
@@ skipping 54 matching lines @@
         if (!duration)
             return;
         lastTime = now;
         lastX += velocityX * duration;
         lastY += velocityY * duration;
         var k = Math.pow(1 / (1 + friction), duration / 1000);
         velocityX *= k;
         velocityY *= k;
         elementDrag(lastX, lastY);
     }
-}
+};
 
 /**
  * @constructor
  * @param {!Document} document
  * @param {boolean=} dimmed
  */
 WebInspector.GlassPane = function(document, dimmed)
 {
     this.element = createElement("div");
     var background = dimmed ? "rgba(255, 255, 255, 0.5)" : "transparent";
     this._zIndex = WebInspector._glassPane ? WebInspector._glassPane._zIndex + 1000 : 3000; // Deliberately starts with 3000 to hide other z-indexed elements below.
     this.element.style.cssText = "position:absolute;top:0;bottom:0;left:0;right:0;background-color:" + background + ";z-index:" + this._zIndex + ";overflow:hidden;";
     document.body.appendChild(this.element);
     WebInspector._glassPane = this;
     // TODO(dgozman): disallow focus outside of glass pane?
-}
+};
 
 WebInspector.GlassPane.prototype = {
     dispose: function()
     {
         delete WebInspector._glassPane;
         this.element.remove();
     }
-}
+};
 
 /** @type {!WebInspector.GlassPane|undefined} */
 WebInspector._glassPane;
 
 /**
  * @param {?Node=} node
  * @return {boolean}
  */
 WebInspector.isBeingEdited = function(node)
 {
     if (!node || node.nodeType !== Node.ELEMENT_NODE)
         return false;
     var element = /** {!Element} */ (node);
     if (element.classList.contains("text-prompt") || element.nodeName === "INPUT" || element.nodeName === "TEXTAREA")
         return true;
 
     if (!WebInspector.__editingCount)
         return false;
 
     while (element) {
         if (element.__editing)
             return true;
         element = element.parentElementOrShadowHost();
     }
     return false;
-}
+};
 
 /**
  * @return {boolean}
  * @suppressGlobalPropertiesCheck
  */
 WebInspector.isEditing = function()
 {
     if (WebInspector.__editingCount)
         return true;
 
     var focused = document.deepActiveElement();
     if (!focused)
         return false;
     return focused.classList.contains("text-prompt") || focused.nodeName === "INPUT" || focused.nodeName === "TEXTAREA";
-}
+};
 
 /**
  * @param {!Element} element
  * @param {boolean} value
  * @return {boolean}
  */
 WebInspector.markBeingEdited = function(element, value)
 {
     if (value) {
         if (element.__editing)
             return false;
         element.classList.add("being-edited");
         element.__editing = true;
         WebInspector.__editingCount = (WebInspector.__editingCount || 0) + 1;
     } else {
         if (!element.__editing)
             return false;
         element.classList.remove("being-edited");
         delete element.__editing;
         --WebInspector.__editingCount;
     }
     return true;
-}
+};
 
 WebInspector.CSSNumberRegex = /^(-?(?:\d+(?:\.\d+)?|\.\d+))$/;
 
 WebInspector.StyleValueDelimiters = " \xA0\t\n\"':;,/()";
 
 
 /**
  * @param {!Event} event
  * @return {?string}
  */
 WebInspector._valueModificationDirection = function(event)
 {
     var direction = null;
     if (event.type === "mousewheel") {
         // When shift is pressed while spinning mousewheel, delta comes as wheelDeltaX.
         if (event.wheelDeltaY > 0 || event.wheelDeltaX > 0)
             direction = "Up";
         else if (event.wheelDeltaY < 0 || event.wheelDeltaX < 0)
             direction = "Down";
     } else {
         if (event.key === "ArrowUp" || event.key === "PageUp")
             direction = "Up";
         else if (event.key === "ArrowDown" || event.key === "PageDown")
             direction = "Down";
     }
     return direction;
-}
+};
 
 /**
  * @param {string} hexString
  * @param {!Event} event
  * @return {?string}
  */
 WebInspector._modifiedHexValue = function(hexString, event)
 {
     var direction = WebInspector._valueModificationDirection(event);
     if (!direction)
@@ skipping 31 matching lines @@
 
     // Increase hex value by 1 and clamp from 0 ... maxValue.
     var maxValue = Math.pow(16, hexStrLen) - 1;
     var result = Number.constrain(number + delta, 0, maxValue);
 
     // Ensure the result length is the same as the original hex value.
     var resultString = result.toString(16).toUpperCase();
     for (var i = 0, lengthDelta = hexStrLen - resultString.length; i < lengthDelta; ++i)
         resultString = "0" + resultString;
     return resultString;
-}
+};
 
 /**
  * @param {number} number
  * @param {!Event} event
  * @return {?number}
  */
 WebInspector._modifiedFloatNumber = function(number, event)
 {
     var direction = WebInspector._valueModificationDirection(event);
     if (!direction)
@@ skipping 17 matching lines @@
     if (direction === "Down")
         delta *= -1;
 
     // Make the new number and constrain it to a precision of 6, this matches numbers the engine returns.
     // Use the Number constructor to forget the fixed precision, so 1.100000 will print as 1.1.
     var result = Number((number + delta).toFixed(6));
     if (!String(result).match(WebInspector.CSSNumberRegex))
         return null;
 
     return result;
-}
+};
 
 /**
  * @param {string} wordString
  * @param {!Event} event
  * @param {function(string, number, string):string=} customNumberHandler
  * @return {?string}
  */
 WebInspector.createReplacementString = function(wordString, event, customNumberHandler)
 {
     var prefix;
@@ skipping 11 matching lines @@
         matches = /(.*?)(-?(?:\d+(?:\.\d+)?|\.\d+))(.*)/.exec(wordString);
         if (matches && matches.length) {
             prefix = matches[1];
             suffix = matches[3];
             number = WebInspector._modifiedFloatNumber(parseFloat(matches[2]), event);
             if (number !== null)
                 replacementString = customNumberHandler ? customNumberHandler(prefix, number, suffix) : prefix + number + suffix;
         }
     }
     return replacementString;
-}
+};
 
 /**
  * @param {!Event} event
  * @param {!Element} element
  * @param {function(string,string)=} finishHandler
  * @param {function(string)=} suggestionHandler
  * @param {function(string, number, string):string=} customNumberHandler
  * @return {boolean}
  */
 WebInspector.handleElementValueModifications = function(event, element, finishHandler, suggestionHandler, customNumberHandler)
@@ skipping 44 matching lines @@
 
         event.handled = true;
         event.preventDefault();
 
         if (finishHandler)
             finishHandler(originalValue, replacementString);
 
         return true;
     }
     return false;
-}
+};
 
 /**
  * @param {number} ms
  * @param {number=} precision
  * @return {string}
  */
 Number.preciseMillisToString = function(ms, precision)
 {
     precision = precision || 0;
     var format = "%." + precision + "f\u2009ms";
     return WebInspector.UIString(format, ms);
-}
+};
 
 /** @type {!WebInspector.UIStringFormat} */
 WebInspector._microsFormat = new WebInspector.UIStringFormat("%.0f\u2009\u03bcs");
 
 /** @type {!WebInspector.UIStringFormat} */
 WebInspector._subMillisFormat = new WebInspector.UIStringFormat("%.2f\u2009ms");
 
 /** @type {!WebInspector.UIStringFormat} */
 WebInspector._millisFormat = new WebInspector.UIStringFormat("%.0f\u2009ms");
 
@@ skipping 36 matching lines @@
     var minutes = seconds / 60;
     if (minutes < 60)
         return WebInspector._minutesFormat.format(minutes);
 
     var hours = minutes / 60;
     if (hours < 24)
         return WebInspector._hoursFormat.format(hours);
 
     var days = hours / 24;
     return WebInspector._daysFormat.format(days);
-}
+};
 
 /**
  * @param {number} seconds
  * @param {boolean=} higherResolution
  * @return {string}
  */
 Number.secondsToString = function(seconds, higherResolution)
 {
     if (!isFinite(seconds))
         return "-";
     return Number.millisToString(seconds * 1000, higherResolution);
-}
+};
 
 /**
  * @param {number} bytes
  * @return {string}
  */
 Number.bytesToString = function(bytes)
 {
     if (bytes < 1024)
         return WebInspector.UIString("%.0f\u2009B", bytes);
 
     var kilobytes = bytes / 1024;
     if (kilobytes < 100)
         return WebInspector.UIString("%.1f\u2009KB", kilobytes);
     if (kilobytes < 1024)
         return WebInspector.UIString("%.0f\u2009KB", kilobytes);
 
     var megabytes = kilobytes / 1024;
     if (megabytes < 100)
         return WebInspector.UIString("%.1f\u2009MB", megabytes);
     else
         return WebInspector.UIString("%.0f\u2009MB", megabytes);
-}
+};
 
 /**
  * @param {number} num
  * @return {string}
  */
 Number.withThousandsSeparator = function(num)
 {
     var str = num + "";
     var re = /(\d+)(\d{3})/;
     while (str.match(re))
         str = str.replace(re, "$1\u2009$2"); // \u2009 is a thin space.
     return str;
-}
+};
 
 /**
  * @param {string} format
  * @param {?ArrayLike} substitutions
  * @return {!Element}
  */
 WebInspector.formatLocalized = function(format, substitutions)
 {
     var formatters = {
         s: substitution => substitution
     };
     /**
      * @param {!Element} a
      * @param {string|!Element} b
      * @return {!Element}
      */
     function append(a, b)
     {
         a.appendChild(typeof b === "string" ? createTextNode(b) : b);
         return a;
     }
     return String.format(WebInspector.UIString(format), substitutions, formatters, createElement("span"), append).formattedResult;
-}
+};
 
 /**
  * @return {string}
  */
 WebInspector.openLinkExternallyLabel = function()
 {
     return WebInspector.UIString.capitalize("Open ^link in ^new ^tab");
-}
+};
 
 /**
  * @return {string}
  */
 WebInspector.copyLinkAddressLabel = function()
 {
     return WebInspector.UIString.capitalize("Copy ^link ^address");
-}
+};
 
 /**
  * @return {string}
  */
 WebInspector.anotherProfilerActiveLabel = function()
 {
     return WebInspector.UIString("Another profiler is already active");
-}
+};
 
 /**
  * @param {string|undefined} description
  * @return {string}
  */
 WebInspector.asyncStackTraceLabel = function(description)
 {
     if (description)
         return description + " " + WebInspector.UIString("(async)");
     return WebInspector.UIString("Async Call");
-}
+};
 
 /**
  * @param {!Element} element
  */
 WebInspector.installComponentRootStyles = function(element)
 {
     WebInspector.appendStyle(element, "ui/inspectorCommon.css");
     WebInspector.themeSupport.injectHighlightStyleSheets(element);
     element.classList.add("platform-" + WebInspector.platform());
-}
+};
 
 /**
  * @param {!Element} element
  * @param {string=} cssFile
  * @return {!DocumentFragment}
  */
 WebInspector.createShadowRootWithCoreStyles = function(element, cssFile)
 {
     var shadowRoot = element.createShadowRoot();
     WebInspector.appendStyle(shadowRoot, "ui/inspectorCommon.css");
     WebInspector.themeSupport.injectHighlightStyleSheets(shadowRoot);
     if (cssFile)
         WebInspector.appendStyle(shadowRoot, cssFile);
     shadowRoot.addEventListener("focus", WebInspector._focusChanged.bind(WebInspector), true);
     return shadowRoot;
-}
+};
 
 /**
  * @param {!Document} document
  * @param {!Event} event
  */
 WebInspector._windowFocused = function(document, event)
 {
     if (event.target.document.nodeType === Node.DOCUMENT_NODE)
         document.body.classList.remove("inactive");
-}
+};
 
 /**
  * @param {!Document} document
  * @param {!Event} event
  */
 WebInspector._windowBlurred = function(document, event)
 {
     if (event.target.document.nodeType === Node.DOCUMENT_NODE)
         document.body.classList.add("inactive");
-}
+};
 
 /**
  * @param {!Event} event
  */
 WebInspector._focusChanged = function(event)
 {
     var document = event.target && event.target.ownerDocument;
     var element = document ? document.deepActiveElement() : null;
     WebInspector.Widget.focusWidgetForNode(element);
-}
+};
 
 /**
  * @param {!Element} element
  * @constructor
  */
 WebInspector.ElementFocusRestorer = function(element)
 {
     this._element = element;
     this._previous = element.ownerDocument.deepActiveElement();
     element.focus();
-}
+};
 
 WebInspector.ElementFocusRestorer.prototype = {
     restore: function()
     {
         if (!this._element)
             return;
         if (this._element.hasFocus() && this._previous)
             this._previous.focus();
         this._previous = null;
         this._element = null;
     }
-}
+};
 
 /**
  * @param {!Element} element
  * @param {number} offset
  * @param {number} length
  * @param {!Array.<!Object>=} domChanges
  * @return {?Element}
  */
 WebInspector.highlightSearchResult = function(element, offset, length, domChanges)
 {
     var result = WebInspector.highlightSearchResults(element, [new WebInspector.SourceRange(offset, length)], domChanges);
     return result.length ? result[0] : null;
-}
+};
 
 /**
  * @param {!Element} element
  * @param {!Array.<!WebInspector.SourceRange>} resultRanges
  * @param {!Array.<!Object>=} changes
  * @return {!Array.<!Element>}
  */
 WebInspector.highlightSearchResults = function(element, resultRanges, changes)
 {
     return WebInspector.highlightRangesWithStyleClass(element, resultRanges, WebInspector.highlightedSearchResultClassName, changes);
-}
+};
 
 /**
  * @param {!Element} element
  * @param {string} className
  */
 WebInspector.runCSSAnimationOnce = function(element, className)
 {
     function animationEndCallback()
     {
         element.classList.remove(className);
         element.removeEventListener("webkitAnimationEnd", animationEndCallback, false);
     }
 
     if (element.classList.contains(className))
         element.classList.remove(className);
 
     element.addEventListener("webkitAnimationEnd", animationEndCallback, false);
     element.classList.add(className);
-}
+};
 
 /**
  * @param {!Element} element
  * @param {!Array.<!WebInspector.SourceRange>} resultRanges
  * @param {string} styleClass
  * @param {!Array.<!Object>=} changes
  * @return {!Array.<!Element>}
  */
 WebInspector.highlightRangesWithStyleClass = function(element, resultRanges, styleClass, changes)
 {
@@ skipping 64 matching lines @@
                 textNode.textContent = "";
                 changes.push({ node: textNode, type: "changed", oldText: text, newText: textNode.textContent });
             }
         }
         startIndex = endIndex;
         nodeRanges[startIndex].offset = endOffset;
         nodeRanges[startIndex].length = lastTextNode.textContent.length;
 
     }
     return highlightNodes;
-}
+};
 
 WebInspector.applyDomChanges = function(domChanges)
 {
     for (var i = 0, size = domChanges.length; i < size; ++i) {
         var entry = domChanges[i];
         switch (entry.type) {
         case "added":
             entry.parent.insertBefore(entry.node, entry.nextSibling);
             break;
         case "changed":
             entry.node.textContent = entry.newText;
             break;
         }
     }
-}
+};
 
 WebInspector.revertDomChanges = function(domChanges)
 {
     for (var i = domChanges.length - 1; i >= 0; --i) {
         var entry = domChanges[i];
         switch (entry.type) {
         case "added":
             entry.node.remove();
             break;
         case "changed":
             entry.node.textContent = entry.oldText;
             break;
         }
     }
-}
+};
 
 /**
  * @param {!Element} element
  * @param {?Element=} containerElement
  * @return {!Size}
  */
 WebInspector.measurePreferredSize = function(element, containerElement)
 {
     var oldParent = element.parentElement;
     var oldNextSibling = element.nextSibling;
     containerElement = containerElement || element.ownerDocument.body;
     containerElement.appendChild(element);
     element.positionAt(0, 0);
     var result = new Size(element.offsetWidth, element.offsetHeight);
 
     element.positionAt(undefined, undefined);
     if (oldParent)
         oldParent.insertBefore(element, oldNextSibling);
     else
         element.remove();
     return result;
-}
+};
 
 /**
  * @constructor
  * @param {boolean} autoInvoke
  */
 WebInspector.InvokeOnceHandlers = function(autoInvoke)
 {
     this._handlers = null;
     this._autoInvoke = autoInvoke;
-}
+};
 
 WebInspector.InvokeOnceHandlers.prototype = {
     /**
      * @param {!Object} object
      * @param {function()} method
      */
     add: function(object, method)
     {
         if (!this._handlers) {
             this._handlers = new Map();
@@ skipping 22 matching lines @@
         var handlers = this._handlers;
         this._handlers = null;
         var keys = handlers.keysArray();
         for (var i = 0; i < keys.length; ++i) {
             var object = keys[i];
             var methods = handlers.get(object).valuesArray();
             for (var j = 0; j < methods.length; ++j)
                 methods[j].call(object);
         }
     }
-}
+};
 
 WebInspector._coalescingLevel = 0;
 WebInspector._postUpdateHandlers = null;
 
 WebInspector.startBatchUpdate = function()
 {
     if (!WebInspector._coalescingLevel++)
         WebInspector._postUpdateHandlers = new WebInspector.InvokeOnceHandlers(false);
-}
+};
 
 WebInspector.endBatchUpdate = function()
 {
     if (--WebInspector._coalescingLevel)
         return;
     WebInspector._postUpdateHandlers.scheduleInvoke();
     WebInspector._postUpdateHandlers = null;
-}
+};
 
 /**
  * @param {!Object} object
  * @param {function()} method
  */
 WebInspector.invokeOnceAfterBatchUpdate = function(object, method)
 {
     if (!WebInspector._postUpdateHandlers)
         WebInspector._postUpdateHandlers = new WebInspector.InvokeOnceHandlers(true);
     WebInspector._postUpdateHandlers.add(object, method);
-}
+};
 
 /**
  * @param {!Window} window
  * @param {!Function} func
  * @param {!Array.<{from:number, to:number}>} params
  * @param {number} frames
  * @param {function()=} animationComplete
  * @return {function()}
  */
 WebInspector.animateFunction = function(window, func, params, frames, animationComplete)
@@ skipping 25 matching lines @@
         func.apply(null, values);
         raf = window.requestAnimationFrame(animationStep);
     }
 
     function cancelAnimation()
     {
         window.cancelAnimationFrame(raf);
     }
 
     return cancelAnimation;
-}
+};
 
 /**
  * @constructor
  * @extends {WebInspector.Object}
  * @param {!Element} element
  * @param {function(!Event)} callback
  */
 WebInspector.LongClickController = function(element, callback)
 {
     this._element = element;
     this._callback = callback;
     this._enable();
-}
+};
 
 WebInspector.LongClickController.prototype = {
     reset: function()
     {
         if (this._longClickInterval) {
             clearInterval(this._longClickInterval);
             delete this._longClickInterval;
         }
     },
 
@@ skipping 41 matching lines @@
         if (!this._longClickData)
             return;
         this._element.removeEventListener("mousedown", this._longClickData.mouseDown, false);
         this._element.removeEventListener("mouseout", this._longClickData.reset, false);
         this._element.removeEventListener("mouseup", this._longClickData.mouseUp, false);
         this._element.addEventListener("click", this._longClickData.reset, true);
         delete this._longClickData;
     },
 
     __proto__: WebInspector.Object.prototype
-}
+};
 
 /**
  * @param {!Document} document
  * @param {!WebInspector.Setting} themeSetting
  */
 WebInspector.initializeUIUtils = function(document, themeSetting)
 {
     document.defaultView.addEventListener("focus", WebInspector._windowFocused.bind(WebInspector, document), false);
     document.defaultView.addEventListener("blur", WebInspector._windowBlurred.bind(WebInspector, document), false);
     document.addEventListener("focus", WebInspector._focusChanged.bind(WebInspector), true);
 
     if (!WebInspector.themeSupport)
         WebInspector.themeSupport = new WebInspector.ThemeSupport(themeSetting);
     WebInspector.themeSupport.applyTheme(document);
 
     var body = /** @type {!Element} */ (document.body);
     WebInspector.appendStyle(body, "ui/inspectorStyle.css");
     WebInspector.appendStyle(body, "ui/popover.css");
-}
+};
 
 /**
  * @param {string} name
  * @return {string}
  */
 WebInspector.beautifyFunctionName = function(name)
 {
     return name || WebInspector.UIString("(anonymous)");
-}
+};
 
 /**
  * @param {string} localName
  * @param {string} typeExtension
  * @param {!Object} prototype
  * @return {function()}
  * @suppressGlobalPropertiesCheck
  * @template T
  */
 function registerCustomElement(localName, typeExtension, prototype)
@@ skipping 398 matching lines @@
     function setValue(value)
     {
         if (value === input.value)
             return;
         var valid = validate(value);
         input.classList.toggle("error-input", !valid);
         input.value = value;
     }
 
     return setValue;
-}
+};
 
 /**
  * @constructor
  * @param {!WebInspector.Setting} setting
  */
 WebInspector.ThemeSupport = function(setting)
 {
     this._themeName = setting.get() || "default";
     this._themableProperties = new Set([
         "color", "box-shadow", "text-shadow", "outline-color",
         "background-image", "background-color",
         "border-left-color", "border-right-color", "border-top-color", "border-bottom-color",
         "-webkit-border-image"]);
     /** @type {!Map<string, string>} */
     this._cachedThemePatches = new Map();
     this._setting = setting;
-}
+};
 
 /**
  * @enum {number}
  */
 WebInspector.ThemeSupport.ColorUsage = {
     Unknown: 0,
     Foreground: 1 << 0,
     Background: 1 << 1,
     Selection: 1 << 2,
 };
@@ skipping 184 matching lines @@
 
     /**
      * @param {!Array<number>} hsla
      * @param {!WebInspector.ThemeSupport.ColorUsage} colorUsage
      */
     _patchHSLA: function(hsla, colorUsage)
     {
         var hue = hsla[0];
         var sat = hsla[1];
         var lit = hsla[2];
-        var alpha = hsla[3]
+        var alpha = hsla[3];
 
         switch (this._themeName) {
         case "dark":
             if (colorUsage & WebInspector.ThemeSupport.ColorUsage.Selection)
                 hue = (hue + 0.5) % 1;
             var minCap = colorUsage & WebInspector.ThemeSupport.ColorUsage.Background ? 0.14 : 0;
             var maxCap = colorUsage & WebInspector.ThemeSupport.ColorUsage.Foreground ? 0.9 : 1;
             lit = 1 - lit;
             if (lit < minCap * 2)
                 lit = minCap + lit / 2;
             else if (lit > 2 * maxCap - 1)
                 lit = maxCap - 1 / 2 + lit / 2;
 
             break;
         }
         hsla[0] = Number.constrain(hue, 0, 1);
         hsla[1] = Number.constrain(sat, 0, 1);
         hsla[2] = Number.constrain(lit, 0, 1);
         hsla[3] = Number.constrain(alpha, 0, 1);
     }
-}
+};
 
 /**
  * @param {?NetworkAgent.ResourcePriority} priority
  * @return {string}
  */
 WebInspector.uiLabelForPriority = function(priority)
 {
     var labelMap = WebInspector.uiLabelForPriority._priorityToUILabel;
     if (!labelMap) {
         labelMap = new Map([
             [NetworkAgent.ResourcePriority.VeryLow, WebInspector.UIString("Lowest")],
             [NetworkAgent.ResourcePriority.Low, WebInspector.UIString("Low")],
             [NetworkAgent.ResourcePriority.Medium, WebInspector.UIString("Medium")],
             [NetworkAgent.ResourcePriority.High, WebInspector.UIString("High")],
             [NetworkAgent.ResourcePriority.VeryHigh, WebInspector.UIString("Highest")]
         ]);
         WebInspector.uiLabelForPriority._priorityToUILabel = labelMap;
     }
     return labelMap.get(priority) || WebInspector.UIString("Unknown");
-}
+};
 
 /**
  * @param {string} url
  * @param {string=} linkText
  * @param {string=} classes
  * @param {boolean=} isExternal
  * @param {string=} tooltipText
  * @return {!Element}
  */
 WebInspector.linkifyURLAsNode = function(url, linkText, classes, isExternal, tooltipText)
@@ skipping 13 matching lines @@
     }
     if (!tooltipText && linkText !== url)
         a.title = url;
     else if (tooltipText)
         a.title = tooltipText;
     a.textContent = linkText.trimMiddle(150);
     if (isExternal)
         a.setAttribute("target", "_blank");
 
     return a;
-}
+};
 
 /**
  * @param {string} article
  * @param {string} title
  * @return {!Element}
  */
 WebInspector.linkifyDocumentationURLAsNode = function(article, title)
 {
     return WebInspector.linkifyURLAsNode("https://developers.google.com/web/tools/chrome-devtools/" + article, title, undefined, true);
-}
+};
 
 /** @type {!WebInspector.ThemeSupport} */
 WebInspector.themeSupport;