---
source: crates/biome_js_analyze/tests/spec_tests.rs
expression: invalid.js
---
# Input
```jsx
let x = "\8"
let x = "\9"
let x = "\"\8\""
let x = "f\9"
let x = "fo\9"
let x = "foo\9"
let x = "foo\8bar"
let x = "👍\8"
let x = "\\\8"
let x = "\\\\\9"
let x = "foo\\\8"
let x = "\\ \8"
let x = "\\1\9"
let x = "foo\\1\9"
let x = "\\n\\n\8\\n"
let x = "\\n.\\n\8\\n"
let x = "\\n.\\nn\8\\n"
let x = "\\👍\8"
let x = "\\\8\9"
let x = "\8\\\9"
let x = "\8 \\\9"
let x = "\8\8"
let x = "\9\8"
let x = "foo\8bar\9baz"
let x = "\8\\1\9"
let x = "\9\\n9\\\9\9"
let x = "\8\\\\\9"
let x = "var foo = '\8'; bar('\9')"
let x = "var foo = '8'\n  bar = '\9'"
let x = "\\\n\8"
let x = "\\\r\n\9"
let x = "\\\\\n\8"
let x = "foo\\\nbar\9baz"
let x = "\\0\8"
let x = "foo\\0\9bar"
let x = "\\1\\0\8"
let x = "\\0\8\9"
let x = "\8\\0\9"
let x = "0\8"
let x = "\\0\8"
let x = "\0 \8"
let x = "\01\8"
let x = "\0\1\8"
let x = "\0\\n\8"

```

# Diagnostics
```
invalid.js:1:10 lint/correctness/noNonoctalDecimalEscape  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ! Don't use `\8` and `\9` escape sequences in string literals.
  
  > 1 │ let x = "\8"
      │          ^^
    2 │ let x = "\9"
    3 │ let x = "\"\8\""
  
  i The nonoctal decimal escape is a deprecated syntax that is left for compatibility and should not be used.
  
  i Unsafe fix: Replace \8 with 8. This maintains the current functionality.
  
    1 │ let·x·=·"\8"
      │          -  

```

```
invalid.js:2:10 lint/correctness/noNonoctalDecimalEscape  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ! Don't use `\8` and `\9` escape sequences in string literals.
  
    1 │ let x = "\8"
  > 2 │ let x = "\9"
      │          ^^
    3 │ let x = "\"\8\""
    4 │ let x = "f\9"
  
  i The nonoctal decimal escape is a deprecated syntax that is left for compatibility and should not be used.
  
  i Unsafe fix: Replace \9 with 9. This maintains the current functionality.
  
    2 │ let·x·=·"\9"
      │          -  

```

```
invalid.js:3:12 lint/correctness/noNonoctalDecimalEscape  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ! Don't use `\8` and `\9` escape sequences in string literals.
  
    1 │ let x = "\8"
    2 │ let x = "\9"
  > 3 │ let x = "\"\8\""
      │            ^^
    4 │ let x = "f\9"
    5 │ let x = "fo\9"
  
  i The nonoctal decimal escape is a deprecated syntax that is left for compatibility and should not be used.
  
  i Unsafe fix: Replace \8 with 8. This maintains the current functionality.
  
    3 │ let·x·=·"\"\8\""
      │            -    

```

```
invalid.js:4:11 lint/correctness/noNonoctalDecimalEscape  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ! Don't use `\8` and `\9` escape sequences in string literals.
  
    2 │ let x = "\9"
    3 │ let x = "\"\8\""
  > 4 │ let x = "f\9"
      │           ^^
    5 │ let x = "fo\9"
    6 │ let x = "foo\9"
  
  i The nonoctal decimal escape is a deprecated syntax that is left for compatibility and should not be used.
  
  i Unsafe fix: Replace \9 with 9. This maintains the current functionality.
  
     2  2 │   let x = "\9"
     3  3 │   let x = "\"\8\""
     4    │ - let·x·=·"f\9"
        4 │ + let·x·=·"f9"
     5  5 │   let x = "fo\9"
     6  6 │   let x = "foo\9"
  

```

```
invalid.js:5:12 lint/correctness/noNonoctalDecimalEscape  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ! Don't use `\8` and `\9` escape sequences in string literals.
  
    3 │ let x = "\"\8\""
    4 │ let x = "f\9"
  > 5 │ let x = "fo\9"
      │            ^^
    6 │ let x = "foo\9"
    7 │ let x = "foo\8bar"
  
  i The nonoctal decimal escape is a deprecated syntax that is left for compatibility and should not be used.
  
  i Unsafe fix: Replace \9 with 9. This maintains the current functionality.
  
     3  3 │   let x = "\"\8\""
     4  4 │   let x = "f\9"
     5    │ - let·x·=·"fo\9"
        5 │ + let·x·=·"fo9"
     6  6 │   let x = "foo\9"
     7  7 │   let x = "foo\8bar"
  

```

```
invalid.js:6:13 lint/correctness/noNonoctalDecimalEscape  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ! Don't use `\8` and `\9` escape sequences in string literals.
  
    4 │ let x = "f\9"
    5 │ let x = "fo\9"
  > 6 │ let x = "foo\9"
      │             ^^
    7 │ let x = "foo\8bar"
    8 │ let x = "👍\8"
  
  i The nonoctal decimal escape is a deprecated syntax that is left for compatibility and should not be used.
  
  i Unsafe fix: Replace \9 with 9. This maintains the current functionality.
  
     4  4 │   let x = "f\9"
     5  5 │   let x = "fo\9"
     6    │ - let·x·=·"foo\9"
        6 │ + let·x·=·"foo9"
     7  7 │   let x = "foo\8bar"
     8  8 │   let x = "👍\8"
  

```

