Used eslint --fix to replace single-quotes with double-quotes

Author: JamesMessinger

best-practices.js

@@ -1,217 +1,217 @@
-'use strict';
+"use strict";
 
 module.exports = {
   rules: {
     // require corresponding getters for any setters
-    'accessor-pairs': 'error',
+    "accessor-pairs": "error",
 
     // treat var statements as if they were block scoped
-    'block-scoped-var': 'error',
+    "block-scoped-var": "error",
 
     // verify calls of super() in constructors
-    'constructor-super': 'error',
+    "constructor-super": "error",
 
     // require the use of === and !==
-    eqeqeq: 'error',
+    eqeqeq: "error",
 
     // make sure for-in loops have an if statement
-    'guard-for-in': 'error',
+    "guard-for-in": "error",
 
     // require a capital letter for constructors
-    'new-cap': 'error',
+    "new-cap": "error",
 
     // disallow the omission of parentheses when invoking a constructor with no arguments
-    'new-parens': 'error',
+    "new-parens": "error",
 
     // disallow use of the Array constructor
-    'no-array-constructor': 'error',
+    "no-array-constructor": "error",
 
     // disallow use of bitwise operators
-    'no-bitwise': 'error',
+    "no-bitwise": "error",
 
     // disallow use of arguments.caller or arguments.callee
-    'no-caller': 'error',
+    "no-caller": "error",
 
     // disallow the catch clause parameter name being the same as a variable in the outer scope
-    'no-catch-shadow': 'warn',
+    "no-catch-shadow": "warn",
 
     // disallow assignment in conditional expressions
-    'no-cond-assign': 'error',
+    "no-cond-assign": "error",
 
     // disallow control characters in regular expressions
-    'no-control-regex': 'error',
+    "no-control-regex": "error",
 
     // disallow use of debugger
-    'no-debugger': 'error',
+    "no-debugger": "error",
 
     // disallow deletion of variables
-    'no-delete-var': 'error',
+    "no-delete-var": "error",
 
     // disallow division operators explicitly at beginning of regular expression
-    'no-div-regex': 'error',
+    "no-div-regex": "error",
 
     // disallow duplicate argument names in functions
-    'no-dupe-args': 'error',
+    "no-dupe-args": "error",
 
     // disallow duplicate keys when creating object literals
-    'no-dupe-keys': 'error',
+    "no-dupe-keys": "error",
 
     // disallow duplicate case labels
-    'no-duplicate-case': 'error',
+    "no-duplicate-case": "error",
 
     // disallow empty statements
-    'no-empty': 'error',
+    "no-empty": "error",
 
     // disallow the use of empty character classes in regular expressions
-    'no-empty-character-class': 'error',
+    "no-empty-character-class": "error",
 
     // disallow comparisons to null without a type-checking operator
-    'no-eq-null': 'error',
+    "no-eq-null": "error",
 
     // disallow use of eval()
-    'no-eval': 'error',
+    "no-eval": "error",
 
     // disallow adding to native types
-    'no-extend-native': 'error',
+    "no-extend-native": "error",
 
     // disallow unnecessary function binding
-    'no-extra-bind': 'error',
+    "no-extra-bind": "error",
 
     // disallow double-negation boolean casts in a boolean context
-    'no-extra-boolean-cast': 'error',
+    "no-extra-boolean-cast": "error",
 
     // disallow unnecessary semicolons
-    'no-extra-semi': 'error',
+    "no-extra-semi": "error",
 
     // disallow fallthrough of case statements
-    'no-fallthrough': 'error',
+    "no-fallthrough": "error",
 
     // disallow the use of leading or trailing decimal points in numeric literals
-    'no-floating-decimal': 'error',
+    "no-floating-decimal": "error",
 
     // disallow overwriting functions written as function declarations
-    'no-func-assign': 'error',
+    "no-func-assign": "error",
 
     // disallow use of eval()-like methods
-    'no-implied-eval': 'error',
+    "no-implied-eval": "error",
 
     // disallow function or variable declarations in nested blocks
-    'no-inner-declarations': 'error',
+    "no-inner-declarations": "error",
 
     // disallow invalid regular expression strings in the RegExp constructor
-    'no-invalid-regexp': 'error',
+    "no-invalid-regexp": "error",
 
     // disallow usage of __iterator__ property
-    'no-iterator': 'error',
+    "no-iterator": "error",
 
     // disallow labels that share a name with a variable
-    'no-label-var': 'error',
+    "no-label-var": "error",
 
     // disallow use of labeled statements
-    'no-labels': 'error',
+    "no-labels": "error",
 
     // disallow unnecessary nested blocks
-    'no-lone-blocks': 'warn',
+    "no-lone-blocks": "warn",
 
     // disallow creation of functions within loops
-    'no-loop-func': 'warn',
+    "no-loop-func": "warn",
 
     // disallow use of multiline strings
-    'no-multi-str': 'error',
+    "no-multi-str": "error",
 
     // disallow reassignments of native objects
-    'no-native-reassign': 'error',
+    "no-native-reassign": "error",
 
     // disallow negation of the left operand of an in expression
-    'no-negated-in-lhs': 'error',
+    "no-negated-in-lhs": "error",
 
     // disallow use of new operator when not part of the assignment or comparison
-    'no-new': 'error',
+    "no-new": "error",
 
     // disallow use of new operator for Function object
-    'no-new-func': 'error',
+    "no-new-func": "error",
 
     // disallow use of the Object constructor
-    'no-new-object': 'error',
+    "no-new-object": "error",
 
     // disallows creating new instances of String, Number, and Boolean
-    'no-new-wrappers': 'error',
+    "no-new-wrappers": "error",
 
     // disallow the use of object properties of the global object (Math and JSON) as functions
-    'no-obj-calls': 'error',
+    "no-obj-calls": "error",
 
     // disallow use of octal literals
-    'no-octal': 'error',
+    "no-octal": "error",
 
     // disallow use of octal escape sequences in string literals, such as var foo = "Copyright \050";
-    'no-octal-escape': 'error',
+    "no-octal-escape": "error",
 
     // disallow usage of __proto__ property
-    'no-proto': 'error',
+    "no-proto": "error",
 
     // disallow declaring the same variable more then once
-    'no-redeclare': 'error',
+    "no-redeclare": "error",
 
     // disallow use of javascript: urls.
-    'no-script-url': 'error',
+    "no-script-url": "error",
 
     // disallow comparisons where both sides are exactly the same
-    'no-self-compare': 'error',
+    "no-self-compare": "error",
 
     // disallow use of comma operator
-    'no-sequences': 'error',
+    "no-sequences": "error",
 
     // disallow declaration of variables already declared in the outer scope
-    'no-shadow': 'warn',
+    "no-shadow": "warn",
 
     // disallow shadowing of names such as arguments
-    'no-shadow-restricted-names': 'error',
+    "no-shadow-restricted-names": "error",
 
     // disallow sparse arrays
-    'no-sparse-arrays': 'error',
+    "no-sparse-arrays": "error",
 
     // disallow throwing non-Error objects
-    'no-throw-literal': 'error',
+    "no-throw-literal": "error",
 
     // disallow use of undeclared variables unless mentioned in a /*global */ block
-    'no-undef': 'error',
+    "no-undef": "error",
 
     // disallow declaration of variables that are not used in the code
-    'no-unused-vars': [
-      'error',
+    "no-unused-vars": [
+      "error",
       {
-        vars: 'all',                // check "all" variables (as opposed to just "local" variables)
-        args: 'after-used',         // check any arguments that come "after-used" arguments
+        vars: "all",                // check "all" variables (as opposed to just "local" variables)
+        args: "after-used",         // check any arguments that come "after-used" arguments
       },
     ],
 
     // disallow use of void operator
-    'no-void': 'error',
+    "no-void": "error",
 
     // disallow use of the with statement
-    'no-with': 'error',
+    "no-with": "error",
 
     // require assignment operator shorthand where possible
-    'operator-assignment': 'error',
+    "operator-assignment": "error",
 
     // Require the "use strict" pragma, either at the global level or function level,
     // depending on whether CommonJS is being used or not
     strict: [
-      'error',
-      'safe',
+      "error",
+      "safe",
     ],
 
     // disallow comparisons with the value NaN
-    'use-isnan': 'error',
+    "use-isnan": "error",
 
     // Ensure that the results of typeof are compared against a valid string
-    'valid-typeof': 'error',
+    "valid-typeof": "error",
 
     // require immediate function invocation to be wrapped in parentheses
-    'wrap-iife': 'error',
+    "wrap-iife": "error",
 
     // disallow Yoda conditions
-    yoda: 'error',
+    yoda: "error",
 
   }
 };

browser.js

@@ -1,4 +1,4 @@
-'use strict';
+"use strict";
 
 module.exports = {
   env: {
@@ -7,13 +7,13 @@ module.exports = {
 
   rules: {
     // disallow the use of alert, confirm, and prompt
-    'no-alert': 'warn',
+    "no-alert": "warn",
 
     // Require the "use strict" pragma at the function level,
     // to avoid problems with loose scripts
     strict: [
-      'error',
-      'function',
+      "error",
+      "function",
     ],
   }
 };

common-js.js

@@ -1,8 +1,8 @@
-'use strict';
+"use strict";
 
 module.exports = {
   parserOptions: {
-    sourceType: 'script',
+    sourceType: "script",
     ecmaFeatures: {
       impliedStrict: false,
     },
@@ -16,8 +16,8 @@ module.exports = {
     // Require the "use strict" pragma at the global level,
     // since CommonJS modules are wrapped in a function
     strict: [
-      'error',
-      'global',
+      "error",
+      "global",
     ],
   }
 };

es5.js

@@ -1,26 +1,26 @@
-'use strict';
+"use strict";
 
 module.exports = {
   env: {
     es6: false,
   },
 
-  parser: 'espree',
+  parser: "espree",
 
   parserOptions: {
     ecmaVersion: 5,
   },
 
   rules: {
     // use `var`, not `let` or `const`
-    'no-var': 'off',
+    "no-var": "off",
 
     // ES5 doesn't support method and property shorthand syntax for object literals
-    'object-shorthand': 'off',
+    "object-shorthand": "off",
 
     // Don't recommend ES6 language features
-    'prefer-arrow-callback': 'off',
-    'prefer-spread': 'off',
-    'prefer-template': 'off',
+    "prefer-arrow-callback": "off",
+    "prefer-spread": "off",
+    "prefer-template": "off",
   }
 };

es6-modules.js

@@ -1,8 +1,8 @@
-'use strict';
+"use strict";
 
 module.exports = {
   parserOptions: {
-    sourceType: 'module',
+    sourceType: "module",
     ecmaFeatures: {
       impliedStrict: true,
     },
@@ -13,8 +13,8 @@ module.exports = {
     // in strict mode, and the pragma is illegal in combination with some
     // ES6 features (e.g. default values in function parameters)
     strict: [
-      'error',
-      'never',
+      "error",
+      "never",
     ],
   }
 };