DevTools: use semicolons after each statement.

third_party/WebKit/Source/devtools/front_end/platform/utilities.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 18 matching lines @@
 
 // FIXME: This performance optimization should be moved to blink so that all developers could enjoy it.
 // console is retrieved with V8Window.getAttribute method which is slow. Here we copy it to a js variable for faster access.
 console = console;
 console.__originalAssert = console.assert;
 console.assert = function(value, message)
 {
     if (value)
         return;
     console.__originalAssert(value, message);
-}
+};
 
 /** @typedef {Array|NodeList|Arguments|{length: number}} */
 var ArrayLike;
 
 /**
  * @param {number} m
  * @param {number} n
  * @return {number}
  */
 function mod(m, n)
 {
     return ((m % n) + n) % n;
 }
 
 /**
  * @param {string} string
  * @return {!Array.<number>}
  */
 String.prototype.findAll = function(string)
 {
     var matches = [];
     var i = this.indexOf(string);
     while (i !== -1) {
         matches.push(i);
         i = this.indexOf(string, i + string.length);
     }
     return matches;
-}
+};
 
 /**
  * @return {string}
  */
 String.prototype.replaceControlCharacters = function()
 {
     // Replace C0 and C1 control character sets with printable character.
     // Do not replace '\t', \n' and '\r'.
     return this.replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u0080-\u009f]/g, "�");