```
invalid.js:7:13 lint/correctness/noNonoctalDecimalEscape  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ! Don't use `\8` and `\9` escape sequences in string literals.
  
    5 │ let x = "fo\9"
    6 │ let x = "foo\9"
  > 7 │ let x = "foo\8bar"
      │             ^^
    8 │ let x = "👍\8"
    9 │ let x = "\\\8"
  
  i The nonoctal decimal escape is a deprecated syntax that is left for compatibility and should not be used.
  
  i Unsafe fix: Replace \8 with 8. This maintains the current functionality.
  
     5  5 │   let x = "fo\9"
     6  6 │   let x = "foo\9"
     7    │ - let·x·=·"foo\8bar"
        7 │ + let·x·=·"foo8bar"
     8  8 │   let x = "👍\8"
     9  9 │   let x = "\\\8"
  

```

```
invalid.js:8:11 lint/correctness/noNonoctalDecimalEscape  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ! Don't use `\8` and `\9` escape sequences in string literals.
  
     6 │ let x = "foo\9"
     7 │ let x = "foo\8bar"
   > 8 │ let x = "👍\8"
       │            ^^
     9 │ let x = "\\\8"
    10 │ let x = "\\\\\9"
  
  i The nonoctal decimal escape is a deprecated syntax that is left for compatibility and should not be used.
  
  i Unsafe fix: Replace \8 with 8. This maintains the current functionality.
  
    8 │ let·x·=·"👍\8"
      │            -  

```

```
invalid.js:9:12 lint/correctness/noNonoctalDecimalEscape  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ! Don't use `\8` and `\9` escape sequences in string literals.
  
     7 │ let x = "foo\8bar"
     8 │ let x = "👍\8"
   > 9 │ let x = "\\\8"
       │            ^^
    10 │ let x = "\\\\\9"
    11 │ let x = "foo\\\8"
  
  i The nonoctal decimal escape is a deprecated syntax that is left for compatibility and should not be used.
  
  i Unsafe fix: Replace \8 with 8. This maintains the current functionality.
  
    9 │ let·x·=·"\\\8"
      │            -  

```

```
invalid.js:10:14 lint/correctness/noNonoctalDecimalEscape  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ! Don't use `\8` and `\9` escape sequences in string literals.
  
     8 │ let x = "👍\8"
     9 │ let x = "\\\8"
  > 10 │ let x = "\\\\\9"
       │              ^^
    11 │ let x = "foo\\\8"
    12 │ let x = "\\ \8"
  
  i The nonoctal decimal escape is a deprecated syntax that is left for compatibility and should not be used.
  
  i Unsafe fix: Replace \9 with 9. This maintains the current functionality.
  
    10 │ let·x·=·"\\\\\9"
       │              -  

```

```
invalid.js:11:15 lint/correctness/noNonoctalDecimalEscape  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ! Don't use `\8` and `\9` escape sequences in string literals.
  
     9 │ let x = "\\\8"
    10 │ let x = "\\\\\9"
  > 11 │ let x = "foo\\\8"
       │               ^^
    12 │ let x = "\\ \8"
    13 │ let x = "\\1\9"
  
  i The nonoctal decimal escape is a deprecated syntax that is left for compatibility and should not be used.
  
  i Unsafe fix: Replace \8 with 8. This maintains the current functionality.
  
    11 │ let·x·=·"foo\\\8"
       │               -  

```

```
invalid.js:12:13 lint/correctness/noNonoctalDecimalEscape  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ! Don't use `\8` and `\9` escape sequences in string literals.
  
    10 │ let x = "\\\\\9"
    11 │ let x = "foo\\\8"
  > 12 │ let x = "\\ \8"
       │             ^^
    13 │ let x = "\\1\9"
    14 │ let x = "foo\\1\9"
  
  i The nonoctal decimal escape is a deprecated syntax that is left for compatibility and should not be used.
  
  i Unsafe fix: Replace \8 with 8. This maintains the current functionality.
  
    12 │ let·x·=·"\\·\8"
       │             -  

```

```
invalid.js:13:13 lint/correctness/noNonoctalDecimalEscape  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ! Don't use `\8` and `\9` escape sequences in string literals.
  
    11 │ let x = "foo\\\8"
    12 │ let x = "\\ \8"
  > 13 │ let x = "\\1\9"
       │             ^^
    14 │ let x = "foo\\1\9"
    15 │ let x = "\\n\\n\8\\n"
  
  i The nonoctal decimal escape is a deprecated syntax that is left for compatibility and should not be used.
  
  i Unsafe fix: Replace \9 with 9. This maintains the current functionality.
  
    11 11 │   let x = "foo\\\8"
    12 12 │   let x = "\\ \8"
    13    │ - let·x·=·"\\1\9"
       13 │ + let·x·=·"\\19"
    14 14 │   let x = "foo\\1\9"
    15 15 │   let x = "\\n\\n\8\\n"
  

```

```
invalid.js:14:16 lint/correctness/noNonoctalDecimalEscape  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ! Don't use `\8` and `\9` escape sequences in string literals.
  
    12 │ let x = "\\ \8"
    13 │ let x = "\\1\9"
  > 14 │ let x = "foo\\1\9"
       │                ^^
    15 │ let x = "\\n\\n\8\\n"
    16 │ let x = "\\n.\\n\8\\n"
  
  i The nonoctal decimal escape is a deprecated syntax that is left for compatibility and should not be used.
  
  i Unsafe fix: Replace \9 with 9. This maintains the current functionality.
  
    12 12 │   let x = "\\ \8"
    13 13 │   let x = "\\1\9"
    14    │ - let·x·=·"foo\\1\9"
       14 │ + let·x·=·"foo\\19"
    15 15 │   let x = "\\n\\n\8\\n"
    16 16 │   let x = "\\n.\\n\8\\n"
  

```

