DevTools: use semicolons after each statement.

third_party/WebKit/Source/devtools/front_end/platform/DOMExtension.js

 /*
  * Copyright (C) 2007 Apple Inc.  All rights reserved.
  * Copyright (C) 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
@@ skipping 104 matching lines @@
     } else {
         endNode = this;
         endOffset = offset;
     }
 
     var result = this.ownerDocument.createRange();
     result.setStart(startNode, startOffset);
     result.setEnd(endNode, endOffset);
 
     return result;
-}
+};
 
 /**
  * @param {!Node=} stayWithin
  * @return {?Node}
  */
 Node.prototype.traverseNextTextNode = function(stayWithin)
 {
     var node = this.traverseNextNode(stayWithin);
     if (!node)
         return null;
     var nonTextTags = { "STYLE": 1, "SCRIPT": 1 };
     while (node && (node.nodeType !== Node.TEXT_NODE || nonTextTags[node.parentElement.nodeName]))
         node = node.traverseNextNode(stayWithin);
 
     return node;
-}
+};
 
 /**
  * @param {number|undefined} x
  * @param {number|undefined} y
  * @param {!Element=} relativeTo
  */
 Element.prototype.positionAt = function(x, y, relativeTo)
 {
     var shift = {x: 0, y: 0};
     if (relativeTo)
         shift = relativeTo.boxInWindow(this.ownerDocument.defaultView);
 
     if (typeof x === "number")
         this.style.setProperty("left", (shift.x + x) + "px");
     else
         this.style.removeProperty("left");
 
     if (typeof y === "number")
         this.style.setProperty("top", (shift.y + y) + "px");
     else
         this.style.removeProperty("top");
 
     if (typeof x === "number" || typeof y === "number")
         this.style.setProperty("position", "absolute");
     else
         this.style.removeProperty("position");
-}
+};
 
 /**
  * @return {boolean}
  */
 Element.prototype.isScrolledToBottom = function()
 {
     // This code works only for 0-width border.
     // The scrollTop, clientHeight and scrollHeight are computed in double values internally.
     // However, they are exposed to javascript differently, each being either rounded (via
     // round, ceil or floor functions) or left intouch.
     // This adds up a total error up to 2.
     return Math.abs(this.scrollTop + this.clientHeight - this.scrollHeight) <= 2;
-}
+};
 
 /**
  * @param {!Array.<string>} nameArray
  * @return {?Node}
  */
 Node.prototype.enclosingNodeOrSelfWithNodeNameInArray = function(nameArray)
 {
     for (var node = this; node && node !== this.ownerDocument; node = node.parentNodeOrShadowHost()) {
         for (var i = 0; i < nameArray.length; ++i) {
             if (node.nodeName.toLowerCase() === nameArray[i].toLowerCase())
                 return node;
         }
     }
     return null;
-}
+};
 
 /**
  * @param {string} nodeName
  * @return {?Node}
  */
 Node.prototype.enclosingNodeOrSelfWithNodeName = function(nodeName)
 {
     return this.enclosingNodeOrSelfWithNodeNameInArray([nodeName]);
-}
+};
 
 /**
  * @param {string} className
  * @param {!Element=} stayWithin
  * @return {?Element}
  */
 Node.prototype.enclosingNodeOrSelfWithClass = function(className, stayWithin)
 {
     return this.enclosingNodeOrSelfWithClassList([className], stayWithin);
-}
+};
 
 /**
  * @param {!Array.<string>} classNames
  * @param {!Element=} stayWithin
  * @return {?Element}
  */
 Node.prototype.enclosingNodeOrSelfWithClassList = function(classNames, stayWithin)
 {
     for (var node = this; node && node !== stayWithin && node !== this.ownerDocument; node = node.parentNodeOrShadowHost()) {
         if (node.nodeType === Node.ELEMENT_NODE) {
             var containsAll = true;
             for (var i = 0; i < classNames.length && containsAll; ++i) {
                 if (!node.classList.contains(classNames[i]))
                     containsAll = false;
             }
             if (containsAll)
                 return /** @type {!Element} */ (node);
         }
     }
     return null;
-}
+};
 
 /**
  * @return {?Element}
  */
 Node.prototype.parentElementOrShadowHost = function()
 {
     var node = this.parentNode;
     if (!node)
         return null;
     if (node.nodeType === Node.ELEMENT_NODE)
         return /** @type {!Element} */ (node);
     if (node.nodeType === Node.DOCUMENT_FRAGMENT_NODE)
         return /** @type {!Element} */ (node.host);
     return null;
-}
+};
 
 /**
  * @return {?Node}
  */
 Node.prototype.parentNodeOrShadowHost = function()
 {
     return this.parentNode || this.host || null;
-}
+};
 
 /**
  * @return {?Selection}
  */
 Node.prototype.getComponentSelection = function()
 {
     var parent = this.parentNode;
     while (parent && parent.nodeType !== Node.DOCUMENT_FRAGMENT_NODE)
         parent = parent.parentNode;
     return parent instanceof ShadowRoot ? parent.getSelection() : this.window().getSelection();
-}
+};
 
 
 /**
  * @return {boolean}
  */
 Node.prototype.isComponentSelectionCollapsed = function()
 {
     // FIXME: crbug.com/447523, use selection.isCollapsed when it is fixed for shadow dom.
     var selection = this.getComponentSelection();
     var range = selection && selection.rangeCount ? selection.getRangeAt(0) : null;
     return range ? range.collapsed : true;
-}
+};
 
 /**
  * @return {boolean}
  */
 Node.prototype.hasSelection = function()
 {
     if (this.isComponentSelectionCollapsed())
         return false;
     return this.getComponentSelection().containsNode(this, true);
-}
+};
 
 /**
  * @return {!Selection}
  */
 Node.prototype.getDeepSelection = function()
 {
     var activeElement = this.ownerDocument.activeElement;
     var shadowRoot = null;
     while (activeElement && activeElement.shadowRoot) {
         shadowRoot = activeElement.shadowRoot;
         activeElement = shadowRoot.activeElement;
     }
 
     return shadowRoot ? shadowRoot.getSelection() : this.window().getSelection();
-}
+};
 
 /**
  * @return {!Window}
  */
 Node.prototype.window = function()
 {
     return this.ownerDocument.defaultView;
-}
+};
 
 Element.prototype.removeChildren = function()
 {
     if (this.firstChild)
         this.textContent = "";
-}
+};
 
 /**
  * @param {string} tagName
  * @param {string=} customElementType
  * @return {!Element}
  * @suppressGlobalPropertiesCheck
  */
 function createElement(tagName, customElementType)
 {
     return document.createElement(tagName, customElementType || "");
@@ skipping 14 matching lines @@
  * @param {string=} className
  * @param {string=} customElementType
  * @return {!Element}
  */
 Document.prototype.createElementWithClass = function(elementName, className, customElementType)
 {
     var element = this.createElement(elementName, customElementType || "");
     if (className)
         element.className = className;
     return element;
-}
+};
 
 /**
  * @param {string} elementName
  * @param {string=} className
  * @param {string=} customElementType
  * @return {!Element}
  * @suppressGlobalPropertiesCheck
  */
 function createElementWithClass(elementName, className, customElementType)
 {
     return document.createElementWithClass(elementName, className, customElementType);
 }
 
 /**
  * @param {string} childType
  * @param {string=} className
  * @return {!Element}
  */
 Document.prototype.createSVGElement = function(childType, className)
 {
     var element = this.createElementNS("http://www.w3.org/2000/svg", childType);
     if (className)
         element.setAttribute("class", className);
     return element;
-}
+};
 
 /**
  * @param {string} childType
  * @param {string=} className
  * @return {!Element}
  * @suppressGlobalPropertiesCheck
  */
 function createSVGElement(childType, className)
 {
     return document.createSVGElement(childType, className);
@@ skipping 12 matching lines @@
  * @param {string} elementName
  * @param {string=} className
  * @param {string=} customElementType
  * @return {!Element}
  */
 Element.prototype.createChild = function(elementName, className, customElementType)
 {
     var element = this.ownerDocument.createElementWithClass(elementName, className, customElementType);
     this.appendChild(element);
     return element;
-}
+};
 
 DocumentFragment.prototype.createChild = Element.prototype.createChild;
 
 /**
  * @param {string} text
  * @return {!Text}
  */
 Element.prototype.createTextChild = function(text)
 {
     var element = this.ownerDocument.createTextNode(text);
     this.appendChild(element);
     return element;
-}
+};
 
 DocumentFragment.prototype.createTextChild = Element.prototype.createTextChild;
 
 /**
  * @param {...string} var_args
  */
 Element.prototype.createTextChildren = function(var_args)
 {
     for (var i = 0, n = arguments.length; i < n; ++i)
         this.createTextChild(arguments[i]);
-}
+};
 
 DocumentFragment.prototype.createTextChildren = Element.prototype.createTextChildren;
 
 /**
  * @return {number}
  */
 Element.prototype.totalOffsetLeft = function()
 {
     return this.totalOffset().left;
-}
+};
 
 /**
  * @return {number}
  */
 Element.prototype.totalOffsetTop = function()
 {
     return this.totalOffset().top;
-}
+};
 
 /**
  * @return {!{left: number, top: number}}
  */
 Element.prototype.totalOffset = function()
 {
     var rect = this.getBoundingClientRect();
     return { left: rect.left, top: rect.top };
-}
+};
 
 /**
  * @param {string} childType
  * @param {string=} className
  * @return {!Element}
  */
 Element.prototype.createSVGChild = function(childType, className)
 {
     var child = this.ownerDocument.createSVGElement(childType, className);
     this.appendChild(child);
     return child;
-}
+};
 
 /**
  * @constructor
  * @param {number=} x
  * @param {number=} y
  * @param {number=} width
  * @param {number=} height
  */
 function AnchorBox(x, y, width, height)
 {
     this.x = x || 0;
     this.y = y || 0;
     this.width = width || 0;
     this.height = height || 0;
 }
 
 /**
  * @param {!AnchorBox} box
  * @return {!AnchorBox}
  */
 AnchorBox.prototype.relativeTo = function(box)
 {
     return new AnchorBox(
         this.x - box.x, this.y - box.y, this.width, this.height);
-}
+};
 
 /**
  * @param {!Element} element
  * @return {!AnchorBox}
  */
 AnchorBox.prototype.relativeToElement = function(element)
 {
     return this.relativeTo(element.boxInWindow(element.ownerDocument.defaultView));
-}
+};
 
 /**
  * @param {?AnchorBox} anchorBox
  * @return {boolean}
  */
 AnchorBox.prototype.equals = function(anchorBox)
 {
     return !!anchorBox && this.x === anchorBox.x && this.y === anchorBox.y && this.width === anchorBox.width && this.height === anchorBox.height;
-}
+};
 
 /**
  * @param {!Window=} targetWindow
  * @return {!AnchorBox}
  */
 Element.prototype.boxInWindow = function(targetWindow)
 {
     targetWindow = targetWindow || this.ownerDocument.defaultView;
 
     var anchorBox = new AnchorBox();
     var curElement = this;
     var curWindow = this.ownerDocument.defaultView;
     while (curWindow && curElement) {
         anchorBox.x += curElement.totalOffsetLeft();
         anchorBox.y += curElement.totalOffsetTop();
         if (curWindow === targetWindow)
             break;
         curElement = curWindow.frameElement;
         curWindow = curWindow.parent;
     }
 
     anchorBox.width = Math.min(this.offsetWidth, targetWindow.innerWidth - anchorBox.x);
     anchorBox.height = Math.min(this.offsetHeight, targetWindow.innerHeight - anchorBox.y);
     return anchorBox;
-}
+};
 
 /**
  * @param {boolean=} preventDefault
  */
 Event.prototype.consume = function(preventDefault)
 {
     this.stopImmediatePropagation();
     if (preventDefault)
         this.preventDefault();
     this.handled = true;
-}
+};
 
 /**
  * @param {number=} start
  * @param {number=} end
  * @return {!Text}
  */
 Text.prototype.select = function(start, end)
 {
     start = start || 0;
     end = end || this.textContent.length;
 
     if (start < 0)
         start = end + start;
 
     var selection = this.getComponentSelection();
     selection.removeAllRanges();
     var range = this.ownerDocument.createRange();
     range.setStart(this, start);
     range.setEnd(this, end);
     selection.addRange(range);
     return this;
-}
+};
 
 /**
  * @return {?number}
  */
 Element.prototype.selectionLeftOffset = function()
 {
     // Calculate selection offset relative to the current element.
 
     var selection = this.getComponentSelection();
     if (!selection.containsNode(this, true))
         return null;
 
     var leftOffset = selection.anchorOffset;
     var node = selection.anchorNode;
 
     while (node !== this) {
         while (node.previousSibling) {
             node = node.previousSibling;
             leftOffset += node.textContent.length;
         }
         node = node.parentNodeOrShadowHost();
     }
 
     return leftOffset;
-}
+};
 
 /**
  * @param {...!Node} var_args
  */
 Node.prototype.appendChildren = function(var_args)
 {
     for (var i = 0, n = arguments.length; i < n; ++i)
         this.appendChild(arguments[i]);
-}
+};
 
 /**
  * @return {string}
  */
 Node.prototype.deepTextContent = function()
 {
     return this.childTextNodes().map(function(node) { return node.textContent; }).join("");
-}
+};
 
 /**
  * @return {!Array.<!Node>}
  */
 Node.prototype.childTextNodes = function()
 {
     var node = this.traverseNextTextNode(this);
     var result = [];
     var nonTextTags = { "STYLE": 1, "SCRIPT": 1 };
     while (node) {
         if (!nonTextTags[node.parentElement.nodeName])
             result.push(node);
         node = node.traverseNextTextNode(this);
     }
     return result;
-}
+};
 
 /**
  * @param {?Node} node
  * @return {boolean}
  */
 Node.prototype.isAncestor = function(node)
 {
     if (!node)
         return false;
 
     var currentNode = node.parentNodeOrShadowHost();
     while (currentNode) {
         if (this === currentNode)
             return true;
         currentNode = currentNode.parentNodeOrShadowHost();
     }
     return false;
-}
+};
 
 /**
  * @param {?Node} descendant
  * @return {boolean}
  */
 Node.prototype.isDescendant = function(descendant)
 {
     return !!descendant && descendant.isAncestor(this);
-}
+};
 
 /**
  * @param {?Node} node
  * @return {boolean}
  */
 Node.prototype.isSelfOrAncestor = function(node)
 {
     return !!node && (node === this || this.isAncestor(node));
-}
+};
 
 /**
  * @param {?Node} node
  * @return {boolean}
  */
 Node.prototype.isSelfOrDescendant = function(node)
 {
     return !!node && (node === this || this.isDescendant(node));
-}
+};
 
 /**
  * @param {!Node=} stayWithin
  * @return {?Node}
  */
 Node.prototype.traverseNextNode = function(stayWithin)
 {
     if (this.shadowRoot)
         return this.shadowRoot;
 
@@ skipping 38 matching lines @@
      * @param {!Node} node
      * @return {?Node}
      */
     function insertionPoint(node)
     {
         var insertionPoints =  node.getDestinationInsertionPoints  ? node.getDestinationInsertionPoints() : [];
         return insertionPoints.length > 0 ? insertionPoints[insertionPoints.length - 1] : null;
     }
 
     return null;
-}
+};
 
 /**
  * @param {!Node=} stayWithin
  * @return {?Node}
  */
 Node.prototype.traversePreviousNode = function(stayWithin)
 {
     if (stayWithin && this === stayWithin)
         return null;
     var node = this.previousSibling;
     while (node && node.lastChild)
         node = node.lastChild;
     if (node)
         return node;
     return this.parentNodeOrShadowHost();
-}
+};
 
 /**
  * @param {*} text
  * @param {string=} placeholder
  * @return {boolean} true if was truncated
  */
 Node.prototype.setTextContentTruncatedIfNeeded = function(text, placeholder)
 {
     // Huge texts in the UI reduce rendering performance drastically.
     // Moreover, Blink/WebKit uses <unsigned short> internally for storing text content
     // length, so texts longer than 65535 are inherently displayed incorrectly.
     const maxTextContentLength = 10000;
 
     if (typeof text === "string" && text.length > maxTextContentLength) {
         this.textContent = typeof placeholder === "string" ? placeholder : text.trimMiddle(maxTextContentLength);
         return true;
     }
 
     this.textContent = text;
     return false;
-}
+};
 
 /**
  * @return {?Node}
  */
 Event.prototype.deepElementFromPoint = function()
 {
     var root = this.target && this.target.getComponentRoot();
     return root ? root.deepElementFromPoint(this.pageX, this.pageY) : null;
-}
+};
 
 /**
  * @param {number} x
  * @param {number} y
  * @return {?Node}
  */
 Document.prototype.deepElementFromPoint = function(x, y)
 {
     var node = this.elementFromPoint(x, y);
     while (node && node.shadowRoot)
         node = node.shadowRoot.elementFromPoint(x, y);
     return node;
-}
+};
 
 DocumentFragment.prototype.deepElementFromPoint = Document.prototype.deepElementFromPoint;
 
 /**
  * @return {?Element}
  */
 Document.prototype.deepActiveElement = function()
 {
     var activeElement = this.activeElement;
     while (activeElement && activeElement.shadowRoot && activeElement.shadowRoot.activeElement)
         activeElement = activeElement.shadowRoot.activeElement;
     return activeElement;
-}
+};
 
 DocumentFragment.prototype.deepActiveElement = Document.prototype.deepActiveElement;
 
 /**
  * @return {boolean}
  */
 Element.prototype.hasFocus = function()
 {
     var root = this.getComponentRoot();
     return !!root && this.isSelfOrAncestor(root.activeElement);
-}
+};
 
 /**
  * @return {?Document|?DocumentFragment}
  */
 Node.prototype.getComponentRoot = function()
 {
     var node = this;
     while (node && node.nodeType !== Node.DOCUMENT_FRAGMENT_NODE && node.nodeType !== Node.DOCUMENT_NODE)
         node = node.parentNode;
     return /** @type {?Document|?DocumentFragment} */ (node);
-}
+};
 
 /**
  * @param {!Event} event
  * @return {boolean}
  */
 function isEnterKey(event)
 {
     // Check if in IME.
     return event.keyCode !== 229 && event.key === "Enter";
 }
@@ skipping 20 matching lines @@
     {
         window.removeEventListener("DOMContentLoaded", windowLoaded, false);
         callback();
     }
 
     if (document.readyState === "complete" || document.readyState === "interactive")
         callback();
     else
         window.addEventListener("DOMContentLoaded", windowLoaded, false);
 }