-}
+};
 
 /**
  * @return {boolean}
  */
 String.prototype.isWhitespace = function()
 {
     return /^\s*$/.test(this);
-}
+};
 
 /**
  * @return {!Array.<number>}
  */
 String.prototype.computeLineEndings = function()
 {
     var endings = this.findAll("\n");
     endings.push(this.length);
     return endings;
-}
+};
 
 /**
  * @param {string} chars
  * @return {string}
  */
 String.prototype.escapeCharacters = function(chars)
 {
     var foundChar = false;
     for (var i = 0; i < chars.length; ++i) {
         if (this.indexOf(chars.charAt(i)) !== -1) {
             foundChar = true;
             break;
         }
     }
 
     if (!foundChar)
         return String(this);
 
     var result = "";
     for (var i = 0; i < this.length; ++i) {
         if (chars.indexOf(this.charAt(i)) !== -1)
             result += "\\";
         result += this.charAt(i);
     }
 
     return result;
-}
+};
 
 /**
  * @return {string}
  */
 String.regexSpecialCharacters = function()
 {
     return "^[]{}()\\.^$*+?|-,";
-}
+};
 
 /**
  * @return {string}
  */
 String.prototype.escapeForRegExp = function()
 {
     return this.escapeCharacters(String.regexSpecialCharacters());
-}
+};
 
 /**
  * @return {string}
  */
 String.prototype.escapeHTML = function()
 {
     return this.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;"); // " doublequotes just for editor
-}
+};
 
 /**
  * @return {string}
  */
 String.prototype.unescapeHTML = function()
 {
     return this.replace(/&lt;/g, "<")
         .replace(/&gt;/g, ">")
         .replace(/&#58;/g, ":")
         .replace(/&quot;/g, "\"")
         .replace(/&#60;/g, "<")
         .replace(/&#62;/g, ">")
         .replace(/&amp;/g, "&");
-}
+};
 
 /**
  * @return {string}
  */
 String.prototype.collapseWhitespace = function()
 {
     return this.replace(/[\s\xA0]+/g, " ");
-}
+};
 
 /**
  * @param {number} maxLength
  * @return {string}
  */
 String.prototype.trimMiddle = function(maxLength)
 {
     if (this.length <= maxLength)
         return String(this);
     var leftHalf = maxLength >> 1;
     var rightHalf = maxLength - leftHalf - 1;
     return this.substr(0, leftHalf) + "\u2026" + this.substr(this.length - rightHalf, rightHalf);
-}
+};
 
 /**
  * @param {number} maxLength
  * @return {string}
  */
 String.prototype.trimEnd = function(maxLength)
 {
     if (this.length <= maxLength)
         return String(this);
     return this.substr(0, maxLength - 1) + "\u2026";
-}
+};
 
 /**
  * @param {?string=} baseURLDomain
  * @return {string}
  */
 String.prototype.trimURL = function(baseURLDomain)
 {
     var result = this.replace(/^(https|http|file):\/\//i, "");
     if (baseURLDomain) {
         if (result.toLowerCase().startsWith(baseURLDomain.toLowerCase()))
             result = result.substr(baseURLDomain.length);
     }
     return result;
-}
+};
 
 /**
  * @return {string}
  */
 String.prototype.toTitleCase = function()
 {
     return this.substring(0, 1).toUpperCase() + this.substring(1);
-}
+};
 
 /**
  * @param {string} other
  * @return {number}
  */
 String.prototype.compareTo = function(other)
 {
     if (this > other)
         return 1;
     if (this < other)
         return -1;
     return 0;
-}
+};
 
 /**
  * @return {string}
  */
 String.prototype.removeURLFragment = function()
 {
     var fragmentIndex = this.indexOf("#");
     if (fragmentIndex === -1)
         fragmentIndex = this.length;
     return this.substring(0, fragmentIndex);
-}
+};
 
 /**
  * @param {string|undefined} string
  * @return {number}
  */
 String.hashCode = function(string)
 {
     if (!string)
         return 0;
     // Hash algorithm for substrings is described in "Über die Komplexität der Multiplikation in
     // eingeschränkten Branchingprogrammmodellen" by Woelfe.
     // http://opendatastructures.org/versions/edition-0.1d/ods-java/node33.html#SECTION00832000000000000000
     var p = ((1 << 30) * 4 - 5); // prime: 2^32 - 5
     var z = 0x5033d967;          // 32 bits from random.org
     var z2 = 0x59d2f15d;         // random odd 32 bit number
     var s = 0;
     var zi = 1;
     for (var i = 0; i < string.length; i++) {
         var xi = string.charCodeAt(i) * z2;
         s = (s + zi * xi) % p;
         zi = (zi * z) % p;
     }
     s = (s + zi * (p - 1)) % p;
     return Math.abs(s | 0);
-}
+};
 
 /**
  * @param {string} string
  * @param {number} index
  * @return {boolean}
  */
 String.isDigitAt = function(string, index)
 {
     var c = string.charCodeAt(index);
     return (48 <= c && c <= 57);
-}
+};
 
 /**
  * @return {string}
  */
 String.prototype.toBase64 = function()
 {
     /**
      * @param {number} b
      * @return {number}
      */
@@ skipping 15 matching lines @@
         if (shift === 2) {
             encoded += String.fromCharCode(encodeBits(v >>> 18 & 63), encodeBits(v >>> 12 & 63), encodeBits(v >>> 6 & 63), encodeBits(v & 63));
             v = 0;
         }
     }
     if (shift === 0)
         encoded += String.fromCharCode(encodeBits(v >>> 18 & 63), encodeBits(v >>> 12 & 63), 61, 61);
     else if (shift === 1)
         encoded += String.fromCharCode(encodeBits(v >>> 18 & 63), encodeBits(v >>> 12 & 63), encodeBits(v >>> 6 & 63), 61);
     return encoded;
-}
+};
 
 /**
  * @param {string} a
  * @param {string} b
  * @return {number}
  */
 String.naturalOrderComparator = function(a, b)
 {
     var chunk = /^\d+|^\D+/;
     var chunka, chunkb, anum, bnum;
@@ skipping 23 matching lines @@
                 if (!+chunka && !+chunkb) // chunks are strings of all 0s (special case)
                     return chunka.length - chunkb.length;
                 else
                     return chunkb.length - chunka.length;
             }
         } else if (chunka !== chunkb)
             return (chunka < chunkb) ? -1 : 1;
         a = a.substring(chunka.length);
         b = b.substring(chunkb.length);
     }