```
invalid.js:15:16 lint/correctness/noNonoctalDecimalEscape  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ! Don't use `\8` and `\9` escape sequences in string literals.
  
    13 │ let x = "\\1\9"
    14 │ let x = "foo\\1\9"
  > 15 │ let x = "\\n\\n\8\\n"
       │                ^^
    16 │ let x = "\\n.\\n\8\\n"
    17 │ let x = "\\n.\\nn\8\\n"
  
  i The nonoctal decimal escape is a deprecated syntax that is left for compatibility and should not be used.
  
  i Unsafe fix: Replace \8 with 8. This maintains the current functionality.
  
    13 13 │   let x = "\\1\9"
    14 14 │   let x = "foo\\1\9"
    15    │ - let·x·=·"\\n\\n\8\\n"
       15 │ + let·x·=·"\\n\\n8\\n"
    16 16 │   let x = "\\n.\\n\8\\n"
    17 17 │   let x = "\\n.\\nn\8\\n"
  

```

```
invalid.js:16:17 lint/correctness/noNonoctalDecimalEscape  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ! Don't use `\8` and `\9` escape sequences in string literals.
  
    14 │ let x = "foo\\1\9"
    15 │ let x = "\\n\\n\8\\n"
  > 16 │ let x = "\\n.\\n\8\\n"
       │                 ^^
    17 │ let x = "\\n.\\nn\8\\n"
    18 │ let x = "\\👍\8"
  
  i The nonoctal decimal escape is a deprecated syntax that is left for compatibility and should not be used.
  
  i Unsafe fix: Replace \8 with 8. This maintains the current functionality.
  
    14 14 │   let x = "foo\\1\9"
    15 15 │   let x = "\\n\\n\8\\n"
    16    │ - let·x·=·"\\n.\\n\8\\n"
       16 │ + let·x·=·"\\n.\\n8\\n"
    17 17 │   let x = "\\n.\\nn\8\\n"
    18 18 │   let x = "\\👍\8"
  

```

```
invalid.js:17:18 lint/correctness/noNonoctalDecimalEscape  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ! Don't use `\8` and `\9` escape sequences in string literals.
  
    15 │ let x = "\\n\\n\8\\n"
    16 │ let x = "\\n.\\n\8\\n"
  > 17 │ let x = "\\n.\\nn\8\\n"
       │                  ^^
    18 │ let x = "\\👍\8"
    19 │ let x = "\\\8\9"
  
  i The nonoctal decimal escape is a deprecated syntax that is left for compatibility and should not be used.
  
  i Unsafe fix: Replace \8 with 8. This maintains the current functionality.
  
    15 15 │   let x = "\\n\\n\8\\n"
    16 16 │   let x = "\\n.\\n\8\\n"
    17    │ - let·x·=·"\\n.\\nn\8\\n"
       17 │ + let·x·=·"\\n.\\nn8\\n"
    18 18 │   let x = "\\👍\8"
    19 19 │   let x = "\\\8\9"
  

```

```
invalid.js:18:13 lint/correctness/noNonoctalDecimalEscape  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ! Don't use `\8` and `\9` escape sequences in string literals.
  
    16 │ let x = "\\n.\\n\8\\n"
    17 │ let x = "\\n.\\nn\8\\n"
  > 18 │ let x = "\\👍\8"
       │              ^^
    19 │ let x = "\\\8\9"
    20 │ let x = "\8\\\9"
  
  i The nonoctal decimal escape is a deprecated syntax that is left for compatibility and should not be used.
  
  i Unsafe fix: Replace \8 with 8. This maintains the current functionality.
  
    18 │ let·x·=·"\\👍\8"
       │              -  

```

```
invalid.js:19:12 lint/correctness/noNonoctalDecimalEscape  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ! Don't use `\8` and `\9` escape sequences in string literals.
  
    17 │ let x = "\\n.\\nn\8\\n"
    18 │ let x = "\\👍\8"
  > 19 │ let x = "\\\8\9"
       │            ^^
    20 │ let x = "\8\\\9"
    21 │ let x = "\8 \\\9"
  
  i The nonoctal decimal escape is a deprecated syntax that is left for compatibility and should not be used.
  
  i Unsafe fix: Replace \8 with 8. This maintains the current functionality.
  
    19 │ let·x·=·"\\\8\9"
       │            -    

```

```
invalid.js:20:10 lint/correctness/noNonoctalDecimalEscape  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ! Don't use `\8` and `\9` escape sequences in string literals.
  
    18 │ let x = "\\👍\8"
    19 │ let x = "\\\8\9"
  > 20 │ let x = "\8\\\9"
       │          ^^
    21 │ let x = "\8 \\\9"
    22 │ let x = "\8\8"
  
  i The nonoctal decimal escape is a deprecated syntax that is left for compatibility and should not be used.
  
  i Unsafe fix: Replace \8 with 8. This maintains the current functionality.
  
    20 │ let·x·=·"\8\\\9"
       │          -      

```

```
invalid.js:21:10 lint/correctness/noNonoctalDecimalEscape  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ! Don't use `\8` and `\9` escape sequences in string literals.
  
    19 │ let x = "\\\8\9"
    20 │ let x = "\8\\\9"
  > 21 │ let x = "\8 \\\9"
       │          ^^
    22 │ let x = "\8\8"
    23 │ let x = "\9\8"
  
  i The nonoctal decimal escape is a deprecated syntax that is left for compatibility and should not be used.
  
  i Unsafe fix: Replace \8 with 8. This maintains the current functionality.
  
    21 │ let·x·=·"\8·\\\9"
       │          -       

```

