@odg/eslint-config 1.0.0 → 1.1.0

package/README.md

@@ -69,11 +69,6 @@
 - [Arrow Function No Break Line](#arrow-function-no-break-line)
 - [No Empty Block](#no-empty-block)
 - [No Long Syntax](#no-long-syntax)
-- [Useless Call Code](#useless-call-code)
-- [Useless Catch Code](#useless-catch-code)
-- [Useless Expression Code](#useless-expression-code)
-- [Useless Return Code](#useless-return-code)
-- [Useless Construct Code](#useless-construct-code)
 - [Useless Parens](#useless-parens)
 - [Useless Boolean](#useless-boolean)
 - [Useless Alias](#useless-alias)
@@ -86,6 +81,8 @@
 - [Disallow Script Url](#disallow-script-url)
 - [Disallow Undefined](#disallow-undefined)
 - [Function Name](#function-name)
+- [Function Name Match](#function-name-match)
+- [Get And Setters](#get-and-setters)
 - [Function Style](#function-style)
 - [No Else Return](#no-else-return)
 - [No Console Spaces](#no-console-spaces)
@@ -128,7 +125,6 @@
 - [No Delete Var](#no-delete-var)
 - [No Lone Blocks](#no-lone-blocks)
 - [No Proto](#no-proto)
-- [No Useless Computed Key](#no-useless-computed-key)
 - [No Declare in Block](#no-declare-in-block)
 - [No Nonoctal Decimal Escape](#no-nonoctal-decimal-escape)
 - [No Import Absolute Path](#no-import-absolute-path)
@@ -196,7 +192,9 @@
 - [Quote Props](#quote-props)
 - [Brace Style](#brace-style)
 - [Comma Style](#comma-style)
-- [Object BreakLine](#object-break-line)
+- [Object Break Line](#object-break-line)
+- [Object Curly Newline](#object-curly-newline)
+- [No Negative Condition](#no-negated-condition)
 - [No Shadow](#no-shadow)
 - [Parentheses New Line](#parentheses-new-line)
 - [No Func Call Spacing](#no-func-call-spacing)
@@ -207,6 +205,7 @@
 - [Inline IF](#inline-if)
 - [New Instance Use Parentheses](#new-instance-use-parentheses)
 - [Logical Assignment Operators](#logical-assignment-operators)
+- [No With](#no-with)
 - [Promise Rules](#promise-rules)
   - [No New Statics](#no-new-statics)
   - [No Return Wrap](#no-return-wrap)
@@ -230,7 +229,8 @@
   - [Import Order](#import-order)
   - [No Anonymous Default Export](#no-anonymous-default-export)
   - [Prefer Node Protocol](#prefer-node-protocol)
-  - [Prefer export…from](#prefer-export-from)
+  - [Prefer export from](#prefer-export-from)
+  - [No Empty Import](#no-empty-import)
 - [Documentation](#documentation)
   - [Space Comment](#spaced-comment)
   - [Capitalized Comments](#capitalized-comments)
@@ -395,6 +395,13 @@
   - [No This Before Super](#no-this-before-super)
   - [No Obj Calls](#no-obj-calls)
   - [No Empty Pattern](#no-empty-pattern)
+  - [No Useless Computed Key](#no-useless-computed-key)
+  - [Useless Call Code](#useless-call-code)
+  - [Useless Catch Code](#useless-catch-code)
+  - [Useless Expression Code](#useless-expression-code)
+  - [Useless Return Code](#useless-return-code)
+  - [Useless Construct Code](#useless-construct-code)
+  - [No Use Before Define](#no-use-before-define)
 - [Possible Errors](#possible-errors)
   - [For Direction](#for-direction)
   - [No Extra Bind](#no-extra-bind)
@@ -411,6 +418,10 @@
   - [No Disable Timeout](#no-disable-timeout)
   - [No Empty Static Block](#no-empty-static-block)
   - [No Fallthrough](#no-fallthrough)
+  - [No Octal](#no-octal)
+  - [Octal Scape](#octal-scape)
+  - [No Global Assign](#no-global-assign)
+  - [No Case Declarations](#no-case-declarations)
 - [YAML / JSON](#yaml-json)
 
 ## Introduction
@@ -466,6 +477,7 @@ export default class Foo {
 Requires semicolons at the end of statements
 
 <https://eslint.org/docs/rules/semi#semi>
+<https://eslint.org/docs/rules/semi-style>
 
 👍 Examples of correct code
 
@@ -479,6 +491,23 @@ object.method = function() {
 class Foo {
     bar = 1;
 }
+
+foo();
+[1, 2, 3].forEach(bar);
+
+for (
+    var i = 0;
+    i < 10;
+    ++i
+) {
+    foo();
+}
+
+class C {
+    static {
+        foo();
+    }
+}
 ```
 
 👎 Examples of incorrect code
@@ -493,6 +522,25 @@ object.method = function() {
 class Foo {
     bar = 1
 }
+
+
+foo()
+;[1, 2, 3].forEach(bar)
+
+for (
+    var i = 0
+    ; i < 10
+    ; ++i
+) {
+    foo()
+}
+
+class C {
+    static {
+        foo()
+        ;bar()
+    }
+}
 ```
 
 ## Quotes Rule
@@ -533,6 +581,7 @@ Tabs Disallow
 <https://eslint.org/docs/rules/indent#indent>
 <https://sonarsource.github.io/rspec/#/rspec/S3973/javascript>
 <https://eslint.org/docs/latest/rules/no-tabs>
+<https://eslint.org/docs/latest/rules/no-mixed-spaces-and-tabs>
 
 👍 Examples of correct code
 
@@ -1842,853 +1891,734 @@ const arr = Array(0, 1, 2);
 const arr = new Array(0, 1, 2);
 ```
 
-## Useless Call Code
+## Useless Parens
 
 ----------
 
-Disallow useless code
+Disallows unnecessary parentheses.
 
-<https://eslint.org/docs/rules/no-useless-call#no-useless-call>
+<https://github.com/typescript-eslint/typescript-eslint/blob/main/packages/eslint-plugin/docs/rules/no-extra-parens.md>
+<https://eslint.org/docs/rules/no-extra-parens#no-extra-parens>
 
 👍 Examples of correct code
 
 ```typescript
-foo.call(obj, 1, 2, 3);
-foo.apply(obj, [1, 2, 3]);
-obj.foo.call(null, 1, 2, 3);
-obj.foo.apply(null, [1, 2, 3]);
-obj.foo.call(otherObj, 1, 2, 3);
-obj.foo.apply(otherObj, [1, 2, 3]);
+a = (b * c);
 
-// The argument list is variadic.
-// Those are warned by the `prefer-spread` rule.
-foo.apply(undefined, args);
-foo.apply(null, args);
-obj.foo.apply(obj, args);
+(a * b) + c;
 
-a[++i].foo.call(a[i], 1, 2, 3);
+for (a in (b, c));
+
+for (a in (b));
+
+for (a of (b));
+
+typeof (a);
+
+(function(){} ? a() : b());
+
+class A {
+    [(x)] = 1;
+}
+
+class B {
+    x = (y + z);
+}
 ```
 
 👎 Examples of incorrect code
 
 ```typescript
-foo.call(undefined, 1, 2, 3);
-foo.apply(undefined, [1, 2, 3]);
-foo.call(null, 1, 2, 3);
-foo.apply(null, [1, 2, 3]);
+a = (b * c);
 
-// These are same as `obj.foo(1, 2, 3);`
-obj.foo.call(obj, 1, 2, 3);
-obj.foo.apply(obj, [1, 2, 3]);
+(a * b) + c;
 
-a[i++].foo.call(a[i++], 1, 2, 3);
+for (a in (b, c));
+
+for (a in (b));
+
+for (a of (b));
+
+typeof (a);
+
+(function(){} ? a() : b());
+
+class A {
+    [(x)] = 1;
+}
+
+class B {
+    x = (y + z);
+}
 ```
 
-## Useless Catch Code
+## Useless Boolean
 
 ----------
 
 Disallow useless code
 
-<https://eslint.org/docs/rules/no-useless-catch#no-useless-catch>
+<https://eslint.org/docs/rules/no-useless-constructor#options>
 
 👍 Examples of correct code
 
 ```typescript
-try {
-  doSomethingThatMightThrow();
-} catch (e) {
-  doSomethingBeforeRethrow();
-  throw e;
-}
+var foo = !!bar;
+var foo = Boolean(bar);
 
-try {
-  doSomethingThatMightThrow();
-} catch (e) {
-  handleError(e);
+function foo() {
+    return !!bar;
 }
 
-try {
-  doSomethingThatMightThrow();
-} finally {
-  cleanUp();
-}
+var foo = bar ? !!baz : !!bat;
 ```
 
 👎 Examples of incorrect code
 
 ```typescript
-try {
-  doSomethingThatMightThrow();
-} catch (e) {
-  throw e;
+var foo = !!!bar;
+
+var foo = !!bar ? baz : bat;
+
+var foo = Boolean(!!bar);
+
+var foo = new Boolean(!!bar);
+
+if (!!foo) {
+    // ...
 }
 
-try {
-  doSomethingThatMightThrow();
-} catch (e) {
-  throw e;
-} finally {
-  cleanUp();
+if (Boolean(foo)) {
+    // ...
+}
+
+while (!!foo) {
+    // ...
+}
+
+do {
+    // ...
+} while (Boolean(foo));
+
+for ( ;!!foo; ) {
+    // ...
 }
 ```
 
-## Useless Expression Code
+## Useless Alias
 
 ----------
 
-Disallow useless code
+Disallows renaming import, export, and destructured assignments to the same name.
 
-<https://eslint.org/docs/rules/no-unused-expressions>
+<https://eslint.org/docs/rules/no-useless-rename>
 
 👍 Examples of correct code
 
 ```typescript
-{} // In this context, this is a block statement, not an object literal
-
-{myLabel: someVar} // In this context, this is a block statement with a label and expression, not an object literal
-
-function namedFunctionDeclaration () {}
-
-(function aGenuineIIFE () {}());
-
-f()
-
-a = 0
+import * as foo from "foo";
+import { foo } from "bar";
+import { foo as bar } from "baz";
+import { "foo" as bar } from "baz";
 
-new C
+export { foo };
+export { foo as bar };
+export { foo as bar } from "foo";
 
-delete a.b
+let { foo } = bar;
+let { foo: bar } = baz;
+let { [foo]: foo } = bar;
 
-void a
+function foo({ bar }) {}
+function foo({ bar: baz }) {}
 
-a ? b() : c();
-a ? (b = c) : d();
+({ foo }) => {}
+({ foo: bar }) => {}
 ```
 
 👎 Examples of incorrect code
 
 ```typescript
-0
+import { foo as foo } from "bar";
+import { "foo" as foo } from "bar";
+export { foo as foo };
+export { foo as "foo" };
+export { foo as foo } from "bar";
+export { "foo" as "foo" } from "bar";
+let { foo: foo } = bar;
+let { 'foo': foo } = bar;
+function foo({ bar: bar }) {}
+({ foo: foo }) => {}
+```
 
-if(0) 0
+## Return New line
 
-{0}
+----------
 
-f(0), {}
+Force new line before return
 
-a && b()
+<https://eslint.org/docs/rules/newline-before-return#newline-before-return>
 
-a, b()
+👍 Examples of correct code
 
-c = a, b;
+```typescript
+function foo(bar) {
+  var baz = 'baz';
 
-a() && function namedFunctionInExpressionContext () {f();}
+  if (bar()) {
+    return true;
+  }
 
-(function anIncompleteIIFE () {});
+  if (!bar) {
+    bar = baz;
 
-injectGlobal`body{ color: red; }`
+    return baz;
+  }
 
-function foo() {
-    "bar" + 1;
+  return bar;
 }
+```
 
-class Foo {
-    static {
-        "use strict"; // class static blocks do not have directive prologues
-    }
+👎 Examples of incorrect code
+
+```typescript
+function foo(bar) {
+  var baz = 'baz';
+  if (bar()) {
+    return true;
+  }
+  if (!bar) {
+    bar = baz;
+    return bar;
+  }
+  return bar;
 }
 ```
 
-## Useless Return Code
+## Comment Multi Line Prefer
 
 ----------
 
-Disallow useless code
+Prefer Multi-line comment formated
 
-<https://eslint.org/docs/rules/no-useless-return#no-useless-return>
+<https://eslint.org/docs/rules/newline-before-return#newline-before-return>
 
 👍 Examples of correct code
 
 ```typescript
-function foo() { return 5; }
+/*
+ * this line
+ * calls foo()
+ */
+foo();
 
-function foo() {
-  return doSomething();
-}
+// single-line comment
+```
 
-function foo() {
-  if (condition) {
-    bar();
-    return;
-  } else {
-    baz();
-  }
-  qux();
-}
+👎 Examples of incorrect code
 
-function foo() {
-  switch (bar) {
-    case 1:
-      doSomething();
-      return;
-    default:
-      doSomethingElse();
-  }
-}
+```typescript
 
-function foo() {
-  for (const foo of bar) {
-    return;
-  }
-}
-```
+// this line
+// calls foo()
+foo();
 
-👎 Examples of incorrect code
+/* this line
+calls foo() */
+foo();
 
-```typescript
-function foo() { return; }
+/* this comment
+ * is missing a newline after /*
+ */
 
-function foo() {
-  doSomething();
-  return;
-}
+/*
+ * this comment
+ * is missing a newline at the end */
 
-function foo() {
-  if (condition) {
-    bar();
-    return;
-  } else {
-    baz();
-  }
-}
+/*
+* the star in this line should have a space before it
+ */
 
-function foo() {
-  switch (bar) {
-    case 1:
-      doSomething();
-    default:
-      doSomethingElse();
-      return;
-  }
-}
+/*
+ * the star on the following line should have a space before it
+*/
 ```
 
-## Useless Construct Code
+## No throw Literal
 
 ----------
 
-Disallow useless code
+Create custom class to Throw
 
-<https://eslint.org/docs/rules/no-useless-constructor#options>
+<https://github.com/typescript-eslint/typescript-eslint/blob/main/packages/eslint-plugin/docs/rules/no-throw-literal.md>
+<https://eslint.org/docs/rules/prefer-promise-reject-errors#prefer-promise-reject-errors>
 
 👍 Examples of correct code
 
 ```typescript
+class CustomError extends Error {
+  // ...
+};
 
-class A { }
+const e = new CustomError("error");
+throw e;
 
-class A {
-    constructor () {
-        doSomething();
-    }
-}
+throw new CustomError("error");
 
-class B extends A {
-    constructor() {
-        super('foo');
-    }
+function err() {
+  return new CustomError();
 }
+throw err();
 
-class B extends A {
-    constructor() {
-        super();
-        doSomething();
-    }
+const foo = {
+  bar: new CustomError();
 }
-```
-
-👎 Examples of incorrect code
+throw foo.bar;
 
-```typescript
-class A {
-    constructor () {
-    }
-}
+// promises
 
-class B extends A {
-    constructor (...args) {
-      super(...args);
-    }
-}
-```
+Promise.reject(new CustomError("something bad happened"));
 
-## Useless Parens
+Promise.reject(new TypeError("something bad happened"));
 
-----------
+new Promise(function(resolve, reject) {
+  reject(new CustomError("something bad happened"));
+});
 
-Disallows unnecessary parentheses.
+var foo = getUnknownValue();
+Promise.reject(foo);
 
-<https://github.com/typescript-eslint/typescript-eslint/blob/main/packages/eslint-plugin/docs/rules/no-extra-parens.md>
-<https://eslint.org/docs/rules/no-extra-parens#no-extra-parens>
+```
 
-👍 Examples of correct code
+👎 Examples of incorrect code
 
 ```typescript
-a = (b * c);
+throw new Error();
 
-(a * b) + c;
+throw 'error';
 
-for (a in (b, c));
+throw 0;
 
-for (a in (b));
+throw undefined;
 
-for (a of (b));
+throw null;
 
-typeof (a);
+const err = new Error();
+throw 'an ' + err;
 
-(function(){} ? a() : b());
+const err = new Error();
+throw `${err}`;
 
-class A {
-    [(x)] = 1;
-}
+const err = '';
+throw err;
 
-class B {
-    x = (y + z);
+function err() {
+  return '';
 }
-```
-
-👎 Examples of incorrect code
-
-```typescript
-a = (b * c);
-
-(a * b) + c;
+throw err();
 
-for (a in (b, c));
+const foo = {
+  bar: '',
+};
+throw foo.bar;
 
-for (a in (b));
+// Promise
 
-for (a of (b));
+Promise.reject("something bad happened");
 
-typeof (a);
+Promise.reject(5);
 
-(function(){} ? a() : b());
+Promise.reject();
 
-class A {
-    [(x)] = 1;
-}
+new Promise(function(resolve, reject) {
+  reject("something bad happened");
+});
 
-class B {
-    x = (y + z);
-}
+new Promise(function(resolve, reject) {
+  reject();
+});
 ```
 
-## Useless Boolean
+## No Unreachable
 
 ----------
 
-Disallow useless code
+No Unreachable code
 
-<https://eslint.org/docs/rules/no-useless-constructor#options>
+<https://eslint.org/docs/rules/no-unreachable>
 
 👍 Examples of correct code
 
 ```typescript
-var foo = !!bar;
-var foo = Boolean(bar);
-
 function foo() {
-    return !!bar;
+    function bar() {
+        return 1;
+    }
+
+    return bar();
+
 }
 
-var foo = bar ? !!baz : !!bat;
+function bar() {
+    var x;
+    return x;
+}
+
+switch (foo) {
+    case 1:
+        break;
+}
 ```
 
 👎 Examples of incorrect code
 
 ```typescript
-var foo = !!!bar;
-
-var foo = !!bar ? baz : bat;
-
-var foo = Boolean(!!bar);
-
-var foo = new Boolean(!!bar);
-
-if (!!foo) {
-    // ...
+function foo() {
+    return true;
+    console.log("done");
 }
 
-if (Boolean(foo)) {
-    // ...
+function bar() {
+    throw new Error("Oops!");
+    console.log("done");
 }
 
-while (!!foo) {
-    // ...
+while(value) {
+    break;
+    console.log("done");
 }
 
-do {
-    // ...
-} while (Boolean(foo));
+throw new Error("Oops!");
+console.log("done");
 
-for ( ;!!foo; ) {
-    // ...
+function baz() {
+    if (Math.random() < 0.5) {
+        return;
+    } else {
+        throw new Error();
+    }
+    console.log("done");
 }
+
+for (;;) {}
+console.log("done");
 ```
 
-## Useless Alias
+## No Multiline String
 
 ----------
 
-Disallows renaming import, export, and destructured assignments to the same name.
+Prevent break line in string
 
-<https://eslint.org/docs/rules/no-useless-rename>
+<https://eslint.org/docs/rules/no-multi-str#no-multi-str>
 
 👍 Examples of correct code
 
 ```typescript
-import * as foo from "foo";
-import { foo } from "bar";
-import { foo as bar } from "baz";
-import { "foo" as bar } from "baz";
-
-export { foo };
-export { foo as bar };
-export { foo as bar } from "foo";
-
-let { foo } = bar;
-let { foo: bar } = baz;
-let { [foo]: foo } = bar;
-
-function foo({ bar }) {}
-function foo({ bar: baz }) {}
+var x = "some very\nlong text";
 
-({ foo }) => {}
-({ foo: bar }) => {}
+var x = "some very " +
+        "long text";
 ```
 
 👎 Examples of incorrect code
 
 ```typescript
-import { foo as foo } from "bar";
-import { "foo" as foo } from "bar";
-export { foo as foo };
-export { foo as "foo" };
-export { foo as foo } from "bar";
-export { "foo" as "foo" } from "bar";
-let { foo: foo } = bar;
-let { 'foo': foo } = bar;
-function foo({ bar: bar }) {}
-({ foo: foo }) => {}
+var x = "some very \
+long text";
 ```
 
-## Return New line
+## No Unsafe Assign
 
 ----------
 
-Force new line before return
+Disallows assigning any to variables and properties.
 
-<https://eslint.org/docs/rules/newline-before-return#newline-before-return>
+<https://github.com/typescript-eslint/typescript-eslint/blob/main/packages/eslint-plugin/docs/rules/no-unsafe-assignment.md>
 
 👍 Examples of correct code
 
 ```typescript
-function foo(bar) {
-  var baz = 'baz';
-
-  if (bar()) {
-    return true;
-  }
-
-  if (!bar) {
-    bar = baz;
-
-    return baz;
-  }
+const x = 1,
+  y = 1;
+const [x] = [1];
+[x] = [1] as [number];
 
-  return bar;
+function foo(a = 1) {}
+class Foo {
+  constructor(private a = 1) {}
+}
+class Foo {
+  private a = 1;
 }
+
+// generic position examples
+const x: Set<string> = new Set<string>();
+const x: Map<string, string> = new Map<string, string>();
+const x: Set<string[]> = new Set<string[]>();
+const x: Set<Set<Set<string>>> = new Set<Set<Set<string>>>();
 ```
 
 👎 Examples of incorrect code
 
 ```typescript
-function foo(bar) {
-  var baz = 'baz';
-  if (bar()) {
-    return true;
-  }
-  if (!bar) {
-    bar = baz;
-    return bar;
-  }
-  return bar;
+const x = 1 as any,
+  y = 1 as any;
+const [x] = 1 as any;
+const [x] = [] as any[];
+const [x] = [1 as any];
+[x] = [1] as [any];
+
+function foo(a = 1 as any) {}
+class Foo {
+  constructor(private a = 1 as any) {}
 }
+class Foo {
+  private a = 1 as any;
+}
+
+// generic position examples
+const x: Set<string> = new Set<any>();
+const x: Map<string, string> = new Map<string, any>();
+const x: Set<string[]> = new Set<any[]>();
+const x: Set<Set<Set<string>>> = new Set<Set<Set<any>>>();
 ```
 
-## Comment Multi Line Prefer
+## Disallow Script Url
 
 ----------
 
-Prefer Multi-line comment formated
+Using javascript: URLs is considered by some as a form of eval.
 
-<https://eslint.org/docs/rules/newline-before-return#newline-before-return>
+<https://eslint.org/docs/rules/no-script-url>
 
 👍 Examples of correct code
 
 ```typescript
-/*
- * this line
- * calls foo()
- */
-foo();
-
-// single-line comment
+location.href = "#";
 ```
 
 👎 Examples of incorrect code
 
 ```typescript
+location.href = "javascript:void(0)";
 
-// this line
-// calls foo()
-foo();
-
-/* this line
-calls foo() */
-foo();
-
-/* this comment
- * is missing a newline after /*
- */
-
-/*
- * this comment
- * is missing a newline at the end */
-
-/*
-* the star in this line should have a space before it
- */
-
-/*
- * the star on the following line should have a space before it
-*/
+location.href = `javascript:void(0)`;
 ```
 
-## No throw Literal
+## Disallow Undefined
 
 ----------
 
-Create custom class to Throw
+Disallows the use of undeclared variables unless mentioned in /\*global\*/ comments.
 
-<https://github.com/typescript-eslint/typescript-eslint/blob/main/packages/eslint-plugin/docs/rules/no-throw-literal.md>
-<https://eslint.org/docs/rules/prefer-promise-reject-errors#prefer-promise-reject-errors>
+<https://eslint.org/docs/rules/no-undef>
 
 👍 Examples of correct code
 
 ```typescript
-class CustomError extends Error {
-  // ...
-};
+/* global someFunction, a */
 
-const e = new CustomError("error");
-throw e;
+var foo = someFunction();
+var bar = a + 1;
+```
 
-throw new CustomError("error");
+👎 Examples of incorrect code
 
-function err() {
-  return new CustomError();
-}
-throw err();
+```typescript
+var foo = someFunction();
+var bar = a + 1;
+```
 
-const foo = {
-  bar: new CustomError();
-}
-throw foo.bar;
+## Function Name
 
-// promises
+----------
 
-Promise.reject(new CustomError("something bad happened"));
+Requires function expressions to have a name, if the name isn't assigned automatically per the ECMAScript specification.
 
-Promise.reject(new TypeError("something bad happened"));
+<https://eslint.org/docs/rules/func-names>
 
-new Promise(function(resolve, reject) {
-  reject(new CustomError("something bad happened"));
-});
+👍 Examples of correct code
 
-var foo = getUnknownValue();
-Promise.reject(foo);
+```typescript
+/* global someFunction, a */
 
+var foo = someFunction();
+var bar = a + 1;
 ```
 
 👎 Examples of incorrect code
 
 ```typescript
-throw new Error();
+Foo.prototype.bar = function() {};
 
-throw 'error';
+(function() {
+    // ...
+}())
 
-throw 0;
+export default function() {}
+```
 
-throw undefined;
+## Function Name Match
 
-throw null;
+----------
 
-const err = new Error();
-throw 'an ' + err;
+This rule requires function names to match the name of the variable or property to which they are assigned.
+The rule will ignore property assignments where the property name is a literal that
+is not a valid identifier in the ECMAScript version specified in your configuration (default ES5).
 
-const err = new Error();
-throw `${err}`;
+<https://eslint.org/docs/latest/rules/func-name-matching>
 
-const err = '';
-throw err;
+👍 Examples of correct code
 
-function err() {
-  return '';
-}
-throw err();
+```typescript
+var foo = function foo() {};
+var foo = function() {};
+var foo = () => {};
+foo = function foo() {};
 
-const foo = {
-  bar: '',
-};
-throw foo.bar;
+obj.foo = function foo() {};
+obj['foo'] = function foo() {};
+obj['foo//bar'] = function foo() {};
+obj[foo] = function bar() {};
 
-// Promise
+var obj = {foo: function foo() {}};
+var obj = {[foo]: function bar() {}};
+var obj = {'foo//bar': function foo() {}};
+var obj = {foo: function() {}};
 
-Promise.reject("something bad happened");
+obj['x' + 2] = function bar(){};
+var [ bar ] = [ function bar(){} ];
+({[foo]: function bar() {}})
 
-Promise.reject(5);
+class C {
+    foo = function foo() {};
+    baz = function() {};
+}
 
-Promise.reject();
+// private names are ignored
+class D {
+    #foo = function foo() {};
+    #bar = function foo() {};
+    baz() {
+        this.#foo = function foo() {};
+        this.#foo = function bar() {};
+    }
+}
 
-new Promise(function(resolve, reject) {
-  reject("something bad happened");
-});
+module.exports = function foo(name) {};
+module['exports'] = function foo(name) {};
+```
 
-new Promise(function(resolve, reject) {
-  reject();
-});
+👎 Examples of incorrect code
+
+```typescript
+var foo = function bar() {};
+foo = function bar() {};
+obj.foo = function bar() {};
+obj['foo'] = function bar() {};
+var obj = {foo: function bar() {}};
+({['foo']: function bar() {}});
+
+class C {
+    foo = function bar() {};
+}
 ```
 
-## No Unreachable
+## Get And Setters
 
 ----------
 
-No Unreachable code
+A getter and setter for the same property don’t necessarily have to be defined adjacent to each other.
 
-<https://eslint.org/docs/rules/no-unreachable>
+<https://eslint.org/docs/latest/rules/grouped-accessor-pairs>
 
 👍 Examples of correct code
 
 ```typescript
-function foo() {
-    function bar() {
-        return 1;
-    }
 
-    return bar();
+var foo = {
+    get a() {
+        return this.val;
+    },
+    set a(value) {
+        this.val = value;
+    },
+    b: 1
+};
 
+var bar = {
+    set b(value) {
+        this.val = value;
+    },
+    get b() {
+        return this.val;
+    },
+    a: 1
 }
 
-function bar() {
-    var x;
-    return x;
+class Foo {
+    set a(value) {
+        this.val = value;
+    }
+    get a() {
+        return this.val;
+    }
+    b(){}
 }
 
-switch (foo) {
-    case 1:
-        break;
+const Bar = class {
+    static get a() {
+        return this.val;
+    }
+    static set a(value) {
+        this.val = value;
+    }
 }
 ```
 
 👎 Examples of incorrect code
 
 ```typescript
-function foo() {
-    return true;
-    console.log("done");
-}
-
-function bar() {
-    throw new Error("Oops!");
-    console.log("done");
-}
-
-while(value) {
-    break;
-    console.log("done");
-}
-
-throw new Error("Oops!");
-console.log("done");
+var foo = {
+    get a() {
+        return this.val;
+    },
+    b: 1,
+    set a(value) {
+        this.val = value;
+    }
+};
 
-function baz() {
-    if (Math.random() < 0.5) {
-        return;
-    } else {
-        throw new Error();
+var bar = {
+    set b(value) {
+        this.val = value;
+    },
+    a: 1,
+    get b() {
+        return this.val;
     }
-    console.log("done");
 }
 
-for (;;) {}
-console.log("done");
-```
-
-## No Multiline String
-
-----------
-
-Prevent break line in string
-
-<https://eslint.org/docs/rules/no-multi-str#no-multi-str>
-
-👍 Examples of correct code
-
-```typescript
-var x = "some very\nlong text";
-
-var x = "some very " +
-        "long text";
-```
-
-👎 Examples of incorrect code
-
-```typescript
-var x = "some very \
-long text";
-```
-
-## No Unsafe Assign
-
-----------
-
-Disallows assigning any to variables and properties.
-
-<https://github.com/typescript-eslint/typescript-eslint/blob/main/packages/eslint-plugin/docs/rules/no-unsafe-assignment.md>
-
-👍 Examples of correct code
-
-```typescript
-const x = 1,
-  y = 1;
-const [x] = [1];
-[x] = [1] as [number];
-
-function foo(a = 1) {}
 class Foo {
-  constructor(private a = 1) {}
-}
-class Foo {
-  private a = 1;
+    set a(value) {
+        this.val = value;
+    }
+    b(){}
+    get a() {
+        return this.val;
+    }
 }
 
-// generic position examples
-const x: Set<string> = new Set<string>();
-const x: Map<string, string> = new Map<string, string>();
-const x: Set<string[]> = new Set<string[]>();
-const x: Set<Set<Set<string>>> = new Set<Set<Set<string>>>();
-```
-
-👎 Examples of incorrect code
-
-```typescript
-const x = 1 as any,
-  y = 1 as any;
-const [x] = 1 as any;
-const [x] = [] as any[];
-const [x] = [1 as any];
-[x] = [1] as [any];
-
-function foo(a = 1 as any) {}
-class Foo {
-  constructor(private a = 1 as any) {}
-}
-class Foo {
-  private a = 1 as any;
+const Bar = class {
+    static get a() {
+        return this.val;
+    }
+    b(){}
+    static set a(value) {
+        this.val = value;
+    }
 }
-
-// generic position examples
-const x: Set<string> = new Set<any>();
-const x: Map<string, string> = new Map<string, any>();
-const x: Set<string[]> = new Set<any[]>();
-const x: Set<Set<Set<string>>> = new Set<Set<Set<any>>>();
-```
-
-## Disallow Script Url
-
-----------
-
-Using javascript: URLs is considered by some as a form of eval.
-
-<https://eslint.org/docs/rules/no-script-url>
-
-👍 Examples of correct code
-
-```typescript
-location.href = "#";
-```
-
-👎 Examples of incorrect code
-
-```typescript
-location.href = "javascript:void(0)";
-
-location.href = `javascript:void(0)`;
-```
-
-## Disallow Undefined
-
-----------
-
-Disallows the use of undeclared variables unless mentioned in /\*global\*/ comments.
-
-<https://eslint.org/docs/rules/no-undef>
-
-👍 Examples of correct code
-
-```typescript
-/* global someFunction, a */
-
-var foo = someFunction();
-var bar = a + 1;
-```
-
-👎 Examples of incorrect code
-
-```typescript
-var foo = someFunction();
-var bar = a + 1;
-```
-
-## Function Name
-
-----------
-
-Requires function expressions to have a name, if the name isn't assigned automatically per the ECMAScript specification.
-
-<https://eslint.org/docs/rules/func-names>
-
-👍 Examples of correct code
-
-```typescript
-/* global someFunction, a */
-
-var foo = someFunction();
-var bar = a + 1;
-```
-
-👎 Examples of incorrect code
-
-```typescript
-Foo.prototype.bar = function() {};
-
-(function() {
-    // ...
-}())
-
-export default function() {}
 ```
 
 ## Function Style
@@ -4337,7 +4267,7 @@ class C {
 }
 ```
 
-### No Proto
+## No Proto
 
 ----------
 
@@ -4367,34 +4297,6 @@ obj.__proto__ = b;
 obj["__proto__"] = b;
 ```
 
-### No Useless Computed Key
-
-----------
-
-Disallow unnecessary computed property keys in objects and classes
-
-<https://eslint.org/docs/latest/rules/no-useless-computed-key>
-
-👍 Examples of correct code
-
-```typescript
-var c = { 'a': 0 };
-var c = { 0: 0 };
-var a = { x() {} };
-var c = { a: 0 };
-var c = { '0+1,234': 0 };
-```
-
-👎 Examples of incorrect code
-
-```typescript
-var a = { ['0']: 0 };
-var a = { ['0+1,234']: 0 };
-var a = { [0]: 0 };
-var a = { ['x']: 0 };
-var a = { ['x']() {} };
-```
-
 ## No Declare in Block
 
 ----------
@@ -7276,27 +7178,23 @@ Enforces placing object properties on separate lines.
 👍 Examples of correct code
 
 ```typescript
-const obj1 = {
-    foo: "foo",
-    bar: "bar",
-    baz: "baz"
-};
+const obj1 = { foo: "foo", bar: "bar", baz: "baz" };
 
 const obj2 = {
-    foo: "foo"
-    , bar: "bar"
-    , baz: "baz"
+    foo: "foo",
+    bar: "bar",
+    baz: "baz",
 };
 
 const user = process.argv[2];
 const obj3 = {
     user,
-    [process.argv[3] ? "foo" : "bar"]: 0,
+    [ process.argv[3] ? "foo" : "bar" ]: 0,
     baz: [
         1,
         2,
         4,
-        8
+        8,
     ]
 };
 ```
@@ -7323,17 +7221,120 @@ const obj3 = {
 };
 ```
 
-## No Shadow
+## Object Curly Newline
 
 ----------
 
-Enforces placing object properties on separate lines.
+A number of style guides require or disallow line breaks inside of object braces and other tokens.
 
-Then any code used within the same scope would not get the global undefined,
-but rather the local version with a very different meaning.
+<https://eslint.org/docs/latest/rules/object-curly-newline>
 
-<https://eslint.org/docs/rules/no-shadow>
-<https://eslint.org/docs/rules/no-shadow-restricted-names>
+👍 Examples of correct code
+
+```typescript
+let a = {};
+let b = { foo: 1 };
+let c = { foo: 1, bar: 2 };
+let d = {
+    foo: 1,
+    bar: 2,
+};
+let e = {
+    foo: function() {
+        dosomething();
+    }
+};
+
+let { f } = obj;
+let { g, h } = obj;
+let {
+    i,
+    j
+} = obj;
+let { k = () => dosomething() } = obj;
+```
+
+👎 Examples of incorrect code
+
+```typescript
+let b = {
+    foo: 1
+};
+let c = { foo: 1,
+    bar: 2 };
+let d = {foo: 1
+    , bar: 2};
+let e = { foo: function() {
+    dosomething();
+} };
+
+let {i,
+    j} = obj;
+```
+
+## No Negative Condition
+
+----------
+
+Negated conditions are more difficult to understand. Code can be made more readable by inverting the condition instead.
+
+<https://eslint.org/docs/latest/rules/no-negated-condition>
+
+👍 Examples of correct code
+
+```typescript
+if (!a) {
+    doSomething();
+}
+
+if (!a) {
+    doSomething();
+} else if (b) {
+    doSomething();
+}
+
+if (a != b) {
+    doSomething();
+}
+
+a ? b : c
+```
+
+👎 Examples of incorrect code
+
+```typescript
+if (!a) {
+    doSomething();
+} else {
+    doSomethingElse();
+}
+
+if (a != b) {
+    doSomething();
+} else {
+    doSomethingElse();
+}
+
+if (a !== b) {
+    doSomething();
+} else {
+    doSomethingElse();
+}
+
+!a ? c : b
+```
+
+## No Shadow
+
+----------
+
+Enforces placing object properties on separate lines.
+
+Then any code used within the same scope would not get the global undefined,
+but rather the local version with a very different meaning.
+
+<https://eslint.org/docs/rules/no-shadow>
+<https://eslint.org/docs/rules/no-shadow-restricted-names>
 
 👍 Examples of correct code
 
@@ -7747,6 +7748,29 @@ a && (a = b)
 a ?? (a = b)
 ```
 
+## No With
+
+----------
+
+The with statement is potentially problematic because it adds members of an object to the current scope,
+making it impossible to tell what a variable inside the block actually refers to.
+
+<https://eslint.org/docs/rules/no-with>
+
+👍 Examples of correct code
+
+```typescript
+const r = ({x, y}) => Math.sqrt(x * x + y * y);
+```
+
+👎 Examples of incorrect code
+
+```typescript
+with (point) {
+    r = Math.sqrt(x * x + y * y); // is r a member of point?
+}
+```
+
 ## Promise Rules
 
 ### No New Statics
@@ -8449,7 +8473,7 @@ import fs from 'fs/promises';
 const fs = require('fs/promises');
 ```
 
-### Prefer export…from
+### Prefer export from
 
 ----------
 
@@ -8501,6 +8525,28 @@ export {
 };
 ```
 
+### No Empty Import
+
+----------
+
+Prevent import empty
+
+<https://github.com/ODGodinho/ODG-Linter-Js>
+
+👍 Examples of correct code
+
+```typescript
+import { a } from './foo.js';
+import a from './foo.js';
+```
+
+👎 Examples of incorrect code
+
+```typescript
+import { } from './foo.js';
+import t, { } from './foo.js';
+```
+
 ## Documentation
 
 ### Spaced Comment
@@ -11601,7 +11647,7 @@ if (foo) {
 Improved version of the no-nested-ternary ESLint rule,
 which allows cases where the nested ternary is only one level and wrapped in Parentheses.
 
-<https://eslint.org/docs/latest/rules/no-nested-ternary#rule-details>
+<https://eslint.org/docs/latest/rules/no-nested-ternary>
 <https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-nested-ternary.md>
 
 👍 Examples of correct code
@@ -13731,49 +13777,450 @@ foo(function() {
     baz(() => this);
 });
 
-var obj = {
-    aaa: function() {
-        return function foo() {
-            // There is in a method `aaa`, but `foo` is not a method.
-            this.a = 0;
-            baz(() => this);
-        };
-    }
-};
+var obj = {
+    aaa: function() {
+        return function foo() {
+            // There is in a method `aaa`, but `foo` is not a method.
+            this.a = 0;
+            baz(() => this);
+        };
+    }
+};
+
+foo.forEach(function() {
+    this.a = 0;
+    baz(() => this);
+});
+```
+
+### No This Before Super
+
+----------
+
+In the constructor of derived classes, if this/super are used before super() calls, it raises a reference error.
+
+<https://eslint.org/docs/latest/rules/no-this-before-super>
+
+👍 Examples of correct code
+
+```typescript
+class A {
+    constructor() {
+        this.a = 0; // OK, this class doesn't have an `extends` clause.
+    }
+}
+
+class A extends B {
+    constructor() {
+        super();
+        this.a = 0; // OK, this is after `super()`.
+    }
+}
+
+class A extends B {
+    foo() {
+        this.a = 0; // OK. this is not in a constructor.
+    }
+}
+```
+
+👎 Examples of incorrect code
+
+```typescript
+class A extends B {
+    constructor() {
+        this.a = 0;
+        super();
+    }
+}
+
+class A extends B {
+    constructor() {
+        this.foo();
+        super();
+    }
+}
+
+class A extends B {
+    constructor() {
+        super.foo();
+        super();
+    }
+}
+
+class A extends B {
+    constructor() {
+        super(this.foo());
+    }
+}
+```
+
+### No Obj Calls
+
+----------
+
+Disallow calling global object properties as functions
+
+<https://eslint.org/docs/latest/rules/no-obj-calls>
+
+👍 Examples of correct code
+
+```typescript
+function area(r) {
+    return Math.PI * r * r;
+}
+
+var object = JSON.parse("{}");
+
+var value = Reflect.get({ x: 1, y: 2 }, "x");
+
+var first = Atomics.load(foo, 0);
+
+var segmenterFr = new Intl.Segmenter("fr", { granularity: "word" });
+```
+
+👎 Examples of incorrect code
+
+```typescript
+var math = Math();
+
+var newMath = new Math();
+
+var json = JSON();
+
+var newJSON = new JSON();
+
+var reflect = Reflect();
+
+var newReflect = new Reflect();
+
+var atomics = Atomics();
+
+var newAtomics = new Atomics();
+
+var intl = Intl();
+
+var newIntl = new Intl();
+```
+
+### No Empty Pattern
+
+----------
+
+Disallow empty destructuring patterns
+
+<https://eslint.org/docs/latest/rules/no-empty-pattern>
+
+👍 Examples of correct code
+
+```typescript
+
+```
+
+👎 Examples of incorrect code
+
+```typescript
+var {} = foo;
+var [] = foo;
+var {a: {}} = foo;
+var {a: []} = foo;
+function foo({}) {}
+function foo([]) {}
+function foo({a: {}}) {}
+function foo({a: []}) {}
+```
+
+### No Useless Computed Key
+
+----------
+
+Disallow unnecessary computed property keys in objects and classes
+
+<https://eslint.org/docs/latest/rules/no-useless-computed-key>
+
+👍 Examples of correct code
+
+```typescript
+var c = { 'a': 0 };
+var c = { 0: 0 };
+var a = { x() {} };
+var c = { a: 0 };
+var c = { '0+1,234': 0 };
+```
+
+👎 Examples of incorrect code
+
+```typescript
+var a = { ['0']: 0 };
+var a = { ['0+1,234']: 0 };
+var a = { [0]: 0 };
+var a = { ['x']: 0 };
+var a = { ['x']() {} };
+```
+
+
+### Useless Call Code
+
+----------
+
+Disallow useless code
+
+<https://eslint.org/docs/rules/no-useless-call#no-useless-call>
+
+👍 Examples of correct code
+
+```typescript
+foo.call(obj, 1, 2, 3);
+foo.apply(obj, [1, 2, 3]);
+obj.foo.call(null, 1, 2, 3);
+obj.foo.apply(null, [1, 2, 3]);
+obj.foo.call(otherObj, 1, 2, 3);
+obj.foo.apply(otherObj, [1, 2, 3]);
+
+// The argument list is variadic.
+// Those are warned by the `prefer-spread` rule.
+foo.apply(undefined, args);
+foo.apply(null, args);
+obj.foo.apply(obj, args);
+
+a[++i].foo.call(a[i], 1, 2, 3);
+```
+
+👎 Examples of incorrect code
+
+```typescript
+foo.call(undefined, 1, 2, 3);
+foo.apply(undefined, [1, 2, 3]);
+foo.call(null, 1, 2, 3);
+foo.apply(null, [1, 2, 3]);
+
+// These are same as `obj.foo(1, 2, 3);`
+obj.foo.call(obj, 1, 2, 3);
+obj.foo.apply(obj, [1, 2, 3]);
+
+a[i++].foo.call(a[i++], 1, 2, 3);
+```
+
+### Useless Catch Code
+
+----------
+
+Disallow useless code
+
+<https://eslint.org/docs/rules/no-useless-catch#no-useless-catch>
+
+👍 Examples of correct code
+
+```typescript
+try {
+  doSomethingThatMightThrow();
+} catch (e) {
+  doSomethingBeforeRethrow();
+  throw e;
+}
+
+try {
+  doSomethingThatMightThrow();
+} catch (e) {
+  handleError(e);
+}
+
+try {
+  doSomethingThatMightThrow();
+} finally {
+  cleanUp();
+}
+```
+
+👎 Examples of incorrect code
+
+```typescript
+try {
+  doSomethingThatMightThrow();
+} catch (e) {
+  throw e;
+}
+
+try {
+  doSomethingThatMightThrow();
+} catch (e) {
+  throw e;
+} finally {
+  cleanUp();
+}
+```
+
+### Useless Expression Code
+
+----------
+
+Disallow useless code
+
+<https://eslint.org/docs/rules/no-unused-expressions>
+
+👍 Examples of correct code
+
+```typescript
+{} // In this context, this is a block statement, not an object literal
+
+{myLabel: someVar} // In this context, this is a block statement with a label and expression, not an object literal
+
+function namedFunctionDeclaration () {}
+
+(function aGenuineIIFE () {}());
+
+f()
+
+a = 0
+
+new C
+
+delete a.b
+
+void a
+
+a ? b() : c();
+a ? (b = c) : d();
+```
+
+👎 Examples of incorrect code
+
+```typescript
+0
+
+if(0) 0
+
+{0}
+
+f(0), {}
+
+a && b()
+
+a, b()
+
+c = a, b;
+
+a() && function namedFunctionInExpressionContext () {f();}
+
+(function anIncompleteIIFE () {});
+
+injectGlobal`body{ color: red; }`
+
+function foo() {
+    "bar" + 1;
+}
+
+class Foo {
+    static {
+        "use strict"; // class static blocks do not have directive prologues
+    }
+}
+```
+
+### Useless Return Code
+
+----------
+
+Disallow useless code
+
+<https://eslint.org/docs/rules/no-useless-return#no-useless-return>
+
+👍 Examples of correct code
+
+```typescript
+function foo() { return 5; }
+
+function foo() {
+  return doSomething();
+}
+
+function foo() {
+  if (condition) {
+    bar();
+    return;
+  } else {
+    baz();
+  }
+  qux();
+}
+
+function foo() {
+  switch (bar) {
+    case 1:
+      doSomething();
+      return;
+    default:
+      doSomethingElse();
+  }
+}
+
+function foo() {
+  for (const foo of bar) {
+    return;
+  }
+}
+```
+
+👎 Examples of incorrect code
+
+```typescript
+function foo() { return; }
+
+function foo() {
+  doSomething();
+  return;
+}
+
+function foo() {
+  if (condition) {
+    bar();
+    return;
+  } else {
+    baz();
+  }
+}
 
-foo.forEach(function() {
-    this.a = 0;
-    baz(() => this);
-});
+function foo() {
+  switch (bar) {
+    case 1:
+      doSomething();
+    default:
+      doSomethingElse();
+      return;
+  }
+}
 ```
 
-### No This Before Super
+### Useless Construct Code
 
 ----------
 
-In the constructor of derived classes, if this/super are used before super() calls, it raises a reference error.
+Disallow useless code
 
-<https://eslint.org/docs/latest/rules/no-this-before-super>
+<https://eslint.org/docs/rules/no-useless-constructor#options>
 
 👍 Examples of correct code
 
 ```typescript
+
+class A { }
+
 class A {
-    constructor() {
-        this.a = 0; // OK, this class doesn't have an `extends` clause.
+    constructor () {
+        doSomething();
     }
 }
 
-class A extends B {
+class B extends A {
     constructor() {
-        super();
-        this.a = 0; // OK, this is after `super()`.
+        super('foo');
     }
 }
 
-class A extends B {
-    foo() {
-        this.a = 0; // OK. this is not in a constructor.
+class B extends A {
+    constructor() {
+        super();
+        doSomething();
     }
 }
 ```
@@ -13781,107 +14228,123 @@ class A extends B {
 👎 Examples of incorrect code
 
 ```typescript
-class A extends B {
-    constructor() {
-        this.a = 0;
-        super();
-    }
-}
-
-class A extends B {
-    constructor() {
-        this.foo();
-        super();
-    }
-}
-
-class A extends B {
-    constructor() {
-        super.foo();
-        super();
+class A {
+    constructor () {
     }
 }
 
-class A extends B {
-    constructor() {
-        super(this.foo());
+class B extends A {
+    constructor (...args) {
+      super(...args);
     }
 }
 ```
 
-### No Obj Calls
+### No Use Before Define
 
 ----------
 
-Disallow calling global object properties as functions
+In JavaScript, prior to ES6, variable and function declarations are hoisted to the top of a scope,
+so it’s possible to use identifiers before their formal declarations in code.
 
-<https://eslint.org/docs/latest/rules/no-obj-calls>
+<https://eslint.org/docs/latest/rules/no-use-before-define>
 
 👍 Examples of correct code
 
 ```typescript
-function area(r) {
-    return Math.PI * r * r;
-}
-
-var object = JSON.parse("{}");
-
-var value = Reflect.get({ x: 1, y: 2 }, "x");
-
-var first = Atomics.load(foo, 0);
-
-var segmenterFr = new Intl.Segmenter("fr", { granularity: "word" });
-```
-
-👎 Examples of incorrect code
-
-```typescript
-var math = Math();
-
-var newMath = new Math();
+var a;
+a = 10;
+alert(a);
 
-var json = JSON();
+function f() {}
+f(1);
 
-var newJSON = new JSON();
+var b = 1;
+function g() {
+    return b;
+}
 
-var reflect = Reflect();
+{
+    let c;
+    c++;
+}
 
-var newReflect = new Reflect();
+{
+    class C {
+        static x = C;
+    }
+}
 
-var atomics = Atomics();
+{
+    const C = class C {
+        static x = C;
+    }
+}
 
-var newAtomics = new Atomics();
+{
+    const C = class {
+        x = C;
+    }
+}
 
-var intl = Intl();
+{
+    const C = class C {
+        static {
+            C.x = "foo";
+        }
+    }
+}
 
-var newIntl = new Intl();
+const foo = 1;
+export { foo };
 ```
 
-### No Empty Pattern
+👎 Examples of incorrect code
 
-----------
+```typescript
+alert(a);
+var a = 10;
 
-Disallow empty destructuring patterns
+f();
+function f() {}
 
-<https://eslint.org/docs/latest/rules/no-empty-pattern>
+function g() {
+    return b;
+}
+var b = 1;
 
-👍 Examples of correct code
+{
+    alert(c);
+    let c = 1;
+}
 
-```typescript
+{
+    class C extends C {}
+}
 
-```
+{
+    class C {
+        static x = "foo";
+        [C.x]() {}
+    }
+}
 
-👎 Examples of incorrect code
+{
+    const C = class {
+        static x = C;
+    }
+}
 
-```typescript
-var {} = foo;
-var [] = foo;
-var {a: {}} = foo;
-var {a: []} = foo;
-function foo({}) {}
-function foo([]) {}
-function foo({a: {}}) {}
-function foo({a: []}) {}
+{
+    const C = class {
+        static {
+            C.x = "foo";
+        }
+    }
+}
+
+export { foo };
+const foo = 1;
 ```
 
 ## Possible Errors
@@ -14576,6 +15039,139 @@ switch(foo) {
 }
 ```
 
+### No Octal
+
+----------
+
+Octal literals are numerals that begin with a leading zero, such as:
+
+<https://eslint.org/docs/latest/rules/no-octal>
+
+👍 Examples of correct code
+
+```typescript
+var test = 71 + 5; // 76
+```
+
+👎 Examples of incorrect code
+
+```typescript
+var num = 071; // 57
+var result = 5 + 07;
+
+var test = 071 + 5; // 62
+```
+
+### Octal Scape
+
+----------
+
+As of the ECMAScript 5 specification, octal escape sequences in string literals
+are deprecated and should not be used. Unicode escape sequences should be used instead.
+
+<https://eslint.org/docs/latest/rules/no-octal-escape>
+
+👍 Examples of correct code
+
+```typescript
+var foo = "Copyright \u00A9";   // unicode
+
+var foo = "Copyright \xA9";     // hexadecimal
+```
+
+👎 Examples of incorrect code
+
+```typescript
+var foo = "Copyright \251";
+```
+
+### No Global Assign
+
+----------
+
+JavaScript environments contain a number of built-in global variables, such as window in browsers
+and process in Node.js. In almost all cases, you don’t want to assign a value to these global
+variables as doing so could result in losing access to important functionality.
+For example, you probably don’t want to do this in browser code:
+
+<https://eslint.org/docs/latest/rules/no-global-assign>
+
+👍 Examples of correct code
+
+```typescript
+a = 1
+const b = 1
+b = 2
+```
+
+👎 Examples of incorrect code
+
+```typescript
+Object = null
+undefined = 1
+window = {}
+length = 1
+top = 1
+```
+
+### No Case Declarations
+
+----------
+
+This rule disallows lexical declarations (let, const, function and class) in case/default clauses.
+The reason is that the lexical declaration is visible in the entire switch block but it only gets
+initialized when it is assigned, which will only happen if the case where it is defined is reached.
+
+<https://eslint.org/docs/latest/rules/no-case-declarations>
+
+👍 Examples of correct code
+
+```typescript
+// Declarations outside switch-statements are valid
+const a = 0;
+
+switch (foo) {
+    // The following case clauses are wrapped into blocks using brackets
+    case 1: {
+        let x = 1;
+        break;
+    }
+    case 2: {
+        const y = 2;
+        break;
+    }
+    case 3: {
+        function f() {}
+        break;
+    }
+    case 4:
+        // Declarations using var without brackets are valid due to function-scope hoisting
+        var z = 4;
+        break;
+    default: {
+        class C {}
+    }
+}
+```
+
+👎 Examples of incorrect code
+
+```typescript
+switch (foo) {
+    case 1:
+        let x = 1;
+        break;
+    case 2:
+        const y = 2;
+        break;
+    case 3:
+        function f() {}
+        break;
+    default:
+        class C {}
+}
+```
+
 ## Yaml Json
 
 add suport yaml and json files