-}
+};
 
 /**
  * @param {string} a
  * @param {string} b
  * @return {number}
  */
 String.caseInsensetiveComparator = function(a, b)
 {
     a = a.toUpperCase();
     b = b.toUpperCase();
     if (a === b)
         return 0;
     return a > b ? 1 : -1;
-}
+};
 
 /**
  * @param {number} num
  * @param {number} min
  * @param {number} max
  * @return {number}
  */
 Number.constrain = function(num, min, max)
 {
     if (num < min)
         num = min;
     else if (num > max)
         num = max;
     return num;
-}
+};
 
 /**
  * @param {number} a
  * @param {number} b
  * @return {number}
  */
 Number.gcd = function(a, b)
 {
     if (b === 0)
         return a;
     else
         return Number.gcd(b, a % b);
-}
+};
 
 /**
  * @param {string} value
  * @return {string}
  */
 Number.toFixedIfFloating = function(value)
 {
     if (!value || isNaN(value))
         return value;
     var number = Number(value);
     return number % 1 ? number.toFixed(3) : String(number);
-}
+};
 
 /**
  * @return {boolean}
  */
 Date.prototype.isValid = function()
 {
-    return !isNaN(this.getTime())
-}
+    return !isNaN(this.getTime());
+};
 
 /**
  * @return {string}
  */
 Date.prototype.toISO8601Compact = function()
 {
     /**
      * @param {number} x
      * @return {string}
      */
     function leadZero(x)
     {
         return (x > 9 ? "" : "0") + x;
     }
     return this.getFullYear() +
            leadZero(this.getMonth() + 1) +
            leadZero(this.getDate()) + "T" +
            leadZero(this.getHours()) +
            leadZero(this.getMinutes()) +
            leadZero(this.getSeconds());
-}
+};
 
 /**
  * @return {string}
  */
 Date.prototype.toConsoleTime = function()
 {
     /**
      * @param {number} x
      * @return {string}
      */
@@ skipping 11 matching lines @@
         return "0".repeat(3 - x.toString().length) + x;
     }
 
     return this.getFullYear() + "-" +
            leadZero2(this.getMonth() + 1) + "-" +
            leadZero2(this.getDate()) + " " +
            leadZero2(this.getHours()) + ":" +
            leadZero2(this.getMinutes()) + ":" +
            leadZero2(this.getSeconds()) + "." +
            leadZero3(this.getMilliseconds());
-}
+};
 
 Object.defineProperty(Array.prototype, "remove", {
     /**
      * @param {!T} value
      * @param {boolean=} firstOnly
      * @return {boolean}
      * @this {Array.<!T>}
      * @template T
      */
     value: function(value, firstOnly)
@@ skipping 123 matching lines @@
                     quickSortRange(array, comparator, left, pivotNewIndex - 1, sortWindowLeft, sortWindowRight);
                 if (pivotNewIndex < sortWindowRight)
                     quickSortRange(array, comparator, pivotNewIndex + 1, right, sortWindowLeft, sortWindowRight);
             }
             if (leftBound === 0 && rightBound === (this.length - 1) && sortWindowLeft === 0 && sortWindowRight >= rightBound)
                 this.sort(comparator);
             else
                 quickSortRange(this, comparator, leftBound, rightBound, sortWindowLeft, sortWindowRight);
             return this;
         }