```
invalid.js:21:15 lint/correctness/noNonoctalDecimalEscape  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ! Don't use `\8` and `\9` escape sequences in string literals.
  
    19 │ let x = "\\\8\9"
    20 │ let x = "\8\\\9"
  > 21 │ let x = "\8 \\\9"
       │               ^^
    22 │ let x = "\8\8"
    23 │ let x = "\9\8"
  
  i The nonoctal decimal escape is a deprecated syntax that is left for compatibility and should not be used.
  
  i Unsafe fix: Replace \9 with 9. This maintains the current functionality.
  
    21 │ let·x·=·"\8·\\\9"
       │               -  

```

```
invalid.js:22:10 lint/correctness/noNonoctalDecimalEscape  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ! Don't use `\8` and `\9` escape sequences in string literals.
  
    20 │ let x = "\8\\\9"
    21 │ let x = "\8 \\\9"
  > 22 │ let x = "\8\8"
       │          ^^
    23 │ let x = "\9\8"
    24 │ let x = "foo\8bar\9baz"
  
  i The nonoctal decimal escape is a deprecated syntax that is left for compatibility and should not be used.
  
  i Unsafe fix: Replace \8 with 8. This maintains the current functionality.
  
    22 │ let·x·=·"\8\8"
       │          -    

```

```
invalid.js:23:10 lint/correctness/noNonoctalDecimalEscape  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ! Don't use `\8` and `\9` escape sequences in string literals.
  
    21 │ let x = "\8 \\\9"
    22 │ let x = "\8\8"
  > 23 │ let x = "\9\8"
       │          ^^
    24 │ let x = "foo\8bar\9baz"
    25 │ let x = "\8\\1\9"
  
  i The nonoctal decimal escape is a deprecated syntax that is left for compatibility and should not be used.
  
  i Unsafe fix: Replace \9 with 9. This maintains the current functionality.
  
    23 │ let·x·=·"\9\8"
       │          -    

```

```
invalid.js:24:13 lint/correctness/noNonoctalDecimalEscape  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ! Don't use `\8` and `\9` escape sequences in string literals.
  
    22 │ let x = "\8\8"
    23 │ let x = "\9\8"
  > 24 │ let x = "foo\8bar\9baz"
       │             ^^
    25 │ let x = "\8\\1\9"
    26 │ let x = "\9\\n9\\\9\9"
  
  i The nonoctal decimal escape is a deprecated syntax that is left for compatibility and should not be used.
  
  i Unsafe fix: Replace \8 with 8. This maintains the current functionality.
  
    22 22 │   let x = "\8\8"
    23 23 │   let x = "\9\8"
    24    │ - let·x·=·"foo\8bar\9baz"
       24 │ + let·x·=·"foo8bar\9baz"
    25 25 │   let x = "\8\\1\9"
    26 26 │   let x = "\9\\n9\\\9\9"
  

```

```
invalid.js:24:18 lint/correctness/noNonoctalDecimalEscape  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ! Don't use `\8` and `\9` escape sequences in string literals.
  
    22 │ let x = "\8\8"
    23 │ let x = "\9\8"
  > 24 │ let x = "foo\8bar\9baz"
       │                  ^^
    25 │ let x = "\8\\1\9"
    26 │ let x = "\9\\n9\\\9\9"
  
  i The nonoctal decimal escape is a deprecated syntax that is left for compatibility and should not be used.
  
  i Unsafe fix: Replace \9 with 9. This maintains the current functionality.
  
    22 22 │   let x = "\8\8"
    23 23 │   let x = "\9\8"
    24    │ - let·x·=·"foo\8bar\9baz"
       24 │ + let·x·=·"foo\8bar9baz"
    25 25 │   let x = "\8\\1\9"
    26 26 │   let x = "\9\\n9\\\9\9"
  

```

```
invalid.js:25:10 lint/correctness/noNonoctalDecimalEscape  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ! Don't use `\8` and `\9` escape sequences in string literals.
  
    23 │ let x = "\9\8"
    24 │ let x = "foo\8bar\9baz"
  > 25 │ let x = "\8\\1\9"
       │          ^^
    26 │ let x = "\9\\n9\\\9\9"
    27 │ let x = "\8\\\\\9"
  
  i The nonoctal decimal escape is a deprecated syntax that is left for compatibility and should not be used.
  
  i Unsafe fix: Replace \8 with 8. This maintains the current functionality.
  
    25 │ let·x·=·"\8\\1\9"
       │          -       

```

```
invalid.js:25:15 lint/correctness/noNonoctalDecimalEscape  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ! Don't use `\8` and `\9` escape sequences in string literals.
  
    23 │ let x = "\9\8"
    24 │ let x = "foo\8bar\9baz"
  > 25 │ let x = "\8\\1\9"
       │               ^^
    26 │ let x = "\9\\n9\\\9\9"
    27 │ let x = "\8\\\\\9"
  
  i The nonoctal decimal escape is a deprecated syntax that is left for compatibility and should not be used.
  
  i Unsafe fix: Replace \9 with 9. This maintains the current functionality.
  
    23 23 │   let x = "\9\8"
    24 24 │   let x = "foo\8bar\9baz"
    25    │ - let·x·=·"\8\\1\9"
       25 │ + let·x·=·"\8\\19"
    26 26 │   let x = "\9\\n9\\\9\9"
    27 27 │   let x = "\8\\\\\9"
  

```

```
invalid.js:26:10 lint/correctness/noNonoctalDecimalEscape  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ! Don't use `\8` and `\9` escape sequences in string literals.
  
    24 │ let x = "foo\8bar\9baz"
    25 │ let x = "\8\\1\9"
  > 26 │ let x = "\9\\n9\\\9\9"
       │          ^^
    27 │ let x = "\8\\\\\9"
    28 │ let x = "var foo = '\8'; bar('\9')"
  
  i The nonoctal decimal escape is a deprecated syntax that is left for compatibility and should not be used.
  
  i Unsafe fix: Replace \9 with 9. This maintains the current functionality.
  
    26 │ let·x·=·"\9\\n9\\\9\9"
       │          -            

```

```
invalid.js:26:18 lint/correctness/noNonoctalDecimalEscape  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ! Don't use `\8` and `\9` escape sequences in string literals.
  
    24 │ let x = "foo\8bar\9baz"
    25 │ let x = "\8\\1\9"
  > 26 │ let x = "\9\\n9\\\9\9"
       │                  ^^
    27 │ let x = "\8\\\\\9"
    28 │ let x = "var foo = '\8'; bar('\9')"
  
  i The nonoctal decimal escape is a deprecated syntax that is left for compatibility and should not be used.
  
  i Unsafe fix: Replace \9 with 9. This maintains the current functionality.
  
    26 │ let·x·=·"\9\\n9\\\9\9"
       │                  -    

```

```
invalid.js:27:10 lint/correctness/noNonoctalDecimalEscape  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ! Don't use `\8` and `\9` escape sequences in string literals.
  
    25 │ let x = "\8\\1\9"
    26 │ let x = "\9\\n9\\\9\9"
  > 27 │ let x = "\8\\\\\9"
       │          ^^
    28 │ let x = "var foo = '\8'; bar('\9')"
    29 │ let x = "var foo = '8'\n  bar = '\9'"
  
  i The nonoctal decimal escape is a deprecated syntax that is left for compatibility and should not be used.
  
  i Unsafe fix: Replace \8 with 8. This maintains the current functionality.
  
    27 │ let·x·=·"\8\\\\\9"
       │          -        

```

```
invalid.js:28:21 lint/correctness/noNonoctalDecimalEscape  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ! Don't use `\8` and `\9` escape sequences in string literals.
  
    26 │ let x = "\9\\n9\\\9\9"
    27 │ let x = "\8\\\\\9"
  > 28 │ let x = "var foo = '\8'; bar('\9')"
       │                     ^^
    29 │ let x = "var foo = '8'\n  bar = '\9'"
    30 │ let x = "\\\n\8"
  
  i The nonoctal decimal escape is a deprecated syntax that is left for compatibility and should not be used.
  
  i Unsafe fix: Replace \8 with 8. This maintains the current functionality.
  
    28 │ let·x·=·"var·foo·=·'\8';·bar('\9')"
       │                     -              

```

```
invalid.js:28:31 lint/correctness/noNonoctalDecimalEscape  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ! Don't use `\8` and `\9` escape sequences in string literals.
  
    26 │ let x = "\9\\n9\\\9\9"
    27 │ let x = "\8\\\\\9"
  > 28 │ let x = "var foo = '\8'; bar('\9')"
       │                               ^^
    29 │ let x = "var foo = '8'\n  bar = '\9'"
    30 │ let x = "\\\n\8"
  
  i The nonoctal decimal escape is a deprecated syntax that is left for compatibility and should not be used.
  
  i Unsafe fix: Replace \9 with 9. This maintains the current functionality.
  
    28 │ let·x·=·"var·foo·=·'\8';·bar('\9')"
       │                               -    

```

```
invalid.js:29:34 lint/correctness/noNonoctalDecimalEscape  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ! Don't use `\8` and `\9` escape sequences in string literals.
  
    27 │ let x = "\8\\\\\9"
    28 │ let x = "var foo = '\8'; bar('\9')"
  > 29 │ let x = "var foo = '8'\n  bar = '\9'"
       │                                  ^^
    30 │ let x = "\\\n\8"
    31 │ let x = "\\\r\n\9"
  
  i The nonoctal decimal escape is a deprecated syntax that is left for compatibility and should not be used.
  
  i Unsafe fix: Replace \9 with 9. This maintains the current functionality.
  
    29 │ let·x·=·"var·foo·=·'8'\n··bar·=·'\9'"
       │                                  -   

```

```
invalid.js:30:14 lint/correctness/noNonoctalDecimalEscape  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ! Don't use `\8` and `\9` escape sequences in string literals.
  
    28 │ let x = "var foo = '\8'; bar('\9')"
    29 │ let x = "var foo = '8'\n  bar = '\9'"
  > 30 │ let x = "\\\n\8"
       │              ^^
    31 │ let x = "\\\r\n\9"
    32 │ let x = "\\\\\n\8"
  
  i The nonoctal decimal escape is a deprecated syntax that is left for compatibility and should not be used.
  
  i Unsafe fix: Replace \8 with 8. This maintains the current functionality.
  
    28 28 │   let x = "var foo = '\8'; bar('\9')"
    29 29 │   let x = "var foo = '8'\n  bar = '\9'"
    30    │ - let·x·=·"\\\n\8"
       30 │ + let·x·=·"\\\n8"
    31 31 │   let x = "\\\r\n\9"
    32 32 │   let x = "\\\\\n\8"
  

```

```
invalid.js:31:16 lint/correctness/noNonoctalDecimalEscape  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ! Don't use `\8` and `\9` escape sequences in string literals.
  
    29 │ let x = "var foo = '8'\n  bar = '\9'"
    30 │ let x = "\\\n\8"
  > 31 │ let x = "\\\r\n\9"
       │                ^^
    32 │ let x = "\\\\\n\8"
    33 │ let x = "foo\\\nbar\9baz"
  
  i The nonoctal decimal escape is a deprecated syntax that is left for compatibility and should not be used.
  
  i Unsafe fix: Replace \9 with 9. This maintains the current functionality.
  
    29 29 │   let x = "var foo = '8'\n  bar = '\9'"
    30 30 │   let x = "\\\n\8"
    31    │ - let·x·=·"\\\r\n\9"
       31 │ + let·x·=·"\\\r\n9"
    32 32 │   let x = "\\\\\n\8"
    33 33 │   let x = "foo\\\nbar\9baz"
  

```