-    }
+    };
     Object.defineProperty(Array.prototype, "sortRange", sortRange);
     Object.defineProperty(Uint32Array.prototype, "sortRange", sortRange);
 })();
 
 Object.defineProperty(Array.prototype, "stableSort", {
     /**
      * @param {function(?T, ?T): number=} comparator
      * @return {!Array.<?T>}
      * @this {Array.<?T>}
      * @template T
@@ skipping 48 matching lines @@
      * @param {number} k
      * @param {function(number, number): number=} comparator
      * @return {number|undefined}
      * @this {Array.<number>}
      */
     value: function(k, comparator)
     {
         if (k < 0 || k >= this.length)
             return;
         if (!comparator)
-            comparator = function(a, b) { return a - b; }
+            comparator = function(a, b) { return a - b; };
 
         var low = 0;
         var high = this.length - 1;
         for (;;) {
             var pivotPosition = this.partition(comparator, low, high, Math.floor((high + low) / 2));
             if (pivotPosition === k)
                 return this[k];
             else if (pivotPosition > k)
                 high = pivotPosition - 1;
             else
@@ skipping 193 matching lines @@
 })();
 
 /**
  * @param {string} format
  * @param {...*} var_arg
  * @return {string}
  */
 String.sprintf = function(format, var_arg)
 {
     return String.vsprintf(format, Array.prototype.slice.call(arguments, 1));
-}
+};
 
 /**
  * @param {string} format
  * @param {!Object.<string, function(string, ...):*>} formatters
  * @return {!Array.<!Object>}
  */
 String.tokenizeFormatString = function(format, formatters)
 {
     var tokens = [];
     var substitutionIndex = 0;
@@ skipping 60 matching lines @@
 
         addSpecifierToken(format[index], precision, substitutionIndex);
 
         ++substitutionIndex;
         ++index;
     }
 
     addStringToken(format.substring(index));
 
     return tokens;
-}
+};
 
 String.standardFormatters = {
     /**
      * @return {number}
      */
     d: function(substitution)
     {
         return !isNaN(substitution) ? substitution : 0;
     },
 
     /**
      * @return {number}
      */
     f: function(substitution, token)
     {
         if (substitution && token.precision > -1)
             substitution = substitution.toFixed(token.precision);
         return !isNaN(substitution) ? substitution : (token.precision > -1 ? Number(0).toFixed(token.precision) : 0);
     },
 
     /**
      * @return {string}
      */
     s: function(substitution)
     {
         return substitution;
     }
-}
+};
 
 /**
  * @param {string} format
  * @param {!Array.<*>} substitutions
  * @return {string}
  */
 String.vsprintf = function(format, substitutions)
 {
     return String.format(format, substitutions, String.standardFormatters, "", function(a, b) { return a + b; }).formattedResult;
-}
+};
 
 /**
  * @param {string} format
  * @param {?ArrayLike} substitutions
  * @param {!Object.<string, function(string, ...):Q>} formatters
  * @param {!T} initialValue
  * @param {function(T, Q): T|undefined} append
  * @param {!Array.<!Object>=} tokenizedFormat
  * @return {!{formattedResult: T, unusedSubstitutions: ?ArrayLike}};
  * @template T, Q
@@ skipping 56 matching lines @@
     }
 
     var unusedSubstitutions = [];
     for (var i = 0; i < substitutions.length; ++i) {
         if (i in usedSubstitutionIndexes)
             continue;
         unusedSubstitutions.push(substitutions[i]);
     }
 
     return { formattedResult: result, unusedSubstitutions: unusedSubstitutions };
-}
+};
 
 /**
  * @param {string} query
  * @param {boolean} caseSensitive
  * @param {boolean} isRegex
  * @return {!RegExp}
  */
 function createSearchRegex(query, caseSensitive, isRegex)
 {
     var regexFlags = caseSensitive ? "g" : "gi";
@@ skipping 71 matching lines @@
     return spacesPadding(paddingLength) + numberString;
 }
 
 /**
  * @return {!Array.<T>}
  * @template T
  */
 Set.prototype.valuesArray = function()
 {
     return Array.from(this.values());
-}
+};
 
 /**
  * @param {!Iterable<T>|!Array<!T>} iterable
  * @template T
  */
 Set.prototype.addAll = function(iterable)
 {
     for (var e of iterable)
         this.add(e);
-}
+};
 
 /**
  * @param {!Iterable<T>|!Array<!T>} iterable
  * @return {boolean}
  * @template T
  */
 Set.prototype.containsAll = function(iterable)
 {
     for (var e of iterable) {
         if (!this.has(e))
             return false;
     }
     return true;
-}
+};
 
 /**
  * @return {T}
  * @template T
  */
 Map.prototype.remove = function(key)
 {
     var value = this.get(key);
     this.delete(key);
     return value;
-}
+};
 
 /**
  * @return {!Array<!VALUE>}
  */
 Map.prototype.valuesArray = function()
 {
     return Array.from(this.values());
-}
+};
 
 /**
  * @return {!Array<!KEY>}
  */
 Map.prototype.keysArray = function()
 {
     return Array.from(this.keys());
-}
+};
 
 /**
  * @return {!Multimap<!KEY, !VALUE>}
  */
 Map.prototype.inverse = function()
 {
     var result = new Multimap();
     for (var key of this.keys()) {
         var value = this.get(key);
         result.set(value, key);
     }
     return result;
-}
+};
 
 /**
  * @constructor
  * @template K, V
  */
 var Multimap = function()
 {
     /** @type {!Map.<K, !Set.<!V>>} */
     this._map = new Map();
-}
+};
 
 Multimap.prototype = {
     /**
      * @param {K} key
      * @param {V} value
      */
     set: function(key, value)
     {
         var set = this._map.get(key);
         if (!set) {
@@ skipping 82 matching lines @@
         var keys = this.keysArray();
         for (var i = 0; i < keys.length; ++i)
             result.pushAll(this.get(keys[i]).valuesArray());
         return result;
     },
 
     clear: function()
     {
         this._map.clear();
     }
-}
+};
 
 /**
  * @param {string} url
  * @return {!Promise.<string>}
  */
 function loadXHR(url)
 {
     return new Promise(load);
 
     function load(successCallback, failureCallback)
@@ skipping 73 matching lines @@
     _incomingCallback: function(userCallback)
     {
         console.assert(this._pendingIncomingCallbacksCount > 0);
         if (userCallback) {
             var args = Array.prototype.slice.call(arguments, 1);
             userCallback.apply(null, args);
         }
         if (!--this._pendingIncomingCallbacksCount && this._outgoingCallback)
             this._outgoingCallback();
     }
-}
+};
 
 /**
  * @param {*} value
  */
 function suppressUnused(value)
 {
 }
 
 /**
  * @param {function()} callback
  * @return {number}
  */
 self.setImmediate = function(callback)
 {
     Promise.resolve().then(callback);
     return 0;
-}
+};
 
 /**
  * @param {function(...?)} callback
  * @return {!Promise.<T>}
  * @template T
  */
 Promise.prototype.spread = function(callback)
 {
     return this.then(spreadPromise);
 
     function spreadPromise(arg)
     {
         return callback.apply(null, arg);
     }
-}
+};
 
 /**
  * @param {T} defaultValue
  * @return {!Promise.<T>}
  * @template T
  */
 Promise.prototype.catchException = function(defaultValue) {
     return this.catch(function(error) {
         console.error(error);
         return defaultValue;
     });
-}
+};
 
 /**
  * @param {!Map<number, ?>} other
  * @param {function(!VALUE,?):boolean} isEqual
  * @return {!{removed: !Array<!VALUE>, added: !Array<?>, equal: !Array<!VALUE>}}
  * @this {Map<number, VALUE>}
  */
 Map.prototype.diff = function(other, isEqual)
 {
     var leftKeys = this.keysArray();
@@ skipping 28 matching lines @@
         removed.push(this.get(leftKey));
     }
     while (rightIndex < rightKeys.length) {
         var rightKey = rightKeys[rightIndex++];
         added.push(other.get(rightKey));
     }
     return {
         added: added,
         removed: removed,
         equal: equal
-    }
-}
+    };
+};