```
invalid.js:32:16 lint/correctness/noNonoctalDecimalEscape  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ! Don't use `\8` and `\9` escape sequences in string literals.
  
    30 │ let x = "\\\n\8"
    31 │ let x = "\\\r\n\9"
  > 32 │ let x = "\\\\\n\8"
       │                ^^
    33 │ let x = "foo\\\nbar\9baz"
    34 │ let x = "\\0\8"
  
  i The nonoctal decimal escape is a deprecated syntax that is left for compatibility and should not be used.
  
  i Unsafe fix: Replace \8 with 8. This maintains the current functionality.
  
    30 30 │   let x = "\\\n\8"
    31 31 │   let x = "\\\r\n\9"
    32    │ - let·x·=·"\\\\\n\8"
       32 │ + let·x·=·"\\\\\n8"
    33 33 │   let x = "foo\\\nbar\9baz"
    34 34 │   let x = "\\0\8"
  

```

```
invalid.js:33:20 lint/correctness/noNonoctalDecimalEscape  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ! Don't use `\8` and `\9` escape sequences in string literals.
  
    31 │ let x = "\\\r\n\9"
    32 │ let x = "\\\\\n\8"
  > 33 │ let x = "foo\\\nbar\9baz"
       │                    ^^
    34 │ let x = "\\0\8"
    35 │ let x = "foo\\0\9bar"
  
  i The nonoctal decimal escape is a deprecated syntax that is left for compatibility and should not be used.
  
  i Unsafe fix: Replace \9 with 9. This maintains the current functionality.
  
    31 31 │   let x = "\\\r\n\9"
    32 32 │   let x = "\\\\\n\8"
    33    │ - let·x·=·"foo\\\nbar\9baz"
       33 │ + let·x·=·"foo\\\nbar9baz"
    34 34 │   let x = "\\0\8"
    35 35 │   let x = "foo\\0\9bar"
  

```

```
invalid.js:34:11 lint/correctness/noNonoctalDecimalEscape  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ! Don't use `\8` and `\9` escape sequences in string literals.
  
    32 │ let x = "\\\\\n\8"
    33 │ let x = "foo\\\nbar\9baz"
  > 34 │ let x = "\\0\8"
       │           ^^^^
    35 │ let x = "foo\\0\9bar"
    36 │ let x = "\\1\\0\8"
  
  i The nonoctal decimal escape is a deprecated syntax that is left for compatibility and should not be used.
  
  i Unsafe fix: Replace \0\8 with \u00008. This maintains the current functionality.
  
    32 32 │   let x = "\\\\\n\8"
    33 33 │   let x = "foo\\\nbar\9baz"
    34    │ - let·x·=·"\\0\8"
       34 │ + let·x·=·"\\u00008"
    35 35 │   let x = "foo\\0\9bar"
    36 36 │   let x = "\\1\\0\8"
  

```

```
invalid.js:34:13 lint/correctness/noNonoctalDecimalEscape  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ! Don't use `\8` and `\9` escape sequences in string literals.
  
    32 │ let x = "\\\\\n\8"
    33 │ let x = "foo\\\nbar\9baz"
  > 34 │ let x = "\\0\8"
       │             ^^
    35 │ let x = "foo\\0\9bar"
    36 │ let x = "\\1\\0\8"
  
  i The nonoctal decimal escape is a deprecated syntax that is left for compatibility and should not be used.
  
  i Unsafe fix: Replace \8 with \u0038. This maintains the current functionality.
  
    32 32 │   let x = "\\\\\n\8"
    33 33 │   let x = "foo\\\nbar\9baz"
    34    │ - let·x·=·"\\0\8"
       34 │ + let·x·=·"\\0\u0038"
    35 35 │   let x = "foo\\0\9bar"
    36 36 │   let x = "\\1\\0\8"
  

```

```
invalid.js:35:14 lint/correctness/noNonoctalDecimalEscape  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ! Don't use `\8` and `\9` escape sequences in string literals.
  
    33 │ let x = "foo\\\nbar\9baz"
    34 │ let x = "\\0\8"
  > 35 │ let x = "foo\\0\9bar"
       │              ^^^^
    36 │ let x = "\\1\\0\8"
    37 │ let x = "\\0\8\9"
  
  i The nonoctal decimal escape is a deprecated syntax that is left for compatibility and should not be used.
  
  i Unsafe fix: Replace \0\9 with \u00009. This maintains the current functionality.
  
    33 33 │   let x = "foo\\\nbar\9baz"
    34 34 │   let x = "\\0\8"
    35    │ - let·x·=·"foo\\0\9bar"
       35 │ + let·x·=·"foo\\u00009bar"
    36 36 │   let x = "\\1\\0\8"
    37 37 │   let x = "\\0\8\9"
  

```

```
invalid.js:35:16 lint/correctness/noNonoctalDecimalEscape  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ! Don't use `\8` and `\9` escape sequences in string literals.
  
    33 │ let x = "foo\\\nbar\9baz"
    34 │ let x = "\\0\8"
  > 35 │ let x = "foo\\0\9bar"
       │                ^^
    36 │ let x = "\\1\\0\8"
    37 │ let x = "\\0\8\9"
  
  i The nonoctal decimal escape is a deprecated syntax that is left for compatibility and should not be used.
  
  i Unsafe fix: Replace \9 with \u0039. This maintains the current functionality.
  
    33 33 │   let x = "foo\\\nbar\9baz"
    34 34 │   let x = "\\0\8"
    35    │ - let·x·=·"foo\\0\9bar"
       35 │ + let·x·=·"foo\\0\u0039bar"
    36 36 │   let x = "\\1\\0\8"
    37 37 │   let x = "\\0\8\9"
  

```

```
invalid.js:36:14 lint/correctness/noNonoctalDecimalEscape  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ! Don't use `\8` and `\9` escape sequences in string literals.
  
    34 │ let x = "\\0\8"
    35 │ let x = "foo\\0\9bar"
  > 36 │ let x = "\\1\\0\8"
       │              ^^^^
    37 │ let x = "\\0\8\9"
    38 │ let x = "\8\\0\9"
  
  i The nonoctal decimal escape is a deprecated syntax that is left for compatibility and should not be used.
  
  i Unsafe fix: Replace \0\8 with \u00008. This maintains the current functionality.
  
    34 34 │   let x = "\\0\8"
    35 35 │   let x = "foo\\0\9bar"
    36    │ - let·x·=·"\\1\\0\8"
       36 │ + let·x·=·"\\1\\u00008"
    37 37 │   let x = "\\0\8\9"
    38 38 │   let x = "\8\\0\9"
  

```

```
invalid.js:36:16 lint/correctness/noNonoctalDecimalEscape  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ! Don't use `\8` and `\9` escape sequences in string literals.
  
    34 │ let x = "\\0\8"
    35 │ let x = "foo\\0\9bar"
  > 36 │ let x = "\\1\\0\8"
       │                ^^
    37 │ let x = "\\0\8\9"
    38 │ let x = "\8\\0\9"
  
  i The nonoctal decimal escape is a deprecated syntax that is left for compatibility and should not be used.
  
  i Unsafe fix: Replace \8 with \u0038. This maintains the current functionality.
  
    34 34 │   let x = "\\0\8"
    35 35 │   let x = "foo\\0\9bar"
    36    │ - let·x·=·"\\1\\0\8"
       36 │ + let·x·=·"\\1\\0\u0038"
    37 37 │   let x = "\\0\8\9"
    38 38 │   let x = "\8\\0\9"
  

```

```
invalid.js:37:11 lint/correctness/noNonoctalDecimalEscape  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ! Don't use `\8` and `\9` escape sequences in string literals.
  
    35 │ let x = "foo\\0\9bar"
    36 │ let x = "\\1\\0\8"
  > 37 │ let x = "\\0\8\9"
       │           ^^^^
    38 │ let x = "\8\\0\9"
    39 │ let x = "0\8"
  
  i The nonoctal decimal escape is a deprecated syntax that is left for compatibility and should not be used.
  
  i Unsafe fix: Replace \0\8 with \u00008. This maintains the current functionality.
  
    35 35 │   let x = "foo\\0\9bar"
    36 36 │   let x = "\\1\\0\8"
    37    │ - let·x·=·"\\0\8\9"
       37 │ + let·x·=·"\\u00008\9"
    38 38 │   let x = "\8\\0\9"
    39 39 │   let x = "0\8"
  

```

```
invalid.js:37:13 lint/correctness/noNonoctalDecimalEscape  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ! Don't use `\8` and `\9` escape sequences in string literals.
  
    35 │ let x = "foo\\0\9bar"
    36 │ let x = "\\1\\0\8"
  > 37 │ let x = "\\0\8\9"
       │             ^^
    38 │ let x = "\8\\0\9"
    39 │ let x = "0\8"
  
  i The nonoctal decimal escape is a deprecated syntax that is left for compatibility and should not be used.
  
  i Unsafe fix: Replace \8 with \u0038. This maintains the current functionality.
  
    35 35 │   let x = "foo\\0\9bar"
    36 36 │   let x = "\\1\\0\8"
    37    │ - let·x·=·"\\0\8\9"
       37 │ + let·x·=·"\\0\u0038\9"
    38 38 │   let x = "\8\\0\9"
    39 39 │   let x = "0\8"
  

```

```
invalid.js:38:10 lint/correctness/noNonoctalDecimalEscape  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ! Don't use `\8` and `\9` escape sequences in string literals.
  
    36 │ let x = "\\1\\0\8"
    37 │ let x = "\\0\8\9"
  > 38 │ let x = "\8\\0\9"
       │          ^^
    39 │ let x = "0\8"
    40 │ let x = "\\0\8"
  
  i The nonoctal decimal escape is a deprecated syntax that is left for compatibility and should not be used.
  
  i Unsafe fix: Replace \8 with 8. This maintains the current functionality.
  
    38 │ let·x·=·"\8\\0\9"
       │          -       

```

```
invalid.js:38:13 lint/correctness/noNonoctalDecimalEscape  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ! Don't use `\8` and `\9` escape sequences in string literals.
  
    36 │ let x = "\\1\\0\8"
    37 │ let x = "\\0\8\9"
  > 38 │ let x = "\8\\0\9"
       │             ^^^^
    39 │ let x = "0\8"
    40 │ let x = "\\0\8"
  
  i The nonoctal decimal escape is a deprecated syntax that is left for compatibility and should not be used.
  
  i Unsafe fix: Replace \0\9 with \u00009. This maintains the current functionality.
  
    36 36 │   let x = "\\1\\0\8"
    37 37 │   let x = "\\0\8\9"
    38    │ - let·x·=·"\8\\0\9"
       38 │ + let·x·=·"\8\\u00009"
    39 39 │   let x = "0\8"
    40 40 │   let x = "\\0\8"
  

```

```
invalid.js:38:15 lint/correctness/noNonoctalDecimalEscape  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ! Don't use `\8` and `\9` escape sequences in string literals.
  
    36 │ let x = "\\1\\0\8"
    37 │ let x = "\\0\8\9"
  > 38 │ let x = "\8\\0\9"
       │               ^^
    39 │ let x = "0\8"
    40 │ let x = "\\0\8"
  
  i The nonoctal decimal escape is a deprecated syntax that is left for compatibility and should not be used.
  
  i Unsafe fix: Replace \9 with \u0039. This maintains the current functionality.
  
    36 36 │   let x = "\\1\\0\8"
    37 37 │   let x = "\\0\8\9"
    38    │ - let·x·=·"\8\\0\9"
       38 │ + let·x·=·"\8\\0\u0039"
    39 39 │   let x = "0\8"
    40 40 │   let x = "\\0\8"
  

```

```
invalid.js:39:11 lint/correctness/noNonoctalDecimalEscape  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ! Don't use `\8` and `\9` escape sequences in string literals.
  
    37 │ let x = "\\0\8\9"
    38 │ let x = "\8\\0\9"
  > 39 │ let x = "0\8"
       │           ^^
    40 │ let x = "\\0\8"
    41 │ let x = "\0 \8"
  
  i The nonoctal decimal escape is a deprecated syntax that is left for compatibility and should not be used.
  
  i Unsafe fix: Replace \8 with 8. This maintains the current functionality.
  
    37 37 │   let x = "\\0\8\9"
    38 38 │   let x = "\8\\0\9"
    39    │ - let·x·=·"0\8"
       39 │ + let·x·=·"08"
    40 40 │   let x = "\\0\8"
    41 41 │   let x = "\0 \8"
  

```

```
invalid.js:40:11 lint/correctness/noNonoctalDecimalEscape  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ! Don't use `\8` and `\9` escape sequences in string literals.
  
    38 │ let x = "\8\\0\9"
    39 │ let x = "0\8"
  > 40 │ let x = "\\0\8"
       │           ^^^^
    41 │ let x = "\0 \8"
    42 │ let x = "\01\8"
  
  i The nonoctal decimal escape is a deprecated syntax that is left for compatibility and should not be used.
  
  i Unsafe fix: Replace \0\8 with \u00008. This maintains the current functionality.
  
    38 38 │   let x = "\8\\0\9"
    39 39 │   let x = "0\8"
    40    │ - let·x·=·"\\0\8"
       40 │ + let·x·=·"\\u00008"
    41 41 │   let x = "\0 \8"
    42 42 │   let x = "\01\8"
  

```

```
invalid.js:40:13 lint/correctness/noNonoctalDecimalEscape  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ! Don't use `\8` and `\9` escape sequences in string literals.
  
    38 │ let x = "\8\\0\9"
    39 │ let x = "0\8"
  > 40 │ let x = "\\0\8"
       │             ^^
    41 │ let x = "\0 \8"
    42 │ let x = "\01\8"
  
  i The nonoctal decimal escape is a deprecated syntax that is left for compatibility and should not be used.
  
  i Unsafe fix: Replace \8 with \u0038. This maintains the current functionality.
  
    38 38 │   let x = "\8\\0\9"
    39 39 │   let x = "0\8"
    40    │ - let·x·=·"\\0\8"
       40 │ + let·x·=·"\\0\u0038"
    41 41 │   let x = "\0 \8"
    42 42 │   let x = "\01\8"
  

```

```
invalid.js:41:13 lint/correctness/noNonoctalDecimalEscape  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ! Don't use `\8` and `\9` escape sequences in string literals.
  
    39 │ let x = "0\8"
    40 │ let x = "\\0\8"
  > 41 │ let x = "\0 \8"
       │             ^^
    42 │ let x = "\01\8"
    43 │ let x = "\0\1\8"
  
  i The nonoctal decimal escape is a deprecated syntax that is left for compatibility and should not be used.
  
  i Unsafe fix: Replace \8 with 8. This maintains the current functionality.
  
    41 │ let·x·=·"\0·\8"
       │             -  

```

```
invalid.js:42:13 lint/correctness/noNonoctalDecimalEscape  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ! Don't use `\8` and `\9` escape sequences in string literals.
  
    40 │ let x = "\\0\8"
    41 │ let x = "\0 \8"
  > 42 │ let x = "\01\8"
       │             ^^
    43 │ let x = "\0\1\8"
    44 │ let x = "\0\\n\8"
  
  i The nonoctal decimal escape is a deprecated syntax that is left for compatibility and should not be used.
  
  i Unsafe fix: Replace \8 with 8. This maintains the current functionality.
  
    40 40 │   let x = "\\0\8"
    41 41 │   let x = "\0 \8"
    42    │ - let·x·=·"\01\8"
       42 │ + let·x·=·"\018"
    43 43 │   let x = "\0\1\8"
    44 44 │   let x = "\0\\n\8"
  

```

```
invalid.js:43:14 lint/correctness/noNonoctalDecimalEscape  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ! Don't use `\8` and `\9` escape sequences in string literals.
  
    41 │ let x = "\0 \8"
    42 │ let x = "\01\8"
  > 43 │ let x = "\0\1\8"
       │              ^^
    44 │ let x = "\0\\n\8"
    45 │ 
  
  i The nonoctal decimal escape is a deprecated syntax that is left for compatibility and should not be used.
  
  i Unsafe fix: Replace \8 with 8. This maintains the current functionality.
  
    41 41 │   let x = "\0 \8"
    42 42 │   let x = "\01\8"
    43    │ - let·x·=·"\0\1\8"
       43 │ + let·x·=·"\0\18"
    44 44 │   let x = "\0\\n\8"
    45 45 │   
  

```

```
invalid.js:44:15 lint/correctness/noNonoctalDecimalEscape  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ! Don't use `\8` and `\9` escape sequences in string literals.
  
    42 │ let x = "\01\8"
    43 │ let x = "\0\1\8"
  > 44 │ let x = "\0\\n\8"
       │               ^^
    45 │ 
  
  i The nonoctal decimal escape is a deprecated syntax that is left for compatibility and should not be used.
  
  i Unsafe fix: Replace \8 with 8. This maintains the current functionality.
  
    42 42 │   let x = "\01\8"
    43 43 │   let x = "\0\1\8"
    44    │ - let·x·=·"\0\\n\8"
       44 │ + let·x·=·"\0\\n8"
    45 45 │   
  

```